Returns the list of layers of a given class. If no layers are present
        then the list will be empty.

        :param class_: class of the expected layers
        :param became: Allow transformed layers in results
341993
def get_layers(self, class_: Type[L], became: bool=True) -> List[L]:
        

        out = self._index.get(class_, [])

        if became:
            out += self._transformed.get(class_, [])

        return out
518328
def _list_class_vars(cls, exclude=None):
    
    cvars = {k: v for k, v in vars(cls).items()
             if not k.startswith('_')}
    cvars = deepcopy(cvars)
    if exclude is not None:
        for e in exclude:
            cvars.pop(e)
    return cvars
947609
def _class_tags(cls):  # pylint: disable=no-self-argument
        
        class_tags = set()

        for base in cls.mro()[1:]:  # pylint: disable=no-member
            class_tags.update(getattr(base, '_class_tags', set()))

        return class_tags
351737
def has_layer(self, class_: Type[L], became: bool=True) -> bool:
        

        return (class_ in self._index or
                (became and class_ in self._transformed))
614218
def other_classes(nb_classes, class_ind):
  
  if class_ind < 0 or class_ind >= nb_classes:
    error_str = "class_ind must be within the range (0, nb_classes - 1)"
    raise ValueError(error_str)

  other_classes_list = list(range(nb_classes))
  other_classes_list.remove(class_ind)

  return other_classes_list
236142
def layers(self):
        
        extensions = ['*.%s' % f for f in EXTENSIONS]
        self.uri.setNameFilters(extensions)
        files = self.uri.entryList()
        self.uri.setNameFilters([])
        files = human_sorting([QFileInfo(f).baseName() for f in files])
        return files
425507
def get_layers(proto):
    
    if len(proto.layer):
        return proto.layer
    elif len(proto.layers):
        return proto.layers
    else:
        raise ValueError('Invalid proto file.')
714224
def get_class(self, name):
        
        for i in self.get_classes():
            if i.get_name() == name:
                return i
        return None
524034
def layer(self, layer_name):
		
		if layer_name in self.__layers.keys():
			return self.__layers[layer_name]
		elif layer_name in self.__class__.__builtin_layers__:
			return self.__class__.__builtin_layers__[layer_name]

		raise RuntimeError('Invalid layer name')
363724
def child_class(self, child):
        
        for prop, klassdef in self.c_children.values():
            if child == prop:
                if isinstance(klassdef, list):
                    return klassdef[0]
                else:
                    return klassdef
        return None
522329
def _subclassed(base, *classes):
        
        return all(map(lambda obj: isinstance(obj, base), classes))
1170275
def obtain_check_classes(self):
        
        check_classes = set()
        for path in self.paths:
            for root, _, files in os.walk(path):
                for fi in files:
                    if not fi.endswith(".py"):
                        continue
                    path = os.path.join(root, fi)
                    check_classes = check_classes.union(set(
                        load_check_classes_from_file(path)))
        return list(check_classes)
1115824
private TestClassResults getResultsForClass(Map<IClass, TestClassResults> flattenedResults,
                                                ITestResult testResult)
    {
        TestClassResults resultsForClass = flattenedResults.get(testResult.getTestClass());
        if (resultsForClass == null)
        {
            resultsForClass = new TestClassResults(testResult.getTestClass());
            flattenedResults.put(testResult.getTestClass(), resultsForClass);
        }
        return resultsForClass;
    }
600967
def layerData(self):
        
        output = {}
        
        output['visible'] = self.isVisible()
        output['zValue']  = self.zValue()
        output['current'] = self.isCurrent()
        
        return output
316359
def get_methods_class(self, class_name):
        
        l = []
        for i in self.get_classes():
            for j in i.get_methods():
                if class_name == j.get_class_name():
                    l.append(j)

        return l
1253559
def classes_(self):
        
        if self.__classes is None:
            try:
                return self.estimator.classes_
            except AttributeError:
                return None
        return self.__classes
396005
def _filter_classes(cls_list, cls_type):
    """"""
    for cls in cls_list:
        if isinstance(cls, type) and issubclass(cls, cls_type):
            if cls_type == TempyPlace and cls._base_place:
                pass
            else:
                yield cls