Returns a list of the collectors for this instance.

        :return     {<str> name: <orb.Collector>, ..}
964888
def collectors(self, recurse=True, flags=0):
        
        output = {}
        if recurse and self.inherits():
            schema = orb.system.schema(self.inherits())
            if not schema:
                raise orb.errors.ModelNotFound(schema=self.inherits())
            else:
                iflags = (flags & ~orb.Collector.Flags.Virtual) if flags else ~orb.Collector.Flags.Virtual
                output.update(schema.collectors(recurse=recurse, flags=iflags))
        output.update({c.name(): c for c in self.__collectors.values() if not flags or c.testFlag(flags)})
        return output
600467
def _members(self):
        
        return {
            key: value
            for key, value in self.__dict__.items()
            # NB: ignore internal SQLAlchemy state and nested relationships
            if not key.startswith("_") and not isinstance(value, Model)
        }
1024163
def objects(self):
        
        return [ObjectInfo(o, self._instance, self._bucket, self._client)
                for o in self._proto.object]
817289
async def list(self) -> List[str]:
        

        LOGGER.debug('NodePoolManager.list >>>')

        rv = [p['pool'] for p in await pool.list_pools()]

        LOGGER.debug('NodePoolManager.list <<< %s', rv)
        return rv
1023918
def get_collectors(self, limit=1000, offset=0):
        
        options = {
            'limit': limit,
            'offset': offset,
        }
        request = requests.get(self.url, params=options, auth=self.auth)

        try:
            results = request.json()['collectors']
        except KeyError:
            results = request.json()
        except json.decoder.JSONDecodeError:
            results = []

        return results
853202
def _name_estimators(estimators):
    

    def get_name(estimator):
        if isinstance(estimator, DelegatingRobustTransformer):
            return get_name(estimator._transformer)

        return type(estimator).__name__.lower()

    names = list(map(get_name, estimators))
    counter = dict(Counter(names))
    counter = select_values(lambda x: x > 1, counter)

    for i in reversed(range(len(estimators))):
        name = names[i]
        if name in counter:
            names[i] += "-%d" % counter[name]
            counter[name] -= 1

    return list(zip(names, estimators))
76352
def getObservers(self):
        
        result = []
        for observer in self._observers:
            result.append(
                          {
                              "observing": observer["observing"],
                              "call": observer["call"]
                          })
        return result
84984
def names(self):
        
        if not self.children:
            return set([self.name])
        ret = set()
        for child in self.children:
            for name in child.names:
                ret.add(name)
        return ret
69518
def get_collection_name(cls):
        '''
        
        '''
        if hasattr(cls, '_meta'):
            np = getattr(cls._meta, 'namespace', None)
            cname = getattr(cls._meta, 'name', None)
            if np:
                return '{}.{}'.format(np, cname or cls.__name__.lower())
        return cname or cls.__name__.lower()
604865
def get_signatures(self):
        
        signatures = self.request_list('GetSignatures')

        return [zobjects.Signature.from_dict(i) for i in signatures]
1182503
def names(self):
        
        # We must sort to preserve the order between calls.
        # The set comprehension is to drop the duplicates.
        return tuple(sorted({
            instr.arg for instr in self.instrs if instr.uses_name
        }))
1118055
def get_renderers(self):
        
        try:
            source = self.get_object()
        except (ImproperlyConfigured, APIException):
            self.renderer_classes = [RENDERER_MAPPING[i] for i in self.__class__.renderers]
            return [RENDERER_MAPPING[i]() for i in self.__class__.renderers]
        else:
            self.renderer_classes = [RENDERER_MAPPING[i] for i in source.__class__.renderers]
            return [RENDERER_MAPPING[i]() for i in source.__class__.renderers]
1276951
def get_displayable_field_names(self):
        
        return [
            f.name
            for f in self.model._meta.get_fields()
            if not f.one_to_many
        ]
368676
def _get_surnames(self):
        
        names = self._read_name_file('surnames.json')
        names = self._compute_weights(names)

        return names
1356615
def names(self) -> [str]:
        
        return sorted([name for name in self.axes_by_sname.keys() if name is not ''])
1237304
def _list_locators(self):
        
        with _handle_client_exception():
            response = self.client.get_account()

        for container in response[1]:
            yield container.pop('name'), container
1215221
def GetNames(cls):
    
    names = []
    for plugin_class in cls._plugins.values():
      name = getattr(plugin_class, 'ARTIFACT_DEFINITION_NAME', None)
      if name:
        names.append(name)

    return names