Add files using upload-large-folder tool

testbed/facebookresearch__hydra/.circleci/config.yml

@@ -0,0 +1,277 @@
+version: 2.1
+
+jobs:
+  # Mac
+  py36_mac:
+    macos:
+      xcode: "10.0.0"
+    steps:
+      - checkout
+      - run:
+          name: "Installing Conda"
+          command: |
+            curl -o Miniconda3-latest-MacOSX-x86_64.sh https://repo.anaconda.com/miniconda/Miniconda3-latest-MacOSX-x86_64.sh
+            bash ./Miniconda3-latest-MacOSX-x86_64.sh -b
+            ~/miniconda3/bin/conda init bash
+      - run:
+          name: "Preparing environment"
+          command: |
+            brew update
+            brew install fish
+            conda create -n hydra python=3.6 -yq
+            conda run -n hydra pip install nox
+      - run:
+          name: "Testing Hydra"
+          no_output_timeout: 10m
+          command: |
+            export NOX_PYTHON_VERSIONS=3.6
+            conda activate hydra
+            pip install nox dataclasses
+            nox
+
+  py37_mac:
+    macos:
+      xcode: "10.0.0"
+    steps:
+      - checkout
+      - run:
+          name: "Installing Conda"
+          command: |
+            curl -o Miniconda3-latest-MacOSX-x86_64.sh https://repo.anaconda.com/miniconda/Miniconda3-latest-MacOSX-x86_64.sh
+            bash ./Miniconda3-latest-MacOSX-x86_64.sh -b
+            ~/miniconda3/bin/conda init bash
+      - run:
+          name: "Preparing environment"
+          command: |
+            brew update
+            brew install fish
+            conda create -n hydra python=3.7 -yq
+            conda run -n hydra pip install nox
+      - run:
+          name: "Testing Hydra"
+          no_output_timeout: 10m
+          command: |
+            export NOX_PYTHON_VERSIONS=3.7
+            conda activate hydra
+            pip install nox
+            nox
+
+  py38_mac:
+    macos:
+      xcode: "10.0.0"
+    steps:
+      - checkout
+      - run:
+          name: "Installing Conda"
+          command: |
+            curl -o Miniconda3-latest-MacOSX-x86_64.sh https://repo.anaconda.com/miniconda/Miniconda3-latest-MacOSX-x86_64.sh
+            bash ./Miniconda3-latest-MacOSX-x86_64.sh -b
+            ~/miniconda3/bin/conda init bash
+      - run:
+          name: "Preparing environment"
+          command: |
+            brew update
+            brew install fish
+            conda create -n hydra python=3.8 -yq
+            conda run -n hydra pip install nox
+      - run:
+          name: "Testing Hydra"
+          no_output_timeout: 10m
+          command: |
+            export NOX_PYTHON_VERSIONS=3.8
+            conda activate hydra
+            pip install nox
+            nox
+
+  # Linux
+  py36_linux:
+    docker:
+      - image: circleci/python:3.6
+    steps:
+      - checkout
+      - run:
+          name: "Preparing environment"
+          command: |
+            sudo apt-get update
+            sudo apt-get install -y expect fish
+            sudo pip install nox
+      - run:
+          name: "Testing Hydra"
+          command: |
+              export NOX_PYTHON_VERSIONS=3.6
+              pip install nox dataclasses
+              nox
+
+  py37_linux:
+    docker:
+      - image: circleci/python:3.7
+    steps:
+      - checkout
+      - run:
+          name: "Preparing environment"
+          command: |
+            sudo apt-get update
+            sudo apt-get install -y expect fish
+            sudo pip install nox
+      - run:
+          name: "Testing Hydra"
+          command: |
+              export NOX_PYTHON_VERSIONS=3.7
+              pip install nox
+              nox
+
+  py38_linux:
+    docker:
+      - image: circleci/python:3.8
+    steps:
+      - checkout
+      - run:
+          name: "Preparing environment"
+          command: |
+            sudo apt-get update
+            sudo apt-get install -y expect fish
+            sudo pip install nox
+      - run:
+          name: "Testing Hydra"
+          command: |
+              export NOX_PYTHON_VERSIONS=3.8
+              pip install nox
+              nox
+
+  # windows
+  py36_win:
+    executor: win/default
+    steps:
+      - checkout
+      - run:
+          name: Installing Conda
+          command: |
+            choco install miniconda3 -y
+            C:\tools\miniconda3\Scripts\conda.exe init powershell
+            choco install openssl -y
+      - run:
+          name: Preparing conda environment
+          command: |
+            conda create -n hydra python=3.6 pywin32 -qy
+            conda activate hydra
+            pip install nox dataclasses
+      - run:
+          name: Testing Hydra
+          no_output_timeout: 20m
+          command: |
+            $env:NOX_PYTHON_VERSIONS=3.6
+            $env:PYTHONIOENCODING="utf_8"
+            conda activate hydra
+            nox
+            exit $LASTEXITCODE
+
+  py37_win:
+    executor: win/default
+    steps:
+      - checkout
+      - run:
+          name: Installing Conda
+          command: |
+            choco install miniconda3 -y
+            C:\tools\miniconda3\Scripts\conda.exe init powershell
+            choco install openssl -y
+      - run:
+          name: Preparing conda environment
+          command: |
+            conda create -n hydra python=3.7 pywin32 -qy
+            conda activate hydra
+            pip install nox
+      - run:
+          name: Testing Hydra
+          no_output_timeout: 20m
+          command: |
+            $env:NOX_PYTHON_VERSIONS=3.7
+            $env:PYTHONIOENCODING="utf_8"
+            conda activate hydra
+            nox
+            exit $LASTEXITCODE
+
+  py38_win:
+    executor: win/default
+    steps:
+      - checkout
+      - run:
+          name: Installing Conda
+          command: |
+            choco install miniconda3 -y
+            C:\tools\miniconda3\Scripts\conda.exe init powershell
+            choco install openssl -y
+      - run:
+          name: Preparing conda environment
+          command: |
+            conda create -n hydra python=3.8 pywin32 -qy
+            conda activate hydra
+            pip install nox
+      - run:
+          name: Testing Hydra
+          no_output_timeout: 20m
+          command: |
+            $env:NOX_PYTHON_VERSIONS=3.8
+            $env:PYTHONIOENCODING="utf_8"
+            conda activate hydra
+            nox
+            exit $LASTEXITCODE
+  # Misc
+  coverage:
+    docker:
+      - image: circleci/python:3.6
+    steps:
+      - checkout
+      - run: sudo pip install nox
+      - run: nox -s coverage
+
+  deploy-website:
+    docker:
+      - image: circleci/node:12
+    steps:
+      - checkout
+      - deploy:
+          name: Deploying to GitHub Pages
+          command: |
+            SUBDIR=website
+            REV=$(git log -5 --pretty=oneline origin/gh-pages | grep "Deploy website" |  awk 'NF>1{print $NF}'  | head -1)
+            # This condition passes in 2 conditions:
+            # 1. The revision does not exist (squash/force push happened)
+            # 2. There are changes between last deployed revision and HEAD
+            if [[ ! $(git rev-parse --verify -q "$REV^{commit}") ||  $(git diff-index $REV -- $SUBDIR) ]]; then
+              echo "Changes detected in directory $SUBDIR between origin/master and this diff"
+
+              cd $SUBDIR
+              yarn --no-progress
+
+              git config --global user.email omry@users.noreply.github.com
+              git config --global user.name omry
+              echo "machine github.com login docusaurus-bot password $GITHUB_TOKEN" > ~/.netrc
+              yarn install && GIT_USER=docusaurus-bot yarn deploy
+            else
+              echo "No changes detected in directory $SUBDIR between origin/master and this diff"
+            fi
+
+workflows:
+  version: 2
+  build:
+    jobs:
+      # linux
+      - py36_linux
+      - py37_linux
+      - py38_linux
+      # mac
+      - py36_mac
+      - py37_mac
+      - py38_mac
+      # windows
+      - py36_win
+      - py37_win
+      - py38_win
+      - deploy-website:
+          filters:
+            branches:
+              only: master
+
+orbs:
+  win: circleci/windows@1.0.0

testbed/facebookresearch__hydra/.coveragerc

@@ -0,0 +1,16 @@
+[run]
+omit = 
+    ${COVERAGE_HOME}/.nox/*
+    ${COVERAGE_HOME}/*tests*
+    ${COVERAGE_HOME}/plugins/*
+
+[report]
+exclude_lines =
+    pragma: no cover
+    # Don't complain if tests don't hit defensive assertion code:
+    raise AssertionError
+    raise NotImplementedError
+    raise TypeError
+    @deprecated
+    assert False
+

testbed/facebookresearch__hydra/.flake8

@@ -0,0 +1,7 @@
+[flake8]
+exclude = .git,.nox,build
+max-line-length = 119
+copyright-check = True
+select = E,F,W,C
+copyright-regexp=Copyright \(c\) Facebook, Inc. and its affiliates. All Rights Reserved
+ignore=W503,E203

testbed/facebookresearch__hydra/.gitattributes

@@ -0,0 +1,29 @@
+# Auto detect text files and perform LF normalization
+* text=auto
+* text eol=lf
+
+# Don't do anything with binaries
+*.png binary
+*.jpg binary
+*.svg binary
+*.jpeg binary
+*.gif binary
+*.ico binary
+*.mov binary
+*.mp4 binary
+*.mp3 binary
+*.flv binary
+*.fla binary
+*.swf binary
+*.gz binary
+*.zip binary
+*.7z binary
+*.ttf binary
+*.eot binary
+*.woff binary
+*.pyc binary
+*.pdf binary
+*.ez binary
+*.bz2 binary
+*.swp binary
+*.webp binary

testbed/facebookresearch__hydra/.gitignore

@@ -0,0 +1,16 @@
+/.idea
+outputs
+multirun
+dist
+build
+__pycache__
+*.pyc
+*.egg-info
+/.nox
+/report.json
+/.coverage
+.mypy_cache
+pip-wheel-metadata
+.ipynb_checkpoints
+/.dmypy.json
+TODO.txt

testbed/facebookresearch__hydra/.isort.cfg

@@ -0,0 +1,10 @@
+[settings]
+multi_line_output=3
+include_trailing_comma=True
+force_grid_wrap=0
+use_parentheses=True
+line_length=88
+ensure_newline_before_comments=True
+known_third_party=omegaconf,ray,pytest,typing_extensions
+known_first_party=hydra
+skip=plugins,.nox

testbed/facebookresearch__hydra/.pre-commit-config.yaml

@@ -0,0 +1,17 @@
+repos:
+  - repo: https://github.com/timothycrosley/isort
+    rev: 'c54b3dd'
+    hooks:
+      - id: isort
+
+  - repo: https://github.com/psf/black
+    rev: stable
+    hooks:
+      - id: black
+        language_version: python3.6
+
+  - repo: https://gitlab.com/pycqa/flake8
+    rev: 3.7.9
+    hooks:
+      - id: flake8
+        additional_dependencies: [-e, "git+git://github.com/pycqa/pyflakes.git@1911c20#egg=pyflakes"]

testbed/facebookresearch__hydra/.yamllint

@@ -0,0 +1,34 @@
+yaml-files:
+  - '*.yaml'
+  - '*.yml'
+  - '.yamllint'
+
+rules:
+  braces: enable
+  brackets: enable
+  colons: enable
+  commas: enable
+  comments:
+    level: warning
+  comments-indentation:
+    level: warning
+  document-end: disable
+  document-start: disable
+  empty-lines: enable
+  empty-values: disable
+  hyphens: enable
+  indentation: enable
+  key-duplicates: enable
+  key-ordering: disable
+  line-length: disable
+  new-line-at-end-of-file: enable
+  new-lines: enable
+  octal-values: disable
+  quoted-strings: disable
+  trailing-spaces: enable
+  truthy:
+    level: warning
+
+ignore: |
+  **/.hydra/*.yaml
+  .*

testbed/facebookresearch__hydra/CHANGELOG.md

@@ -0,0 +1 @@
+Please see NEWS.rst for an updated change log

testbed/facebookresearch__hydra/CODE_OF_CONDUCT.md

@@ -0,0 +1,2 @@
+# Code of Conduct
+Facebook has adopted a Code of Conduct that we expect project participants to adhere to. Please [read the full text](https://code.fb.com/codeofconduct) so that you can understand what actions will and will not be tolerated.

testbed/facebookresearch__hydra/CONTRIBUTING.md

@@ -0,0 +1,32 @@
+# Contributing to hydra
+We want to make contributing to this project as easy and transparent as
+possible.
+
+Please see the [developer guide](https://hydra.cc/docs/development/contributing/) on the website.
+
+## Pull Requests
+We welcome your pull requests.
+
+1. Fork the repo and create your feature branch from `master`.
+2. If you've added code add suitable tests.
+3. If you've changed APIs, update the documentation.
+4. Ensure the test suite and lint pass.
+5. If you haven't already, complete the Contributor License Agreement ("CLA").
+
+## Contributor License Agreement ("CLA")
+In order to accept your pull request, we need you to submit a CLA. You only need
+to do this once to work on any of Facebook's open source projects.
+
+Complete your CLA here: <https://code.facebook.com/cla>
+
+## Issues
+We use GitHub issues to track public bugs. Please ensure your description is
+clear and has sufficient instructions to be able to reproduce the issue.
+
+Facebook has a [bounty program](https://www.facebook.com/whitehat/) for the safe
+disclosure of security bugs. In those cases, please go through the process
+outlined on that page and do not file a public issue.
+
+## License
+By contributing to hydra, you agree that your contributions will be licensed
+under the LICENSE file in the root directory of this source tree.

testbed/facebookresearch__hydra/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) Facebook, Inc. and its affiliates.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

testbed/facebookresearch__hydra/MANIFEST.in

@@ -0,0 +1,5 @@
+include hydra/py.typed
+global-exclude *.pyc
+global-exclude __pycache__
+recursive-include hydra/* *
+

testbed/facebookresearch__hydra/NEWS.md

@@ -0,0 +1,323 @@
+1.0.0-rc1 (2020-05-31)
+======================
+Hydra 1.0 is a major release introducing many new features and breaking some compatibility.
+
+Features
+--------
+- Upgrade to OmegaConf 2.0 ([Release notes](https://github.com/omry/omegaconf/releases/tag/2.0.0)) (#630)
+- Optional config type safety via Structured Configs (#629)
+- Improve command line and config composition error reporting (#349)
+- Hydra config can now be accessed through interpolation using ${hydra:key}, for example ${hydra:job.name} ([#325](https://github.com/facebookresearch/hydra/issues/325))
+- Support for setting environment variable of running job ([#7](https://github.com/facebookresearch/hydra/issues/7))
+- Changes command line processing (requiring + and ~ prefixes for appending and removing items) ([#598](https://github.com/facebookresearch/hydra/issues/598))
+- Introducing `@package` header for config files ([#586](https://github.com/facebookresearch/hydra/issues/586))
+- Add command line override flags for `config_path` and `config_name` ([#386](https://github.com/facebookresearch/hydra/issues/386))
+- hydra.main() now take an optional cfg object to passthrough to the function ([#575](https://github.com/facebookresearch/hydra/issues/575))
+- Add hydra.experimental.{initialize_with_file, initialize_with_module} ([#574](https://github.com/facebookresearch/hydra/issues/574))
+- Support for disabling the creation of the `.hydra` subdirectory by overriding "hydra.output_subdir" to "null" ([#324](https://github.com/facebookresearch/hydra/issues/324))
+- Add `hydra.utils.call()` to call methods and functions as well as instantiate objects.  Search module paths more generically. ([#498](https://github.com/facebookresearch/hydra/issues/498))
+- Add support for overriding package from command line and defaults list ([#235](https://github.com/facebookresearch/hydra/issues/235))
+- Config source is now abstracted, allowing additional config sources to be used ([#257](https://github.com/facebookresearch/hydra/issues/257))
+- New ConfigSource plugin API allowing configs to be provided by external plugins ([#367](https://github.com/facebookresearch/hydra/issues/367))
+- Add isort to ensure imports are always sorted ([#340](https://github.com/facebookresearch/hydra/issues/340))
+- Codebase is now passing mypy --strict type checking ([#342](https://github.com/facebookresearch/hydra/issues/342))
+- Improve performance of plugin discovery and instantiation ([#489](https://github.com/facebookresearch/hydra/issues/489))
+- Modules whose name starts with "_" are skipped during plugin discovery ([#494](https://github.com/facebookresearch/hydra/issues/494))
+
+Plugins
+-------
+- Add [Ax](https://ax.dev) Sweeper plugin ([Shagun Sodhani](https://shagunsodhani.com/))
+- Add [Nevergrad](https://github.com/facebookresearch/nevergrad) Sweeper plugin ([Jérémy Rapin](https://github.com/jrapin))
+- Add [Joblib](https://joblib.readthedocs.io/en/latest/) Launcher plugin ([Jan-Matthis](https://github.com/jan-matthis))
+- Add [Submitit](https://github.com/facebookincubator/submitit) Launcher plugin to launch jobs to SLURM clusters
+- Add [Fish](https://fishshell.com/) shell Tab Completion plugin ([Binsheng Liu](https://binshengliu.github.io/)) ([#549](https://github.com/facebookresearch/hydra/issues/549))
+
+API Change (Renames, deprecations and removals)
+-----------------------------------------------
+- Drop support Python 2.7 and 3.5 ([#313](https://github.com/facebookresearch/hydra/issues/313))
+- hydra.main() now takes an additional optional config_name and composite-style config_path is deprecated ([#395](https://github.com/facebookresearch/hydra/issues/395))
+- Launcher API launch method now takes an additional initial_job_idx indicating the id of the first job in the batch ([#284](https://github.com/facebookresearch/hydra/issues/284))
+- Singleton metaclass is now exposed at hydra.core.Singleton ([#371](https://github.com/facebookresearch/hydra/issues/371))
+- Moved HydraConfig from hydra.plugins.common.utils to hydra.core ([#371](https://github.com/facebookresearch/hydra/issues/371))
+- Move several formerly internal APIs to hydra/core to ensure plugins does not need to use internal APIs ([#371](https://github.com/facebookresearch/hydra/issues/371))
+- Plugin import now requires explicit name (from hydra.plugins.launcher import Launcher) ([#371](https://github.com/facebookresearch/hydra/issues/371))
+- Object Config "class" field is deprecated in favor of "cls" and will be removed in a future version. ([#389](https://github.com/facebookresearch/hydra/issues/389))
+- Experimental compose API config_file changed to config_name ([#395](https://github.com/facebookresearch/hydra/issues/395))
+- User plugins should be modified to not import twice during plugin discovery. see issue for details. ([#482](https://github.com/facebookresearch/hydra/issues/482))
+- Change hydra.core.plugins.Plugins class to a Singleton. access should be changed to the pattern Plugins.instance().foo() ([#489](https://github.com/facebookresearch/hydra/issues/489))
+- Plugins should now include test fixtures (sweep_runner, task_runner) via a standardized conftest.py ([#521](https://github.com/facebookresearch/hydra/issues/521))
+- Switch Python 3 native namespace packages for plugins (See task for details) ([#534](https://github.com/facebookresearch/hydra/issues/534))
+- Packaged configuration directories now requires an `__init__.py` at their top level ([#536](https://github.com/facebookresearch/hydra/issues/536))
+- Appending config groups to the defaults list via the command line now requires a + prefix ([#598](https://github.com/facebookresearch/hydra/issues/598))
+- Removing an item from the defaults list by assigning null (db=null) is deprecated, use ~db instead ([#598](https://github.com/facebookresearch/hydra/issues/598))
+- Installed Hydra applications no longer need have an additional `entry()` function on the stack ([#92](https://github.com/facebookresearch/hydra/issues/92))
+
+Bug Fixes
+---------
+
+- Fix a bug causing sys.exit() error code to not be propagated ([#351](https://github.com/facebookresearch/hydra/issues/351))
+- Shutdown logging subsystem aftter job finishes to ensure log files are flushed and closed ([#378](https://github.com/facebookresearch/hydra/issues/378))
+- Fix a bug with utils.instantiate() failing if params contains interpolated values. ([#388](https://github.com/facebookresearch/hydra/issues/388))
+- Allow hydra.utils.instantiate() to accept non primitive objects for passthrough by name ([#400](https://github.com/facebookresearch/hydra/issues/400))
+- Fix to work when an Hydra app is executed in Jupyter notebook using the %run command ([#481](https://github.com/facebookresearch/hydra/issues/481))
+- Plugins are no longer imported twice during plugin discovery ([#482](https://github.com/facebookresearch/hydra/issues/482))
+- to_absolute_dir(path) now converts relative path to be relative to os.cwd() when used outside of Hydra ([#496](https://github.com/facebookresearch/hydra/issues/496))
+
+Improved Documentation
+----------------------
+
+- Working examples are provided for all Hydra plugins in [plugins/examples](https://github.com/facebookresearch/hydra/tree/master/plugins/examples) ([#253](https://github.com/facebookresearch/hydra/issues/253))
+- The basic tutorial was rewritten to reflect many changes ([#602](https://github.com/facebookresearch/hydra/issues/602))
+- Add a new tutorial covering Structured Configs ([#628](https://github.com/facebookresearch/hydra/issues/628))
+
+
+0.11.3 (2019-12-29)
+===================
+
+Bug Fixes
+---------
+
+- Pin Hydra 0.11 to OmegaConf 1.4 to avoid breaking compatibility when OmegaConf 2.0 is released ([#334](https://github.com/facebookresearch/hydra/issues/334))
+
+Improved Documentation
+----------------------
+
+- Document a simple Ray example ([#317](https://github.com/facebookresearch/hydra/issues/317))
+
+
+0.11.2 (2019-12-04)
+===================
+
+Features
+--------
+
+- Change website from cli.dev to hydra.cc (#314)
+
+Bug Fixes
+---------
+
+- Fixes --cfg command line flag not working (#305)
+
+
+0.11.0 (2019-11-19)
+===================
+
+Features
+--------
+
+- Add hydra.experimental API for composing configuration on demand (hydra.experimental.compose) (#219)
+- Add hydra.utils.get_original_cwd() to access original working directory and hydra.utils.to_absolute_path() to convert a path to absolute path (#251)
+- Change hydra logging format pattern, example: "[2019-10-22 16:13:10,769][HYDRA] Installed Hydra Plugins" (#254)
+- Change --cfg to require config type (one of 'job', 'hydra' or 'all') (#270)
+- Upgrade to OmegaConf 1.4.0, see full change log [here](https://github.com/omry/omegaconf/releases/tag/1.4.0) (#280)
+- Experimental support for Jupyter notebooks via compose API (#281)
+- Allow configuring override_dirname via hydra.job.config.override_dirname to exclude specific keys or change separator characters (#95)
+
+Bug Fixes
+---------
+
+- Fix a bug that caused out of order composition when mixing config-groups with non-config-group in the defaults block (#261)
+- Allow '=' to be used in the value of an override, eg. foo=bar=10 (key foo, value bar=10). (#266)
+- Allow composing config files with dot in their name (foo.bar.yaml) (#271)
+
+Plugins
+-------
+
+- hydra-colorlog plugin adds colored log output.
+
+Improved Documentation
+----------------------
+
+- Document utils.get_original_cwd() and utils.to_absolute_path("foo") (#251)
+
+
+0.10.0 (2019-10-19)
+===================
+
+Configuration structure changes
+-------------------------------
+
+- Change the default sweep subdir from ${hydra.job.num}_${hydra.job.id} to ${hydra.job.num} (#150)
+
+Features
+--------
+
+- App help now contains config groups and generated config
+  App help can now be customized
+  Hydra help is now available via --hydra-help (#1)
+- Simplify install and uninstall commands for tab completion (#200)
+- hydra.runtime.cwd now contains the original working directory the app was launched from (#244)
+
+Bug Fixes
+---------
+
+- Fix an error with tab completion that occurred when a TAB was pressed after two spaces (#203)
+- Fix a bug when sweeping over groups that are used in an interpolation in defaults (#206)
+- Fix tab completion for cases where app name looks like foo.par (#213)
+
+Improved Documentation
+----------------------
+
+- Describe news fragment types in more details in development/contributing (#150)
+- Examples dir now mirrors the structure of the website docs (#209)
+
+
+0.9.0 (2019-10-01)
+==================
+
+Deprecations and Removals
+-------------------------
+
+- Old demos directory was removed and a new tutorial directory as added (#167)
+
+Features
+--------
+
+- Make strict mode the default when a config file is specified directly (#150)
+- Replace --verbose with a standard override (hydra.verbose) (#161)
+- Add IntegrationTestSuite to test_utils for testing Launcher plugins (#168)
+- Add support for specifying which config to print in -c, options are job (default), hydra or all. (#176)
+- Hydra is now hosted on https://cli.dev! (#75)
+- Move all Hydra configuration files to a subfolder (.hydra by default) under the output folder (#77)
+
+Bug Fixes
+---------
+
+- Fix a bug in tab completion of missing mandatory values. (#145)
+- Fix a bug with multirun overriding free config groups (not in defaults) when strict mode is enabled (#181)
+- Fix a bug that prevented sweeping over an unspecified ('???') default group (#187)
+
+Improved Documentation
+----------------------
+
+- Updated the primary tutorial on the web site and added a brand new tutorial directory (#58)
+- Documented debugging methods in website (#6)
+
+
+0.1.5 (2019-09-22)
+==================
+
+Deprecations and Removals
+-------------------------
+
+- Move FAIRTask, Submititit and FAIR-cluster-defaults plugins to fairinternal/hydra-fair-plugins repository (#138)
+- Remove Fairtask and Submitit example configs from demos as they are no longer needed (#146)
+
+Features
+--------
+
+- Created hydra-core pip package, Hydra can now installed with 'pip install hydra-core' (#143)
+- Finalized submitit support (#18)
+
+Plugins
+-------
+
+- Add default launcher config for Fairtask and Submitit launcher plugins
+
+
+0.1.4 (2019-09-18)
+==================
+
+Features
+--------
+
+- hydra.utils.instantiate() can now take an additional optional kwargs dictionary to pass to constructor of the instantiated object (#142)
+- Initial support for bash completion, see documentation for details (#8)
+
+Bug Fixes
+---------
+
+- Fixed Town Crier to generate correct links to issues in generated news file. (#122)
+- Fixed bug with overriding hydra defaults from user config file. (#123)
+- Fixed Singletons not getting serialized to remote jobs. (#128)
+- Fixed a bug that prevented using submitit in strict mode (#129)
+- Fixed example submitit config to set the job name (#133)
+
+
+0.1.3 (2019-09-02)
+==================
+
+Configuration structure changes
+-------------------------------
+
+- Changed Hydra core defaults to be more appropriate for open source use. To get the FAIR cluster defaults install the fair_cluster plugin (#103)
+- Changed output directories default to group by day (output/DAY/TIME instead of output/DAY_TIME) (#121)
+
+Features
+--------
+
+- Added the ability to prevent a default from being merged it by assigning null to it (hydra/launcher=null) (#106)
+- Implemented Plugin discovery mechanism, this can be used to find all installed plugins that implement a specific interface (#119)
+- Implemented an API to for manipulating the config search path (#120)
+
+Bug Fixes
+---------
+
+- Fixed config loading to properly support the use case in demos/8_specializing_config (#104)
+- Fixed error message when the user config contains defaults that is a mapping and not a list (#107)
+- Fixed config loading order to allow properly overriding Hydra config groups from user config (#115)
+
+Plugins
+-------
+
+- New plugin: fair_cluster
+  Change Hydra defaults to be appropriate for the FAIR cluster
+
+Improved Documentation
+----------------------
+
+- Initial search path and plugins documentation (#103)
+
+
+0.1.2 (2019-08-26)
+==================
+
+Deprecations and Removals
+-------------------------
+
+- Hydra config groups were moved to the hydra/namespace (#101)
+- Removed support for .hydra directory, Hydra can be configured directly from the job config. (#91)
+
+Bug Fixes
+---------
+
+- Config loading rewrite fixed #88 (#88)
+
+
+0.1.1 (2019-08-22)
+==================
+
+Deprecations and Removals
+-------------------------
+
+- Move non-public APIs into hydra._internal:
+    - Moved non-API code into hydra._interanl to flag it as private.
+    - Moved plugin interfaces into hydra.plugins.
+    - Moved code meant to be used by plugins to hydra.plugins.common. (#78)
+
+Features
+--------
+
+- Integrated towncrier to bring you this news! (#45)
+- Hydra is now compatible with Windows (#63)
+- Hydra apps can now be packaged and installed along with their configuration files. (#87)
+
+Bug Fixes
+---------
+
+- It is now possible to use ${override_dirname} in the output directory of a local job (#31)
+- Override_dirname separator changed from : to =, for example: foo/a:10,b:10 => foo/a=10,b=10 (#63)
+- Fixed automatic detection of missing copyright headers (#72)
+- fixed a bug that caused an empty config to be returned if specifed config file did not have a .yaml extension. (#80)
+- Multi change diff:
+    - Logging config search path in verbose logging to assist debugging of config load issues
+    - Saving hydra.yaml into the job dir to assist debugging hydra issues
+    - Fixed a bug caused by fairtask logging change
+    - Improved integration-tests debuggability by switching hydra to debug logging in them
+    - Added selective plugin testing to nox using env, for example PLUGINS=fairtask would only test fairtask. (#87)
+
+Improved Documentation
+----------------------
+
+- Improved the contributing docs (#45)
+- Documented Hydra app packaging under Deployment/Application packaging (#87)

testbed/facebookresearch__hydra/README.md

@@ -0,0 +1,49 @@
+[![PyPI](https://img.shields.io/pypi/v/hydra-core)](https://pypi.org/project/hydra-core/)
+[![CircleCI](https://img.shields.io/circleci/build/github/facebookresearch/hydra?token=af199cd2deca9e70e53776f9ded96284b10687e9)](https://circleci.com/gh/facebookresearch/hydra)
+![PyPI - License](https://img.shields.io/pypi/l/hydra-core)
+![PyPI - Python Version](https://img.shields.io/pypi/pyversions/hydra-core)
+[![Downloads](https://pepy.tech/badge/hydra-core/month)](https://pepy.tech/project/hydra-core/month?versions=0.11.*&versions=1.0.*)
+[![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
+[![Total alerts](https://img.shields.io/lgtm/alerts/g/facebookresearch/hydra.svg?logo=lgtm&logoWidth=18)](https://lgtm.com/projects/g/facebookresearch/hydra/alerts/)
+[![Language grade: Python](https://img.shields.io/lgtm/grade/python/g/facebookresearch/hydra.svg?logo=lgtm&logoWidth=18)](https://lgtm.com/projects/g/facebookresearch/hydra/context:python)
+[![](https://img.shields.io/badge/zulip-join_chat-brightgreen.svg)](https://hydra-framework.zulipchat.com)
+
+# Hydra
+A framework for elegantly configuring complex applications.
+
+Check the [website](https://hydra.cc/) for more information.
+
+### Releases
+#### Stable
+**Hydra 0.11** is the stable version of Hydra.
+- [Documentation](https://hydra.cc/docs/intro)
+- Installation : `pip install hydra-core --upgrade`
+
+#### Release candidate
+**Hydra 1.0** is the next major version of Hydra. It is currently a release candidate.  
+Please report any issues.
+- [Release notes](https://github.com/facebookresearch/hydra/releases/tag/hydra-1.0.0rc1)
+- [Documentation](https://hydra.cc/docs/next/intro)
+- Installation : `pip install hydra-core --upgrade --pre`
+
+### License
+Hydra is licensed under [MIT License](LICENSE).
+
+## Community
+Ask questions in the chat or StackOverflow (Use the tag #fb-hydra or #omegaconf):
+* [Chat](https://hydra-framework.zulipchat.com)
+* [StackOverflow](https://stackexchange.com/filters/391828/hydra-questions)
+* [Twitter](https://twitter.com/Hydra_Framework)
+
+
+### Citing Hydra
+If you use Hydra in your research please use the following BibTeX entry:
+```text
+@Misc{,
+  author =       {Omry Yadan},
+  title =        {A framework for elegantly configuring complex applications},
+  howpublished = {Github},
+  year =         {2019},
+  url =          {https://github.com/facebookresearch/hydra}
+}
+```

testbed/facebookresearch__hydra/extra/hydra-pytest-plugin/MANIFEST.in

@@ -0,0 +1,3 @@
+include hydra_pytest_plugin/py.typed
+global-exclude *.pyc
+global-exclude __pycache__

testbed/facebookresearch__hydra/extra/hydra-pytest-plugin/README.md

@@ -0,0 +1,5 @@
+# Hydra pytest plugin
+
+This plugin adds common Hydra related pytest fixtures.
+
+NOTE: The fixtures are currently experimental are likely to change with a future version of Hydra.

testbed/facebookresearch__hydra/extra/hydra-pytest-plugin/hydra_pytest_plugin/__init__.py

@@ -0,0 +1,88 @@
+# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved
+# Source of truth for version
+__version__ = "1.0.0rc1"
+import copy
+from typing import Callable, List, Optional
+
+import pytest
+
+from hydra.core.singleton import Singleton
+from hydra.test_utils.test_utils import SweepTaskFunction, TaskTestFunction
+from hydra.types import TaskFunction
+
+
+@pytest.fixture(scope="function")  # type: ignore
+def hydra_restore_singletons() -> None:
+    """
+    Restore singletons state after the function returns
+    """
+    state = copy.deepcopy(Singleton.get_state())
+    yield
+    Singleton.set_state(state)
+
+
+@pytest.fixture(scope="function")  # type: ignore
+def hydra_sweep_runner() -> Callable[
+    [
+        Optional[str],
+        Optional[str],
+        Optional[TaskFunction],
+        Optional[str],
+        Optional[str],
+        Optional[List[str]],
+        Optional[bool],
+    ],
+    SweepTaskFunction,
+]:
+    def _(
+        calling_file: Optional[str],
+        calling_module: Optional[str],
+        task_function: Optional[TaskFunction],
+        config_path: Optional[str],
+        config_name: Optional[str],
+        overrides: Optional[List[str]],
+        strict: Optional[bool] = None,
+    ) -> SweepTaskFunction:
+        sweep = SweepTaskFunction()
+        sweep.calling_file = calling_file
+        sweep.calling_module = calling_module
+        sweep.task_function = task_function
+        sweep.config_path = config_path
+        sweep.config_name = config_name
+        sweep.strict = strict
+        sweep.overrides = overrides or []
+        return sweep
+
+    return _
+
+
+@pytest.fixture(scope="function")  # type: ignore
+def hydra_task_runner() -> Callable[
+    [
+        Optional[str],
+        Optional[str],
+        Optional[str],
+        Optional[str],
+        Optional[List[str]],
+        Optional[bool],
+    ],
+    TaskTestFunction,
+]:
+    def _(
+        calling_file: Optional[str],
+        calling_module: Optional[str],
+        config_path: Optional[str],
+        config_name: Optional[str],
+        overrides: Optional[List[str]] = None,
+        strict: Optional[bool] = None,
+    ) -> TaskTestFunction:
+        task = TaskTestFunction()
+        task.overrides = overrides or []
+        task.calling_file = calling_file
+        task.config_name = config_name
+        task.calling_module = calling_module
+        task.config_path = config_path
+        task.strict = strict
+        return task
+
+    return _

testbed/facebookresearch__hydra/extra/hydra-pytest-plugin/setup.py

@@ -0,0 +1,35 @@
+# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved
+import codecs
+import os
+import re
+
+from setuptools import find_packages, setup
+
+
+def find_version(*file_paths):
+    here = os.path.abspath(os.path.dirname(__file__))
+    with codecs.open(os.path.join(here, *file_paths), "r") as fp:
+        version_file = fp.read()
+    version_match = re.search(r"^__version__ = ['\"]([^'\"]*)['\"]", version_file, re.M)
+    if version_match:
+        return version_match.group(1)
+    raise RuntimeError("Unable to find version string.")
+
+
+with open("README.md", "r") as fh:
+    LONG_DESC = fh.read()
+    setup(
+        name="hydra-pytest-plugin",
+        version=find_version("hydra_pytest_plugin", "__init__.py"),
+        author="Omry Yadan",
+        author_email="omry@fb.com",
+        description="Hydra pytest plugin",
+        long_description=LONG_DESC,
+        long_description_content_type="text/markdown",
+        url="https://github.com/facebookresearch/hydra/",
+        packages=find_packages(include=["hydra_pytest_plugin"]),
+        classifiers=["License :: OSI Approved :: MIT License", "Framework :: Pytest"],
+        install_requires=["hydra-core~=1.0.0rc1"],
+        # the following makes a plugin available to pytest
+        entry_points={"pytest11": ["name_of_plugin = hydra_pytest_plugin"]},
+    )

testbed/facebookresearch__hydra/lgtm.yml

@@ -0,0 +1,2 @@
+queries:
+  - exclude: py/import-own-module

testbed/facebookresearch__hydra/noxfile.py

@@ -0,0 +1,379 @@
+# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved
+# type: ignore
+import copy
+import os
+import platform
+from dataclasses import dataclass
+from typing import List
+
+import nox
+from nox.logger import logger
+
+BASE = os.path.abspath(os.path.dirname(__file__))
+
+DEFAULT_PYTHON_VERSIONS = ["3.6", "3.7", "3.8"]
+DEFAULT_OS_NAMES = ["Linux", "MacOS", "Windows"]
+
+PYTHON_VERSIONS = os.environ.get(
+    "NOX_PYTHON_VERSIONS", ",".join(DEFAULT_PYTHON_VERSIONS)
+).split(",")
+
+PLUGINS_INSTALL_COMMANDS = (["pip", "install"], ["pip", "install", "-e"])
+
+# Allow limiting testing to specific plugins
+# The list ['ALL'] indicates all plugins
+PLUGINS = os.environ.get("PLUGINS", "ALL").split(",")
+
+SKIP_CORE_TESTS = "0"
+SKIP_CORE_TESTS = os.environ.get("SKIP_CORE_TESTS", SKIP_CORE_TESTS) != "0"
+FIX = os.environ.get("FIX", "0") == "1"
+VERBOSE = os.environ.get("VERBOSE", "0")
+SILENT = VERBOSE == "0"
+
+
+@dataclass
+class Plugin:
+    name: str
+    path: str
+    module: str
+
+
+def get_current_os() -> str:
+    current_os = platform.system()
+    if current_os == "Darwin":
+        current_os = "MacOS"
+    return current_os
+
+
+print(f"Operating system\t:\t{get_current_os()}")
+print(f"NOX_PYTHON_VERSIONS\t:\t{PYTHON_VERSIONS}")
+print(f"PLUGINS\t\t\t:\t{PLUGINS}")
+print(f"SKIP_CORE_TESTS\t\t:\t{SKIP_CORE_TESTS}")
+print(f"FIX\t\t\t:\t{FIX}")
+print(f"VERBOSE\t\t\t:\t{VERBOSE}")
+
+
+def _upgrade_basic(session):
+    session.run(
+        "python",
+        "-m",
+        "pip",
+        "install",
+        "--upgrade",
+        "setuptools",
+        "pip",
+        silent=SILENT,
+    )
+
+
+def find_python_files_for_mypy(folder):
+    exclude_list = [""]
+
+    def excluded(file: str) -> bool:
+        for exclude in exclude_list:
+            if file.startswith(exclude):
+                return True
+        return False
+
+    for root, folders, files in os.walk(folder):
+        for filename in folders + files:
+            if filename.endswith(".py"):
+                if excluded(filename):
+                    yield os.path.join(root, filename)
+
+
+def install_hydra(session, cmd):
+    # clean install hydra
+    session.chdir(BASE)
+    session.run(*cmd, ".", silent=SILENT)
+    session.run(*cmd, "extra/hydra-pytest-plugin", silent=SILENT)
+    if not SILENT:
+        session.install("pipdeptree", silent=SILENT)
+        session.run("pipdeptree", "-p", "hydra-core")
+
+
+def pytest_args(session, *args):
+    ret = ["pytest", "-Werror"]
+    ret.extend(args)
+    if len(session.posargs) > 0:
+        ret.extend(session.posargs)
+    return ret
+
+
+def run_pytest(session, directory=".", *args):
+    pytest_cmd = pytest_args(session, directory, *args)
+    session.run(*pytest_cmd, silent=SILENT)
+
+
+def get_setup_python_versions(classifiers):
+    pythons = filter(lambda line: "Programming Language :: Python" in line, classifiers)
+    return [p[len("Programming Language :: Python :: ") :] for p in pythons]
+
+
+def get_plugin_os_names(classifiers: List[str]) -> List[str]:
+    oses = list(filter(lambda line: "Operating System" in line, classifiers))
+    if len(oses) == 0:
+        # No Os is specified so all oses are supported
+        return DEFAULT_OS_NAMES
+    if len(oses) == 1 and oses[0] == "Operating System :: OS Independent":
+        # All oses are supported
+        return DEFAULT_OS_NAMES
+    else:
+        return [p.split("::")[-1].strip() for p in oses]
+
+
+def select_plugins(session) -> List[Plugin]:
+    """
+    Select all plugins that should be tested in this session.
+    Considers the current Python version and operating systems against the supported ones,
+    as well as the user plugins selection (via the PLUGINS environment variable).
+    """
+
+    assert session.python is not None, "Session python version is not specified"
+    blacklist = [".isort.cfg"]
+    example_plugins = [
+        {"dir_name": x, "path": f"examples/{x}"}
+        for x in sorted(os.listdir(os.path.join(BASE, "plugins/examples")))
+        if x not in blacklist
+    ]
+    plugins = [
+        {"dir_name": x, "path": x}
+        for x in sorted(os.listdir(os.path.join(BASE, "plugins")))
+        if x != "examples"
+        if x not in blacklist
+    ]
+    available_plugins = plugins + example_plugins
+
+    ret = []
+    skipped = []
+    for plugin in available_plugins:
+        if not (plugin["dir_name"] in PLUGINS or PLUGINS == ["ALL"]):
+            skipped.append(f"Deselecting {plugin['dir_name']}: User request")
+            continue
+
+        setup_py = os.path.join(BASE, "plugins", plugin["path"], "setup.py")
+        classifiers = session.run(
+            "python", setup_py, "--name", "--classifiers", silent=True
+        ).splitlines()
+        plugin_name = classifiers.pop(0)
+        plugin_python_versions = get_setup_python_versions(classifiers)
+        python_supported = session.python in plugin_python_versions
+
+        plugin_os_names = get_plugin_os_names(classifiers)
+        os_supported = get_current_os() in plugin_os_names
+
+        if not python_supported:
+            py_str = ", ".join(plugin_python_versions)
+            skipped.append(
+                f"Deselecting {plugin['dir_name']} : Incompatible Python {session.python}. Supports [{py_str}]"
+            )
+            continue
+
+        # Verify this plugin supports the OS we are testing on, skip otherwise
+        if not os_supported:
+            os_str = ", ".join(plugin_os_names)
+            skipped.append(
+                f"Deselecting {plugin['dir_name']}: Incompatible OS {get_current_os()}. Supports [{os_str}]"
+            )
+            continue
+
+        ret.append(
+            Plugin(
+                name=plugin_name,
+                path=plugin["path"],
+                module="hydra_plugins." + plugin["dir_name"],
+            )
+        )
+
+    for msg in skipped:
+        logger.warn(msg)
+
+    if len(ret) == 0:
+        logger.warn("No plugins selected")
+    return ret
+
+
+def install_lint_deps(session):
+    _upgrade_basic(session)
+    session.run("pip", "install", "-r", "requirements/dev.txt", silent=SILENT)
+    session.run("pip", "install", "-e", ".", silent=SILENT)
+
+
+@nox.session(python=PYTHON_VERSIONS)
+def lint(session):
+    install_lint_deps(session)
+    install_hydra(session, ["pip", "install", "-e"])
+    session.run("black", "--check", ".", silent=SILENT)
+    session.run(
+        "isort",
+        "--check",
+        "--diff",
+        ".",
+        "--skip=plugins",
+        "--skip=.nox",
+        silent=SILENT,
+    )
+    session.run("mypy", ".", "--strict", silent=SILENT)
+    session.run("flake8", "--config", ".flake8")
+    session.run("yamllint", ".")
+    # Mypy for examples
+    for pyfile in find_python_files_for_mypy("examples"):
+        session.run("mypy", pyfile, "--strict", silent=SILENT)
+
+
+@nox.session(python=PYTHON_VERSIONS)
+def lint_plugins(session):
+
+    install_cmd = ["pip", "install", "-e"]
+    install_hydra(session, install_cmd)
+    plugins = select_plugins(session)
+
+    # plugin linting requires the plugins and their dependencies to be installed
+    for plugin in plugins:
+        cmd = install_cmd + [os.path.join("plugins", plugin.path)]
+        session.run(*cmd, silent=SILENT)
+
+    install_lint_deps(session)
+
+    session.run("flake8", "--config", ".flake8", "plugins")
+    # Mypy for plugins
+    for plugin in plugins:
+        session.chdir(os.path.join("plugins", plugin.path))
+        blackcmd = ["black", "."]
+        isortcmd = ["isort", "."]
+        if not FIX:
+            blackcmd += ["--check"]
+            isortcmd += ["--check", "--diff"]
+        session.run(*blackcmd, silent=SILENT)
+        session.run(*isortcmd, silent=SILENT)
+        session.chdir(BASE)
+
+    session.run("mypy", ".", "--strict", silent=SILENT)
+
+
+@nox.session(python=PYTHON_VERSIONS)
+@nox.parametrize(
+    "install_cmd",
+    PLUGINS_INSTALL_COMMANDS,
+    ids=[" ".join(x) for x in PLUGINS_INSTALL_COMMANDS],
+)
+def test_core(session, install_cmd):
+    _upgrade_basic(session)
+    install_hydra(session, install_cmd)
+    session.install("pytest")
+
+    run_pytest(session, "tests")
+
+    # test discovery_test_plugin
+    run_pytest(session, "tests/test_plugins/discovery_test_plugin", "--noconftest")
+
+    # run namespace config loader tests
+    run_pytest(session, "tests/test_plugins/namespace_pkg_config_source_test")
+
+    # Install and test example app
+    session.chdir(f"{BASE}/examples/advanced/hydra_app_example")
+    session.run(*install_cmd, ".", silent=SILENT)
+    run_pytest(session, ".")
+
+
+@nox.session(python=PYTHON_VERSIONS)
+@nox.parametrize(
+    "install_cmd",
+    PLUGINS_INSTALL_COMMANDS,
+    ids=[" ".join(x) for x in PLUGINS_INSTALL_COMMANDS],
+)
+def test_plugins(session, install_cmd):
+    _upgrade_basic(session)
+    session.install("pytest")
+    install_hydra(session, install_cmd)
+    selected_plugin = select_plugins(session)
+    for plugin in selected_plugin:
+        cmd = list(install_cmd) + [os.path.join("plugins", plugin.path)]
+        session.run(*cmd, silent=SILENT)
+        if not SILENT:
+            session.run("pipdeptree", "-p", plugin.name)
+
+    # Test that we can import Hydra
+    session.run("python", "-c", "from hydra import main", silent=SILENT)
+
+    # Test that we can import all installed plugins
+    for plugin in selected_plugin:
+        session.run("python", "-c", f"import {plugin.module}")
+
+    # Run Hydra tests to verify installed plugins did not break anything
+    if not SKIP_CORE_TESTS:
+        run_pytest(session, "tests")
+    else:
+        session.log("Skipping Hydra core tests")
+
+    # Run tests for all installed plugins
+    for plugin in selected_plugin:
+        # install all other plugins that are compatible with the current Python version
+        session.chdir(os.path.join(BASE, "plugins", plugin.path))
+        run_pytest(session)
+
+
+@nox.session(python="3.8")
+def coverage(session):
+    coverage_env = {
+        "COVERAGE_HOME": BASE,
+        "COVERAGE_FILE": f"{BASE}/.coverage",
+        "COVERAGE_RCFILE": f"{BASE}/.coveragerc",
+    }
+
+    _upgrade_basic(session)
+    session.install("coverage", "pytest")
+    install_hydra(session, ["pip", "install", "-e"])
+    session.run("coverage", "erase")
+
+    selected_plugins = select_plugins(session)
+    for plugin in selected_plugins:
+        session.run(
+            "pip", "install", "-e", os.path.join("plugins", plugin.path), silent=SILENT,
+        )
+
+    session.run("coverage", "erase", env=coverage_env)
+    # run plugin coverage
+    for plugin in selected_plugins:
+        session.chdir(os.path.join("plugins", plugin.path))
+        cov_args = ["coverage", "run", "--append", "-m"]
+        cov_args.extend(pytest_args(session))
+        session.run(*cov_args, silent=SILENT, env=coverage_env)
+        session.chdir(BASE)
+
+    # run hydra-core coverage
+    session.run(
+        "coverage",
+        "run",
+        "--append",
+        "-m",
+        silent=SILENT,
+        env=coverage_env,
+        *pytest_args(session),
+    )
+
+    # Increase the fail_under as coverage improves
+    session.run("coverage", "report", "--fail-under=80", env=coverage_env)
+    session.run("coverage", "erase", env=coverage_env)
+
+
+@nox.session(python=PYTHON_VERSIONS)
+def test_jupyter_notebooks(session):
+    versions = copy.copy(DEFAULT_PYTHON_VERSIONS)
+    if session.python not in versions:
+        session.skip(
+            f"Not testing Jupyter notebook on Python {session.python}, supports [{','.join(versions)}]"
+        )
+    # pyzmq 19.0.1 has installation issues on Windows
+    session.install("jupyter", "nbval", "pyzmq==19.0.0")
+    install_hydra(session, ["pip", "install", "-e"])
+    args = pytest_args(
+        session, "--nbval", "examples/notebook/hydra_notebook_example.ipynb"
+    )
+    # Jupyter notebook test on Windows yield warnings
+    args = [x for x in args if x != "-Werror"]
+    session.run(*args, silent=SILENT)
+
+    args = pytest_args(session, "--nbval", "examples/notebook/%run_test.ipynb")
+    args = [x for x in args if x != "-Werror"]
+    session.run(*args, silent=SILENT)

testbed/facebookresearch__hydra/pyproject.toml

@@ -0,0 +1,49 @@
+[tool.towncrier]
+    package = "hydra"
+    package_dir = ""
+    filename = "NEWS.md"
+    directory = "news/"
+    title_format = "{version} ({project_date})"
+    template = "news/_template.rst"
+    issue_format = "[#{issue}](https://github.com/facebookresearch/hydra/issues/{issue})"
+    start_string = "<!-- TOWNCRIER -->\n"
+
+  [[tool.towncrier.type]]
+  directory = "feature"
+  name = "Features"
+  showcontent = true
+
+  [[tool.towncrier.type]]
+  directory = "api_change"
+  name = "API Change (Renames, deprecations and removals)"
+  showcontent = true
+
+  [[tool.towncrier.type]]
+  directory = "bugfix"
+  name = "Bug Fixes"
+  showcontent = true
+
+  [[tool.towncrier.type]]
+  directory = "plugin"
+  name = "Plugins"
+  showcontent = true
+
+  [[tool.towncrier.type]]
+  directory = "config"
+  name = "Configuration structure changes"
+  showcontent = true
+
+  [[tool.towncrier.type]]
+  directory = "docs"
+  name = "Improved Documentation"
+  showcontent = true
+
+  [[tool.towncrier.type]]
+  directory = "trivial"
+  name = "Trivial Changes"
+  showcontent = false
+
+  [[tool.towncrier.type]]
+  directory = "maintenance"
+  name = "Maintenance Changes"
+  showcontent = true

testbed/facebookresearch__hydra/pytest.ini

@@ -0,0 +1,8 @@
+[pytest]
+# reasons for excludes:
+# 	.nox: large and irrelevant
+# 	plugins: tested separately
+# 	examples: contains the test for the example app, tested separately (app needs to be installed first)
+#	website: No python code
+#   tests/test_plugins : tested separately
+norecursedirs = .nox plugins examples website tests/test_plugins build

testbed/facebookresearch__hydra/setup.cfg

@@ -0,0 +1,3 @@
+[mypy]
+python_version = 3.6
+mypy_path=.stubs

testbed/facebookresearch__hydra/setup.py

@@ -0,0 +1,115 @@
+# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved
+# type: ignore
+import codecs
+import os
+import pathlib
+import re
+import shutil
+from distutils import cmd
+from os.path import exists, isdir, join
+from typing import Any, List
+
+import pkg_resources
+from setuptools import find_packages, setup
+
+
+def find_version(*file_paths):
+    here = os.path.abspath(os.path.dirname(__file__))
+    with codecs.open(os.path.join(here, *file_paths), "r") as fp:
+        version_file = fp.read()
+    version_match = re.search(r"^__version__ = ['\"]([^'\"]*)['\"]", version_file, re.M)
+    if version_match:
+        return version_match.group(1)
+    raise RuntimeError("Unable to find version string.")
+
+
+with pathlib.Path("requirements/requirements.txt").open() as requirements_txt:
+    install_requires = [
+        str(requirement)
+        for requirement in pkg_resources.parse_requirements(requirements_txt)
+    ]
+
+
+class CleanCommand(cmd.Command):
+    """
+    Our custom command to clean out junk files.
+    """
+
+    description = "Cleans out junk files we don't want in the repo"
+    user_options: List[Any] = []
+
+    def initialize_options(self):
+        pass
+
+    def finalize_options(self):
+        pass
+
+    @staticmethod
+    def find(root, includes, excludes=[]):
+        res = []
+        for parent, dirs, files in os.walk(root):
+            for f in dirs + files:
+                add = list()
+                for include in includes:
+                    if re.findall(include, f):
+                        add.append(join(parent, f))
+                res.extend(add)
+        final_list = []
+        # Exclude things that matches an exclude pattern
+        for ex in excludes:
+            for file in res:
+                if not re.findall(ex, file):
+                    final_list.append(file)
+        return final_list
+
+    def run(self):
+        delete_patterns = [
+            ".eggs",
+            ".egg-info",
+            ".pytest_cache",
+            "build",
+            "dist",
+            "__pycache__",
+            ".pyc",
+        ]
+        deletion_list = CleanCommand.find(
+            ".", includes=delete_patterns, excludes=["\\.nox/.*"]
+        )
+
+        for f in deletion_list:
+            if exists(f):
+                if isdir(f):
+                    shutil.rmtree(f, ignore_errors=True)
+                else:
+                    os.unlink(f)
+
+
+with open("README.md", "r") as fh:
+    LONG_DESC = fh.read()
+    setup(
+        cmdclass={"clean": CleanCommand},
+        name="hydra-core",
+        version=find_version("hydra", "__init__.py"),
+        author="Omry Yadan",
+        author_email="omry@fb.com",
+        description="A framework for elegantly configuring complex applications",
+        long_description=LONG_DESC,
+        long_description_content_type="text/markdown",
+        url="https://github.com/facebookresearch/hydra",
+        keywords="command-line configuration yaml tab-completion",
+        packages=find_packages(include=["hydra"]),
+        include_package_data=True,
+        classifiers=[
+            "License :: OSI Approved :: MIT License",
+            "Development Status :: 4 - Beta",
+            "Programming Language :: Python :: 3.6",
+            "Programming Language :: Python :: 3.7",
+            "Programming Language :: Python :: 3.8",
+            "Operating System :: POSIX :: Linux",
+            "Operating System :: MacOS",
+            "Operating System :: Microsoft :: Windows",
+        ],
+        install_requires=install_requires,
+        # Install development dependencies with
+        # pip install -r requirements/dev.txt -e .
+    )

testbed/facebookresearch__hydra/tests/__init__.py

@@ -0,0 +1,4 @@
+# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved
+from hydra.core.utils import verify_pytest_plugin_version
+
+verify_pytest_plugin_version()

testbed/facebookresearch__hydra/tests/scripts/test_bash_completion.exp

@@ -0,0 +1,46 @@
+# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved
+log_user 0
+set timeout 4
+set env(PS1) >>
+
+# Under pycharm, for some unknown reason readline displays
+# the suggestions in a different order, breaking the test.
+# This enables debug output from Hydra which is easier to test
+set env(HYDRA_COMP_DEBUG) 1
+set env(INPUTRC) /dev/null
+
+# Suppress bash deprecation warning on Mac
+set env(BASH_SILENCE_DEPRECATION_WARNING) 1
+
+# parray env
+
+spawn bash --norc --noprofile
+expect >>
+
+set in_line [lindex $argv 1]
+set len [expr [string length $in_line] - 1]
+set line [string range $in_line 5 $len]
+set num_tabs [lindex $argv 2]
+puts "input line: '$line'"
+puts "num_tabs: $num_tabs"
+
+send "eval \"\$([lindex $argv 0] -sc install=bash)\"\r"
+expect >>
+
+set command "[lindex $argv 0] $line"
+while {$num_tabs > 0} {
+    incr num_tabs -1
+    append command "\t"
+}
+
+puts "command: '$command'"
+
+send $command
+
+puts "\nMatching:\n"
+foreach arg [lrange $argv 3 end] {
+    expect {
+        "$arg" {puts "matched '$arg' to '$expect_out(0,string)'\nbuffer: '$expect_out(buffer)'";continue}
+        timeout {puts "Error matching $arg"; exit 1}
+    }
+}

testbed/facebookresearch__hydra/tests/test_apps/app_with_cfg_groups/conf/dataset/imagenet.yaml

@@ -0,0 +1,4 @@
+# @package _global_
+dataset:
+  name: imagenet
+  path: /datasets/imagenet

testbed/facebookresearch__hydra/tests/test_apps/app_with_config_with_free_group/conf/config.yaml

@@ -0,0 +1,3 @@
+# @package _global_
+defaults:
+  - group: opt1

testbed/facebookresearch__hydra/tests/test_apps/app_with_config_with_free_group/conf/group/opt1.yaml

@@ -0,0 +1,2 @@
+# @package _global_
+group_opt1: true

testbed/facebookresearch__hydra/tests/test_basic_launcher.py

@@ -0,0 +1,45 @@
+# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved
+import pytest
+
+from hydra.test_utils.launcher_common_tests import (
+    BatchedSweeperTestSuite,
+    IntegrationTestSuite,
+    LauncherTestSuite,
+)
+
+
+@pytest.mark.parametrize("launcher_name, overrides", [("basic", [])])
+class TestBasicLauncher(LauncherTestSuite):
+    pass
+
+
+@pytest.mark.parametrize(
+    "task_launcher_cfg, extra_flags",
+    [
+        pytest.param(
+            {
+                "defaults": [
+                    {"hydra/launcher": "basic"},
+                    {"hydra/hydra_logging": "hydra_debug"},
+                    {"hydra/job_logging": "disabled"},
+                ]
+            },
+            ["-m"],
+            id="basic_launcher_multirun",
+        )
+    ],
+)
+class TestBasicLauncherIntegration(IntegrationTestSuite):
+    """
+    Run this launcher through the integration test suite.
+    """
+
+    pass
+
+
+@pytest.mark.parametrize(
+    "launcher_name, overrides",
+    [("basic", ["hydra/sweeper=basic", "hydra.sweeper.params.max_batch_size=2"])],
+)
+class TestBasicSweeperWithBatching(BatchedSweeperTestSuite):
+    ...

testbed/facebookresearch__hydra/tests/test_completion.py

@@ -0,0 +1,314 @@
+# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved
+import distutils.spawn
+import os
+import re
+import subprocess
+import sys
+from pathlib import Path
+from typing import List
+
+import pytest
+from packaging import version
+
+from hydra._internal.config_loader_impl import ConfigLoaderImpl
+from hydra._internal.core_plugins.bash_completion import BashCompletion
+from hydra._internal.utils import create_config_search_path
+from hydra.plugins.completion_plugin import DefaultCompletionPlugin
+from hydra.test_utils.test_utils import chdir_hydra_root
+
+chdir_hydra_root()
+
+
+def is_expect_exists() -> bool:
+    return distutils.spawn.find_executable("expect") is not None
+
+
+def is_fish_supported() -> bool:
+    if distutils.spawn.find_executable("fish") is None:
+        return False
+
+    proc = subprocess.run(
+        ["fish", "--version"], stdout=subprocess.PIPE, encoding="utf-8"
+    )
+    matches = re.match(r".*version\s+(\d\.\d\.\d)(.*)", proc.stdout)
+    if not matches:
+        return False
+
+    fish_version, git_version = matches.groups()
+
+    # Release after 3.1.2 or git build after 3.1.2 contain space fix.
+    if version.parse(fish_version) > version.parse("3.1.2"):
+        return True
+    elif version.parse(fish_version) >= version.parse("3.1.2") and git_version:
+        return True
+    else:
+        return False
+
+
+def create_config_loader() -> ConfigLoaderImpl:
+    return ConfigLoaderImpl(
+        config_search_path=create_config_search_path(
+            search_path_dir=os.path.realpath("hydra/test_utils/configs/completion_test")
+        )
+    )
+
+
+base_completion_list: List[str] = [
+    "dict.",
+    "dict_prefix=",
+    "group=",
+    "hydra.",
+    "hydra/",
+    "list.",
+    "list_prefix=",
+    "test_hydra/",
+]
+
+
+@pytest.mark.parametrize("line_prefix", ["", "dict.key1=val1 ", "-r "])
+@pytest.mark.parametrize(
+    "line,num_tabs,expected",
+    [
+        ("", 2, base_completion_list),
+        (" ", 2, base_completion_list),
+        ("dict", 2, ["dict.", "dict_prefix="]),
+        ("dict.", 3, ["dict.key1=", "dict.key2=", "dict.key3="]),
+        ("dict.key", 2, ["dict.key1=", "dict.key2=", "dict.key3="]),
+        ("dict.key1=", 2, ["dict.key1=val1"]),
+        ("dict.key3=", 2, ["dict.key3="]),  # no value because dict.key3 is ???
+        ("list", 2, ["list.", "list_prefix="]),
+        ("list.", 2, ["list.0=", "list.1=", "list.2="]),
+        (
+            "hydra/",
+            3,
+            [
+                "hydra/help=",
+                "hydra/hydra_help=",
+                "hydra/hydra_logging=",
+                "hydra/job_logging=",
+                "hydra/launcher=",
+                "hydra/output=",
+                "hydra/sweeper=",
+            ],
+        ),
+        ("test_hydra/lau", 2, ["test_hydra/launcher="]),
+        ("test_hydra/launcher=", 2, ["test_hydra/launcher=fairtask"]),
+        ("test_hydra/launcher=fa", 2, ["test_hydra/launcher=fairtask"]),
+        # loading groups
+        ("gro", 2, ["group="]),
+        ("group=di", 2, ["group=dict"]),
+        (
+            "group=dict ",
+            3,
+            [
+                "dict.",
+                "dict_prefix=",
+                "group.",
+                "group=",
+                "hydra.",
+                "hydra/",
+                "list.",
+                "list_prefix=",
+                "test_hydra/",
+                "toys.",
+            ],
+        ),
+        ("group=", 2, ["group=dict", "group=list"]),
+        ("group=dict group.dict=", 2, ["group.dict=true"]),
+        ("group=dict group=", 2, ["group=dict", "group=list"]),
+    ],
+)
+class TestCompletion:
+    def test_completion_plugin(
+        self, line_prefix: str, num_tabs: int, line: str, expected: List[str]
+    ) -> None:
+        config_loader = create_config_loader()
+        bc = DefaultCompletionPlugin(config_loader)
+        ret = bc._query(config_name="config.yaml", line=line_prefix + line)
+        assert ret == expected
+
+    @pytest.mark.skipif(  # type: ignore
+        not is_expect_exists(),
+        reason="expect should be installed to run the expects tests",
+    )
+    @pytest.mark.parametrize(  # type: ignore
+        "prog", [["python", "hydra/test_utils/completion.py"]]
+    )
+    @pytest.mark.parametrize("shell", ["bash", "fish"])  # type: ignore
+    def test_shell_integration(
+        self,
+        shell: str,
+        prog: List[str],
+        num_tabs: int,
+        line_prefix: str,
+        line: str,
+        expected: List[str],
+    ) -> None:
+        if shell == "fish" and not is_fish_supported():
+            pytest.skip("fish is not installed or the version is too old")
+
+        # verify expect will be running the correct Python.
+        # This preemptively detect a much harder to understand error from expect.
+        ret = subprocess.check_output(["which", "python"], env=os.environ)
+        assert os.path.realpath(ret.decode("utf-8").strip()) == os.path.realpath(
+            sys.executable.strip()
+        )
+
+        verbose = os.environ.get("VERBOSE", "0") != "0"
+
+        line1 = "line={}".format(line_prefix + line)
+        cmd = ["expect"]
+        if verbose:
+            cmd.append("-d")
+
+        cmd.extend(
+            [
+                "tests/scripts/test_{}_completion.exp".format(shell),
+                f"{' '.join(prog)}",
+                line1,
+                str(num_tabs),
+            ]
+        )
+
+        if shell == "fish":
+            # Fish will add a space to an unambiguous completion.
+            expected = [x + " " if re.match(r".*=\w+$", x) else x for x in expected]
+
+            # Exactly match token end. See
+            # https://github.com/fish-shell/fish-shell/issues/6928
+            expected = [re.escape(x) + "$" for x in expected]
+
+        cmd.extend(expected)
+        if verbose:
+            print("\nCOMMAND:\n" + " ".join([f"'{x}'" for x in cmd]))
+        subprocess.check_call(cmd)
+
+
+@pytest.mark.parametrize(  # type: ignore
+    "line,expected",
+    [
+        ("-c job", base_completion_list),
+        ("-c hydra ", base_completion_list),
+        ("-c all ", base_completion_list),
+    ],
+)
+def test_with_flags(line: str, expected: List[str]) -> None:
+    config_loader = create_config_loader()
+    bc = DefaultCompletionPlugin(config_loader)
+    ret = bc._query(config_name="config.yaml", line=line)
+    assert ret == expected
+
+
+@pytest.mark.parametrize("relative", [True, False])  # type: ignore
+@pytest.mark.parametrize("line_prefix", ["", "dict.key1=val1 "])  # type: ignore
+@pytest.mark.parametrize(  # type: ignore
+    "key_eq, fname_prefix, files, expected",
+    [
+        ("abc=", "", ["foo.txt"], ["foo.txt"]),
+        ("abc=", "fo", ["foo.txt"], ["foo.txt"]),
+        ("abc=", "foo.txt", ["foo.txt"], ["foo.txt"]),
+        ("abc=", "foo", ["foo1.txt", "foo2.txt"], ["foo1.txt", "foo2.txt"]),
+        ("abc=", "foo1", ["foo1.txt", "foo2.txt"], ["foo1.txt"]),
+        ("abc=", "foo/bar", [], []),
+    ],
+)
+def test_file_completion(
+    tmpdir: Path,
+    files: List[str],
+    line_prefix: str,
+    key_eq: str,
+    fname_prefix: str,
+    expected: List[str],
+    relative: bool,
+) -> None:
+    def create_files(in_files: List[str]) -> None:
+        for f in in_files:
+            path = Path(f)
+            dirname = path.parent
+            if str(dirname) != ".":
+                Path.mkdir(dirname, parents=True)
+            Path(f).touch(exist_ok=True)
+
+    config_loader = create_config_loader()
+    try:
+        pwd = os.getcwd()
+        os.chdir(str(tmpdir))
+        create_files(files)
+        bc = DefaultCompletionPlugin(config_loader)
+        probe = line_prefix + key_eq
+        if relative:
+            prefix = "." + os.path.sep
+            probe += prefix + fname_prefix
+        else:
+            prefix = os.path.realpath(".")
+            probe += os.path.join(prefix, fname_prefix)
+
+        ret = bc._query(config_name="config.yaml", line=probe)
+        assert len(expected) == len(ret)
+        for idx, file in enumerate(expected):
+            assert key_eq + os.path.join(prefix, file) == ret[idx]
+    finally:
+        os.chdir(pwd)
+
+
+@pytest.mark.parametrize(  # type: ignore
+    "prefix", ["", " ", "\t", "/foo/bar", " /foo/bar/"]
+)
+@pytest.mark.parametrize(  # type: ignore
+    "app_prefix",
+    [
+        "python foo.py",
+        "hydra_app",
+        "hydra_app ",
+        "hy1-_=ra_app",
+        "foo.par",
+        "f_o-o1=2.par",
+        "python  foo.py",
+        "python tutorials/hydra_app/example/hydra_app/main.py",
+        "python foo.py",
+    ],
+)
+@pytest.mark.parametrize(  # type: ignore
+    "args_line, args_line_index",
+    [
+        ("", None),
+        ("foo=bar", None),
+        ("foo=bar bar=baz0", None),
+        ("", 0),
+        ("foo=bar", 3),
+        ("foo=bar bar=baz0", 3),
+        ("dict.", 0),
+        ("dict.", 5),
+    ],
+)
+def test_strip(
+    prefix: str, app_prefix: str, args_line: str, args_line_index: int
+) -> None:
+    app_prefix = prefix + app_prefix
+    if args_line:
+        app_prefix = app_prefix + " "
+    line = "{}{}".format(app_prefix, args_line)
+    result_line = BashCompletion.strip_python_or_app_name(line)
+    assert result_line == args_line
+
+
+@pytest.mark.parametrize(  # type: ignore
+    "shell,script,comp_func",
+    [
+        (
+            "bash",
+            "tests/scripts/test_bash_install_uninstall.sh",
+            "hydra_bash_completion",
+        ),
+        (
+            "fish",
+            "tests/scripts/test_fish_install_uninstall.fish",
+            "hydra_fish_completion",
+        ),
+    ],
+)
+def test_install_uninstall(shell: str, script: str, comp_func: str) -> None:
+    if shell == "fish" and not is_fish_supported():
+        pytest.skip("fish is not installed or the version is too old")
+    cmd = [shell, script, "python hydra/test_utils/completion.py", comp_func]
+    subprocess.check_call(cmd)

testbed/facebookresearch__hydra/tests/test_config_loader.py

@@ -0,0 +1,1194 @@
+# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved
+import re
+from dataclasses import dataclass
+from typing import Any, List
+
+import pkg_resources
+import pytest
+from omegaconf import MISSING, OmegaConf, ValidationError, open_dict
+
+from hydra._internal.config_loader_impl import (
+    ConfigLoaderImpl,
+    DefaultElement,
+    ParsedConfigOverride,
+    ParsedOverride,
+)
+from hydra._internal.utils import create_config_search_path
+from hydra.core.config_loader import LoadTrace
+from hydra.core.config_store import ConfigStore, ConfigStoreWithProvider
+from hydra.core.utils import env_override
+from hydra.errors import HydraException, MissingConfigException
+from hydra.test_utils.test_utils import chdir_hydra_root
+
+chdir_hydra_root()
+
+
+@dataclass
+class MySQLConfig:
+    driver: str = MISSING
+    host: str = MISSING
+    port: int = MISSING
+    user: str = MISSING
+    password: str = MISSING
+
+
+@dataclass
+class TopLevelConfig:
+    normal_yaml_config: bool = MISSING
+    db: MySQLConfig = MySQLConfig()
+
+
+hydra_load_list: List[LoadTrace] = [
+    LoadTrace("hydra_config", "structured://", "hydra", None),
+    LoadTrace("hydra/hydra_logging/default", "pkg://hydra.conf", "hydra", None),
+    LoadTrace("hydra/job_logging/default", "pkg://hydra.conf", "hydra", None),
+    LoadTrace("hydra/launcher/basic", "pkg://hydra.conf", "hydra", None),
+    LoadTrace("hydra/sweeper/basic", "pkg://hydra.conf", "hydra", "hydra"),
+    LoadTrace("hydra/output/default", "pkg://hydra.conf", "hydra", None),
+    LoadTrace("hydra/help/default", "pkg://hydra.conf", "hydra", None),
+    LoadTrace("hydra/hydra_help/default", "pkg://hydra.conf", "hydra", None),
+]
+
+
+@pytest.mark.parametrize(
+    "path",
+    [
+        pytest.param("file://hydra/test_utils/configs", id="file"),
+        pytest.param("pkg://hydra.test_utils.configs", id="pkg"),
+    ],
+)
+class TestConfigLoader:
+    def test_load_configuration(self, path: str) -> None:
+        config_loader = ConfigLoaderImpl(
+            config_search_path=create_config_search_path(path)
+        )
+        cfg = config_loader.load_configuration(
+            config_name="config.yaml", strict=False, overrides=["abc=123"]
+        )
+        with open_dict(cfg):
+            del cfg["hydra"]
+        assert cfg == {"normal_yaml_config": True, "abc": 123}
+
+    def test_load_with_missing_default(self, path: str) -> None:
+        config_loader = ConfigLoaderImpl(
+            config_search_path=create_config_search_path(path)
+        )
+        with pytest.raises(MissingConfigException):
+            config_loader.load_configuration(
+                config_name="missing-default.yaml", overrides=[], strict=False
+            )
+
+    def test_load_with_missing_optional_default(self, path: str) -> None:
+        config_loader = ConfigLoaderImpl(
+            config_search_path=create_config_search_path(path)
+        )
+        cfg = config_loader.load_configuration(
+            config_name="missing-optional-default.yaml", overrides=[], strict=False
+        )
+        with open_dict(cfg):
+            del cfg["hydra"]
+        assert cfg == {}
+
+    def test_load_with_optional_default(self, path: str) -> None:
+        config_loader = ConfigLoaderImpl(
+            config_search_path=create_config_search_path(path)
+        )
+        cfg = config_loader.load_configuration(
+            config_name="optional-default.yaml", overrides=[], strict=False
+        )
+        with open_dict(cfg):
+            del cfg["hydra"]
+        assert cfg == {"foo": 10}
+
+    def test_load_changing_group_in_default(self, path: str) -> None:
+        config_loader = ConfigLoaderImpl(
+            config_search_path=create_config_search_path(path)
+        )
+        cfg = config_loader.load_configuration(
+            config_name="optional-default.yaml",
+            overrides=["group1=file2"],
+            strict=False,
+        )
+        with open_dict(cfg):
+            del cfg["hydra"]
+        assert cfg == {"foo": 20}
+
+    @pytest.mark.parametrize(  # type: ignore
+        "overrides,expected",
+        [
+            pytest.param(
+                [],
+                {"group1_option1": True, "pkg1": {"group2_option1": True}},
+                id="no_overrides",
+            ),
+            pytest.param(
+                ["group1@:pkg2=option1"],
+                {"pkg2": {"group1_option1": True}, "pkg1": {"group2_option1": True}},
+                id="override_unspecified_pkg_of_default",
+            ),
+            pytest.param(
+                ["group1@:pkg1=option1"],
+                {"pkg1": {"group1_option1": True, "group2_option1": True}},
+                id="override_two_groups_to_same_package",
+            ),
+        ],
+    )
+    def test_load_changing_group_and_package_in_default(
+        self, path: str, overrides: List[str], expected: Any
+    ) -> None:
+        config_loader = ConfigLoaderImpl(
+            config_search_path=create_config_search_path(f"{path}/package_tests")
+        )
+        cfg = config_loader.load_configuration(
+            config_name="pkg_override", overrides=overrides
+        )
+        with open_dict(cfg):
+            del cfg["hydra"]
+        assert cfg == expected
+
+    @pytest.mark.parametrize(  # type: ignore
+        "overrides,expected",
+        [
+            pytest.param(
+                [],
+                {"pkg1": {"group1_option1": True}, "pkg2": {"group1_option1": True}},
+                id="baseline",
+            ),
+            pytest.param(
+                ["+group1@pkg3=option1"],
+                {
+                    "pkg1": {"group1_option1": True},
+                    "pkg2": {"group1_option1": True},
+                    "pkg3": {"group1_option1": True},
+                },
+                id="append",
+            ),
+            pytest.param(
+                ["~group1@pkg1"],
+                {"pkg2": {"group1_option1": True}},
+                id="delete_package",
+            ),
+            pytest.param(
+                ["group1@pkg1:new_pkg=option1"],
+                {"new_pkg": {"group1_option1": True}, "pkg2": {"group1_option1": True}},
+                id="change_pkg1",
+            ),
+            pytest.param(
+                ["group1@pkg2:new_pkg=option1"],
+                {"pkg1": {"group1_option1": True}, "new_pkg": {"group1_option1": True}},
+                id="change_pkg2",
+            ),
+        ],
+    )
+    def test_override_compose_two_package_one_group(
+        self, path: str, overrides: List[str], expected: Any
+    ) -> None:
+        config_loader = ConfigLoaderImpl(
+            config_search_path=create_config_search_path(f"{path}/package_tests")
+        )
+        cfg = config_loader.load_configuration(
+            config_name="two_packages_one_group", overrides=overrides
+        )
+        with open_dict(cfg):
+            del cfg["hydra"]
+        assert cfg == expected
+
+    def test_load_adding_group_not_in_default(self, path: str) -> None:
+        config_loader = ConfigLoaderImpl(
+            config_search_path=create_config_search_path(path)
+        )
+        cfg = config_loader.load_configuration(
+            config_name="optional-default.yaml",
+            overrides=["+group2=file1"],
+            strict=False,
+        )
+        with open_dict(cfg):
+            del cfg["hydra"]
+        assert cfg == {"foo": 10, "bar": 100}
+
+    def test_change_run_dir_with_override(self, path: str) -> None:
+        config_loader = ConfigLoaderImpl(
+            config_search_path=create_config_search_path(path)
+        )
+        cfg = config_loader.load_configuration(
+            config_name="overriding_run_dir.yaml",
+            overrides=["hydra.run.dir=abc"],
+            strict=False,
+        )
+        assert cfg.hydra.run.dir == "abc"
+
+    def test_change_run_dir_with_config(self, path: str) -> None:
+        config_loader = ConfigLoaderImpl(
+            config_search_path=create_config_search_path(path)
+        )
+        cfg = config_loader.load_configuration(
+            config_name="overriding_run_dir.yaml", overrides=[], strict=False
+        )
+        assert cfg.hydra.run.dir == "cde"
+
+    def test_load_strict(self, path: str) -> None:
+        """
+        Ensure that in strict mode we can override only things that are already in the config
+        :return:
+        """
+        config_loader = ConfigLoaderImpl(
+            config_search_path=create_config_search_path(path)
+        )
+        # Test that overriding existing things works in strict mode
+        cfg = config_loader.load_configuration(
+            config_name="compose.yaml", overrides=["foo=ZZZ"], strict=True
+        )
+        with open_dict(cfg):
+            del cfg["hydra"]
+        assert cfg == {"foo": "ZZZ", "bar": 100}
+
+        # Test that accessing a key that is not there will fail
+        with pytest.raises(AttributeError):
+            # noinspection PyStatementEffect
+            cfg.not_here
+
+        # Test that bad overrides triggers the KeyError
+        with pytest.raises(HydraException):
+            config_loader.load_configuration(
+                config_name="compose.yaml", overrides=["f00=ZZZ"], strict=True
+            )
+
+    def test_load_history(self, path: str) -> None:
+        config_loader = ConfigLoaderImpl(
+            config_search_path=create_config_search_path(path)
+        )
+        config_loader.load_configuration(
+            config_name="missing-optional-default.yaml", overrides=[], strict=False
+        )
+        expected = hydra_load_list.copy()
+        expected.append(LoadTrace("missing-optional-default.yaml", path, "main", None))
+        expected.append(LoadTrace("foo/missing", None, None, None))
+
+        assert config_loader.get_load_history() == expected
+
+    def test_load_history_with_basic_launcher(self, path: str) -> None:
+        config_loader = ConfigLoaderImpl(
+            config_search_path=create_config_search_path(path)
+        )
+        config_loader.load_configuration(
+            config_name="custom_default_launcher.yaml",
+            overrides=["hydra/launcher=basic"],
+            strict=False,
+        )
+
+        expected = hydra_load_list.copy()
+        expected.append(LoadTrace("custom_default_launcher.yaml", path, "main", None))
+        assert config_loader.get_load_history() == expected
+
+    def test_load_yml_file(self, path: str) -> None:
+        config_loader = ConfigLoaderImpl(
+            config_search_path=create_config_search_path(path)
+        )
+        cfg = config_loader.load_configuration(
+            config_name="config.yml", overrides=[], strict=False
+        )
+        with open_dict(cfg):
+            del cfg["hydra"]
+
+        assert cfg == {"yml_file_here": True}
+
+    def test_override_with_equals(self, path: str) -> None:
+        config_loader = ConfigLoaderImpl(
+            config_search_path=create_config_search_path(path)
+        )
+        cfg = config_loader.load_configuration(
+            config_name="config.yaml", overrides=["abc='cde=12'"], strict=False
+        )
+        with open_dict(cfg):
+            del cfg["hydra"]
+        assert cfg == OmegaConf.create({"normal_yaml_config": True, "abc": "cde=12"})
+
+    def test_compose_file_with_dot(self, path: str) -> None:
+        config_loader = ConfigLoaderImpl(
+            config_search_path=create_config_search_path(path)
+        )
+        cfg = config_loader.load_configuration(
+            config_name="compose.yaml", overrides=["group1=abc.cde"], strict=False
+        )
+        with open_dict(cfg):
+            del cfg["hydra"]
+        assert cfg == {"abc=cde": None, "bar": 100}
+
+    def test_load_config_with_schema(
+        self, hydra_restore_singletons: Any, path: str
+    ) -> None:
+
+        ConfigStore.instance().store(
+            name="config", node=TopLevelConfig, provider="this_test"
+        )
+        ConfigStore.instance().store(
+            group="db", name="mysql", node=MySQLConfig, provider="this_test",
+        )
+
+        config_loader = ConfigLoaderImpl(
+            config_search_path=create_config_search_path(path)
+        )
+
+        cfg = config_loader.load_configuration(
+            config_name="config", overrides=["+db=mysql"]
+        )
+        with open_dict(cfg):
+            del cfg["hydra"]
+        assert cfg == {
+            "normal_yaml_config": True,
+            "db": {
+                "driver": "mysql",
+                "host": "???",
+                "port": "???",
+                "user": "omry",
+                "password": "secret",
+            },
+        }
+
+        expected = hydra_load_list.copy()
+        expected.append(LoadTrace("config", path, "main", "this_test"))
+        expected.append(LoadTrace("db/mysql", path, "main", "this_test"))
+        assert config_loader.get_load_history() == expected
+
+        # verify illegal modification is rejected at runtime
+        with pytest.raises(ValidationError):
+            cfg.db.port = "fail"
+
+        # verify illegal override is rejected during load
+        with pytest.raises(HydraException):
+            config_loader.load_configuration(
+                config_name="db/mysql", overrides=["db.port=fail"]
+            )
+
+    def test_load_config_file_with_schema_validation(
+        self, hydra_restore_singletons: Any, path: str
+    ) -> None:
+
+        with ConfigStoreWithProvider("this_test") as cs:
+            cs.store(name="config", node=TopLevelConfig)
+            cs.store(group="db", name="mysql", node=MySQLConfig, package="db")
+
+        config_loader = ConfigLoaderImpl(
+            config_search_path=create_config_search_path(path)
+        )
+        cfg = config_loader.load_configuration(
+            config_name="config", overrides=["+db=mysql"], strict=False
+        )
+
+        with open_dict(cfg):
+            del cfg["hydra"]
+        assert cfg == {
+            "normal_yaml_config": True,
+            "db": {
+                "driver": "mysql",
+                "host": "???",
+                "port": "???",
+                "user": "omry",
+                "password": "secret",
+            },
+        }
+
+        expected = hydra_load_list.copy()
+        expected.append(LoadTrace("config", path, "main", "this_test"))
+        expected.append(LoadTrace("db/mysql", path, "main", "this_test"))
+        assert config_loader.get_load_history() == expected
+
+    def test_assign_null(
+        self, hydra_restore_singletons: Any, path: str, recwarn: Any
+    ) -> None:
+        config_loader = ConfigLoaderImpl(
+            config_search_path=create_config_search_path(path)
+        )
+        cfg = config_loader.load_configuration(
+            config_name="config.yaml", overrides=["abc=null"]
+        )
+        with open_dict(cfg):
+            del cfg["hydra"]
+        assert cfg == {"normal_yaml_config": True, "abc": None}
+        assert len(recwarn) == 0
+
+
+@pytest.mark.parametrize(  # type:ignore
+    "in_primary,in_merged,expected",
+    [
+        ([], [], []),
+        (
+            [DefaultElement(config_group="a", config_name="aa")],
+            [],
+            [DefaultElement(config_group="a", config_name="aa")],
+        ),
+        (
+            [DefaultElement(config_group="a", config_name="aa")],
+            [DefaultElement(config_group="b", config_name="bb")],
+            [
+                DefaultElement(config_group="a", config_name="aa"),
+                DefaultElement(config_group="b", config_name="bb"),
+            ],
+        ),
+        (
+            [
+                DefaultElement(config_group="hydra_logging", config_name="default"),
+                DefaultElement(config_group="job_logging", config_name="default"),
+                DefaultElement(config_group="launcher", config_name="basic"),
+                DefaultElement(config_group="sweeper", config_name="basic"),
+            ],
+            [
+                DefaultElement(config_group="optimizer", config_name="nesterov"),
+                DefaultElement(config_group="launcher", config_name="basic"),
+            ],
+            [
+                DefaultElement(config_group="hydra_logging", config_name="default"),
+                DefaultElement(config_group="job_logging", config_name="default"),
+                DefaultElement(config_group="launcher", config_name="basic"),
+                DefaultElement(config_group="sweeper", config_name="basic"),
+                DefaultElement(config_group="optimizer", config_name="nesterov"),
+            ],
+        ),
+    ],
+)
+def test_merge_default_lists(
+    in_primary: List[DefaultElement],
+    in_merged: List[DefaultElement],
+    expected: List[DefaultElement],
+) -> None:
+    ConfigLoaderImpl._combine_default_lists(in_primary, in_merged)
+    assert in_primary == expected
+
+
+@pytest.mark.parametrize(  # type:ignore
+    "config_file, overrides",
+    [
+        # remove from config
+        ("removing-hydra-launcher-default.yaml", []),
+        # remove from override
+        ("config.yaml", ["~hydra/launcher"]),
+        # remove from both
+        ("removing-hydra-launcher-default.yaml", ["~hydra/launcher"]),
+        # second overrides removes
+        ("config.yaml", ["hydra/launcher=submitit", "~hydra/launcher"]),
+    ],
+)
+def test_default_removal(config_file: str, overrides: List[str]) -> None:
+    config_loader = ConfigLoaderImpl(
+        config_search_path=create_config_search_path("hydra/test_utils/configs")
+    )
+    config_loader.load_configuration(
+        config_name=config_file, overrides=overrides, strict=False
+    )
+
+    expected = list(
+        filter(lambda x: x.filename != "hydra/launcher/basic", hydra_load_list.copy())
+    )
+    expected.append(
+        LoadTrace(config_file, "file://hydra/test_utils/configs", "main", None)
+    )
+    assert config_loader.get_load_history() == expected
+
+
+def test_defaults_not_list_exception() -> None:
+    config_loader = ConfigLoaderImpl(
+        config_search_path=create_config_search_path("hydra/test_utils/configs")
+    )
+    with pytest.raises(ValueError):
+        config_loader.load_configuration(
+            config_name="defaults_not_list.yaml", overrides=[], strict=False
+        )
+
+
+@pytest.mark.parametrize(  # type:ignore
+    "module_name, resource_name",
+    [
+        ("hydra.test_utils", ""),
+        ("hydra.test_utils", "__init__.py"),
+        ("hydra.test_utils", "configs"),
+        ("hydra.test_utils", "configs/config.yaml"),
+        ("hydra.test_utils.configs", ""),
+        ("hydra.test_utils.configs", "config.yaml"),
+        ("hydra.test_utils.configs", "group1"),
+        ("hydra.test_utils.configs", "group1/file1.yaml"),
+    ],
+)
+def test_resource_exists(module_name: str, resource_name: str) -> None:
+    assert pkg_resources.resource_exists(module_name, resource_name) is True
+
+
+def test_override_hydra_config_value_from_config_file() -> None:
+    config_loader = ConfigLoaderImpl(
+        config_search_path=create_config_search_path("hydra/test_utils/configs")
+    )
+
+    cfg = config_loader.load_configuration(
+        config_name="overriding_output_dir.yaml", overrides=[], strict=False
+    )
+    assert cfg.hydra.run.dir == "foo"
+
+
+def test_override_hydra_config_group_from_config_file() -> None:
+    config_loader = ConfigLoaderImpl(
+        config_search_path=create_config_search_path("hydra/test_utils/configs")
+    )
+
+    config_loader.load_configuration(
+        config_name="overriding_logging_default.yaml", overrides=[], strict=False
+    )
+
+    # This load history is too different to easily reuse the standard hydra_load_list
+    assert config_loader.get_load_history() == [
+        LoadTrace("hydra_config", "structured://", "hydra", None),
+        LoadTrace("hydra/hydra_logging/hydra_debug", "pkg://hydra.conf", "hydra", None),
+        LoadTrace("hydra/job_logging/disabled", "pkg://hydra.conf", "hydra", None),
+        LoadTrace("hydra/sweeper/basic", "pkg://hydra.conf", "hydra", "hydra"),
+        LoadTrace("hydra/output/default", "pkg://hydra.conf", "hydra", None),
+        LoadTrace("hydra/help/default", "pkg://hydra.conf", "hydra", None),
+        LoadTrace("hydra/hydra_help/default", "pkg://hydra.conf", "hydra", None),
+        LoadTrace(
+            "overriding_logging_default.yaml",
+            "file://hydra/test_utils/configs",
+            "main",
+            None,
+        ),
+    ]
+
+
+def test_list_groups() -> None:
+    config_loader = ConfigLoaderImpl(
+        config_search_path=create_config_search_path(
+            "hydra/test_utils/configs/cloud_infra_example"
+        )
+    )
+    groups = config_loader.list_groups("")
+    assert sorted(groups) == [
+        "application",
+        "cloud_provider",
+        "db",
+        "environment",
+        "hydra",
+    ]
+
+    assert sorted(config_loader.list_groups("hydra")) == [
+        "help",
+        "hydra_help",
+        "hydra_logging",
+        "job_logging",
+        "launcher",
+        "output",
+        "sweeper",
+    ]
+
+
+def test_non_config_group_default() -> None:
+    config_loader = ConfigLoaderImpl(
+        config_search_path=create_config_search_path("hydra/test_utils/configs")
+    )
+    config_loader.load_configuration(
+        config_name="non_config_group_default.yaml", overrides=[], strict=False
+    )
+
+    expected = hydra_load_list.copy()
+    expected.extend(
+        [
+            LoadTrace(
+                "non_config_group_default.yaml",
+                "file://hydra/test_utils/configs",
+                "main",
+                None,
+            ),
+            LoadTrace("some_config", "file://hydra/test_utils/configs", "main", None),
+        ]
+    )
+    assert config_loader.get_load_history() == expected
+
+
+def test_mixed_composition_order() -> None:
+    """
+    Tests that the order of mixed composition (defaults contains both config group and non config group
+    items) is correct
+    """
+    config_loader = ConfigLoaderImpl(
+        config_search_path=create_config_search_path("hydra/test_utils/configs")
+    )
+    config_loader.load_configuration(
+        config_name="mixed_compose.yaml", overrides=[], strict=False
+    )
+
+    expected = hydra_load_list.copy()
+    expected.extend(
+        [
+            LoadTrace(
+                "mixed_compose.yaml", "file://hydra/test_utils/configs", "main", None
+            ),
+            LoadTrace("some_config", "file://hydra/test_utils/configs", "main", None),
+            LoadTrace("group1/file1", "file://hydra/test_utils/configs", "main", None),
+            LoadTrace("config", "file://hydra/test_utils/configs", "main", None),
+        ]
+    )
+
+    assert config_loader.get_load_history() == expected
+
+
+def test_load_schema_as_config(hydra_restore_singletons: Any) -> None:
+    """
+    Load structured config as a configuration
+    """
+    ConfigStore.instance().store(
+        name="config", node=TopLevelConfig, provider="this_test"
+    )
+
+    ConfigStore.instance().store(
+        name="db/mysql", node=MySQLConfig, provider="this_test",
+    )
+
+    config_loader = ConfigLoaderImpl(config_search_path=create_config_search_path(None))
+    cfg = config_loader.load_configuration(config_name="config", overrides=[])
+    with open_dict(cfg):
+        del cfg["hydra"]
+    assert cfg == {
+        "normal_yaml_config": "???",
+        "db": {
+            "driver": MISSING,
+            "host": MISSING,
+            "port": MISSING,
+            "user": MISSING,
+            "password": MISSING,
+        },
+    }
+
+    expected = hydra_load_list.copy()
+    expected.extend([LoadTrace("config", "structured://", "this_test", None)])
+    assert config_loader.get_load_history() == expected
+
+
+@dataclass
+class Plugin:
+    name: str = MISSING
+    params: Any = MISSING
+
+
+@dataclass
+class ConcretePlugin(Plugin):
+    name: str = "foobar_plugin"
+
+    @dataclass
+    class FoobarParams:
+        foo: int = 10
+
+    params: FoobarParams = FoobarParams()
+
+
+@dataclass
+# A plugin that does not extend the parent Plugin class
+class InvalidPlugin:
+    name: str = "invalid_plugin"
+
+
+@dataclass
+class Config:
+    plugin: Plugin = Plugin()
+
+
+def test_overlapping_schemas(hydra_restore_singletons: Any) -> None:
+
+    cs = ConfigStore.instance()
+    cs.store(name="config", node=Config)
+    cs.store(group="plugin", name="concrete", node=ConcretePlugin)
+
+    config_loader = ConfigLoaderImpl(config_search_path=create_config_search_path(None))
+    cfg = config_loader.load_configuration(config_name="config", overrides=[])
+    with open_dict(cfg):
+        del cfg["hydra"]
+
+    assert cfg == {"plugin": {"name": "???", "params": "???"}}
+    assert OmegaConf.get_type(cfg.plugin) == Plugin
+
+    cfg = config_loader.load_configuration(
+        config_name="config", overrides=["+plugin=concrete"]
+    )
+    with open_dict(cfg):
+        del cfg["hydra"]
+
+    assert cfg == {"plugin": {"name": "foobar_plugin", "params": {"foo": 10}}}
+    assert OmegaConf.get_type(cfg.plugin) == ConcretePlugin
+    assert OmegaConf.get_type(cfg.plugin.params) == ConcretePlugin.FoobarParams
+    with pytest.raises(ValidationError):
+        cfg.plugin = 10
+
+
+def test_invalid_plugin_merge(hydra_restore_singletons: Any) -> Any:
+    cs = ConfigStore.instance()
+    cs.store(name="config", node=Config)
+    cs.store(group="plugin", name="invalid", node=InvalidPlugin)
+
+    cl = ConfigLoaderImpl(config_search_path=create_config_search_path(None))
+    with pytest.raises(HydraException):
+        cl.load_configuration(config_name="config", overrides=["plugin=invalid"])
+
+
+def test_job_env_copy() -> None:
+    config_loader = ConfigLoaderImpl(config_search_path=create_config_search_path(None))
+    with env_override({"zonk": "123456"}):
+        cfg = config_loader.load_configuration(
+            config_name=None, overrides=["hydra.job.env_copy=[zonk]"]
+        )
+        assert cfg.hydra.job.env_set == {"zonk": "123456"}
+
+
+@pytest.mark.parametrize(  # type: ignore
+    "overrides,expected",
+    [
+        (
+            [],
+            {
+                "optimizer": {"type": "adam", "lr": 0.1, "beta": 0.01},
+                "dataset": {"name": "imagenet", "path": "/datasets/imagenet"},
+                "adam_imagenet": True,
+            },
+        ),
+        (
+            ["optimizer=nesterov"],
+            {
+                "optimizer": {"type": "nesterov", "lr": 0.001},
+                "dataset": {"name": "imagenet", "path": "/datasets/imagenet"},
+                "nesterov_imagenet": True,
+            },
+        ),
+    ],
+)
+def test_complex_defaults(overrides: Any, expected: Any) -> None:
+    config_loader = ConfigLoaderImpl(
+        config_search_path=create_config_search_path(
+            "tests/test_apps/sweep_complex_defaults/conf"
+        )
+    )
+
+    cfg = config_loader.load_configuration(config_name="config", overrides=overrides)
+    with open_dict(cfg):
+        del cfg["hydra"]
+    assert cfg == expected
+
+
+@pytest.mark.parametrize(  # type: ignore
+    "override, expected",
+    [
+        # changing item
+        pytest.param(
+            "db=postgresql",
+            ParsedOverride(None, "db", None, None, "postgresql"),
+            id="change_option",
+        ),
+        pytest.param(
+            "db@dest=postgresql",
+            ParsedOverride(None, "db", "dest", None, "postgresql"),
+            id="change_option",
+        ),
+        pytest.param(
+            "db@src:dest=postgresql",
+            ParsedOverride(None, "db", "src", "dest", "postgresql"),
+            id="change_both",
+        ),
+        pytest.param(
+            "db@dest",
+            ParsedOverride(None, "db", "dest", None, None),
+            id="change_package",
+        ),
+        pytest.param(
+            "db@src:dest",
+            ParsedOverride(None, "db", "src", "dest", None),
+            id="change_package",
+        ),
+        # adding item
+        pytest.param(
+            "+model=resnet",
+            ParsedOverride("+", "model", None, None, "resnet"),
+            id="add_item",
+        ),
+        pytest.param(
+            "+db@offsite_backup=mysql",
+            ParsedOverride("+", "db", "offsite_backup", None, "mysql"),
+            id="add_item",
+        ),
+        # deleting item
+        pytest.param(
+            "~db", ParsedOverride("~", "db", None, None, None), id="delete_item",
+        ),
+        pytest.param(
+            "~db@src", ParsedOverride("~", "db", "src", None, None), id="delete_item",
+        ),
+        pytest.param(
+            "~db", ParsedOverride("~", "db", None, None, None), id="delete_item",
+        ),
+        pytest.param(
+            "~db@src", ParsedOverride("~", "db", "src", None, None), id="delete_item",
+        ),
+    ],
+)
+def test_parse_override(override: str, expected: ParsedOverride) -> None:
+    ret = ConfigLoaderImpl._parse_override(override)
+    assert ret.override == expected
+
+
+config_parse_error_msg = (
+    "Error parsing config override : '{override}'"
+    "\nAccepted forms:"
+    "\n\tOverride:  key=value"
+    "\n\tAppend:   +key=value"
+    "\n\tDelete:   ~key=value, ~key"
+)
+
+
+@pytest.mark.parametrize(  # type: ignore
+    "override, expected",
+    [
+        pytest.param(
+            "x.y.z=abc", ParsedConfigOverride(None, "x.y.z", "abc"), id="change_option",
+        ),
+        pytest.param(
+            "+x.y.z=abc", ParsedConfigOverride("+", "x.y.z", "abc"), id="adding",
+        ),
+        pytest.param(
+            "~x.y.z=abc", ParsedConfigOverride("~", "x.y.z", "abc"), id="adding",
+        ),
+        pytest.param("~x.y.z=", ParsedConfigOverride("~", "x.y.z", ""), id="adding"),
+        pytest.param(
+            "=a",
+            pytest.raises(
+                HydraException,
+                match=re.escape(config_parse_error_msg.format(override="=a")),
+            ),
+            id="no_key",
+        ),
+    ],
+)
+def test_parse_config_override(override: str, expected: Any) -> None:
+    if isinstance(expected, ParsedConfigOverride):
+        ret = ConfigLoaderImpl._parse_config_override(override)
+        assert ret == expected
+    else:
+        with expected:
+            ConfigLoaderImpl._parse_config_override(override)
+
+
+defaults_list = [{"db": "mysql"}, {"db@src": "mysql"}, {"hydra/launcher": "basic"}]
+
+
+@pytest.mark.parametrize(  # type: ignore
+    "input_defaults,overrides,expected",
+    [
+        # change item
+        pytest.param(
+            defaults_list,
+            ["db=postgresql"],
+            [{"db": "postgresql"}, {"db@src": "mysql"}, {"hydra/launcher": "basic"}],
+            id="change_option",
+        ),
+        pytest.param(
+            defaults_list,
+            ["db@src=postgresql"],
+            [{"db": "mysql"}, {"db@src": "postgresql"}, {"hydra/launcher": "basic"}],
+            id="change_option",
+        ),
+        pytest.param(
+            defaults_list,
+            ["db@:dest=postgresql"],
+            [
+                {"db@dest": "postgresql"},
+                {"db@src": "mysql"},
+                {"hydra/launcher": "basic"},
+            ],
+            id="change_both",
+        ),
+        pytest.param(
+            defaults_list,
+            ["db@src:dest=postgresql"],
+            [{"db": "mysql"}, {"db@dest": "postgresql"}, {"hydra/launcher": "basic"}],
+            id="change_both",
+        ),
+        pytest.param(
+            defaults_list,
+            ["db@XXX:dest=postgresql"],
+            pytest.raises(
+                HydraException,
+                match=re.escape(
+                    "Could not rename package. No match for 'db@XXX' in the defaults list."
+                ),
+            ),
+            id="change_both_invalid_package",
+        ),
+        pytest.param(
+            defaults_list,
+            ["db@:dest"],
+            [{"db@dest": "mysql"}, {"db@src": "mysql"}, {"hydra/launcher": "basic"}],
+            id="change_package",
+        ),
+        pytest.param(
+            defaults_list,
+            ["db@src:dest"],
+            [{"db": "mysql"}, {"db@dest": "mysql"}, {"hydra/launcher": "basic"}],
+            id="change_package",
+        ),
+        pytest.param(
+            defaults_list,
+            ["db@XXX:dest"],
+            pytest.raises(
+                HydraException,
+                match=re.escape(
+                    "Could not rename package. No match for 'db@XXX' in the defaults list."
+                ),
+            ),
+            id="change_package_from_invalid",
+        ),
+        # adding item
+        pytest.param([], ["+db=mysql"], [{"db": "mysql"}], id="adding_item"),
+        pytest.param(
+            defaults_list,
+            ["+db@backup=mysql"],
+            [
+                {"db": "mysql"},
+                {"db@src": "mysql"},
+                {"hydra/launcher": "basic"},
+                {"db@backup": "mysql"},
+            ],
+            id="adding_item_at_package",
+        ),
+        pytest.param(
+            defaults_list,
+            ["+db=mysql"],
+            pytest.raises(
+                HydraException,
+                match=re.escape(
+                    "Could not add. An item matching 'db' is already in the defaults list"
+                ),
+            ),
+            id="adding_duplicate_item",
+        ),
+        pytest.param(
+            defaults_list,
+            ["+db@src:foo=mysql"],
+            pytest.raises(
+                HydraException,
+                match=re.escape(
+                    "Add syntax does not support package rename, remove + prefix"
+                ),
+            ),
+            id="add_rename_error",
+        ),
+        pytest.param(
+            defaults_list,
+            ["+db@src=mysql"],
+            pytest.raises(
+                HydraException,
+                match=re.escape(
+                    "Could not add. An item matching 'db@src' is already in the defaults list"
+                ),
+            ),
+            id="adding_duplicate_item",
+        ),
+        pytest.param(
+            [],
+            ["db=mysql"],
+            pytest.raises(
+                HydraException,
+                match=re.escape(
+                    "Could not override 'db'. No match in the defaults list."
+                    "\nTo append to your default list use +db=mysql"
+                ),
+            ),
+            id="adding_without_plus",
+        ),
+        # deleting item
+        pytest.param(
+            [],
+            ["~db=mysql"],
+            pytest.raises(
+                HydraException,
+                match=re.escape(
+                    "Could not delete. No match for 'db' in the defaults list."
+                ),
+            ),
+            id="delete_no_match",
+        ),
+        pytest.param(
+            defaults_list,
+            ["~db"],
+            [{"db@src": "mysql"}, {"hydra/launcher": "basic"}],
+            id="delete",
+        ),
+        pytest.param(
+            defaults_list,
+            ["~db=mysql"],
+            [{"db@src": "mysql"}, {"hydra/launcher": "basic"}],
+            id="delete",
+        ),
+        pytest.param(
+            defaults_list,
+            ["~db=postgresql"],
+            pytest.raises(
+                HydraException,
+                match=re.escape(
+                    "Could not delete. No match for 'db=postgresql' in the defaults list."
+                ),
+            ),
+            id="delete_mismatch_value",
+        ),
+        pytest.param(
+            defaults_list,
+            ["~db@src"],
+            [{"db": "mysql"}, {"hydra/launcher": "basic"}],
+            id="delete",
+        ),
+        # syntax error
+        pytest.param(
+            defaults_list,
+            ["db"],
+            pytest.raises(
+                HydraException,
+                match=re.escape("Error parsing config group override : 'db'"),
+            ),
+            id="syntax_error",
+        ),
+    ],
+)
+def test_apply_overrides_to_defaults(
+    input_defaults: List[str], overrides: List[str], expected: Any
+) -> None:
+    defaults = ConfigLoaderImpl._parse_defaults(
+        OmegaConf.create({"defaults": input_defaults})
+    )
+    parsed_overrides = [
+        ConfigLoaderImpl._parse_override(override) for override in overrides
+    ]
+
+    if isinstance(expected, list):
+        expected_defaults = ConfigLoaderImpl._parse_defaults(
+            OmegaConf.create({"defaults": expected})
+        )
+        ConfigLoaderImpl._apply_overrides_to_defaults(
+            overrides=parsed_overrides, defaults=defaults
+        )
+        assert defaults == expected_defaults
+    else:
+        with expected:
+            ConfigLoaderImpl._apply_overrides_to_defaults(
+                overrides=parsed_overrides, defaults=defaults
+            )
+
+
+def test_delete_by_assigning_null_is_deprecated() -> None:
+    msg = (
+        "\nRemoving from the defaults list by assigning 'null' "
+        "is deprecated and will be removed in Hydra 1.1."
+        "\nUse ~db"
+    )
+
+    defaults = ConfigLoaderImpl._parse_defaults(
+        OmegaConf.create({"defaults": [{"db": "mysql"}]})
+    )
+    parsed_overrides = [ConfigLoaderImpl._parse_override("db=null")]
+
+    with pytest.warns(expected_warning=UserWarning, match=re.escape(msg)):
+        assert parsed_overrides[0].override.is_delete()
+        ConfigLoaderImpl._apply_overrides_to_defaults(
+            overrides=parsed_overrides, defaults=defaults
+        )
+        assert defaults == []
+
+
+@pytest.mark.parametrize(  # type: ignore
+    "input_cfg,strict,overrides,expected",
+    [
+        # append
+        pytest.param({}, False, ["x=10"], {"x": 10}, id="append"),
+        pytest.param(
+            {},
+            True,
+            ["x=10"],
+            pytest.raises(
+                HydraException,
+                match=re.escape(
+                    "Could not override 'x'. No match in config."
+                    "\nTo append to your config use +x=10"
+                ),
+            ),
+            id="append",
+        ),
+        pytest.param({}, True, ["+x=10"], {"x": 10}, id="append"),
+        # append item with @
+        pytest.param(
+            {},
+            False,
+            ["user@hostname=active"],
+            {"user@hostname": "active"},
+            id="append@",
+        ),
+        pytest.param(
+            {},
+            True,
+            ["+user@hostname=active"],
+            {"user@hostname": "active"},
+            id="append@",
+        ),
+        pytest.param(
+            {"x": 20},
+            True,
+            ["+x=10"],
+            pytest.raises(
+                HydraException,
+                match=re.escape(
+                    "Could not append to config. An item is already at 'x'"
+                ),
+            ),
+            id="append",
+        ),
+        # override
+        pytest.param({"x": 20}, False, ["x=10"], {"x": 10}, id="override"),
+        pytest.param({"x": 20}, True, ["x=10"], {"x": 10}, id="override"),
+        pytest.param(
+            {"x": 20}, False, ["x=null"], {"x": None}, id="override_with_null"
+        ),
+        # delete
+        pytest.param({"x": 20}, False, ["~x"], {}, id="delete"),
+        pytest.param({"x": 20}, False, ["~x=20"], {}, id="delete"),
+        pytest.param({"x": {"y": 10}}, False, ["~x"], {}, id="delete"),
+        pytest.param({"x": {"y": 10}}, False, ["~x.y"], {"x": {}}, id="delete"),
+        pytest.param({"x": {"y": 10}}, False, ["~x.y=10"], {"x": {}}, id="delete"),
+        pytest.param({"x": 20}, True, ["~x"], {}, id="delete_strict"),
+        pytest.param({"x": 20}, True, ["~x=20"], {}, id="delete_strict"),
+        pytest.param({"x": {"y": 10}}, True, ["~x"], {}, id="delete_strict"),
+        pytest.param({"x": {"y": 10}}, True, ["~x.y"], {"x": {}}, id="delete_strict"),
+        pytest.param(
+            {"x": {"y": 10}}, True, ["~x.y=10"], {"x": {}}, id="delete_strict"
+        ),
+        pytest.param(
+            {"x": 20},
+            False,
+            ["~z"],
+            pytest.raises(
+                HydraException,
+                match=re.escape("Could not delete from config. 'z' does not exist."),
+            ),
+            id="delete_error_key",
+        ),
+        pytest.param(
+            {"x": 20},
+            False,
+            ["~x=10"],
+            pytest.raises(
+                HydraException,
+                match=re.escape(
+                    "Could not delete from config. The value of 'x' is 20 and not 10."
+                ),
+            ),
+            id="delete_error_value",
+        ),
+    ],
+)
+def test_apply_overrides_to_config(
+    input_cfg: Any, strict: bool, overrides: List[str], expected: Any
+) -> None:
+    cfg = OmegaConf.create(input_cfg)
+    OmegaConf.set_struct(cfg, strict)
+    if isinstance(expected, dict):
+        ConfigLoaderImpl._apply_overrides_to_config(overrides=overrides, cfg=cfg)
+        assert cfg == expected
+    else:
+        with expected:
+            ConfigLoaderImpl._apply_overrides_to_config(overrides=overrides, cfg=cfg)

testbed/facebookresearch__hydra/tests/test_config_repository.py

@@ -0,0 +1,179 @@
+# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved
+import re
+from typing import Any, List, Optional
+
+import pytest
+
+from hydra._internal.config_repository import ConfigRepository
+from hydra._internal.config_search_path_impl import ConfigSearchPathImpl
+from hydra._internal.core_plugins.file_config_source import FileConfigSource
+from hydra._internal.core_plugins.package_config_source import PackageConfigSource
+from hydra._internal.core_plugins.structured_config_source import StructuredConfigSource
+from hydra.core.object_type import ObjectType
+from hydra.core.plugins import Plugins
+from hydra.plugins.config_source import ConfigSource
+from hydra.test_utils.config_source_common_tests import ConfigSourceTestSuite
+from hydra.test_utils.test_utils import chdir_hydra_root
+
+chdir_hydra_root()
+
+
+@pytest.mark.parametrize(
+    "type_, path",
+    [
+        pytest.param(
+            FileConfigSource,
+            "file://tests/test_apps/config_source_test/dir",
+            id="FileConfigSource",
+        ),
+        pytest.param(
+            PackageConfigSource,
+            "pkg://tests.test_apps.config_source_test.dir",
+            id="PackageConfigSource",
+        ),
+        pytest.param(
+            StructuredConfigSource,
+            "structured://tests.test_apps.config_source_test.structured",
+            id="StructuredConfigSource",
+        ),
+    ],
+)
+class TestCoreConfigSources(ConfigSourceTestSuite):
+    pass
+
+
+def create_config_search_path(path: str) -> ConfigSearchPathImpl:
+    csp = ConfigSearchPathImpl()
+    csp.append(provider="test", path=path)
+    return csp
+
+
+@pytest.mark.parametrize(
+    "path",
+    [
+        "file://tests/test_apps/config_source_test/dir",
+        "pkg://tests.test_apps.config_source_test.dir",
+    ],
+)
+class TestConfigRepository:
+    def test_config_repository_load(
+        self, hydra_restore_singletons: Any, path: str
+    ) -> None:
+        Plugins.instance()  # initializes
+        config_search_path = create_config_search_path(path)
+        repo = ConfigRepository(config_search_path=config_search_path)
+        ret = repo.load_config(
+            config_path="dataset/imagenet.yaml", is_primary_config=False
+        )
+        assert ret is not None
+        assert ret.config == {
+            "dataset": {"name": "imagenet", "path": "/datasets/imagenet"}
+        }
+        assert (
+            repo.load_config(config_path="not_found.yaml", is_primary_config=True)
+            is None
+        )
+
+    def test_config_repository_exists(
+        self, hydra_restore_singletons: Any, path: str
+    ) -> None:
+        Plugins.instance()  # initializes
+        config_search_path = create_config_search_path(path)
+        repo = ConfigRepository(config_search_path=config_search_path)
+        assert repo.config_exists("dataset/imagenet.yaml")
+        assert not repo.config_exists("not_found.yaml")
+
+    @pytest.mark.parametrize(  # type: ignore
+        "config_path,results_filter,expected",
+        [
+            (
+                "",
+                None,
+                [
+                    "config_without_group",
+                    "dataset",
+                    "level1",
+                    "optimizer",
+                    "package_test",
+                    "primary_config",
+                    "primary_config_with_non_global_package",
+                ],
+            ),
+            ("", ObjectType.GROUP, ["dataset", "level1", "optimizer", "package_test"]),
+            (
+                "",
+                ObjectType.CONFIG,
+                [
+                    "config_without_group",
+                    "dataset",
+                    "primary_config",
+                    "primary_config_with_non_global_package",
+                ],
+            ),
+            ("dataset", None, ["cifar10", "imagenet"]),
+            ("dataset", ObjectType.GROUP, []),
+            ("dataset", ObjectType.CONFIG, ["cifar10", "imagenet"]),
+            ("level1", ObjectType.GROUP, ["level2"]),
+            ("level1", ObjectType.CONFIG, []),
+            ("level1/level2", ObjectType.CONFIG, ["nested1", "nested2"]),
+        ],
+    )
+    def test_config_repository_list(
+        self,
+        hydra_restore_singletons: Any,
+        path: str,
+        config_path: str,
+        results_filter: Optional[ObjectType],
+        expected: List[str],
+    ) -> None:
+        Plugins.instance()  # initializes
+        config_search_path = create_config_search_path(path)
+        repo = ConfigRepository(config_search_path=config_search_path)
+        ret = repo.get_group_options(
+            group_name=config_path, results_filter=results_filter
+        )
+        assert ret == expected
+
+
+@pytest.mark.parametrize("sep", [" "])  # type: ignore
+@pytest.mark.parametrize(  # type: ignore
+    "cfg_text, expected",
+    [
+        ("# @package{sep}foo.bar", {"package": "foo.bar"}),
+        ("# @package{sep} foo.bar", {"package": "foo.bar"}),
+        ("# @package {sep}foo.bar", {"package": "foo.bar"}),
+        ("#@package{sep}foo.bar", {"package": "foo.bar"}),
+        ("#@package{sep}foo.bar ", {"package": "foo.bar"}),
+        (
+            "#@package{sep}foo.bar bah",
+            pytest.raises(ValueError, match=re.escape("Too many components in"),),
+        ),
+        (
+            "#@package",
+            pytest.raises(
+                ValueError, match=re.escape("Expected header format: KEY VALUE, got"),
+            ),
+        ),
+        (
+            """# @package{sep}foo.bar
+foo: bar
+# comment dsa
+""",
+            {"package": "foo.bar"},
+        ),
+        (
+            """
+# @package{sep}foo.bar
+""",
+            {"package": "foo.bar"},
+        ),
+    ],
+)
+def test_get_config_header(cfg_text: str, expected: Any, sep: str) -> None:
+    cfg_text = cfg_text.format(sep=sep)
+    if isinstance(expected, dict):
+        header = ConfigSource._get_header_dict(cfg_text)
+        assert header == expected
+    else:
+        with expected:
+            ConfigSource._get_header_dict(cfg_text)

testbed/facebookresearch__hydra/tests/test_config_search_path.py

@@ -0,0 +1,175 @@
+# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved
+from os.path import realpath
+from typing import List, Optional, Tuple
+
+import pytest
+
+from hydra._internal.config_search_path_impl import ConfigSearchPathImpl
+from hydra._internal.utils import compute_search_path_dir
+from hydra.core.config_search_path import SearchPathElement, SearchPathQuery
+
+
+def create_search_path(base_list: List[Tuple[str, str]]) -> ConfigSearchPathImpl:
+    csp = ConfigSearchPathImpl()
+    csp.config_search_path = [SearchPathElement(x[0], x[1]) for x in base_list]
+    return csp
+
+
+def to_tuples_list(
+    search_path: ConfigSearchPathImpl,
+) -> List[Tuple[Optional[str], Optional[str]]]:
+    return [(x.provider, x.path) for x in search_path.config_search_path]
+
+
+@pytest.mark.parametrize(  # type: ignore
+    "input_list, reference, expected_idx",
+    [
+        ([], ("", ""), -1),
+        ([("a", "10")], ("a", None), 0),
+        ([("a", "10"), ("b", "20"), ("a", "30")], ("a", None), 2),
+        ([("a", "10"), ("b", "20"), ("a", "30")], ("b", None), 1),
+        ([("a", "10"), ("b", "20"), ("a", "30")], ("a", "10"), 0),
+    ],
+)
+def test_find_last_match(
+    input_list: List[Tuple[str, str]], reference: str, expected_idx: int,
+) -> None:
+    csp = create_search_path(input_list)
+    assert (
+        csp.find_last_match(SearchPathQuery(reference[0], reference[1])) == expected_idx
+    )
+
+
+@pytest.mark.parametrize(  # type: ignore
+    "input_list, reference, expected_idx",
+    [
+        ([], ("", ""), -1),
+        ([("a", "10")], ("a", None), 0),
+        ([("a", "10"), ("b", "20"), ("a", "30")], ("a", None), 0),
+        ([("a", "10"), ("b", "20"), ("a", "30")], ("b", None), 1),
+        ([("a", "10"), ("b", "20"), ("a", "30")], ("a", "10"), 0),
+    ],
+)
+def test_find_first_match(
+    input_list: List[Tuple[str, str]], reference: str, expected_idx: int,
+) -> None:
+    csp = create_search_path(input_list)
+    sp = SearchPathQuery(reference[0], reference[1])
+    assert csp.find_first_match(sp) == expected_idx
+
+
+@pytest.mark.parametrize(  # type: ignore
+    "base_list, provider, path, anchor_provider, result_list",
+    [
+        # appending to an empty list
+        ([], "foo", "/path", None, [("foo", "/path")]),
+        # appending to a non empty list
+        ([("f1", "/p1")], "f2", "/p2", None, [("f1", "/p1"), ("f2", "/p2")]),
+        # appending after an anchor at key 0
+        (
+            [("f1", "A"), ("f2", "B")],
+            "f3",
+            "B",
+            SearchPathQuery(None, "A"),
+            [("f1", "A"), ("f3", "B"), ("f2", "B")],
+        ),
+        # appending after an anchor at the end of the list
+        (
+            [("f1", "A"), ("f2", "B")],
+            "f3",
+            "B",
+            SearchPathQuery(None, "B"),
+            [("f1", "A"), ("f2", "B"), ("f3", "B")],
+        ),
+        # appending after a non existent anchor
+        (
+            [],
+            "new_provider",
+            "/path",
+            "unregister_provider",
+            [("new_provider", "/path")],
+        ),
+    ],
+)
+def test_append(
+    base_list: List[Tuple[str, str]],
+    provider: str,
+    path: str,
+    anchor_provider: SearchPathQuery,
+    result_list: List[Tuple[str, str]],
+) -> None:
+    csp = create_search_path(base_list)
+    csp.append(provider=provider, path=path, anchor=anchor_provider)
+    assert to_tuples_list(csp) == result_list
+
+
+@pytest.mark.parametrize(  # type: ignore
+    "base_list, provider, path, anchor_provider, result_list",
+    [
+        # prepending to an empty list
+        ([], "foo", "/path", None, [("foo", "/path")]),
+        # prepending to a full list
+        (
+            [("foo", "/path")],
+            "foo2",
+            "/path2",
+            None,
+            [("foo2", "/path2"), ("foo", "/path")],
+        ),
+        # prepending in front of an anchor at key 0
+        (
+            [("foo", "/path")],
+            "foo2",
+            "/path2",
+            SearchPathQuery("foo", "/path"),
+            [("foo2", "/path2"), ("foo", "/path")],
+        ),
+        # prepending in front of an anchor at key 1
+        (
+            [("foo", "/path"), ("foo2", "/path2")],
+            "foo3",
+            "/path3",
+            SearchPathQuery("foo2", "/path2"),
+            [("foo", "/path"), ("foo3", "/path3"), ("foo2", "/path2")],
+        ),
+        # prepending in front of a none existing anchor results in prepending to the head of the list
+        ([], "foo2", "/path2", "does not exist", [("foo2", "/path2")]),
+    ],
+)
+def test_prepend(
+    base_list: List[Tuple[str, str]],
+    provider: str,
+    path: str,
+    anchor_provider: SearchPathQuery,
+    result_list: List[Tuple[str, str]],
+) -> None:
+    csp = create_search_path(base_list)
+    csp.prepend(provider=provider, path=path, anchor=anchor_provider)
+    assert to_tuples_list(csp) == result_list
+
+
+@pytest.mark.parametrize(  # type:ignore
+    "calling_file, calling_module, config_path, expected",
+    [
+        ("foo.py", None, None, realpath("")),
+        ("foo/bar.py", None, None, realpath("foo")),
+        ("foo/bar.py", None, "conf", realpath("foo/conf")),
+        ("foo/bar.py", None, "../conf", realpath("conf")),
+        ("c:/foo/bar.py", None, "conf", realpath("c:/foo/conf")),
+        ("c:/foo/bar.py", None, "../conf", realpath("c:/conf")),
+        # short module name, keep it to avoid empty module error
+        (None, "module", None, "pkg://module"),
+        (None, "package.module", None, "pkg://package"),
+        (None, "package.module", "conf", "pkg://package/conf"),
+        # This is an unusual one. this behavior is intentional.
+        (None, "package.module", "../conf", "pkg://conf"),
+        (None, "package1.package2.module", "../conf", "pkg://package1/conf"),
+        # prefer package
+        ("foo", "package1.package2.module", "../conf", "pkg://package1/conf"),
+    ],
+)
+def test_compute_search_path_dir(
+    calling_file: str, calling_module: str, config_path: str, expected: str
+) -> None:
+    res = compute_search_path_dir(calling_file, calling_module, config_path)
+    assert res == expected

testbed/facebookresearch__hydra/tests/test_core_utils.py

@@ -0,0 +1,25 @@
+# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved
+from typing import Any
+
+from omegaconf import open_dict
+
+from hydra._internal.config_loader_impl import ConfigLoaderImpl
+from hydra._internal.utils import create_config_search_path
+from hydra.core import utils
+from hydra.core.hydra_config import HydraConfig
+
+
+def test_accessing_hydra_config(hydra_restore_singletons: Any) -> Any:
+    utils.setup_globals()
+
+    config_loader = ConfigLoaderImpl(
+        config_search_path=create_config_search_path("pkg://hydra.test_utils.configs")
+    )
+    cfg = config_loader.load_configuration(
+        config_name="accessing_hydra_config", overrides=[]
+    )
+    HydraConfig.instance().set_config(cfg)
+    with open_dict(cfg):
+        del cfg["hydra"]
+    assert cfg.job_name == "UNKNOWN_NAME"
+    assert cfg.config_name == "accessing_hydra_config"

testbed/facebookresearch__hydra/tests/test_hydra.py

@@ -0,0 +1,814 @@
+# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved
+import os
+import re
+import subprocess
+import sys
+from pathlib import Path
+from typing import Any, List, Set
+
+import pytest
+from omegaconf import DictConfig, OmegaConf
+
+from hydra import MissingConfigException
+from hydra.test_utils.test_utils import (
+    TSweepRunner,
+    TTaskRunner,
+    chdir_hydra_root,
+    integration_test,
+    verify_dir_outputs,
+)
+
+chdir_hydra_root()
+
+
+@pytest.mark.parametrize(  # type: ignore
+    "calling_file, calling_module", [(".", None), (None, ".")]
+)
+def test_missing_conf_dir(
+    hydra_restore_singletons: Any,
+    hydra_task_runner: TTaskRunner,
+    calling_file: str,
+    calling_module: str,
+) -> None:
+    with pytest.raises(MissingConfigException):
+        with hydra_task_runner(
+            calling_file=calling_file,
+            calling_module=calling_module,
+            config_path="dir_not_found",
+            config_name=None,
+        ):
+            pass
+
+
+@pytest.mark.parametrize(  # type: ignore
+    "calling_file, calling_module",
+    [
+        ("tests/test_apps/app_without_config/my_app.py", None),
+        (None, "tests.test_apps.app_without_config.my_app"),
+    ],
+)
+def test_missing_conf_file(
+    hydra_restore_singletons: Any,
+    hydra_task_runner: TTaskRunner,
+    calling_file: str,
+    calling_module: str,
+) -> None:
+    with pytest.raises(MissingConfigException):
+        with hydra_task_runner(
+            calling_file=calling_file,
+            calling_module=calling_module,
+            config_path=None,
+            config_name="not_found.yaml",
+        ):
+            pass
+
+
+@pytest.mark.parametrize(  # type: ignore
+    "calling_file, calling_module",
+    [
+        ("tests/test_apps/app_without_config/my_app.py", None),
+        (None, "tests.test_apps.app_without_config.my_app"),
+    ],
+)
+def test_app_without_config___no_overrides(
+    hydra_restore_singletons: Any,
+    hydra_task_runner: TTaskRunner,
+    calling_file: str,
+    calling_module: str,
+) -> None:
+    with hydra_task_runner(
+        calling_file=calling_file,
+        calling_module=calling_module,
+        config_path=None,
+        config_name=None,
+    ) as task:
+        assert task.job_ret is not None
+        assert task.job_ret.cfg == {}
+
+
+@pytest.mark.parametrize(  # type: ignore
+    "calling_file, calling_module",
+    [
+        ("tests/test_apps/hydra_main_rerun/my_app.py", None),
+        (None, "tests.test_apps.hydra_main_rerun.my_app"),
+    ],
+)
+def test_hydra_main_rerun(
+    hydra_restore_singletons: Any,
+    hydra_task_runner: TTaskRunner,
+    calling_file: str,
+    calling_module: str,
+) -> None:
+    with hydra_task_runner(
+        calling_file=calling_file,
+        calling_module=calling_module,
+        config_path=None,
+        config_name=None,
+    ) as task:
+        assert task.job_ret is not None
+        assert task.job_ret.cfg == {}
+
+
+@pytest.mark.parametrize(  # type: ignore
+    "calling_file, calling_module",
+    [
+        ("tests/test_apps/app_without_config/my_app.py", None),
+        (None, "tests.test_apps.app_without_config.my_app"),
+    ],
+)
+def test_app_without_config__with_append(
+    hydra_restore_singletons: Any,
+    hydra_task_runner: TTaskRunner,
+    calling_file: str,
+    calling_module: str,
+) -> None:
+    with hydra_task_runner(
+        calling_file=calling_file,
+        calling_module=calling_module,
+        config_path="",
+        config_name=None,
+        overrides=["+abc=123", "+a.b=1", "+a.a=2"],
+    ) as task:
+        assert task.job_ret is not None and task.job_ret.cfg == dict(
+            abc=123, a=dict(b=1, a=2)
+        )
+        verify_dir_outputs(task.job_ret, task.overrides)
+
+
+@pytest.mark.parametrize(  # type: ignore
+    "calling_file, calling_module",
+    [
+        ("tests/test_apps/app_with_cfg/my_app.py", None),
+        (None, "tests.test_apps.app_with_cfg.my_app"),
+    ],
+)
+def test_app_with_config_file__no_overrides(
+    hydra_restore_singletons: Any,
+    hydra_task_runner: TTaskRunner,
+    calling_file: str,
+    calling_module: str,
+) -> None:
+
+    task = hydra_task_runner(
+        calling_file=calling_file,
+        calling_module=calling_module,
+        config_path=None,  # Testing legacy mode, both path and named are in config_path
+        config_name="config.yaml",
+    )
+    with task:
+        assert task.job_ret is not None and task.job_ret.cfg == {
+            "dataset": {"name": "imagenet", "path": "/datasets/imagenet"}
+        }
+
+        verify_dir_outputs(task.job_ret)
+
+
+@pytest.mark.parametrize(  # type: ignore
+    "calling_file, calling_module",
+    [
+        ("tests/test_apps/app_with_cfg_groups_no_header/my_app.py", None,),
+        (None, "tests.test_apps.app_with_cfg_groups_no_header.my_app",),
+    ],
+)
+def test_config_without_package_header_warnings(
+    hydra_restore_singletons: Any,
+    hydra_task_runner: TTaskRunner,
+    calling_file: str,
+    calling_module: str,
+    recwarn: Any,
+) -> None:
+    task = hydra_task_runner(
+        calling_file=calling_file,
+        calling_module=calling_module,
+        config_path="conf",
+        config_name="config.yaml",
+    )
+    with task:
+        assert task.job_ret is not None and task.job_ret.cfg == {
+            "optimizer": {"type": "nesterov", "lr": 0.001}
+        }
+
+    assert len(recwarn) == 1
+    msg = recwarn.pop().message.args[0]
+    assert "Missing @package directive optimizer/nesterov.yaml in " in msg
+    assert (
+        "See https://hydra.cc/docs/next/upgrades/0.11_to_1.0/adding_a_package_directive"
+        in msg
+    )
+
+
+@pytest.mark.parametrize(  # type: ignore
+    "calling_file, calling_module",
+    [
+        ("tests/test_apps/app_with_cfg_groups/my_app.py", None),
+        (None, "tests.test_apps.app_with_cfg_groups.my_app"),
+    ],
+)
+def test_app_with_config_path_backward_compatibility(
+    hydra_restore_singletons: Any,
+    hydra_task_runner: TTaskRunner,
+    calling_file: str,
+    calling_module: str,
+) -> None:
+    msg = (
+        "\nUsing config_path to specify the config name is deprecated, specify the config name via config_name"
+        "\nSee https://hydra.cc/next/upgrades/0.11_to_1.0/config_path_changes"
+    )
+
+    with pytest.warns(expected_warning=UserWarning, match=re.escape(msg)):
+        task = hydra_task_runner(
+            calling_file=calling_file,
+            calling_module=calling_module,
+            config_path="conf/config.yaml",  # Testing legacy mode, both path and named are in config_path
+            config_name=None,
+        )
+        with task:
+            assert task.job_ret is not None and task.job_ret.cfg == {
+                "optimizer": {"type": "nesterov", "lr": 0.001}
+            }
+
+            verify_dir_outputs(task.job_ret)
+
+
+@pytest.mark.parametrize(  # type: ignore
+    "calling_file, calling_module",
+    [
+        ("tests/test_apps/app_with_cfg/my_app.py", None),
+        (None, "tests.test_apps.app_with_cfg.my_app"),
+    ],
+)
+def test_app_with_config_file__with_overide(
+    hydra_restore_singletons: Any,
+    hydra_task_runner: TTaskRunner,
+    calling_file: str,
+    calling_module: str,
+) -> None:
+    with hydra_task_runner(
+        calling_file=calling_file,
+        calling_module=calling_module,
+        config_path=None,
+        config_name="config.yaml",
+        overrides=["dataset.path=/datasets/imagenet2"],
+    ) as task:
+        assert task.job_ret is not None and task.job_ret.cfg == dict(
+            dataset=dict(name="imagenet", path="/datasets/imagenet2")
+        )
+        verify_dir_outputs(task.job_ret, task.overrides)
+
+
+@pytest.mark.parametrize(  # type: ignore
+    "calling_file, calling_module",
+    [
+        ("tests/test_apps/app_with_split_cfg/my_app.py", None),
+        (None, "tests.test_apps.app_with_split_cfg.my_app"),
+    ],
+)
+def test_app_with_split_config(
+    hydra_restore_singletons: Any,
+    hydra_task_runner: TTaskRunner,
+    calling_file: str,
+    calling_module: str,
+) -> None:
+    with hydra_task_runner(
+        calling_file=calling_file,
+        calling_module=calling_module,
+        config_path=None,
+        config_name="config.yaml",
+    ) as task:
+        assert task.job_ret is not None and task.job_ret.cfg == dict(
+            dataset=dict(name="imagenet", path="/datasets/imagenet"),
+            optimizer=dict(lr=0.001, type="nesterov"),
+        )
+        verify_dir_outputs(task.job_ret)
+
+
+@pytest.mark.parametrize(  # type: ignore
+    "calling_file, calling_module",
+    [
+        ("tests/test_apps/app_with_cfg_groups/my_app.py", None),
+        (None, "tests.test_apps.app_with_cfg_groups.my_app"),
+    ],
+)
+def test_app_with_config_groups__override_dataset__wrong(
+    hydra_restore_singletons: Any,
+    hydra_task_runner: TTaskRunner,
+    calling_file: str,
+    calling_module: str,
+) -> None:
+    with pytest.raises(MissingConfigException) as ex:
+        with hydra_task_runner(
+            calling_file=calling_file,
+            calling_module=calling_module,
+            config_path="conf",
+            config_name=None,
+            overrides=["+optimizer=wrong_name"],
+        ):
+            pass
+    assert sorted(ex.value.options) == sorted(["adam", "nesterov"])
+
+
+@pytest.mark.parametrize(  # type: ignore
+    "calling_file, calling_module",
+    [
+        ("tests/test_apps/app_with_cfg_groups/my_app.py", None),
+        (None, "tests.test_apps.app_with_cfg_groups.my_app"),
+    ],
+)
+def test_app_with_config_groups__override_all_configs(
+    hydra_restore_singletons: Any,
+    hydra_task_runner: TTaskRunner,
+    calling_file: str,
+    calling_module: str,
+) -> None:
+    with hydra_task_runner(
+        calling_file=calling_file,
+        calling_module=calling_module,
+        config_path="conf",
+        config_name=None,
+        overrides=["+optimizer=adam", "optimizer.lr=10"],
+    ) as task:
+        assert task.job_ret is not None and task.job_ret.cfg == dict(
+            optimizer=dict(type="adam", lr=10, beta=0.01)
+        )
+        verify_dir_outputs(task.job_ret, overrides=task.overrides)
+
+
+@pytest.mark.parametrize(  # type: ignore
+    "calling_file, calling_module",
+    [
+        ("tests/test_apps/app_with_custom_launcher/my_app.py", None),
+        (None, "tests.test_apps.app_with_custom_launcher.my_app"),
+    ],
+)
+def test_app_with_sweep_cfg__override_to_basic_launcher(
+    hydra_restore_singletons: Any,
+    hydra_task_runner: TTaskRunner,
+    calling_file: str,
+    calling_module: str,
+) -> None:
+    with hydra_task_runner(
+        calling_file=calling_file,
+        calling_module=calling_module,
+        config_path=None,
+        config_name="config.yaml",
+        overrides=["hydra/launcher=basic"],
+    ) as task:
+        assert task.job_ret is not None
+        assert task.job_ret.hydra_cfg is not None
+        hydra_cfg = task.job_ret.hydra_cfg
+        assert (
+            hydra_cfg.hydra.launcher.cls
+            == "hydra._internal.core_plugins.basic_launcher.BasicLauncher"
+        )
+        assert len(task.job_ret.hydra_cfg.hydra.launcher.params) == 0
+
+
+def test_short_module_name(tmpdir: Path) -> None:
+    cmd = [
+        sys.executable,
+        "examples/tutorials/basic/your_first_hydra_app/2_config_file/my_app.py",
+        "hydra.run.dir=" + str(tmpdir),
+    ]
+    result = subprocess.check_output(cmd)
+    assert OmegaConf.create(str(result.decode("utf-8"))) == {
+        "db": {"driver": "mysql", "password": "secret", "user": "omry"}
+    }
+
+
+def test_hydra_main_module_override_name(tmpdir: Path) -> None:
+    cfg = OmegaConf.create()
+    integration_test(
+        tmpdir=tmpdir,
+        task_config=cfg,
+        overrides=[],
+        prints="HydraConfig.get().job.name",
+        expected_outputs="Foo",
+        env_override={"HYDRA_MAIN_MODULE": "hydra.test_utils.configs.Foo"},
+    )
+
+
+def test_short_hydra_main_module_override_name(tmpdir: Path) -> None:
+    cfg = OmegaConf.create()
+    integration_test(
+        tmpdir=tmpdir,
+        task_config=cfg,
+        overrides=[],
+        prints="HydraConfig.get().job.name",
+        expected_outputs="Foo",
+        env_override={"HYDRA_MAIN_MODULE": "Foo"},
+    )
+
+
+@pytest.mark.parametrize(  # type: ignore
+    "env_name", ["HYDRA_MAIN_MODULE", "FB_PAR_MAIN_MODULE", "FB_XAR_MAIN_MODULE"]
+)
+def test_module_env_override(tmpdir: Path, env_name: str) -> None:
+    """
+    Tests that module name overrides are working.
+    """
+    cmd = [
+        sys.executable,
+        "examples/tutorials/basic/your_first_hydra_app/2_config_file/my_app.py",
+        "hydra.run.dir=" + str(tmpdir),
+    ]
+    modified_env = os.environ.copy()
+    modified_env[env_name] = "hydra.test_utils.configs.Foo"
+    result = subprocess.check_output(cmd, env=modified_env)
+    assert OmegaConf.create(str(result.decode("utf-8"))) == {"normal_yaml_config": True}
+
+
+@pytest.mark.parametrize(  # type: ignore
+    "flag,expected_keys",
+    [("--cfg=all", ["db", "hydra"]), ("--cfg=hydra", ["hydra"]), ("--cfg=job", ["db"])],
+)
+def test_cfg(tmpdir: Path, flag: str, expected_keys: List[str]) -> None:
+    cmd = [
+        sys.executable,
+        "examples/tutorials/basic/your_first_hydra_app/5_defaults/my_app.py",
+        "hydra.run.dir=" + str(tmpdir),
+        flag,
+    ]
+    result = subprocess.check_output(cmd)
+    conf = OmegaConf.create(str(result.decode("utf-8")))
+    for key in expected_keys:
+        assert key in conf
+
+
+@pytest.mark.parametrize(  # type: ignore
+    "flags,expected",
+    [
+        (
+            ["--cfg=job", "--package=_global_"],
+            """# @package _global_
+db:
+  driver: mysql
+  user: omry
+  pass: secret
+""",
+        ),
+        (
+            ["--cfg=job", "--package=db"],
+            """# @package db
+driver: mysql
+user: omry
+pass: secret
+""",
+        ),
+        (["--cfg=job", "--package=db.driver"], "mysql\n"),
+    ],
+)
+def test_cfg_with_package(tmpdir: Path, flags: List[str], expected: str) -> None:
+    cmd = [
+        sys.executable,
+        "examples/tutorials/basic/your_first_hydra_app/5_defaults/my_app.py",
+        "hydra.run.dir=" + str(tmpdir),
+    ] + flags
+
+    def norm(s: str) -> str:
+        return s.replace("\r\n", "\n").replace("\r", "\n")
+
+    result = subprocess.check_output(cmd).decode("utf-8")
+    assert norm(result) == norm(expected)
+
+
+@pytest.mark.parametrize(  # type: ignore
+    "calling_file, calling_module",
+    [
+        ("tests/test_apps/app_with_config_with_free_group/my_app.py", None),
+        (None, "tests.test_apps.app_with_config_with_free_group.my_app"),
+    ],
+)
+@pytest.mark.parametrize("overrides", [["+free_group=opt1,opt2"]])  # type: ignore
+def test_multirun_with_free_override(
+    hydra_restore_singletons: Any,
+    hydra_sweep_runner: TSweepRunner,
+    calling_file: str,
+    calling_module: str,
+    overrides: List[str],
+) -> None:
+    sweep = hydra_sweep_runner(
+        calling_file=calling_file,
+        calling_module=calling_module,
+        config_path="conf/",
+        config_name="config.yaml",
+        task_function=None,
+        overrides=overrides,
+    )
+    with sweep:
+        assert sweep.returns is not None and len(sweep.returns[0]) == 2
+        assert sweep.returns[0][0].overrides == ["+free_group=opt1"]
+        assert sweep.returns[0][0].cfg == {"group_opt1": True, "free_group_opt1": True}
+        assert sweep.returns[0][1].overrides == ["+free_group=opt2"]
+        assert sweep.returns[0][1].cfg == {"group_opt1": True, "free_group_opt2": True}
+
+
+@pytest.mark.parametrize(  # type: ignore
+    "calling_file, calling_module",
+    [
+        pytest.param(
+            "tests/test_apps/sweep_complex_defaults/my_app.py", None, id="file_path"
+        ),
+        pytest.param(
+            None, "tests.test_apps.sweep_complex_defaults.my_app", id="pkg_path"
+        ),
+    ],
+)
+def test_sweep_complex_defaults(
+    hydra_restore_singletons: Any,
+    hydra_sweep_runner: TSweepRunner,
+    calling_file: str,
+    calling_module: str,
+) -> None:
+    with hydra_sweep_runner(
+        calling_file=calling_file,
+        calling_module=calling_module,
+        config_path="conf",
+        config_name="config.yaml",
+        task_function=None,
+        overrides=["optimizer=adam,nesterov"],
+    ) as sweep:
+        assert sweep.returns is not None and len(sweep.returns[0]) == 2
+        assert sweep.returns[0][0].overrides == ["optimizer=adam"]
+        assert sweep.returns[0][1].overrides == ["optimizer=nesterov"]
+
+
+@pytest.mark.parametrize(  # type: ignore
+    "script, flag, overrides,expected",
+    [
+        pytest.param(
+            "examples/tutorials/basic/your_first_hydra_app/1_simple_cli/my_app.py",
+            "--help",
+            ["hydra.help.template=foo"],
+            "foo\n",
+            id="simple_cli_app",
+        ),
+        pytest.param(
+            "examples/tutorials/basic/your_first_hydra_app/2_config_file/my_app.py",
+            "--help",
+            ["hydra.help.template=foo"],
+            "foo\n",
+            id="overriding_help_template",
+        ),
+        pytest.param(
+            "examples/tutorials/basic/your_first_hydra_app/2_config_file/my_app.py",
+            "--help",
+            ["hydra.help.template=$CONFIG", "db.user=root"],
+            """db:
+  driver: mysql
+  user: root
+  password: secret
+
+""",
+            id="overriding_help_template:$CONFIG",
+        ),
+        pytest.param(
+            "examples/tutorials/basic/your_first_hydra_app/2_config_file/my_app.py",
+            "--help",
+            ["hydra.help.template=$FLAGS_HELP"],
+            """--help,-h : Application's help
+--hydra-help : Hydra's help
+--version : show program's version number and exit
+--cfg,-c : Show config instead of running [job|hydra|all]
+--package,-p : Config package to show
+--run,-r : Run a job
+--multirun,-m : Run multiple jobs with the configured launcher
+--shell-completion,-sc : Install or Uninstall shell completion:
+    Bash - Install:
+    eval "$(python {script} -sc install=bash)"
+    Bash - Uninstall:
+    eval "$(python {script} -sc uninstall=bash)"
+
+    Fish - Install:
+    python {script} -sc install=fish | source
+    Fish - Uninstall:
+    python {script} -sc uninstall=fish | source
+
+--config-path,-cp : Overrides the config_path specified in hydra.main().
+                    The config_path is relative to the Python file declaring @hydra.main()
+--config-name,-cn : Overrides the config_name specified in hydra.main()
+--info,-i : Print Hydra information
+Overrides : Any key=value arguments to override config values (use dots for.nested=overrides)
+""",
+            id="overriding_help_template:$FLAGS_HELP",
+        ),
+        pytest.param(
+            "examples/tutorials/basic/your_first_hydra_app/4_config_groups/my_app.py",
+            "--help",
+            ["hydra.help.template=$APP_CONFIG_GROUPS"],
+            """db: mysql, postgresql
+
+""",
+            id="overriding_help_template:$APP_CONFIG_GROUPS",
+        ),
+        pytest.param(
+            "examples/tutorials/basic/your_first_hydra_app/2_config_file/my_app.py",
+            "--hydra-help",
+            ["hydra.hydra_help.template=foo"],
+            "foo\n",
+            id="overriding_hydra_help_template",
+        ),
+        pytest.param(
+            "examples/tutorials/basic/your_first_hydra_app/2_config_file/my_app.py",
+            "--hydra-help",
+            ["hydra.hydra_help.template=$FLAGS_HELP"],
+            """--help,-h : Application's help
+--hydra-help : Hydra's help
+--version : show program's version number and exit
+--cfg,-c : Show config instead of running [job|hydra|all]
+--package,-p : Config package to show
+--run,-r : Run a job
+--multirun,-m : Run multiple jobs with the configured launcher
+--shell-completion,-sc : Install or Uninstall shell completion:
+    Bash - Install:
+    eval "$(python {script} -sc install=bash)"
+    Bash - Uninstall:
+    eval "$(python {script} -sc uninstall=bash)"
+
+    Fish - Install:
+    python {script} -sc install=fish | source
+    Fish - Uninstall:
+    python {script} -sc uninstall=fish | source
+
+--config-path,-cp : Overrides the config_path specified in hydra.main().
+                    The config_path is relative to the Python file declaring @hydra.main()
+--config-name,-cn : Overrides the config_name specified in hydra.main()
+--info,-i : Print Hydra information
+Overrides : Any key=value arguments to override config values (use dots for.nested=overrides)
+""",
+            id="overriding_hydra_help_template:$FLAGS_HELP",
+        ),
+    ],
+)
+def test_help(
+    tmpdir: Path, script: str, flag: str, overrides: List[str], expected: Any,
+) -> None:
+    cmd = [sys.executable, script, "hydra.run.dir=" + str(tmpdir)]
+    cmd.extend(overrides)
+    cmd.append(flag)
+    print(" ".join(cmd))
+    result = str(subprocess.check_output(cmd).decode("utf-8"))
+    # normalize newlines on Windows to make testing easier
+    result = result.replace("\r\n", "\n")
+    assert result == expected.format(script=script)
+
+
+@pytest.mark.parametrize(  # type: ignore
+    "calling_file, calling_module",
+    [
+        ("tests/test_apps/interpolating_dir_hydra_to_app/my_app.py", None),
+        (None, "tests.test_apps.interpolating_dir_hydra_to_app.my_app"),
+    ],
+)
+def test_interpolating_dir_hydra_to_app(
+    hydra_restore_singletons: Any,
+    hydra_task_runner: TTaskRunner,
+    calling_file: str,
+    calling_module: str,
+) -> None:
+    basedir = "foo"
+    with hydra_task_runner(
+        calling_file=calling_file,
+        calling_module=calling_module,
+        config_path=None,
+        config_name="config.yaml",
+        overrides=["experiment.base_dir=" + basedir],
+    ) as task:
+        assert task.temp_dir is not None
+        path = Path(task.temp_dir) / basedir
+        assert path.exists()
+
+
+def test_sys_exit(tmpdir: Path) -> None:
+    cmd = [
+        sys.executable,
+        "tests/test_apps/sys_exit/my_app.py",
+        "hydra.run.dir=" + str(tmpdir),
+    ]
+    assert subprocess.run(cmd).returncode == 42
+
+
+@pytest.mark.parametrize(  # type: ignore
+    "task_config, overrides, expected_dir",
+    [
+        ({"hydra": {"run": {"dir": "foo"}}}, [], "foo"),
+        ({}, ["hydra.run.dir=bar"], "bar"),
+        ({"hydra": {"run": {"dir": "foo"}}}, ["hydra.run.dir=boom"], "boom"),
+        (
+            {
+                "hydra": {"run": {"dir": "foo-${hydra.job.override_dirname}"}},
+                "app": {"a": 1, "b": 2},
+            },
+            ["app.a=20"],
+            "foo-app.a=20",
+        ),
+    ],
+)
+def test_local_run_workdir(
+    tmpdir: Path, task_config: DictConfig, overrides: List[str], expected_dir: str
+) -> None:
+    cfg = OmegaConf.create(task_config)
+    assert isinstance(cfg, DictConfig)
+    expected_dir1 = tmpdir / expected_dir
+    integration_test(
+        tmpdir=tmpdir,
+        task_config=cfg,
+        overrides=overrides,
+        prints="os.getcwd()",
+        expected_outputs=str(expected_dir1),
+    )
+
+
+def test_hydra_env_set(tmpdir: Path) -> None:
+    cfg = OmegaConf.create({"hydra": {"job": {"env_set": {"foo": "bar"}}}})
+    integration_test(
+        tmpdir=tmpdir,
+        task_config=cfg,
+        overrides=[],
+        prints="os.environ['foo']",
+        expected_outputs="bar",
+    )
+
+
+@pytest.mark.parametrize(  # type: ignore
+    "override", [pytest.param("xyz", id="db=xyz"), pytest.param("", id="db=")]
+)
+@pytest.mark.parametrize(  # type: ignore
+    "calling_file, calling_module",
+    [
+        pytest.param("hydra/test_utils/example_app.py", None, id="file"),
+        pytest.param(None, "hydra.test_utils.example_app", id="module"),
+    ],
+)
+def test_override_with_invalid_group_choice(
+    hydra_restore_singletons: Any,
+    hydra_task_runner: TTaskRunner,
+    calling_file: str,
+    calling_module: str,
+    override: str,
+) -> None:
+    msg = f"""Could not load db/{override}, available options:\ndb:\n\tmysql\n\tpostgresql"""
+
+    with pytest.raises(MissingConfigException, match=re.escape(msg)):
+        with hydra_task_runner(
+            calling_file=calling_file,
+            calling_module=calling_module,
+            config_path="configs",
+            config_name="db_conf",
+            overrides=[f"db={override}"],
+        ):
+            ...
+
+
+@pytest.mark.parametrize("config_path", ["dir1", "dir2"])  # type: ignore
+@pytest.mark.parametrize("config_name", ["cfg1", "cfg2"])  # type: ignore
+def test_config_name_and_path_overrides(
+    tmpdir: Path, config_path: str, config_name: str
+) -> None:
+    cmd = [
+        sys.executable,
+        "tests/test_apps/app_with_multiple_config_dirs/my_app.py",
+        "hydra.run.dir=" + str(tmpdir),
+        f"--config-name={config_name}",
+        f"--config-path={config_path}",
+    ]
+    print(" ".join(cmd))
+    result = str(subprocess.check_output(cmd).decode("utf-8")).strip()
+    # normalize newlines on Windows to make testing easier
+    result = result.replace("\r\n", "\n")
+    assert result == f"{config_path}_{config_name}: true"
+
+
+@pytest.mark.parametrize(  # type: ignore
+    "overrides, expected_files",
+    [
+        ([], {"my_app.log", ".hydra"}),
+        (["hydra.output_subdir=foo"], {"my_app.log", "foo"}),
+        (["hydra.output_subdir=null"], {"my_app.log"}),
+    ],
+)
+@pytest.mark.parametrize(  # type: ignore
+    "calling_file, calling_module",
+    [
+        ("tests/test_apps/app_with_cfg/my_app.py", None),
+        (None, "tests.test_apps.app_with_cfg.my_app"),
+    ],
+)
+def test_hydra_output_dir(
+    hydra_restore_singletons: Any,
+    hydra_task_runner: TTaskRunner,
+    calling_file: str,
+    calling_module: str,
+    overrides: List[str],
+    expected_files: Set[str],
+) -> None:
+    with hydra_task_runner(
+        calling_file=calling_file,
+        calling_module=calling_module,
+        config_path=None,
+        config_name=None,
+        overrides=overrides,
+    ) as task:
+        assert task.temp_dir is not None
+        path = Path(task.temp_dir)
+        files = set([str(x)[len(task.temp_dir) + 1 :] for x in path.iterdir()])
+        assert files == expected_files

testbed/facebookresearch__hydra/tests/test_plugins/namespace_pkg_config_source_test/setup.py

@@ -0,0 +1,12 @@
+# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved
+from setuptools import find_namespace_packages, setup
+
+setup(
+    name="hydra-namespace-test-plugin",
+    version="0.1.0",
+    author="Omry Yadan",
+    author_email="omry@fb.com",
+    url="https://github.com/facebookresearch/hydra/",
+    packages=find_namespace_packages(include=["some_namespace.*"]),
+    install_requires=["hydra-core==1.0.*"],
+)

testbed/facebookresearch__hydra/tests/test_plugins/namespace_pkg_config_source_test/some_namespace/namespace_test/dir/level1/level2/nested1.yaml

@@ -0,0 +1,2 @@
+# @package _global_
+l1_l2_n1: true

testbed/facebookresearch__hydra/tests/test_plugins/namespace_pkg_config_source_test/some_namespace/namespace_test/dir/package_test/explicit.yaml

@@ -0,0 +1,2 @@
+# @package a.b
+foo: bar

testbed/facebookresearch__hydra/tests/test_plugins/namespace_pkg_config_source_test/some_namespace/namespace_test/dir/package_test/group_name.yaml

@@ -0,0 +1,2 @@
+# @package foo._group_._name_
+foo: bar

testbed/facebookresearch__hydra/tests/test_utils.py

@@ -0,0 +1,322 @@
+# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved
+import copy
+import os
+from pathlib import Path
+from typing import Any, Dict, Optional
+
+import pytest
+from omegaconf import DictConfig, OmegaConf
+
+import hydra._internal.utils as internal_utils
+from hydra import utils
+from hydra.conf import HydraConf, RuntimeConf
+from hydra.core.hydra_config import HydraConfig
+from hydra.types import ObjectConf
+
+
+def some_method() -> int:
+    return 42
+
+
+class Bar:
+    def __init__(self, a: Any, b: Any, c: Any, d: Any = "default_value") -> None:
+        self.a = a
+        self.b = b
+        self.c = c
+        self.d = d
+
+    def __repr__(self) -> str:
+        return f"a={self.a}, b={self.b}, c={self.c}, d={self.d}"
+
+    @staticmethod
+    def static_method() -> int:
+        return 43
+
+    def __eq__(self, other: Any) -> Any:
+        """Overrides the default implementation"""
+        if isinstance(other, Bar):
+
+            return (
+                self.a == other.a
+                and self.b == other.b
+                and self.c == other.c
+                and self.d == other.d
+            )
+        return NotImplemented
+
+    def __ne__(self, other: Any) -> Any:
+        """Overrides the default implementation (unnecessary in Python 3)"""
+        x = self.__eq__(other)
+        if x is not NotImplemented:
+            return not x
+        return NotImplemented
+
+
+class Foo:
+    def __init__(self, x: int) -> None:
+        self.x = x
+
+    def __eq__(self, other: Any) -> Any:
+        if isinstance(other, Foo):
+            return self.x == other.x
+        return False
+
+
+class Baz(Foo):
+    @classmethod
+    def class_method(self, y: int) -> Any:
+        return self(y + 1)
+
+    @staticmethod
+    def static_method(z: int) -> int:
+        return z
+
+
+class Fii:
+    def __init__(self, a: Baz = Baz(10)):
+        self.a = a
+
+    def __repr__(self) -> str:
+        return f"a={self.a}"
+
+    def __eq__(self, other: Any) -> Any:
+        """Overrides the default implementation"""
+        if isinstance(other, Fii):
+
+            return self.a == other.a
+        return NotImplemented
+
+    def __ne__(self, other: Any) -> Any:
+        """Overrides the default implementation (unnecessary in Python 3)"""
+        x = self.__eq__(other)
+        if x is not NotImplemented:
+            return not x
+        return NotImplemented
+
+
+fii = Fii()
+
+
+def fum(k: int) -> int:
+    return k + 1
+
+
+@pytest.mark.parametrize(  # type: ignore
+    "path,expected_type", [("tests.test_utils.Bar", Bar)]
+)
+def test_get_class(path: str, expected_type: type) -> None:
+    assert utils.get_class(path) == expected_type
+
+
+@pytest.mark.parametrize(  # type: ignore
+    "path,return_value", [("tests.test_utils.some_method", 42)]
+)
+def test_get_method(path: str, return_value: Any) -> None:
+    assert utils.get_method(path)() == return_value
+
+
+@pytest.mark.parametrize(  # type: ignore
+    "path,return_value", [("tests.test_utils.Bar.static_method", 43)]
+)
+def test_get_static_method(path: str, return_value: Any) -> None:
+    assert utils.get_static_method(path)() == return_value
+
+
+@pytest.mark.parametrize(  # type: ignore
+    "input_conf, key_to_get_config, kwargs_to_pass, expected",
+    [
+        (
+            {
+                "cls": "tests.test_utils.Bar",
+                "params": {"a": 10, "b": 20, "c": 30, "d": 40},
+            },
+            None,
+            {},
+            Bar(10, 20, 30, 40),
+        ),
+        (
+            {
+                "all_params": {
+                    "main": {
+                        "cls": "tests.test_utils.Bar",
+                        "params": {"a": 10, "b": 20, "c": "${all_params.aux.c}"},
+                    },
+                    "aux": {"c": 30},
+                }
+            },
+            "all_params.main",
+            {"d": 40},
+            Bar(10, 20, 30, 40),
+        ),
+        (
+            {"cls": "tests.test_utils.Bar", "params": {"b": 20, "c": 30}},
+            None,
+            {"a": 10, "d": 40},
+            Bar(10, 20, 30, 40),
+        ),
+        (
+            {"cls": "tests.test_utils.Bar", "params": {"b": 200, "c": "${params.b}"}},
+            None,
+            {"a": 10, "d": 40},
+            Bar(10, 200, 200, 40),
+        ),
+        # Check class and static methods
+        (
+            {"cls": "tests.test_utils.Baz.class_method", "params": {"y": 10}},
+            None,
+            {},
+            Baz(11),
+        ),
+        (
+            {"cls": "tests.test_utils.Baz.static_method", "params": {"z": 43}},
+            None,
+            {},
+            43,
+        ),
+        # Check nested types and static methods
+        ({"cls": "tests.test_utils.Fii", "params": {}}, None, {}, Fii(Baz(10)),),
+        (
+            {"cls": "tests.test_utils.fii.a.class_method", "params": {"y": 10}},
+            None,
+            {},
+            Baz(11),
+        ),
+        (
+            {"cls": "tests.test_utils.fii.a.static_method", "params": {"z": 43}},
+            None,
+            {},
+            43,
+        ),
+        # Check that default value is respected
+        (
+            {"cls": "tests.test_utils.Bar", "params": {"b": 200, "c": "${params.b}"}},
+            None,
+            {"a": 10},
+            Bar(10, 200, 200, "default_value"),
+        ),
+        (
+            {"cls": "tests.test_utils.Bar", "params": {}},
+            None,
+            {"a": 10, "b": 20, "c": 30},
+            Bar(10, 20, 30, "default_value"),
+        ),
+        # call a function from a module
+        ({"cls": "tests.test_utils.fum", "params": {"k": 43}}, None, {}, 44,),
+        # Check builtins
+        ({"cls": "builtins.str", "params": {"object": 43}}, None, {}, "43",),
+    ],
+)
+def test_class_instantiate(
+    input_conf: Dict[str, Any],
+    key_to_get_config: Optional[str],
+    kwargs_to_pass: Dict[str, Any],
+    expected: Any,
+) -> Any:
+    conf = OmegaConf.create(input_conf)
+    assert isinstance(conf, DictConfig)
+    if key_to_get_config is None:
+        config_to_pass = conf
+    else:
+        config_to_pass = OmegaConf.select(conf, key_to_get_config)
+    config_to_pass_copy = copy.deepcopy(config_to_pass)
+    obj = utils.instantiate(config_to_pass, **kwargs_to_pass)
+    assert obj == expected
+    # make sure config is not modified by instantiate
+    assert config_to_pass == config_to_pass_copy
+
+
+def test_class_instantiate_pass_omegaconf_node() -> Any:
+    pc = ObjectConf()
+    # This is a bit clunky because it exposes a problem with the backport of dataclass on Python 3.6
+    # see: https://github.com/ericvsmith/dataclasses/issues/155
+    pc.cls = "tests.test_utils.Bar"
+    pc.params = {"b": 200, "c": {"x": 10, "y": "${params.b}"}}
+    conf = OmegaConf.structured(pc)
+    obj = utils.instantiate(conf, **{"a": 10, "d": Foo(99)})
+    assert obj == Bar(10, 200, {"x": 10, "y": 200}, Foo(99))
+    assert OmegaConf.is_config(obj.c)
+
+
+def test_class_warning() -> None:
+    expected = Bar(10, 20, 30, 40)
+    with pytest.warns(UserWarning):
+        config = OmegaConf.structured(
+            {
+                "class": "tests.test_utils.Bar",
+                "params": {"a": 10, "b": 20, "c": 30, "d": 40},
+            }
+        )
+        assert utils.instantiate(config) == expected
+
+    config = OmegaConf.structured(
+        {"cls": "tests.test_utils.Bar", "params": {"a": 10, "b": 20, "c": 30, "d": 40}}
+    )
+    assert utils.instantiate(config) == expected
+
+
+def test_get_original_cwd(hydra_restore_singletons: Any) -> None:
+    orig = "/foo/bar"
+    cfg = OmegaConf.create({"hydra": HydraConf(runtime=RuntimeConf(cwd=orig))})
+    assert isinstance(cfg, DictConfig)
+    HydraConfig.instance().set_config(cfg)
+    assert utils.get_original_cwd() == orig
+
+
+def test_get_original_cwd_without_hydra(hydra_restore_singletons: Any) -> None:
+    with pytest.raises(ValueError):
+        utils.get_original_cwd()
+
+
+@pytest.mark.parametrize(  # type: ignore
+    "orig_cwd, path, expected",
+    [
+        ("/home/omry/hydra", "foo/bar", "/home/omry/hydra/foo/bar"),
+        ("/home/omry/hydra/", "foo/bar", "/home/omry/hydra/foo/bar"),
+        ("/home/omry/hydra/", "/foo/bar", "/foo/bar"),
+    ],
+)
+def test_to_absolute_path(
+    hydra_restore_singletons: Any, orig_cwd: str, path: str, expected: str
+) -> None:
+    # normalize paths to current OS
+    orig_cwd = str(Path(orig_cwd))
+    path = str(Path(path))
+    expected = str(Path(expected))
+    cfg = OmegaConf.create({"hydra": HydraConf(runtime=RuntimeConf(cwd=orig_cwd))})
+    assert isinstance(cfg, DictConfig)
+    HydraConfig().set_config(cfg)
+    assert utils.to_absolute_path(path) == expected
+
+
+@pytest.mark.parametrize(  # type: ignore
+    "path, expected",
+    [
+        ("foo/bar", f"{os.getcwd()}/foo/bar"),
+        ("foo/bar", f"{os.getcwd()}/foo/bar"),
+        ("/foo/bar", os.path.abspath("/foo/bar")),
+    ],
+)
+def test_to_absolute_path_without_hydra(
+    hydra_restore_singletons: Any, path: str, expected: str
+) -> None:
+    # normalize paths to current OS
+    path = str(Path(path))
+    expected = str(Path(expected).absolute())
+    assert utils.to_absolute_path(path) == expected
+
+
+@pytest.mark.parametrize(  # type: ignore
+    "matrix,expected",
+    [
+        ([["a"]], [1]),
+        ([["a", "bb"]], [1, 2]),
+        ([["a", "bb"], ["aa", "b"]], [2, 2]),
+        ([["a"], ["aa", "b"]], [2, 1]),
+        ([["a", "aa"], ["bb"]], [2, 2]),
+        ([["a"]], [1]),
+        ([["a"]], [1]),
+        ([["a"]], [1]),
+    ],
+)
+def test_get_column_widths(matrix: Any, expected: Any) -> None:
+    assert internal_utils.get_column_widths(matrix) == expected

testbed/facebookresearch__hydra/website/.gitignore

@@ -0,0 +1,20 @@
+# dependencies
+/node_modules
+
+# production
+/build
+
+# generated files
+.docusaurus
+.cache-loader
+
+# misc
+.DS_Store
+.env.local
+.env.development.local
+.env.test.local
+.env.production.local
+
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*

testbed/facebookresearch__hydra/website/.yarnclean

@@ -0,0 +1,45 @@
+# test directories
+__tests__
+test
+tests
+powered-test
+
+# asset directories
+docs
+doc
+website
+images
+assets
+
+# examples
+example
+examples
+
+# code coverage directories
+coverage
+.nyc_output
+
+# build scripts
+Makefile
+Gulpfile.js
+Gruntfile.js
+
+# configs
+appveyor.yml
+circle.yml
+codeship-services.yml
+codeship-steps.yml
+wercker.yml
+.tern-project
+.gitattributes
+.editorconfig
+.*ignore
+.eslintrc
+.jshintrc
+.flowconfig
+.documentup.json
+.yarn-metadata.json
+.travis.yml
+
+# misc
+*.md

testbed/facebookresearch__hydra/website/README.md

@@ -0,0 +1,34 @@
+# Website
+
+This website is built using Docusaurus 2, a modern static website generator.
+
+### Installation
+
+```
+$ yarn
+```
+
+### Local Development
+
+```
+$ yarn start
+```
+
+This command starts a local development server and open up a browser window. Most changes are reflected live without having to restart the server.
+
+### Build
+
+```
+$ yarn build
+```
+
+This command generates static content into the `build` directory and can be served using any static contents hosting service.
+
+### Deployment
+
+Done automatically once a website change is landed to master.
+
+
+### Adding pages
+
+New pages, e.g., for a new plugin, should be added to `docs/`. They can be accessed on a local server via `http://localhost:3000/docs/next/page_name`.

testbed/facebookresearch__hydra/website/blog/2020-05-04-New-blog.md

@@ -0,0 +1,20 @@
+---
+title: New Hydra blog
+author: Omry Yadan
+author_title: Creator of Hydra
+author_url: https://github.com/omry
+author_image_url: http://graph.facebook.com/733244046/picture/?height=200&width=200
+tags: [Hydra]
+---
+Welcome to the Hydra blog.
+
+Catching up on some previous content:
+
+##### Apr/8/2020
+[FLOSS Weekly interview](https://twit.tv/shows/floss-weekly/episodes/573)
+
+##### Feb/3/2020
+[PyTorch Medium channel blog post](http://bit.ly/2Sdq2B3)
+
+##### Oct/3/2019
+[Facebook engineering blog release post](https://engineering.fb.com/open-source/hydra/)

testbed/facebookresearch__hydra/website/docs/advanced/command_line_overrides.md

@@ -0,0 +1,56 @@
+---
+id: command_line_overrides
+title: Command line overrides
+---
+You can manipulate your configuration via the command line. This includes:
+- Manipulation of the defaults list
+- Manipulation of the resulting config object
+
+Both of those looks similar in the command line.
+Command line overrides matching a Config group are manipulating the Defaults List; The rest are manipulating the resulting config object.
+
+```text  title="Defaults List overrides"
+PACKAGE   : PATH[.PATH]*
+PATH      : [A-Za-z0-9_-]+ 
+OPTION    : .*
+
+# Changing an existing item
+GROUP[@SRC_PKG[:DEST_PKG]][=OPTION]
+
+# Appending a new item
++GROUP@[SRC_PKG]=OPTION
+
+# Deleting an existing item
+~GROUP[@PACKAGE][=OPTION]
+```
+
+```text title="Config overrides"
+KEY=VALUE
+KEY   : .+
+VALUE : .+
+
+# Changing an existing item
+KEY=VALUE
+
+# Appending a new item
++KEY=VALUE
+
+# Deleting an existing item
+~KEY[=VALUE]
+```
+
+# Examples
+## Config values
+- Overriding a config value : `foo.bar=value`
+- Appending a config value : `+foo.bar=value`
+- Removing a config value : `~foo.bar`, `~foo.bar=value`
+
+## Defaults list
+- Overriding selected Option: `db=mysql`
+- Overriding selected Option and renaming package: `db@src_pkg:dst_pkg=mysql`
+- Renaming package: `db@src_pkg:dst_pkg`
+- Appending to defaults: `+experiment=exp1`
+- Deleting from defaults: `~db`, `~db=mysql`
+
+When renaming a package, if the current item in the defaults list does not have a package, 
+use the empty string for the source package, e.g: `db@:dst_package`.  

testbed/facebookresearch__hydra/website/docs/advanced/overriding_packages.md

@@ -0,0 +1,135 @@
+---
+id: overriding_packages
+title: Overriding packages
+---
+
+The contents of a config file can be relocated, or replicated, within the config, via package overrides.
+
+### Package specification
+
+``` text title="Definition of a package"
+PACKAGE      : _global_ | COMPONENT[.COMPONENT]*
+COMPONENT    : _group_ | _name_ | \w+
+
+_global_     : the top level package (equivalent to the empty string).
+_group_      : the config group in dot notation: foo/bar/zoo.yaml -> foo.bar
+_name_       : the config file name: foo/bar/zoo.yaml -> zoo
+```
+
+### Overriding the package in a file via a package directive
+
+A `@package directive` specifies a common [package](/terminology.md#package) for all nodes in the config file.
+It must be placed at the top of each `config group file`.
+
+```text title="Package directive examples"
+# @package foo.bar
+# @package _global_
+# @package _group_
+# @package _group_._name_
+# @package foo._group_._name_
+```
+#### Examples
+##### A package directive with a literal
+<div className="row">
+<div className="col col--6">
+
+```yaml title="mysql.yaml" {1-2}
+# @package foo.bar
+
+db:
+  host: localhost
+  port: 3306
+```
+
+</div>
+
+<div className="col  col--6">
+
+```yaml title="Interpretation" {1-2}
+foo:
+  bar:
+    db:
+      host: localhost
+      port: 3306
+``` 
+
+</div>
+</div>
+
+
+##### A package directive with `_group_` and `_name_`
+
+<div className="row">
+<div className="col col--6">
+
+```yaml title="db/mysql.yaml" {1-2}
+# @package _group_._name_
+
+host: localhost
+port: 3306
+```
+</div><div className="col  col--6">
+
+```yaml title="Interpretation" {1-2}
+db:
+  mysql:
+    host: localhost
+    port: 3306
+``` 
+</div></div>
+
+### Overriding the package via the defaults list
+The following example adds the `mysql` config in under the packages `src` and `dst`.
+
+
+<div className="row">
+<div className="col col--6">
+
+```yaml title="config.yaml"
+defaults:
+ - db@db.src: mysql
+ - db@db.dst: mysql
+
+
+
+
+```
+</div><div className="col  col--6">
+
+```yaml title="Interpretation"
+db:
+  src:
+    host: localhost
+    port: 3306
+  dst:
+    host: localhost
+    port: 3306
+```
+</div></div>
+
+### Overriding the package via the command line
+Overriding the package for `db` specified in the defaults list from `db.dst` to `backup`: 
+```bash
+$ python my_app.py db@db.dst:backup
+$ python my_app.py db@db.dst:backup=postgresql # And change the config group option
+```
+
+Overriding the package of a config group option not in the defaults list:
+```text
+python my_app.py +webserver@prod=apache
+```
+
+For more details, see the [Command line overrides](advanced/command_line_overrides.md) page.
+
+### History and future of the package directive
+The primary config, named in `@hydra.main()` should not have a package directive.
+
+For config files in config groups the default depends on the version:
+ - In **Hydra 0.11**, there was an implicit default of `_global_`
+ - **Hydra 1.0** the default is `_global_`  
+ A warning is issued for each **config group file** without a `@package` directive.
+ - In **Hydra 1.1** the default for **config group files** will become `_group_`
+
+By adding an explicit `@package` to your configs files, you guarantee that they  
+will not break when you upgrade to Hydra 1.1.
+

testbed/facebookresearch__hydra/website/docs/advanced/packaging.md

@@ -0,0 +1,34 @@
+---
+id: app_packaging
+title: Application packaging
+sidebar_label: Application packaging 
+---
+
+You can package your Hydra application along with its configuration.
+There is a working example [here](https://github.com/facebookresearch/hydra/tree/master/examples/advanced/hydra_app_example).
+
+You can run it with:
+
+```yaml
+$ python examples/advanced/hydra_app_example/hydra_app/main.py
+dataset:
+  name: imagenet
+  path: /datasets/imagenet
+```
+
+To install it, use:
+```text
+$ pip install examples/advanced/hydra_app_example
+...
+Successfully installed hydra-app-0.1
+```
+
+Run the installed app with:
+```yaml
+$ hydra_app
+dataset:
+  name: imagenet
+  path: /datasets/imagenet
+```
+
+The installed app will use the packaged configuration files.