Returns an iterator of the actual modules, not just their names

        :returns: generator, each module under self.controller_prefix
359689
def modules(self):
        
        for modname in self.module_names:
            module = importlib.import_module(modname)
            yield module
1126267
def print_controllers():
    
    _check_import()
    pp = pprint.PrettyPrinter(indent=2)
    for discovery in find_all_controllers():
        pp.pprint(discovery.controller)
1339845
def print_modules(self):
		
		shutit_global.shutit_global_object.yield_to_draw()
		cfg = self.cfg
		module_string = ''
		module_string += 'Modules: \n'
		module_string += '    Run order    Build    Remove    Module ID\n'
		for module_id in self.module_ids():
			module_string += '    ' + str(self.shutit_map[module_id].run_order) + '        ' + str(
				cfg[module_id]['shutit.core.module.build']) + '    ' + str(
				cfg[module_id]['shutit.core.module.remove']) + '    ' + module_id + '\n'
		return module_string
607504
def get_methodnames(self, node):
        '''
        '''
        nodekey = self.get_nodekey(node)
        prefix = self._method_prefix
        if isinstance(nodekey, self.GeneratorType):
            for nodekey in nodekey:
                yield self._method_prefix + nodekey
        else:
            yield self._method_prefix + nodekey
1286707
def get_all():
    

    _import_all_importer_files()

    for module in (value for key, value in globals().items()
                   if key in __all__):
        for klass_name, klass in inspect.getmembers(module, inspect.isclass):
            if klass is not BaseImporter and issubclass(klass, BaseImporter):
                yield klass

    for klass in _get_importers_from_entry_points():
        yield klass
728212
def iter_related(self):
        '''
        
        '''
        for tpl in self.provider_run.templates:
            yield tpl.providers[self.index]
234387
def get_modules(self, type_name):
        '''
        '''
        modules = []
        for module in self:
            if module.__class__.__name__ == type_name:
                modules.append(module)
        return modules
875891
def array_controllers(self):
        
        return array_controller.HPEArrayControllerCollection(
            self._conn, utils.get_subresource_path_by(
                self, ['Links', 'ArrayControllers']),
            redfish_version=self.redfish_version)
1334314
protected function getGlobalMiddleWareHandlers(): Generator
    {
        // select global middleware from routes
        foreach ($this->selectClasses($this->getRoutesPath(), RoutesConfiguratorInterface::class) as $selectClass) {
            /** @var RoutesConfiguratorInterface $selectClass */
            foreach ($selectClass::getMiddleware() as $middlewareClass) {
                $handler = [$middlewareClass, MiddlewareInterface::MIDDLEWARE_METHOD_NAME];
                yield $handler;
            }
        }

        // select global middleware from providers
        $interfaceName = ProvidesMiddlewareInterface::class;
        foreach ($this->selectClassImplements($this->getProviderClasses(), $interfaceName) as $providerClass) {
            /** @var ProvidesMiddlewareInterface $providerClass */
            foreach ($providerClass::getMiddleware() as $middlewareClass) {
                $handler = [$middlewareClass, MiddlewareInterface::MIDDLEWARE_METHOD_NAME];
                yield $handler;
            }
        }
    }
418774
def process_controllers
				process_services
				modules= Jinda::Module.all
				modules.each do |m|
					next if controller_exists?(m.code)
					puts "    Rails generate controller #{m.code}"
				end
			end
68200
def collect_modules(self):
        
        try:
            res = {}
            m = sys.modules
            for k in m:
                # Don't report submodules (e.g. django.x, django.y, django.z)
                # Skip modules that begin with underscore
                if ('.' in k) or k[0] == '_':
                    continue
                if m[k]:
                    try:
                        d = m[k].__dict__
                        if "version" in d and d["version"]:
                            res[k] = self.jsonable(d["version"])
                        elif "__version__" in d and d["__version__"]:
                            res[k] = self.jsonable(d["__version__"])
                        else:
                            res[k] = get_distribution(k).version
                    except DistributionNotFound:
                        pass
                    except Exception:
                        logger.debug("collect_modules: could not process module: %s" % k)

        except Exception:
            logger.debug("collect_modules", exc_info=True)
        else:
            return res
1031658
public void findModules() {
        ServiceLoader<ClientModuleFactory> loader = ServiceLoader.load(ClientModuleFactory.class);

        Iterator<ClientModuleFactory> iterator = loader.iterator();
        while (iterator.hasNext()) {
            ClientModuleFactory factory = iterator.next();
            Module module = factory.create();
            addModule(module);
        }

        objectMapper.findAndRegisterModules();
    }
842395
def get_methods(self):
        
        for c in self.classes.values():
            for m in c.get_methods():
                yield m
416616
def modules(self):
        

        if not self.get_objects_by_type('module'):
            self.inventory()
        return {int(c.index): c for c in self.get_objects_by_type('module')}
860048
def get_generator(self):
        
        s = self.slice
        gen = drange(s.start, s.stop, s.step) # intialises the generator
        return gen
240371
def list_of(*generators):
    

    class ListOfGenerators(ArbitraryInterface):
        """
        A closure class around the generators specified above, which
        generates a list of the generators.
        """

        @classmethod
        def arbitrary(cls):
            """
            Generate a list of the enclosed generators.
            """
            arbitrary_list = []
            for generator in generators:
                arbitrary_list += [
                    arbitrary(generator)
                    # max_length / len(generators):
                    for _ in range(arbitrary(int) % 100)
                ]
            return arbitrary_list

    ListOfGenerators.__name__ = ''.join([
        'list_of(', ', '.join(generator.__name__ for generator in generators),
        ')'
    ])
    return ListOfGenerators
1045208
private function getAttributeKeys(): \Generator
    {
        foreach ($this->handlers as $attributeHandler) {
            /** @var MetaModelAttributeHandlerInterface $attributeHandler */
            $prefix = $attributeHandler->getPrefix();
            foreach ($this->idListGenerator() as $id) {
                yield $id . '.' . $prefix;
            }
        }
    }