Get the trashed state.

        Returns:
            bool: Whether this item is trashed.
350615
def trashed(self):
        
        return self.timestamps.trashed is not None and self.timestamps.trashed > NodeTimestamps.int_to_dt(0)
1299782
def state(self):
        
        self._state, value = self.get_attr_set(self._state, 'state')
        return value
904957
def get_versioned_delete_collector_class():
    
    key = 'VERSIONED_DELETE_COLLECTOR'
    try:
        cls = _cache[key]
    except KeyError:
        collector_class_string = getattr(settings, key)
        cls = import_from_string(collector_class_string, key)
        _cache[key] = cls
    return cls
947677
def _only_trashed(self, builder):
        
        model = builder.get_model()

        self.remove(builder, model)

        builder.get_query().where_not_null(model.get_qualified_deleted_at_column())
1170770
def ndeleted(self):
        """"""
        if not self._counters_calculated:
            self._counters_calculated = True
            self._extract_counters()

        return self._ndeleted
102982
def get_all_if_deleted(self):
        

        with self._lock:
            results = {}
            for add, fut in self._state.items():
                if self._contains_and_deleted(add):
                    results[add] = fut.result()
            return results
33607
def Get(self, path, rootpy=True, **kwargs):
        
        thing = super(_DirectoryBase, self).Get(path)
        if not thing:
            raise DoesNotExist

        # Ensure that the file we took the object from is alive at least as
        # long as the object being taken from it.

        # Note, Python does *not* own `thing`, it is ROOT's responsibility to
        # delete it in the C++ sense. (SetOwnership is False). However, ROOT
        # will delete the object when the TFile's destructor is run.
        # Therefore, when `thing` goes out of scope and the file referred to
        # by `this` has no references left, the file is destructed and calls
        # `thing`'s delete.

        # (this is thanks to the fact that weak referents (used by keepalive)
        #  are notified when they are dead).

        keepalive(thing, self)

        if rootpy:
            return asrootpy(thing, **kwargs)
        return thing
295442
def get_state(self, minimal:bool=True):
        ""
        to_remove = ['exclude', 'not_min'] + getattr(self, 'exclude', []).copy()
        if minimal: to_remove += getattr(self, 'not_min', []).copy()
        return {k:v for k,v in self.__dict__.items() if k not in to_remove}
661059
def deleted(self, deleted_since, filters=None, params=None):
        

        return self.tc_requests.deleted(
            self.api_type,
            self.api_sub_type,
            deleted_since,
            owner=self.owner,
            filters=filters,
            params=params,
        )
492643
def checkState(self):
        
        if self.data is True:
            return Qt.Checked
        elif self.data is False:
            return Qt.Unchecked
        else:
            raise ValueError("Unexpected data: {!r}".format(self.data))
135606
public final Boolean isDeleted() {
        Boolean deleted = getObject(DELETED_CONST, Boolean.class);
        return deleted != null ? deleted : false;
    }
237816
def IsAllocated(self):
    
    if self._stat_object is None:
      self._stat_object = self._GetStat()
    return self._stat_object and self._stat_object.is_allocated
354161
function(){
      Dataset.flushChanges(this);

      var deleted = this.getItems();
      var listenHandler = this.listen.item;
      var delta;

      if (deleted.length)
      {
        if (listenHandler)
          for (var i = 0; i < deleted.length; i++)
            deleted[i].removeHandler(listenHandler, this);

        this.emit_itemsChanged(delta = {
          deleted: deleted
        });

        this.members_ = {};
      }

      return delta;
    }
608967
def items(self):
        ''''''
        if hasattr(self, '_items'):
            return self.filter_items(self._items)
        self._items = self.get_items()
        return self.filter_items(self._items)
1358087
def are_items_shuffled(self):
        
        if self._my_map['itemsShuffled'] is None:
            return self.get_assessment().are_items_shuffled()
        return bool(self._my_map['itemsShuffled'])
1218010
def _do_perform_delete_on_model(self):
        
        if self._force_deleting:
            return self.with_trashed().where(self.get_key_name(), self.get_key()).force_delete()

        return self._run_soft_delete()
1180324
def get_key_state(self, status, state_dict):
        
        for key, val in state_dict.items():
            if val == status:
                return key