Return the objects for each individual set flag.
335119
def enabled_flags(self):
        """"""
        if not self.value:
            yield self.__flags_members__[0]
            return

        val = self.value
        while val:
            lowest_bit = val & -val
            val ^= lowest_bit
            yield self.__flags_members__[lowest_bit]
283936
def sets(self):
        """"""
        sets = {}
        for x in self._parents:
            sets.setdefault(self[x], set()).add(x)
        return frozenset(frozenset(v) for v in six.viewvalues(sets))
445167
def getobject(bunchdt, key, name):
    """"""
    # TODO : throw exception if more than one object, or return more objects
    idfobjects = bunchdt[key]
    if idfobjects:
        # second item in list is a unique ID
        unique_id = idfobjects[0].objls[1]
    theobjs = [idfobj for idfobj in idfobjects if
               idfobj[unique_id].upper() == name.upper()]
    try:
        return theobjs[0]
    except IndexError:
        return None
959098
def get_object_attrs(obj):
    
    attrs = [k for k in dir(obj) if not k.startswith('__')]
    if not attrs:
        attrs = dir(obj)
    return attrs
70662
def values(self, start=None, stop=None):
        """"""
        return (item[1] for item in self.items(start, stop))
31281
def get_suitable_vis_classes(obj):
    """"""

    ret = []
    for class_ in classes_vis():
        if isinstance(obj, class_.input_classes):
            ret.append(class_)
    return ret
599033
def get_objects(self, subject=None, predicate=None):
        """"""

        for triple in self.triples:

            # Filter out non-matches
            if ((subject and triple['subject'] != subject) or
                (predicate and triple['predicate'] != predicate)):
                continue

            yield triple['object']
1147837
def get_objects_by_offset(self, start):
        

        _, container = self._get_container(start)
        if container is None:
            return set()
        else:
            return container.internal_objects
502688
def getSets(self):
        
        sets = lock_and_call(
            lambda: self._impl.getSets(),
            self._lock
        )
        return EntityMap(sets, Set)
160016
def visit_Set(self, node: ast.Set) -> Set[Any]:
        """"""
        result = set(self.visit(node=elt) for elt in node.elts)

        self.recomputed_values[node] = result
        return result
1108173
def index_sets(self, as_set=False):
        """"""
        indexes = frozenset if as_set else tuple
        return [indexes(b.iter_set()) for b in self]
273170
def running_objects(self):
        """"""
        return [obj for obj in self.database_objects
                if obj.status in [obj.known_statuses.RUNNING]]
557372
def all(cls, otp=False, ccid=False, u2f=False):
        """"""
        modes = set([
            cls.OTP,
            cls.CCID,
            cls.OTP_CCID,
            cls.U2F,
            cls.OTP_U2F,
            cls.U2F_CCID,
            cls.OTP_U2F_CCID
        ])

        if otp:
            modes.difference_update(set([
                cls.CCID,
                cls.U2F,
                cls.U2F_CCID
            ]))

        if ccid:
            modes.difference_update(set([
                cls.OTP,
                cls.U2F,
                cls.OTP_U2F
            ]))

        if u2f:
            modes.difference_update(set([
                cls.OTP,
                cls.CCID,
                cls.OTP_CCID
            ]))

        return modes
1214286
def flags(self, index):
        """"""
        # This method was implemented in CollectionsModel only, but to enable
        # tuple exploration (even without editing), this method was moved here
        if not index.isValid():
            return Qt.ItemIsEnabled
        return Qt.ItemFlags(QAbstractTableModel.flags(self, index)|
                            Qt.ItemIsEditable)
1247370
def members(self, as_set=False):
        """"""
        if as_set:
            return frozenset(map(self._members.__getitem__, self._indexes()))
        return tuple(map(self._members.__getitem__, self._indexes()))
213826
def _get_flags(osm_obj):
    
    flags = []
    if osm_obj.visible:
        flags.append('visible')
    if osm_obj.user:
        flags.append('user: %s' % osm_obj.user)
    if osm_obj.timestamp:
        flags.append('timestamp: %s' % osm_obj.timestamp.isoformat())
    if osm_obj.tags:
        flags.append(', '.join('%s: %s' % (k, v)
                               for k, v in sorted(osm_obj.tags.items())))
    return flags
1191051
def get_set(self, project, articleset, **filters):
        """"""
        url = URL.articleset.format(**locals())
        return self.request(url, **filters)