Collect all the options info from the other modules.
321253
def get_options():
    """"""
    options = collections.defaultdict(list)
    for opt_class in config_factory.get_options():
        if not issubclass(opt_class, config_base.Options):
            continue
        config_options = opt_class(None)
        options[config_options.group_name].extend(config_options.list())
    return [(key, value) for key, value in options.items()]
1194213
def yang_modules(self):
        
        res = {}
        for c in self.capabilities:
            m = c.parameters.get("module")
            if m is None or m in res: continue
            res[m] = c.parameters.get("revision")
        return res.items()
108233
def load_module_opts_from_file(path, module_options):
    """"""
    module_options_file = os.path.join(path,
                                       'runway.module.yml')
    if os.path.isfile(module_options_file):
        with open(module_options_file, 'r') as stream:
            module_options = merge_dicts(module_options,
                                         yaml.safe_load(stream))
    return module_options
57203
public function findAll(): OptionCollection
    {
        $options = [];

        foreach ($this->repositories as $repository) {
            array_push($options, ...$repository->findAll());
        }

        return new OptionCollection\ArrayOptionCollection($options);
    }
1310655
def options(self, context, module_options):
        '''
        
        '''
        self.domains = None
        if module_options and 'DOMAIN' in module_options:
            self.domains = module_options['DOMAIN']
328474
def extract_options_dict(template, options):
    """"""
    for option, val in template.items():
        if options and option in options:
            yield option, options[option]
        else:
            yield option, Default(template[option]['default'](os.environ))
813006
def _load_all(self):
        '''
        
        '''
        with self._lock:
            for name in self.file_mapping:
                if name in self.loaded_files or name in self.missing_modules:
                    continue
                self._load_module(name)

            self.loaded = True
462509
def get_options(self):
        
        return reduce(
            list.__add__,
            [list(option_list) for option_list in self.get_option_lists()],
            [])
1070144
def modules(self):
        """"""
        defmodule = lib.EnvGetNextDefmodule(self._env, ffi.NULL)

        while defmodule != ffi.NULL:
            yield Module(self._env, defmodule)

            defmodule = lib.EnvGetNextDefmodule(self._env, defmodule)
1096523
def _get_options_from_config(self):
        """"""

        options = get_config()
        self.output_dir = options.get('rsr_dir', './')
        self.path = options[self.platform_name + '-' + self.instrument]['path']
        self.options = options
991756
def get_help_option_names(self, ctx):
        """"""
        all_names = set(ctx.help_option_names)
        for param in self.params:
            all_names.difference_update(param.opts)
            all_names.difference_update(param.secondary_opts)
        return all_names
866284
def _gather_exposed_methods(self):
        

        self._extract_methods_from_container(self)

        for module in self.modules:
            self._extract_methods_from_container(module)
1150321
def parse_options(cls, options):
        """"""
        cls.known_modules = {
            project2module(k): v.split(",")
            for k, v in [
                x.split(":[")
                for x in re.split(r"],?", options.known_modules)[:-1]
            ]
        }
725890
def get_options_values(self, hidden=False):
        
        values = {}
        for opt_name, opt in self._options.items():
            if hidden or not opt.hidden:
                values[opt_name] = opt.value
        return values
968388
def options(self):
        
        if self._options is None:
            self._options = Option.View(self)
        return self._options
210618
def options(self, section):
        """"""
        try:
            opts = self._sections[section].copy()
        except KeyError:
            raise from_none(NoSectionError(section))
        opts.update(self._defaults)
        return list(opts.keys())
669816
def available_options(self):
        
        for option in list(self.cmd.options.values()):
            if (option.is_multiple or
                    option not in list(self.used_options)):
                yield option