:return:
            A list of :class:`Processor` or its children classes grouped by
            each cid, [(cid, [:class:`Processor`)]]
11305
def list_by_cid(self):
        
        prs = self._processors
        return sorted(((cid, [prs[cid]]) for cid in sorted(prs.keys())),
                      key=operator.itemgetter(0))
491269
def get_all_children(self):
        
        children = self._children[:]
        oldlen = 0
        newlen = len(children)
        while oldlen != newlen:
            start = oldlen
            oldlen = len(children)
            for i in range(start, len(children)):
                children.extend(children[i]._children)
            newlen = len(children)
        return children
224211
def parents(self):
        
        entries = []
        command = self
        while command.parent is not None:
            command = command.parent
            entries.append(command)

        return entries
710562
def children(self):
        
        if self._children is None:
            self._children = Matches(None, self.input_string)
        return self._children
1285714
def from_list(commands):
    
    def subtrees(commands, level):
        if not commands:
            return

        acc = []
        parent, *commands = commands

        for command in commands:
            if command['level'] > level:
                acc.append(command)
            else:
                yield (parent, acc)
                parent = command
                acc.clear()
        yield (parent, acc)

    def walk(commands, level=0):
        return [
            {
                'description': key['description'],
                'children': walk(subtree, level + 1),
                'id': key['id']
            }
            for key, subtree in subtrees(commands, level)
        ]

    return walk(commands)
681225
def containers(self) -> list:
        

        all_containers: List = list()
        for slot in self:
            all_containers += slot.get_children_list()

        for container in all_containers:
            if getattr(container, 'stackable', False):
                all_containers += container.get_children_list()

        return all_containers
103469
def kids(self):
        
        self._uptodate()
        return [key.kid for key in self._keys if key.kid != ""]
253034
def members(self):
        
        return list(
            [
                self.children_class(child)
                for child in self.graph.subjects(RDF_NAMESPACES.DTS.parent, self.asNode())
            ]
        )
277471
def all_subclasses(cls):
    """"""
    for s in cls.__subclasses__():
      yield s
      for c in s.all_subclasses():
        yield c
173177
def children(self):
        
        if self._children is None:
            topdowns = tuple(Relationship.topdown())
            self._children = TermList()
            self._children.extend(
                [ other
                    for rship,others in six.iteritems(self.relations)
                        for other in others
                            if rship in topdowns
                ]
            )
        return self._children
640100
def all_subclasses(cls):
    
    subclasses = cls.__subclasses__() 
    return subclasses + [g for s in subclasses for g in all_subclasses(s)]
676108
def get_reader_classes(parent=Reader):
    """"""
    children = parent.__subclasses__()
    descendants = children[:]
    for child in children:
        grandchildren = get_reader_classes(child)
        if grandchildren:
            descendants.remove(child)
            descendants.extend(grandchildren)
    return descendants
810518
def get_processors(self):
        ""
        procs_x,procs_y = listify(self.train.x._processor),listify(self.train.y._processor)
        xp = ifnone(self.train.x.processor, [p(ds=self.train.x) for p in procs_x])
        yp = ifnone(self.train.y.processor, [p(ds=self.train.y) for p in procs_y])
        return xp,yp
1350271
def GetChildClassId(self, classId):
		
		childList = []
		for ch in self.child:
			if ch.classId.lower() == classId.lower():
				childList.append(ch)
		return childList
748853
public final List<OSProcess> getChildren() {
            List<OSProcess> r = new ArrayList<OSProcess>();
            for (OSProcess p : ProcessTree.this)
                if(p.getParent()==this)
                    r.add(p);
            return r;
        }
7957
def protocol_tree_items(self):
        
        result = {}
        for i, group in enumerate(self.rootItem.children):
            result[i] = [child for child in group.children]

        return result
390737
def childIds(self) -> BaseReferenceSet:
        
        if self._childIds is None:
            self._childIds = self.getReffs()
        return self._childIds