Find all comic scraper classes in the plugins directory.
    The result is cached.
    @return: list of Scraper classes
    @rtype: list of Scraper
180106
def get_scraperclasses():
    
    global _scraperclasses
    if _scraperclasses is None:
        out.debug(u"Loading comic modules...")
        modules = loader.get_modules('plugins')
        plugins = loader.get_plugins(modules, Scraper)
        _scraperclasses = list(plugins)
        check_scrapers()
        out.debug(u"... %d modules loaded." % len(_scraperclasses))
    return _scraperclasses
544583
def list(self):
        
        resp = self.client.api.plugins()
        return [self.prepare_model(r) for r in resp]
901699
def classes(self):
        
        p = lambda o: isinstance(o, Class) and self._docfilter(o)
        return sorted(filter(p, self.doc.values()))
764660
def get_new_requests(self):
        

        content_type = self.__queue_item.response.headers.get('content-type')
        scrapers = self.__get_all_scrapers()
        new_requests = []

        for scraper in scrapers:
            instance = scraper(self.__options, self.__queue_item)
            if self.__content_type_matches(content_type, instance.content_types):
                new_requests.extend(instance.get_requests())

        return new_requests
1253559
def classes_(self):
        
        if self.__classes is None:
            try:
                return self.estimator.classes_
            except AttributeError:
                return None
        return self.__classes
246126
def scrape(cls, selector, root, xpath=False):
        """"""
        log.debug('Called scrape classmethod with root: %s' % root)
        roots = selector.xpath(root) if xpath else selector.css(root)
        results = [cls(r) for r in roots]
        return EntityList(*results)
642509
def find_all_item_classes(self):
        ''''''
        # This is a circular import, but performed after the class is defined and an object is instatiated.
        # We do this in order to get references to any objects definitions in the redmine.py file
        # without requiring anyone editing the file to do anything other than create a class with the proper name.
        import redmine as public_classes

        item_class = {}
        for key, value in public_classes.__dict__.items():
            try:
                if issubclass(value, Redmine_Item):
                    item_class[key.lower()] = value
            except:
                continue
        self.item_class = item_class
949720
def get_plugs_mail_classes(self, app):
        
        classes = []
        members = self.get_members(app)
        for member in members:
            name, cls = member
            if inspect.isclass(cls) and issubclass(cls, PlugsMail) and name != 'PlugsMail':
                files_ = self.get_template_files(app.__file__, name)
                for file_ in files_:
                    try:
                        description = cls.description
                        location = file_
                        language = self.get_template_language(location)
                        classes.append((name, location, description, language))
                    except AttributeError:
                        raise AttributeError('Email class must specify email description.')
        return classes
433083
def get_all_plugins(self):
        
        return [{
            "manifest": i,
            "plugin": self.get_plugin(i["name"]),
            "module": self.get_module(i["name"])
        } for i in self._manifests]
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
1113998
def get_classes(self):
        
        for idx, digest in enumerate(self.analyzed_vms):
            dx = self.analyzed_vms[digest]
            for vm in dx.vms:
                filename = self.analyzed_digest[digest]
                yield idx, filename, digest, vm.get_classes()
1181397
def get_css_classes(cls, instance):
        
        css_classes = []
        if hasattr(cls, 'default_css_class'):
            css_classes.append(cls.default_css_class)
        for attr in getattr(cls, 'default_css_attributes', []):
            css_class = instance.glossary.get(attr)
            if isinstance(css_class, six.string_types):
                css_classes.append(css_class)
            elif isinstance(css_class, list):
                css_classes.extend(css_class)
        return css_classes
296187
def get_methods_class(self, class_name):
        
        l = []
        for i in self.classes.class_def:
            for j in i.get_methods():
                if class_name == j.get_class_name():
                    l.append(j)

        return l
1138328
def get_plugins(modules, classobj):
    
    for module in modules:
        for plugin in get_module_plugins(module, classobj):
            yield plugin
476621
def _get_classes_to_inspect(self):
        
        return tuple(filter(lambda c:
                      SerializableMixIn._get_version(c, require=False) or
                      (SerializableMixIn._get_serialize_fields(c) or
                       SerializableMixIn._get_interpolation_map(c)),
                      self.__class__.__mro__))
135050
def get_default_classes(self):
        
        default_classes = super(TabGroup, self).get_default_classes()
        default_classes.extend(CSS_TAB_GROUP_CLASSES)
        return default_classes
1162281
def get_crawler_class(self, crawler):
        
        settings = Settings()
        settings.set('SPIDER_MODULES', [self.__crawer_module])
        spider_loader = SpiderLoader(settings)
        return spider_loader.load(crawler)