facebookresearch__hydra-273

{
  "status": "ok",
  "stdout": "18:from ..errors import MissingConfigException\n299:                    raise MissingConfigException(msg, new_cfg)\n308:                    raise MissingConfigException(msg, new_cfg, options)\n",
  "stderr": "",
  "exit_code": 0
}

{
  "status": "ok",
  "filepath": "hydra/_internal/config_loader.py",
  "content": "                            files.append(file)\n                        elif file_type == \"file\" and file.endswith(\".yaml\"):\n                            files.append(file[0 : -len(\".yaml\")])\n\n            options.extend(files)\n        return options\n\n    def _merge_config(self, cfg, family, name, required):\n\n        if family != \"\":\n            new_cfg = \"{}/{}\".format(family, name)\n        else:\n            new_cfg = name\n\n        loaded_cfg = self._load_config_impl(new_cfg)\n        if loaded_cfg is None:\n            if required:\n                if family == \"\":\n                    msg = \"Could not load {}\".format(new_cfg)\n                    raise MissingConfigException(msg, new_cfg)\n                else:\n                    options = self.get_group_options(family)\n                    if options:\n                        msg = \"Could not load {}, available options:\\n{}:\\n\\t{}\".format(\n                            new_cfg, family, \"\\n\\t\".join(options)\n                        )\n                    else:\n                        msg = \"Could not load {}\".format(new_cfg)\n                    raise MissingConfigException(msg, new_cfg, options)\n            else:\n                return cfg\n\n        else:\n            return OmegaConf.merge(cfg, loaded_cfg)\n\n        assert False\n\n    @staticmethod\n    def _split_module_and_resource(filename):\n        sep = filename.find(\"/\")\n        if sep == -1:",
  "start_line": 280,
  "end_line": 320,
  "total_lines": 453,
  "is_truncated": false
}

{
  "status": "ok",
  "stdout": "201:    def _load_config_impl(self, input_file, record_load=True):\n",
  "stderr": "",
  "exit_code": 0
}

{
  "status": "ok",
  "filepath": "hydra/_internal/config_loader.py",
  "content": "\n    def _load_config_impl(self, input_file, record_load=True):\n        \"\"\"\n        :param input_file:\n        :param record_load:\n        :return: the loaded config or None if it was not found\n        \"\"\"\n        loaded_cfg = None\n        filename, search_path = self._find_config(input_file)\n        if search_path is None and record_load:\n            assert search_path is None\n            self.all_config_checked.append((filename, None, None))\n\n        if search_path is not None:\n            fullpath = \"{}/{}\".format(search_path.path, filename)\n            is_pkg = search_path.path.startswith(\"pkg://\")\n            if is_pkg:\n                fullpath = fullpath[len(\"pkg://\") :]\n                module_name, resource_name = ConfigLoader._split_module_and_resource(\n                    fullpath\n                )\n                with resource_stream(module_name, resource_name) as stream:\n                    loaded_cfg = OmegaConf.load(stream)\n                if record_load:\n                    self.all_config_checked.append(\n                        (filename, search_path.path, search_path.provider)\n                    )\n            elif os.path.exists(fullpath):\n                loaded_cfg = OmegaConf.load(fullpath)\n                if record_load:\n                    self.all_config_checked.append(\n                        (filename, search_path.path, search_path.provider)\n                    )\n            else:\n                # This should never happen because we just searched for it and found it\n                assert False, \"'{}' not found\".format(fullpath)\n        return loaded_cfg\n\n    def list_groups(self, parent_name):\n        ret = list(set(self.get_group_options(parent_name, file_type=\"dir\")))\n        return ret\n\n    def get_group_options(self, group_name, file_type=\"file\"):\n        options = []\n        for search_path in self.config_search_path.config_search_path:\n            search_path = search_path.path\n            is_pkg, path = self._split_path(search_path)\n            files = []\n            if is_pkg:\n                module_name, resource_name = ConfigLoader._split_module_and_resource(\n                    \"{}/{}\".format(path, group_name)",
  "start_line": 200,
  "end_line": 250,
  "total_lines": 453,
  "is_truncated": false
}

{
  "status": "ok",
  "stdout": "117:    def _find_config(self, filepath):\n",
  "stderr": "",
  "exit_code": 0
}

{
  "status": "ok",
  "filepath": "hydra/_internal/config_loader.py",
  "content": "    def _split_path(path):\n        prefix = \"pkg://\"\n        is_pkg = path.startswith(prefix)\n        if is_pkg:\n            path = path[len(prefix) :]\n        return is_pkg, path\n\n    def _find_config(self, filepath):\n        found_search_path = None\n        for search_path in self.config_search_path.config_search_path:\n            is_pkg, path = self._split_path(search_path.path)\n            config_file = \"{}/{}\".format(path, filepath)\n            if self._exists(is_pkg, config_file):\n                found_search_path = search_path\n                break\n        return filepath, found_search_path\n\n    @staticmethod\n    def _split_key_val(s):\n        assert \"=\" in s, \"'{}' not a valid override, expecting key=value format\".format(\n            s\n        )\n\n        idx = s.find(\"=\")\n        assert idx != -1\n        return s[0:idx], s[idx + 1 :]\n\n    @staticmethod\n    def _apply_defaults_overrides(overrides, defaults):\n        consumed = []\n        key_to_idx = {}\n        for idx, d in enumerate(defaults):\n            if isinstance(d, DictConfig):\n                key = next(iter(d.keys()))\n                key_to_idx[key] = idx\n        for override in copy.deepcopy(overrides):\n            key, value = ConfigLoader._split_key_val(override)\n            if key in key_to_idx:\n                if \",\" in value:\n                    # If this is a multirun config (comma separated list), flag the default to prevent it from being\n                    # loaded until we are constructing the config for individual jobs.\n                    value = \"_SKIP_\"\n\n                if value == \"null\":\n                    del defaults[key_to_idx[key]]\n                else:\n                    defaults[key_to_idx[key]][key] = value\n\n                overrides.remove(override)\n                consumed.append(override)\n        return consumed",
  "start_line": 110,
  "end_line": 160,
  "total_lines": 453,
  "is_truncated": false
}

{
  "status": "ok",
  "stdout": "334:    def _exists(is_pkg, filename):\n",
  "stderr": "",
  "exit_code": 0
}

{
  "status": "ok",
  "filepath": "hydra/_internal/config_loader.py",
  "content": "\n        return module_name, resource_name\n\n    @staticmethod\n    def _exists(is_pkg, filename):\n        if is_pkg:\n            module_name, resource_name = ConfigLoader._split_module_and_resource(\n                filename\n            )\n            try:\n                ret = resource_exists(module_name, resource_name)\n            except ImportError:\n                ret = False\n            except ValueError:  # Python 2.7 throws ValueError empty module name sometimes.\n                ret = False\n            except NotImplementedError:\n                raise NotImplementedError(\n                    \"Unable to load {}/{}, are you missing an __init__.py?\".format(\n                        module_name, resource_name\n                    )\n                )\n            # Uncomment to debug issues with configs not getting loaded.\n            # WARNING: breaks integration tests that relies on specified output from the process.\n            # print(\"_exists? {}, {} == {}\".format(module_name, resource_name, ret))\n            return ret\n        else:\n            return os.path.exists(filename)\n\n    def _merge_defaults(self, cfg, defaults, split_at):\n        def get_filename(config_name):\n            filename, ext = os.path.splitext(config_name)",
  "start_line": 330,
  "end_line": 360,
  "total_lines": 453,
  "is_truncated": false
}

{
  "status": "ok",
  "filepath": "hydra/_internal/config_loader.py",
  "content": "            filename, ext = os.path.splitext(config_name)\n            if ext == \"\":\n                ext = \".yaml\"\n            return \"{}{}\".format(filename, ext)\n\n        def merge_defaults(merged_cfg, def_list):\n            cfg_with_list = OmegaConf.create(dict(defaults=def_list))\n            for default1 in cfg_with_list.defaults:\n                if isinstance(default1, DictConfig):\n                    is_optional = False\n                    if default1.optional is not None:\n                        is_optional = default1.optional\n                        del default1[\"optional\"]\n                    family = next(iter(default1.keys()))\n                    name = default1[family]\n                    # Name is none if default value is removed\n                    if name is not None and \"_SKIP_\" not in name:\n                        merged_cfg = self._merge_config(\n                            cfg=merged_cfg,\n                            family=family,\n                            name=get_filename(name),\n                            required=not is_optional,\n                        )\n                else:\n                    assert isinstance(default1, str)\n                    if \"_SKIP_\" not in default1:\n                        merged_cfg = self._merge_config(\n                            cfg=merged_cfg,\n                            family=\"\",\n                            name=get_filename(default1),\n                            required=True,\n                        )\n            return merged_cfg\n\n        system_list = []\n        user_list = []\n        for default in defaults:\n            if len(system_list) < split_at:\n                system_list.append(default)\n            else:\n                user_list.append(default)",
  "start_line": 360,
  "end_line": 400,
  "total_lines": 453,
  "is_truncated": false
}

{
  "status": "error",
  "error_type": "CommandError",
  "error_message": "",
  "details": {
    "stdout": "",
    "stderr": "",
    "exit_code": 1
  }
}

{
  "status": "ok",
  "filepath": "hydra/_internal/config_loader.py",
  "content": "                            and resource_isdir(\n                                module_name, os.path.join(group_name, file)\n                            )\n                            and file != \"__pycache__\"\n                        ):\n                            files.append(file)\n                        elif file_type == \"file\" and file.endswith(\".yaml\"):\n                            files.append(file[0 : -len(\".yaml\")])\n            else:\n                group_path = \"{}/{}\".format(path, group_name)\n                if os.path.isdir(group_path):\n                    all_files = os.listdir(group_path)\n                    files = []\n                    for file in all_files:\n                        full_path = os.path.join(group_path, group_name, file)\n                        if (\n                            file_type == \"dir\"\n                            and os.path.isdir(full_path)\n                            and file != \"__pycache__\"\n                        ):\n                            files.append(file)",
  "start_line": 260,
  "end_line": 280,
  "total_lines": 453,
  "is_truncated": false
}

{
  "status": "error",
  "error_type": "CommandError",
  "error_message": "Traceback (most recent call last):\n  File \"my_app.py\", line 4, in <module>\n    @hydra.main(config_path=\"conf\", config_name=\"config\")\nTypeError: main() got an unexpected keyword argument 'config_name'\n",
  "details": {
    "stdout": "",
    "stderr": "Traceback (most recent call last):\n  File \"my_app.py\", line 4, in <module>\n    @hydra.main(config_path=\"conf\", config_name=\"config\")\nTypeError: main() got an unexpected keyword argument 'config_name'\n",
    "exit_code": 1
  }
}

{
  "status": "ok",
  "filepath": "hydra/main.py",
  "content": "# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved\nimport functools\nimport sys\nfrom ._internal.utils import run_hydra, get_args_parser\n\n\ndef main(config_path=\"\", strict=None):\n    \"\"\"\n    :param config_path: the config path, can be a directory in which it's used as the config root\n    or a file to load\n    :param strict: strict mode, will throw an error if command line overrides are not changing an\n    existing key or\n           if the code is accessing a non existent key\n    \"\"\"\n\n    def main_decorator(task_function):\n        @functools.wraps(task_function)\n        def decorated_main():\n            try:\n                run_hydra(\n                    args_parser=get_args_parser(),\n                    task_function=task_function,\n                    config_path=config_path,\n                    strict=strict,\n                )\n            except KeyboardInterrupt:\n                sys.exit(-1)\n            except SystemExit:\n                pass\n\n        return decorated_main\n\n    return main_decorator",
  "start_line": 1,
  "end_line": 33,
  "total_lines": 33,
  "is_truncated": false
}

{
  "status": "ok",
  "filepath": "hydra/_internal/utils.py",
  "content": "# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved\nimport inspect\nimport os\nimport sys\nfrom .hydra import Hydra\nimport argparse\n\n\ndef run_hydra(args_parser, task_function, config_path, strict):\n    stack = inspect.stack()\n    frame = stack[2]\n\n    calling_file = None\n    calling__module = None\n    try:\n        calling_file = frame[0].f_locals[\"__file__\"]\n    except KeyError:\n        pass\n    try:\n        module_envs = [\"HYDRA_MAIN_MODULE\", \"FB_PAR_MAIN_MODULE\", \"FB_XAR_MAIN_MODULE\"]\n        for module_env in module_envs:\n            if module_env in os.environ:\n                calling__module = os.environ[module_env]\n                break\n\n        if calling__module is None:\n            calling__module = frame[0].f_globals[frame[3]].__module__\n    except KeyError:\n        pass\n\n    hydra = Hydra(\n        calling_file=calling_file,\n        calling_module=calling__module,\n        config_path=config_path,\n        task_function=task_function,\n        strict=strict,\n    )\n\n    args = args_parser.parse_args()\n    if args.help:\n        hydra.app_help(args_parser=args_parser, args=args)\n        sys.exit(0)\n    if args.hydra_help:\n        hydra.hydra_help(args_parser=args_parser, args=args)\n        sys.exit(0)\n\n    has_show_cfg = args.cfg is not None\n    num_commands = args.run + has_show_cfg + args.multirun + args.shell_completion\n    if num_commands > 1:\n        raise ValueError(\n            \"Only one of --run, --multirun,  -cfg and --shell_completion can be specified\"\n        )\n    if num_commands == 0:\n        args.run = True\n    if args.run:\n        hydra.run(overrides=args.overrides)\n    elif args.multirun:\n        hydra.multirun(overrides=args.overrides)\n    elif args.cfg:\n        hydra.show_cfg(overrides=args.overrides, cfg_type=args.cfg)\n    elif args.shell_completion:\n        hydra.shell_completion(overrides=args.overrides)\n    else:\n        print(\"Command not specified\")\n        sys.exit(1)\n\n\ndef _get_exec_command():\n    if sys.argv[0].endswith(\".py\"):\n        return \"python {}\".format(sys.argv[0])\n    else:\n        # Running as an installed app (setuptools entry point)\n        executable = os.path.basename(sys.argv[0])\n        return executable\n\n\ndef get_args_parser():\n    from .. import __version__\n\n    parser = argparse.ArgumentParser(add_help=False, description=\"Hydra\")\n    parser.add_argument(\"--help\", \"-h\", action=\"store_true\", help=\"Application's help\")\n    parser.add_argument(\"--hydra-help\", action=\"store_true\", help=\"Hydra's help\")\n    parser.add_argument(\n        \"--version\", action=\"version\", version=\"Hydra {}\".format(__version__)\n    )\n    parser.add_argument(\n        \"overrides\",\n        nargs=\"*\",\n        help=\"Any key=value arguments to override config values (use dots for.nested=overrides)\",\n    )\n\n    parser.add_argument(\n        \"--cfg\",\n        \"-c\",\n        const=\"job\",\n        nargs=\"?\",\n        choices=[\"job\", \"hydra\", \"all\"],\n        help=\"Show config instead of running, optional value indicates which config to show (defaults to job)\",\n    )\n\n    parser.add_argument(\"--run\", \"-r\", action=\"store_true\", help=\"Run a job\")\n\n    parser.add_argument(\n        \"--multirun\",\n        \"-m\",\n        action=\"store_true\",\n        help=\"Run multiple jobs with the configured launcher\",\n    )\n\n    shell = \"SHELL_NAME\"\n    install_cmd = 'eval \"$({} -sc install={})\"'.format(_get_exec_command(), shell)\n    uninstall_cmd = 'eval \"$({} -sc uninstall={})\"'.format(_get_exec_command(), shell)\n    parser.add_argument(\n        \"--shell_completion\",\n        \"-sc\",\n        action=\"store_true\",\n        help=\"\"\"Install or Uninstall shell completion:\n    Install:\n    {}\n\n    Uninstall:\n    {}\n\"\"\".format(\n            install_cmd, uninstall_cmd\n        ),\n    )\n    return parser\n\n\ndef get_args(args=None):\n    return get_args_parser().parse_args(args=args)",
  "start_line": 1,
  "end_line": 131,
  "total_lines": 131,
  "is_truncated": false
}

{
  "status": "ok",
  "filepath": "hydra/_internal/hydra.py",
  "content": "# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved\nimport copy\nimport logging\nimport os\nimport string\nfrom collections import defaultdict\nfrom os.path import realpath, dirname, splitext, basename\n\nfrom omegaconf import open_dict, OmegaConf\n\nfrom .config_loader import ConfigLoader\nfrom .config_search_path import ConfigSearchPath\nfrom .plugins import Plugins\nfrom ..errors import MissingConfigException\nfrom ..plugins import SearchPathPlugin, Launcher, Sweeper, CompletionPlugin\nfrom ..plugins.common.utils import (\n    configure_log,\n    run_job,\n    get_valid_filename,\n    JobRuntime,\n    HydraConfig,\n    setup_globals,\n    get_overrides_dirname,\n)\n\nlog = None\n\n\nclass Hydra:\n    def __init__(\n        self, calling_file, calling_module, config_path, task_function, strict\n    ):\n        setup_globals()\n        assert calling_module is not None or calling_file is not None\n        basedir_prefix = \"\"\n        if calling_module is None:\n            # executed with python file.py\n            abs_base_dir = realpath(dirname(calling_file))\n            target_file = os.path.basename(calling_file)\n            task_name = os.path.splitext(target_file)[0]\n        else:\n            # module is installed, use pkg:// access to get configs\n            last_dot = calling_module.rfind(\".\")\n            if last_dot != -1:\n                task_name = calling_module[last_dot + 1 :]\n            else:\n                task_name = calling_module\n            basedir_prefix = \"pkg://\"\n            abs_base_dir = calling_module\n\n        task_name = get_valid_filename(task_name)\n        JobRuntime().set(\"name\", task_name)\n        self.task_name = task_name\n        self.task_function = task_function\n\n        split_file = splitext(config_path)\n        if split_file[1] in (\".yaml\", \".yml\"):\n            # assuming dir/config.yaml form\n            config_file = basename(config_path)\n            config_dir = dirname(config_path)\n        else:\n            # assuming dir form without a config file.\n            config_file = None\n            config_dir = config_path\n\n        if config_dir != \"\":\n            abs_config_dir = \"{}/{}\".format(abs_base_dir, config_dir)\n        else:\n            abs_config_dir = abs_base_dir\n\n        abs_config_dir = basedir_prefix + abs_config_dir\n\n        search_path = ConfigSearchPath()\n        search_path.append(\"hydra\", \"pkg://hydra.conf\")\n        search_path.append(\"main\", abs_config_dir)\n\n        search_path_plugins = Plugins.discover(SearchPathPlugin)\n        for spp in search_path_plugins:\n            plugin = spp()\n            plugin.manipulate_search_path(search_path)\n\n        # decide on strict mode\n        strict = self._strict_mode_strategy(strict, config_file)\n\n        self.config_loader = ConfigLoader(\n            config_file=config_file, config_search_path=search_path, strict_cfg=strict\n        )\n        if not self.config_loader.exists(abs_config_dir):\n            raise MissingConfigException(\n                missing_cfg_file=abs_config_dir,\n                message=\"Primary config dir not found: {}\".format(abs_config_dir),\n            )\n\n        if config_file is not None and not self.config_loader.exists_in_search_path(\n            config_file\n        ):\n            raise MissingConfigException(\n                missing_cfg_file=config_file,\n                message=\"Cannot find primary config file: {}\".format(config_file),\n            )\n\n    def run(self, overrides):\n        cfg = self._load_config(overrides)\n        HydraConfig().set_config(cfg)\n        with open_dict(cfg):\n            cfg.hydra.job.override_dirname = get_overrides_dirname(\n                cfg.hydra.overrides.task\n            )\n\n        return run_job(\n            config=cfg,\n            task_function=self.task_function,\n            job_dir_key=\"hydra.run.dir\",\n            job_subdir_key=None,\n        )\n\n    def multirun(self, overrides):\n        cfg = self._load_config(overrides)\n        HydraConfig().set_config(cfg)\n        sweeper = Plugins.instantiate_sweeper(\n            config=cfg,\n            config_loader=self.config_loader,\n            task_function=self.task_function,\n        )\n        task_overrides = cfg.hydra.overrides.task\n        return sweeper.sweep(arguments=task_overrides)\n\n    @staticmethod\n    def get_sanitized_hydra_cfg(src_cfg):\n        cfg = copy.deepcopy(src_cfg)\n        for key in list(cfg.keys()):\n            if key != \"hydra\":\n                del cfg[key]\n        del cfg.hydra[\"hydra_help\"]\n        del cfg.hydra[\"help\"]\n        return cfg\n\n    def show_cfg(self, overrides, cfg_type):\n        assert cfg_type in [\"job\", \"hydra\", \"all\"]\n        cfg = self._load_config(overrides)\n        if cfg_type == \"job\":\n            del cfg[\"hydra\"]\n        elif cfg_type == \"hydra\":\n            cfg = self.get_sanitized_hydra_cfg(cfg)\n        print(cfg.pretty())\n\n    @staticmethod\n    def get_shell_to_plugin_map(config_loader):\n        shell_to_plugin = defaultdict(list)\n        for clazz in Plugins.discover(CompletionPlugin):",
  "start_line": 1,
  "end_line": 150,
  "total_lines": 368,
  "is_truncated": true
}

{
  "status": "ok",
  "filepath": "hydra/_internal/config_loader.py",
  "content": "# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved\n\"\"\"\nConfiguration loader\n\"\"\"\n\nimport copy\nimport os\n\nfrom omegaconf import OmegaConf, DictConfig, ListConfig, open_dict\nfrom pkg_resources import (\n    resource_stream,\n    resource_exists,\n    resource_listdir,\n    resource_isdir,\n)\n\nfrom .config_search_path import ConfigSearchPath\nfrom ..errors import MissingConfigException\nfrom ..plugins.common.utils import JobRuntime\n\n\nclass ConfigLoader:\n    \"\"\"\n    Configuration loader\n    \"\"\"\n\n    def __init__(self, config_file, strict_cfg, config_search_path):\n        assert isinstance(config_search_path, ConfigSearchPath)\n        self.config_file = config_file\n        self.config_search_path = config_search_path\n        self.all_config_checked = []\n        self.strict_cfg = strict_cfg\n\n    def load_configuration(self, overrides=[]):\n        assert overrides is None or isinstance(overrides, list)\n        overrides = overrides or []\n\n        # Load hydra config\n        hydra_cfg = self._create_cfg(cfg_filename=\"hydra.yaml\")\n\n        # Load job config\n        job_cfg = self._create_cfg(cfg_filename=self.config_file, record_load=False)\n\n        defaults = hydra_cfg.defaults or []\n        if self.config_file is not None:\n            defaults.append(self.config_file)\n        split_at = len(defaults)\n        ConfigLoader._merge_default_lists(defaults, job_cfg.defaults or [])\n        consumed = self._apply_defaults_overrides(overrides, defaults)\n\n        consumed_free_job_defaults = self._apply_free_defaults(defaults, overrides)\n\n        ConfigLoader._validate_defaults(defaults)\n\n        # Load and defaults and merge them into cfg\n        cfg = self._merge_defaults(hydra_cfg, defaults, split_at)\n\n        job = OmegaConf.create(dict(name=JobRuntime().get(\"name\")))\n        cfg.hydra.job = OmegaConf.merge(job, cfg.hydra.job)\n\n        OmegaConf.set_struct(cfg, self.strict_cfg)\n\n        # Merge all command line overrides after enabling strict flag\n        all_consumed = consumed + consumed_free_job_defaults\n        remaining_overrides = [x for x in overrides if x not in all_consumed]\n        cfg.merge_with_dotlist(remaining_overrides)\n\n        remaining = consumed + consumed_free_job_defaults + remaining_overrides\n\n        def is_hydra(x):\n            return x.startswith(\"hydra.\") or x.startswith(\"hydra/\")\n\n        cfg.hydra.overrides.task = [x for x in remaining if not is_hydra(x)]\n        cfg.hydra.overrides.hydra = [x for x in remaining if is_hydra(x)]\n\n        return cfg\n\n    def load_sweep_config(self, master_config, sweep_overrides):\n        # Recreate the config for this sweep instance with the appropriate overrides\n        overrides = master_config.hydra.overrides.hydra.to_container() + sweep_overrides\n        sweep_config = self.load_configuration(overrides)\n\n        with open_dict(sweep_config):\n            sweep_config.hydra.runtime = master_config.hydra.runtime\n\n        # Copy old config cache to ensure we get the same resolved values (for things like timestamps etc)\n        OmegaConf.copy_cache(from_config=master_config, to_config=sweep_config)\n\n        return sweep_config\n\n    def exists_in_search_path(self, filepath):\n        _filename, search_path = self._find_config(filepath)\n        return search_path is not None\n\n    def exists(self, filename):\n        is_pkg, path = self._split_path(filename)\n        return ConfigLoader._exists(is_pkg, path)\n\n    def get_search_path(self):\n        return self.config_search_path",
  "start_line": 1,
  "end_line": 100,
  "total_lines": 453,
  "is_truncated": false
}

{
  "status": "ok",
  "stdout": "408:    def _create_cfg(self, cfg_filename, record_load=True):\n",
  "stderr": "",
  "exit_code": 0
}

{
  "status": "ok",
  "filepath": "hydra/_internal/config_loader.py",
  "content": "                            name=get_filename(name),\n                            required=not is_optional,\n                        )\n                else:\n                    assert isinstance(default1, str)\n                    if \"_SKIP_\" not in default1:\n                        merged_cfg = self._merge_config(\n                            cfg=merged_cfg,\n                            family=\"\",\n                            name=get_filename(default1),\n                            required=True,\n                        )\n            return merged_cfg\n\n        system_list = []\n        user_list = []\n        for default in defaults:\n            if len(system_list) < split_at:\n                system_list.append(default)\n            else:\n                user_list.append(default)\n        cfg = merge_defaults(cfg, system_list)\n        cfg = merge_defaults(cfg, user_list)\n\n        if \"defaults\" in cfg:\n            del cfg[\"defaults\"]\n        return cfg\n\n    def _create_cfg(self, cfg_filename, record_load=True):\n        if cfg_filename is None:\n            cfg = OmegaConf.create()\n        else:\n            cfg = self._load_config_impl(cfg_filename, record_load=record_load)\n            if cfg is None:\n                raise IOError(\n                    \"could not find {}, config path:\\n\\t\".format(\n                        cfg_filename,\n                        \"\\n\\t\".join(self.config_search_path.config_search_path),\n                    )\n                )\n        if cfg.defaults is not None:\n            self._validate_defaults(cfg.defaults)\n        return cfg\n\n    @staticmethod\n    def _validate_defaults(defaults):\n        valid_example = \"\"\"\n        Example of a valid defaults:\n        defaults:\n          - dataset: imagenet\n          - model: alexnet\n            optional: true\n          - optimizer: nesterov\n        \"\"\"\n        if not isinstance(defaults, ListConfig):\n            raise ValueError(\n                \"defaults must be a list because composition is order sensitive, \"\n                + valid_example\n            )\n\n        for default in defaults:\n            assert isinstance(default, DictConfig) or isinstance(default, str)\n            if isinstance(default, DictConfig):\n                assert len(default) in (1, 2)\n                if len(default) == 2:\n                    assert default.optional is not None and isinstance(\n                        default.optional, bool\n                    )\n                else:\n                    # optional can't be the only config key in a default\n                    assert default.optional is None, \"Missing config key\"\n            elif isinstance(default, str):\n                # single file to load\n                pass",
  "start_line": 380,
  "end_line": 453,
  "total_lines": 453,
  "is_truncated": false
}

{
  "status": "ok",
  "stdout": "201:    def _load_config_impl(self, input_file, record_load=True):\n",
  "stderr": "",
  "exit_code": 0
}

{
  "status": "ok",
  "filepath": "hydra/_internal/config_loader.py",
  "content": "    def _load_config_impl(self, input_file, record_load=True):\n        \"\"\"\n        :param input_file:\n        :param record_load:\n        :return: the loaded config or None if it was not found\n        \"\"\"\n        loaded_cfg = None\n        filename, search_path = self._find_config(input_file)\n        if search_path is None and record_load:\n            assert search_path is None\n            self.all_config_checked.append((filename, None, None))\n\n        if search_path is not None:\n            fullpath = \"{}/{}\".format(search_path.path, filename)\n            is_pkg = search_path.path.startswith(\"pkg://\")\n            if is_pkg:\n                fullpath = fullpath[len(\"pkg://\") :]\n                module_name, resource_name = ConfigLoader._split_module_and_resource(\n                    fullpath\n                )\n                with resource_stream(module_name, resource_name) as stream:\n                    loaded_cfg = OmegaConf.load(stream)\n                if record_load:\n                    self.all_config_checked.append(\n                        (filename, search_path.path, search_path.provider)\n                    )\n            elif os.path.exists(fullpath):\n                loaded_cfg = OmegaConf.load(fullpath)\n                if record_load:\n                    self.all_config_checked.append(\n                        (filename, search_path.path, search_path.provider)\n                    )\n            else:\n                # This should never happen because we just searched for it and found it\n                assert False, \"'{}' not found\".format(fullpath)\n        return loaded_cfg\n\n    def list_groups(self, parent_name):\n        ret = list(set(self.get_group_options(parent_name, file_type=\"dir\")))\n        return ret\n\n    def get_group_options(self, group_name, file_type=\"file\"):\n        options = []\n        for search_path in self.config_search_path.config_search_path:\n            search_path = search_path.path\n            is_pkg, path = self._split_path(search_path)\n            files = []\n            if is_pkg:\n                module_name, resource_name = ConfigLoader._split_module_and_resource(\n                    \"{}/{}\".format(path, group_name)",
  "start_line": 201,
  "end_line": 250,
  "total_lines": 453,
  "is_truncated": false,
  "budget_warning": "Only 10 tool call(s) remaining (20/30 used). Finalize your edits and call submit_patch soon."
}

{
  "status": "ok",
  "stdout": "117:    def _find_config(self, filepath):\n",
  "stderr": "",
  "exit_code": 0,
  "budget_warning": "Only 9 tool call(s) remaining (21/30 used). Finalize your edits and call submit_patch soon."
}

{
  "status": "ok",
  "filepath": "hydra/_internal/config_loader.py",
  "content": "    def _find_config(self, filepath):\n        found_search_path = None\n        for search_path in self.config_search_path.config_search_path:\n            is_pkg, path = self._split_path(search_path.path)\n            config_file = \"{}/{}\".format(path, filepath)\n            if self._exists(is_pkg, config_file):\n                found_search_path = search_path\n                break\n        return filepath, found_search_path\n\n    @staticmethod\n    def _split_key_val(s):\n        assert \"=\" in s, \"'{}' not a valid override, expecting key=value format\".format(\n            s\n        )\n\n        idx = s.find(\"=\")\n        assert idx != -1\n        return s[0:idx], s[idx + 1 :]\n\n    @staticmethod\n    def _apply_defaults_overrides(overrides, defaults):\n        consumed = []\n        key_to_idx = {}\n        for idx, d in enumerate(defaults):\n            if isinstance(d, DictConfig):\n                key = next(iter(d.keys()))\n                key_to_idx[key] = idx\n        for override in copy.deepcopy(overrides):\n            key, value = ConfigLoader._split_key_val(override)\n            if key in key_to_idx:\n                if \",\" in value:\n                    # If this is a multirun config (comma separated list), flag the default to prevent it from being\n                    # loaded until we are constructing the config for individual jobs.\n                    value = \"_SKIP_\"\n\n                if value == \"null\":\n                    del defaults[key_to_idx[key]]\n                else:\n                    defaults[key_to_idx[key]][key] = value\n\n                overrides.remove(override)\n                consumed.append(override)\n        return consumed\n\n    def _apply_free_defaults(self, defaults, overrides):\n        consumed = []\n        for override in overrides:\n            key, value = ConfigLoader._split_key_val(override)\n            if self.exists_in_search_path(key):\n                # Do not add multirun configs into defaults, those will be added to the defaults\n                # during the runs after list is broken into items\n                if \",\" not in value:\n                    defaults.append({key: value})\n                overrides.remove(override)\n                consumed.append(override)\n\n        return consumed\n\n    @staticmethod\n    def _merge_default_lists(primary, merged_list):\n        def get_key(d1):\n            keys_iter = iter(d1.keys())\n            key1 = next(keys_iter)",
  "start_line": 117,
  "end_line": 180,
  "total_lines": 453,
  "is_truncated": false,
  "budget_warning": "Only 8 tool call(s) remaining (22/30 used). Finalize your edits and call submit_patch soon."
}

{
  "status": "ok",
  "stdout": "334:    def _exists(is_pkg, filename):\n",
  "stderr": "",
  "exit_code": 0,
  "budget_warning": "Only 7 tool call(s) remaining (23/30 used). Finalize your edits and call submit_patch soon."
}

{
  "status": "ok",
  "filepath": "hydra/_internal/config_loader.py",
  "content": "    def _exists(is_pkg, filename):\n        if is_pkg:\n            module_name, resource_name = ConfigLoader._split_module_and_resource(\n                filename\n            )\n            try:\n                ret = resource_exists(module_name, resource_name)\n            except ImportError:\n                ret = False\n            except ValueError:  # Python 2.7 throws ValueError empty module name sometimes.\n                ret = False\n            except NotImplementedError:\n                raise NotImplementedError(\n                    \"Unable to load {}/{}, are you missing an __init__.py?\".format(\n                        module_name, resource_name\n                    )\n                )\n            # Uncomment to debug issues with configs not getting loaded.\n            # WARNING: breaks integration tests that relies on specified output from the process.\n            # print(\"_exists? {}, {} == {}\".format(module_name, resource_name, ret))\n            return ret\n        else:\n            return os.path.exists(filename)\n\n    def _merge_defaults(self, cfg, defaults, split_at):\n        def get_filename(config_name):\n            filename, ext = os.path.splitext(config_name)",
  "start_line": 334,
  "end_line": 360,
  "total_lines": 453,
  "is_truncated": false,
  "budget_warning": "Only 6 tool call(s) remaining (24/30 used). Finalize your edits and call submit_patch soon."
}

{
  "status": "ok",
  "filepath": "hydra/_internal/config_loader.py",
  "content": "            if ext == \"\":\n                ext = \".yaml\"\n            return \"{}{}\".format(filename, ext)\n\n        def merge_defaults(merged_cfg, def_list):\n            cfg_with_list = OmegaConf.create(dict(defaults=def_list))\n            for default1 in cfg_with_list.defaults:\n                if isinstance(default1, DictConfig):\n                    is_optional = False\n                    if default1.optional is not None:\n                        is_optional = default1.optional\n                        del default1[\"optional\"]\n                    family = next(iter(default1.keys()))\n                    name = default1[family]\n                    # Name is none if default value is removed\n                    if name is not None and \"_SKIP_\" not in name:\n                        merged_cfg = self._merge_config(\n                            cfg=merged_cfg,\n                            family=family,\n                            name=get_filename(name),\n                            required=not is_optional,\n                        )\n                else:\n                    assert isinstance(default1, str)\n                    if \"_SKIP_\" not in default1:\n                        merged_cfg = self._merge_config(\n                            cfg=merged_cfg,\n                            family=\"\",\n                            name=get_filename(default1),\n                            required=True,\n                        )\n            return merged_cfg\n\n        system_list = []\n        user_list = []\n        for default in defaults:\n            if len(system_list) < split_at:\n                system_list.append(default)\n            else:\n                user_list.append(default)\n        cfg = merge_defaults(cfg, system_list)\n        cfg = merge_defaults(cfg, user_list)\n\n        if \"defaults\" in cfg:\n            del cfg[\"defaults\"]\n        return cfg\n",
  "start_line": 361,
  "end_line": 407,
  "total_lines": 453,
  "is_truncated": false,
  "budget_warning": "Only 5 tool call(s) remaining (25/30 used). Finalize your edits and call submit_patch soon."
}

{
  "status": "ok",
  "filepath": "hydra/_internal/config_loader.py",
  "content": "            filename, ext = os.path.splitext(config_name)\n            if ext == \"\":\n                ext = \".yaml\"\n            return \"{}{}\".format(filename, ext)\n\n        def merge_defaults(merged_cfg, def_list):\n            cfg_with_list = OmegaConf.create(dict(defaults=def_list))\n            for default1 in cfg_with_list.defaults:\n                if isinstance(default1, DictConfig):\n                    is_optional = False\n                    if default1.optional is not None:",
  "start_line": 360,
  "end_line": 370,
  "total_lines": 453,
  "is_truncated": false,
  "budget_warning": "Only 4 tool call(s) remaining (26/30 used). Finalize your edits and call submit_patch soon."
}

{
  "status": "ok",
  "stdout": "./hydra/_internal/config_loader.py:359:        def get_filename(config_name):\n",
  "stderr": "",
  "exit_code": 0,
  "budget_warning": "Only 3 tool call(s) remaining (27/30 used). Finalize your edits and call submit_patch soon."
}

{
  "status": "error",
  "error_type": "CommandError",
  "error_message": "Traceback (most recent call last):\n  File \"<stdin>\", line 4, in <module>\nImportError: cannot import name 'HydraConfig' from 'hydra' (/workspace/hydra/__init__.py)\n",
  "details": {
    "stdout": "",
    "stderr": "Traceback (most recent call last):\n  File \"<stdin>\", line 4, in <module>\nImportError: cannot import name 'HydraConfig' from 'hydra' (/workspace/hydra/__init__.py)\n",
    "exit_code": 1
  },
  "budget_warning": "Only 2 tool call(s) remaining (28/30 used). Finalize your edits and call submit_patch soon."
}

{
  "status": "ok",
  "stdout": "Stdout: \nStderr: Traceback (most recent call last):\n  File \"temp_app.py\", line 3, in <module>\n    @hydra.main(config_path=\"conf\", config_name=\"config\")\nTypeError: main() got an unexpected keyword argument 'config_name'\n\n",
  "stderr": "",
  "exit_code": 0,
  "budget_warning": "Only 1 tool call(s) remaining (29/30 used). Finalize your edits and call submit_patch soon."
}

{
  "status": "ok",
  "stdout": "'my_config.yaml'\n'my_config.yaml'\n'0.1'\n",
  "stderr": "",
  "exit_code": 0,
  "budget_warning": "Only 0 tool call(s) remaining (30/30 used). Finalize your edits and call submit_patch soon."
}