deps: bumps dvc-azure>=2.21.2

Closes #9506 via https://github.com/iterative/dvc-azure/pull/48

(cherry picked from commit a1b891ce01)

.dvc/.gitignore

@@ -1,3 +1,12 @@
+/state
+/lock
 /config.local
-/tmp
+/updater
+/updater.lock
+/state-journal
+/state-wal
 /cache
+/pkg
+/repos
+/tmp
+/experiments

.dvc/config

@@ -0,0 +1,4 @@
+['remote "dvc"']
+url = https://remote.dvc.org/dvc
+[core]
+remote = dvc

.flake8

@@ -1,20 +1,19 @@
 [flake8]
-max_line_length = 88
-extend-ignore=
+ignore=
     # Whitespace before ':'
     E203
+    # Too many leading '#' for block comment
+    E266
     # Line break occurred before a binary operator
     W503
     # unindexed parameters in the str.format, see:
     # https://pypi.org/project/flake8-string-format/
     P1
+    # use `!r` instead of surrounding by quotes
+    B028
+max_line_length = 88
 max-complexity = 10
+select = B,C,E,F,W,T4,B902,T,P,TYP
 show_source = true
 count = true
 min_python_version = 3.8.0
-per-file-ignores =
-    dvc/testing/benchmarks/conftest.py:F401
-    dvc/testing/conftest.py:F401
-    dvc/testing/plugin.py:F401
-    tests/conftest.py:F401
-    tests/func/experiments/executor/test_ssh.py:F401

.github/mergify.yml

@@ -7,4 +7,3 @@ pull_request_rules:
       backport:
         branches:
           - "2.x"
-        title: ({{ destination_branch }}) {{ title }}

.github/workflows/build.yaml

@@ -1,92 +0,0 @@
-name: Build and upload package
-on:
-  push:
-    branches:
-    - main
-  release:
-    types:
-    - published
-  workflow_dispatch:
-
-env:
-  FORCE_COLOR: 1
-
-permissions:
-  contents: read
-
-jobs:
-  build:
-    name: Build & Verify package
-    runs-on: ubuntu-latest
-    steps:
-    - uses: actions/checkout@v4
-      with:
-        fetch-depth: 0
-
-    - uses: actions/setup-python@v4
-      with:
-        python-version: 3.8
-
-    - run: python -m pip install --upgrade pip setuptools_scm build twine
-
-    - name: Force version for Test PyPI upload
-      if: ${{ !startsWith(github.ref, 'refs/tags') }}
-      run: echo version=$(python -m setuptools_scm | awk -F+ '{print $1}' | tail -1) >> $GITHUB_ENV
-
-    - run: echo 'PKG = "pip"'>dvc/_build.py
-    - run: python -m build
-      env:
-        SETUPTOOLS_SCM_PRETEND_VERSION_FOR_DVC: ${{ env.version }}
-    - run: twine check --strict dist/*
-
-    - uses: actions/upload-artifact@v3
-      with:
-        name: Packages
-        path: dist/
-
-  test-pypi-publish:
-    name: Publish dev package to test.pypi.org
-    runs-on: ubuntu-latest
-    needs: build
-    if: ${{ github.event.action == 'published' || (github.repository == 'iterative/dvc' && github.event_name == 'push' && github.ref == 'refs/heads/main') }}
-
-    environment:
-      name: test-pypi
-      url: https://test.pypi.org/p/dvc
-
-    permissions:
-      id-token: write
-
-    steps:
-    - uses: actions/download-artifact@v3
-      with:
-        name: Packages
-        path: dist
-
-    - name: Upload package to Test PyPI
-      uses: pypa/gh-action-pypi-publish@release/v1
-      with:
-        repository-url: https://test.pypi.org/legacy/
-        skip-existing: true
-
-  pypi-publish:
-    name: Publish released package to pypi.org
-    runs-on: ubuntu-latest
-    needs: build
-    if: github.event.action == 'published'
-
-    environment:
-      name: pypi
-      url: https://pypi.org/p/dvc
-
-    permissions:
-      id-token: write
-
-    steps:
-    - uses: actions/download-artifact@v3
-      with:
-        name: Packages
-        path: dist
-
-    - name: Upload package to PyPI
-      uses: pypa/gh-action-pypi-publish@release/v1

.github/workflows/codeql.yml

@@ -28,7 +28,7 @@ jobs:
 
     steps:
     - name: Checkout repository
-      uses: actions/checkout@v4
+      uses: actions/checkout@v3
 
     - name: Initialize CodeQL
       uses: github/codeql-action/init@v2

.github/workflows/packages.yaml

@@ -0,0 +1,111 @@
+name: Build packages
+on:
+  push:
+    branches:
+    - main
+  release:
+    types: [released, prereleased]
+  workflow_dispatch:
+
+permissions:  # added using https://github.com/step-security/secure-workflows
+  contents: read
+
+jobs:
+  binary:
+    permissions:
+      contents: write  # for actions/upload-release-asset to upload release asset
+    strategy:
+      matrix:
+        include:
+         - {pkg: "deb",  os: "ubuntu-20.04", asset: "dvc_${{ github.event.release.tag_name }}_amd64.deb"}
+         - {pkg: "rpm", os: "ubuntu-20.04", asset: "dvc-${{ github.event.release.tag_name }}-1.x86_64.rpm"}
+         - {pkg: "osxpkg", os: "macos-11", asset: "dvc-${{ github.event.release.tag_name }}.pkg"}
+         - {pkg: "exe",  os: "windows-2019", asset: "dvc-${{ github.event.release.tag_name }}.exe"}
+
+    name: ${{ matrix.pkg }}
+    runs-on: ${{ matrix.os }}
+    steps:
+    - uses: actions/checkout@v3
+      with:
+          fetch-depth: 0
+
+    - name: Set up Python 3.10
+      uses: actions/setup-python@v4
+      with:
+        python-version: "3.10"
+        cache: pip
+        cache-dependency-path: |
+          pyproject.toml
+          scripts/build-requirements.txt
+
+    - name: Set up Ruby 2.6
+      uses: ruby/setup-ruby@v1
+      if: matrix.pkg != 'exe'
+      with:
+        ruby-version: '2.6'
+
+    - name: Install fpm
+      if: matrix.pkg != 'exe'
+      run: gem install --no-document fpm
+
+    - name: Install deps
+      run: |
+        pip install --upgrade pip wheel setuptools
+        pip install .[all]
+        pip install -r scripts/build-requirements.txt
+
+    - name: Pull images
+      run: dvc pull
+
+    - name: Build ${{ matrix.pkg }}
+      run: python scripts/build.py ${{ matrix.pkg }}
+
+    - name: Publish ${{ matrix.pkg }}
+      if: github.event_name == 'release'
+      uses: actions/[email protected]
+      env:
+        GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+      with:
+        upload_url: ${{ github.event.release.upload_url }}
+        asset_path: scripts/${{ matrix.pkg == 'exe' && 'innosetup' || 'fpm' }}/${{ matrix.asset }}
+        asset_name: ${{ matrix.asset }}
+        asset_content_type: binary/octet-stream
+
+  pip:
+    runs-on: ubuntu-20.04
+    permissions:
+      id-token: write
+    steps:
+    - uses: actions/checkout@v3
+      with:
+        fetch-depth: 0
+
+    - name: Set up Python 3.8
+      uses: actions/setup-python@v4
+      with:
+        python-version: 3.8
+
+    - name: Install
+      run: pip install --upgrade pip wheel
+
+    - name: Force version for Test PyPI uploads
+      if: ${{ !startsWith(github.ref, 'refs/tags') }}
+      run: |
+        pip install setuptools_scm
+        echo version=$(python -m setuptools_scm | awk -F+ '{print $1}' | tail -1) >> $GITHUB_ENV
+
+    - name: Build packages
+      run: ./scripts/build_package.sh
+      env:
+        SETUPTOOLS_SCM_PRETEND_VERSION: ${{ env.version }}
+
+    - name: Publish packages to PyPI
+      if: github.event_name == 'release'
+      uses: pypa/gh-action-pypi-publish@release/v1
+
+    - name: Publish to Test PyPI
+      if: ${{ github.event_name == 'release' || (github.event_name == 'push' && github.ref == 'refs/heads/main') }}
+      uses: pypa/gh-action-pypi-publish@release/v1
+      with:
+        repository_url: https://test.pypi.org/legacy/
+        skip_existing: true

.github/workflows/plugin_tests.yaml

@@ -23,11 +23,11 @@ jobs:
         plugin: ["dvc-s3"]
 
     steps:
-    - uses: actions/checkout@v4
+    - uses: actions/checkout@v3
       with:
         path: dvc
 
-    - uses: actions/checkout@v4
+    - uses: actions/checkout@v3
       with:
         repository: iterative/${{ matrix.plugin }}
         ref: main

.github/workflows/tests.yaml

@@ -26,7 +26,7 @@ jobs:
         pyv: ["3.8", "3.9", "3.10", "3.11"]
 
     steps:
-    - uses: actions/checkout@v4
+    - uses: actions/checkout@v3
       with:
         fetch-depth: 0
     - name: Set up Python
@@ -66,7 +66,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
     - name: Slack Notification
-      uses: rtCamp/[email protected].1
+      uses: rtCamp/[email protected].0
       env:
         SLACK_WEBHOOK: ${{ secrets.SLACK_WEBHOOK }}
         SLACK_COLOR: ${{ job.status }}

.pre-commit-config.yaml

@@ -23,29 +23,42 @@ repos:
       - id: mixed-line-ending
       - id: sort-simple-yaml
       - id: trailing-whitespace
+  - repo: https://github.com/lovesegfault/beautysh
+    rev: v6.2.1
+    hooks:
+      - id: beautysh
+        args: ["-i", "2"]
+  - repo: https://github.com/asottile/pyupgrade
+    rev: v3.3.1
+    hooks:
+      - id: pyupgrade
+        args:
+          - --py38-plus
   - repo: https://github.com/psf/black
-    rev: 23.9.1
+    rev: 23.3.0
     hooks:
       - id: black
   - repo: https://github.com/PyCQA/isort
     rev: 5.12.0
     hooks:
       - id: isort
-  - repo: https://github.com/astral-sh/ruff-pre-commit
-    rev: 'v0.0.291'
+  - repo: https://github.com/charliermarsh/ruff-pre-commit
+    rev: 'v0.0.261'
     hooks:
       - id: ruff
-        args: [--fix, --exit-non-zero-on-fix]
   - repo: https://github.com/codespell-project/codespell
-    rev: v2.2.5
+    rev: v2.2.4
     hooks:
       - id: codespell
         additional_dependencies: ["tomli"]
   - repo: https://github.com/PyCQA/flake8
-    rev: 6.1.0
+    rev: 6.0.0
     hooks:
       - id: flake8
         additional_dependencies:
+          - flake8-bugbear
+          - flake8-comprehensions
+          - flake8-debugger
           - flake8-string-format
           - flake8-typing-imports
   - repo: https://github.com/PyCQA/bandit

README.rst

@@ -280,8 +280,8 @@ Barrak, A., Eghan, E.E. and Adams, B. `On the Co-evolution of ML Pipelines and S
    :target: https://pypi.org/project/dvc
    :alt: PyPI Downloads
 
-.. |Packages| image:: https://img.shields.io/badge/deb|pkg|rpm|exe-blue
-   :target: https://dvc.org/doc/install
+.. |Packages| image:: https://img.shields.io/github/v/release/iterative/dvc?label=deb|pkg|rpm|exe&logo=GitHub
+   :target: https://github.com/iterative/dvc/releases/latest
    :alt: deb|pkg|rpm|exe
 
 .. |DOI| image:: https://img.shields.io/badge/DOI-10.5281/zenodo.3677553-blue.svg

dvc/__init__.py

@@ -4,7 +4,6 @@ DVC
 Make your data science projects reproducible and shareable.
 """
 import dvc.logger
-from dvc.build import PKG  # noqa: F401
 from dvc.version import __version__, version_tuple  # noqa: F401
 
 dvc.logger.setup()

dvc/__pyinstaller/__init__.py

@@ -1,5 +0,0 @@
-import os
-
-
-def get_hook_dirs():
-    return [os.path.dirname(__file__)]

dvc/_debug.py

@@ -198,84 +198,33 @@ def debugtools(args: Optional["Namespace"] = None, **kwargs):
 def add_debugging_flags(parser):
     from argparse import SUPPRESS
 
-    # For detailed info see:
-    # https://github.com/iterative/dvc/wiki/Debugging,-Profiling-and-Benchmarking-DVC
-    args, _ = parser.parse_known_args()
-    verbose = args.verbose
-
-    def debug_help(msg):
-        if verbose:
-            return msg
-        return SUPPRESS
-
-    parser = parser.add_argument_group("debug options")
-
-    parser.add_argument(
-        "--cprofile",
-        action="store_true",
-        default=False,
-        help=debug_help("Generate cprofile data for tools like snakeviz / tuna"),
-    )
-    parser.add_argument(
-        "--cprofile-dump", help=debug_help("Location to dump cprofile file")
-    )
-    parser.add_argument(
-        "--yappi",
-        action="store_true",
-        default=False,
-        help=debug_help(
-            "Generate a callgrind file for use with tools like "
-            "kcachegrind / qcachegrind"
-        ),
-    )
+    parser.add_argument("--cprofile", action="store_true", default=False, help=SUPPRESS)
+    parser.add_argument("--yappi", action="store_true", default=False, help=SUPPRESS)
     parser.add_argument(
         "--yappi-separate-threads",
         action="store_true",
         default=False,
-        help=debug_help("Generate one callgrind file per thread"),
+        help=SUPPRESS,
     )
     parser.add_argument(
-        "--viztracer",
-        action="store_true",
-        default=False,
-        help=debug_help("Generate a viztracer file for use with vizviewer"),
+        "--viztracer", action="store_true", default=False, help=SUPPRESS
+    )
+    parser.add_argument("--viztracer-depth", type=int, help=SUPPRESS)
+    parser.add_argument(
+        "--viztracer-async", action="store_true", default=False, help=SUPPRESS
+    )
+    parser.add_argument("--cprofile-dump", help=SUPPRESS)
+    parser.add_argument("--pdb", action="store_true", default=False, help=SUPPRESS)
+    parser.add_argument(
+        "--instrument", action="store_true", default=False, help=SUPPRESS
     )
     parser.add_argument(
-        "--viztracer-depth",
-        type=int,
-        help=debug_help("Set viztracer maximum stack depth"),
-    )
-    parser.add_argument(
-        "--viztracer-async",
-        action="store_true",
-        default=False,
-        help=debug_help("Treat async tasks as threads"),
-    )
-    parser.add_argument(
-        "--pdb",
-        action="store_true",
-        default=False,
-        help=debug_help("Drop into the pdb/ipdb debugger on any exception"),
-    )
-    parser.add_argument(
-        "--instrument",
-        action="store_true",
-        default=False,
-        help=debug_help("Use pyinstrument CLI profiler"),
-    )
-    parser.add_argument(
-        "--instrument-open",
-        action="store_true",
-        default=False,
-        help=debug_help("Use pyinstrument web profiler"),
+        "--instrument-open", action="store_true", default=False, help=SUPPRESS
     )
     parser.add_argument(
         "--show-stack",
         "--ss",
         action="store_true",
         default=False,
-        help=debug_help(
-            r"Use Ctrl+T on macOS or Ctrl+\ on Linux to print the stack "
-            "frame currently executing. Unavailable on Windows."
-        ),
+        help=SUPPRESS,
     )

dvc/annotations.py

@@ -17,6 +17,12 @@ class Annotation:
     labels: List[str] = field(default_factory=list)
     meta: Dict[str, Any] = field(default_factory=dict)
 
+    def update(self, **kwargs) -> "Annotation":
+        for attr, value in kwargs.items():
+            if value and hasattr(self, attr):
+                setattr(self, attr, value)
+        return self
+
     def to_dict(self) -> Dict[str, str]:
         return compact(asdict(self))
 

dvc/api/__init__.py

@@ -1,9 +1,8 @@
 from dvc.fs.dvc import _DVCFileSystem as DVCFileSystem
 
-from .artifacts import artifacts_show
 from .data import open  # pylint: disable=redefined-builtin
 from .data import get_url, read
-from .experiments import exp_save, exp_show
+from .experiments import exp_save, exp_show, make_checkpoint
 from .scm import all_branches, all_commits, all_tags
 from .show import metrics_show, params_show
 
@@ -11,10 +10,10 @@ __all__ = [
     "all_branches",
     "all_commits",
     "all_tags",
-    "artifacts_show",
     "exp_save",
     "exp_show",
     "get_url",
+    "make_checkpoint",
     "open",
     "params_show",
     "metrics_show",

dvc/api/artifacts.py

@@ -1,47 +0,0 @@
-from typing import Any, Dict, Optional
-
-from dvc.repo import Repo
-
-
-def artifacts_show(
-    name: str,
-    version: Optional[str] = None,
-    stage: Optional[str] = None,
-    repo: Optional[str] = None,
-) -> Dict[str, str]:
-    """
-    Return path and Git revision for an artifact in a DVC project.
-
-    The resulting path and revision can be used in conjunction with other dvc.api
-    calls to open and read the artifact.
-
-    Args:
-        name (str): name of the artifact to open.
-        version (str, optional): version of the artifact to open. Defaults to
-            the latest version.
-        stage (str, optional): name of the model registry stage.
-        repo: (str, optional): path or URL for the DVC repo.
-
-    Returns:
-        Dictionary of the form:
-            {
-                "rev": ...,
-                "path": ...,
-            }
-
-    Raises:
-        dvc.exceptions.ArtifactNotFoundError: The specified artifact was not found in
-            the repo.
-    """
-    if version and stage:
-        raise ValueError("Artifact version and stage are mutually exclusive.")
-
-    repo_kwargs: Dict[str, Any] = {
-        "subrepos": True,
-        "uninitialized": True,
-    }
-    with Repo.open(repo, **repo_kwargs) as _repo:
-        rev = _repo.artifacts.get_rev(name, version=version, stage=stage)
-        with _repo.switch(rev):
-            path = _repo.artifacts.get_path(name)
-        return {"rev": rev, "path": path}

dvc/api/data.py

@@ -36,22 +36,21 @@ def get_url(path, repo=None, rev=None, remote=None):
     NOTE: This function does not check for the actual existence of the file or
     directory in the remote storage.
     """
-    from dvc.config import NoRemoteError
-    from dvc_data.index import StorageKeyError
+    with Repo.open(repo, rev=rev, subrepos=True, uninitialized=True) as _repo:
+        with _wrap_exceptions(_repo, path):
+            fs_path = _repo.dvcfs.from_os_path(path)
 
-    repo_kwargs: Dict[str, Any] = {}
-    if remote:
-        repo_kwargs["config"] = {"core": {"remote": remote}}
-    with Repo.open(
-        repo, rev=rev, subrepos=True, uninitialized=True, **repo_kwargs
-    ) as _repo:
-        index, entry = _repo.get_data_index_entry(path)
-        with reraise(
-            (StorageKeyError, ValueError),
-            NoRemoteError(f"no remote specified in {_repo}"),
-        ):
-            remote_fs, remote_path = index.storage_map.get_remote(entry)
-            return remote_fs.unstrip_protocol(remote_path)
+            with reraise(FileNotFoundError, PathMissingError(path, repo)):
+                info = _repo.dvcfs.info(fs_path)
+
+            dvc_info = info.get("dvc_info")
+            if not dvc_info:
+                raise OutputNotFoundError(path, repo)
+
+            dvc_repo = info["repo"]  # pylint: disable=unsubscriptable-object
+            md5 = dvc_info["md5"]
+
+            return dvc_repo.cloud.get_url_for(remote, checksum=md5)
 
 
 class _OpenContextManager(GCM):
@@ -67,15 +66,13 @@ class _OpenContextManager(GCM):
         raise AttributeError("dvc.api.open() should be used in a with statement.")
 
 
-def open(  # noqa: A001, pylint: disable=redefined-builtin
+def open(  # noqa, pylint: disable=redefined-builtin
     path: str,
     repo: Optional[str] = None,
     rev: Optional[str] = None,
     remote: Optional[str] = None,
     mode: str = "r",
     encoding: Optional[str] = None,
-    config: Optional[Dict[str, Any]] = None,
-    remote_config: Optional[Dict[str, Any]] = None,
 ):
     """
     Opens a file tracked in a DVC project.
@@ -117,11 +114,6 @@ def open(  # noqa: A001, pylint: disable=redefined-builtin
             Defaults to None.
             This should only be used in text mode.
             Mirrors the namesake parameter in builtin `open()`_.
-        config(dict, optional): config to be passed to the DVC repository.
-            Defaults to None.
-        remote_config(dict, optional): remote config to be passed to the DVC
-            repository.
-            Defaults to None.
 
     Returns:
         _OpenContextManager: A context manager that generatse a corresponding
@@ -217,29 +209,14 @@ def open(  # noqa: A001, pylint: disable=redefined-builtin
         "rev": rev,
         "mode": mode,
         "encoding": encoding,
-        "config": config,
-        "remote_config": remote_config,
     }
     return _OpenContextManager(_open, args, kwargs)
 
 
-def _open(
-    path,
-    repo=None,
-    rev=None,
-    remote=None,
-    mode="r",
-    encoding=None,
-    config=None,
-    remote_config=None,
-):
-    repo_kwargs: Dict[str, Any] = {
-        "subrepos": True,
-        "uninitialized": True,
-        "remote": remote,
-        "config": config,
-        "remote_config": remote_config,
-    }
+def _open(path, repo=None, rev=None, remote=None, mode="r", encoding=None):
+    repo_kwargs: Dict[str, Any] = {"subrepos": True, "uninitialized": True}
+    if remote:
+        repo_kwargs["config"] = {"core": {"remote": remote}}
 
     with Repo.open(repo, rev=rev, **repo_kwargs) as _repo:
         with _wrap_exceptions(_repo, path):
@@ -274,29 +251,13 @@ def _open(
                 raise DvcIsADirectoryError(f"'{path}' is a directory") from exc
 
 
-def read(
-    path,
-    repo=None,
-    rev=None,
-    remote=None,
-    mode="r",
-    encoding=None,
-    config=None,
-    remote_config=None,
-):
+def read(path, repo=None, rev=None, remote=None, mode="r", encoding=None):
     """
     Returns the contents of a tracked file (by DVC or Git). For Git repos, HEAD
     is used unless a rev argument is supplied. The default remote is tried
     unless a remote argument is supplied.
     """
     with open(
-        path,
-        repo=repo,
-        rev=rev,
-        remote=remote,
-        mode=mode,
-        encoding=encoding,
-        config=config,
-        remote_config=remote_config,
+        path, repo=repo, rev=rev, remote=remote, mode=mode, encoding=encoding
     ) as fd:
         return fd.read()

dvc/api/experiments.py

@@ -1,9 +1,40 @@
+import builtins
+import os
+from time import sleep
 from typing import Dict, List, Optional, Union
 
 from rich.text import Text
 
+from dvc.env import DVC_CHECKPOINT, DVC_ROOT
 from dvc.repo import Repo
 from dvc.repo.experiments.show import tabulate
+from dvc.stage.monitor import CheckpointTask
+
+
+def make_checkpoint():
+    """
+    Signal DVC to create a checkpoint experiment.
+
+    If the current process is being run from DVC, this function will block
+    until DVC has finished creating the checkpoint. Otherwise, this function
+    will return immediately.
+    """
+    if os.getenv(DVC_CHECKPOINT) is None:
+        return
+
+    root_dir = os.getenv(DVC_ROOT, Repo.find_root())
+    signal_file = os.path.join(
+        root_dir, Repo.DVC_DIR, "tmp", CheckpointTask.SIGNAL_FILE
+    )
+
+    with builtins.open(signal_file, "w", encoding="utf-8") as fobj:
+        # NOTE: force flushing/writing empty file to disk, otherwise when
+        # run in certain contexts (pytest) file may not actually be written
+        fobj.write("")
+        fobj.flush()
+        os.fsync(fobj.fileno())
+    while os.path.exists(signal_file):
+        sleep(0.1)
 
 
 def exp_save(
@@ -65,7 +96,6 @@ def exp_show(
     num: int = 1,
     param_deps: bool = False,
     force: bool = False,
-    config: Optional[Dict] = None,
 ) -> List[Dict]:
     """Get DVC experiments tracked in `repo`.
 
@@ -100,15 +130,13 @@ def exp_show(
             When `force` is specified, DVC will reload all experiment data and
             ignore any previously cached results.
             Defaults to `False`.
-        config (dict, optional): config to be passed through to DVC project.
-            Defaults to `None`.
 
     Returns:
         List[Dict]: Each item in the list will contain a dictionary with
             the info for an individual experiment.
             See Examples below.
     """
-    with Repo.open(repo, config=config) as _repo:
+    with Repo.open(repo) as _repo:
         experiments = _repo.experiments.show(
             revs=revs,
             num=num,

dvc/api/show.py

@@ -7,6 +7,10 @@ from funcy import first
 from dvc.repo import Repo
 
 
+def _onerror_raise(exception: Exception, *args, **kwargs):
+    raise exception
+
+
 def _postprocess(results):
     processed: Dict[str, Dict] = {}
     for rev, rev_data in results.items():
@@ -19,6 +23,7 @@ def _postprocess(results):
         for file_data in rev_data["data"].values():
             for k in file_data["data"]:
                 counts[k] += 1
+
         for file_name, file_data in rev_data["data"].items():
             to_merge = {
                 (k if counts[k] == 1 else f"{file_name}:{k}"): v
@@ -36,7 +41,6 @@ def metrics_show(
     *targets: str,
     repo: Optional[str] = None,
     rev: Optional[str] = None,
-    config: Optional[Dict] = None,
 ) -> Dict:
     """Get metrics tracked in `repo`.
 
@@ -65,8 +69,6 @@ def metrics_show(
             hash or a dvc experiment name.
             If `repo` is not a Git repo, this option is ignored.
             If `None`, the current working tree will be used.
-        config (dict, optional): config to be passed through to DVC project.
-            Defaults to `None`.
 
     Returns:
         Dict: See Examples below.
@@ -133,17 +135,13 @@ def metrics_show(
     .. _Git revision:
         https://git-scm.com/docs/revisions
     """
-    from dvc.repo.metrics.show import to_relpath
 
-    with Repo.open(repo, config=config) as _repo:
+    with Repo.open(repo) as _repo:
         metrics = _repo.metrics.show(
             targets=targets,
             revs=rev if rev is None else [rev],
-            on_error="raise",
+            onerror=_onerror_raise,
         )
-        metrics = {
-            k: to_relpath(_repo.fs, _repo.root_dir, v) for k, v in metrics.items()
-        }
 
     metrics = _postprocess(metrics)
 
@@ -159,7 +157,6 @@ def params_show(
     stages: Optional[Union[str, Iterable[str]]] = None,
     rev: Optional[str] = None,
     deps: bool = False,
-    config: Optional[Dict] = None,
 ) -> Dict:
     """Get parameters tracked in `repo`.
 
@@ -198,8 +195,6 @@ def params_show(
         deps (bool, optional): Whether to retrieve only parameters that are
             stage dependencies or not.
             Defaults to `False`.
-        config (dict, optional): config to be passed through to DVC project.
-            Defaults to `None`.
 
     Returns:
         Dict: See Examples below.
@@ -381,20 +376,17 @@ def params_show(
         https://git-scm.com/docs/revisions
 
     """
-    from dvc.repo.metrics.show import to_relpath
-
     if isinstance(stages, str):
         stages = [stages]
 
-    with Repo.open(repo, config=config) as _repo:
+    with Repo.open(repo) as _repo:
         params = _repo.params.show(
             revs=rev if rev is None else [rev],
             targets=targets,
-            deps_only=deps,
-            on_error="raise",
+            deps=deps,
+            onerror=_onerror_raise,
             stages=stages,
         )
-        params = {k: to_relpath(_repo.fs, _repo.root_dir, v) for k, v in params.items()}
 
     params = _postprocess(params)
 

dvc/build.py

@@ -1,10 +0,0 @@
-from typing import Optional
-
-try:
-    # file is created during dvc build
-    # pylint:disable=unused-import
-    from . import _build  # type: ignore[attr-defined, import]
-
-    PKG: Optional[str] = _build.PKG  # type: ignore[assignment]
-except ImportError:
-    PKG = None  # type: ignore[assignment]

dvc/cachemgr.py

@@ -1,50 +1,40 @@
 import os
-from typing import TYPE_CHECKING, Optional, Tuple
 
 from dvc.fs import GitFileSystem, Schemes
 from dvc_data.hashfile.db import get_odb
-from dvc_data.hashfile.hash import DEFAULT_ALGORITHM
-
-if TYPE_CHECKING:
-    from dvc.repo import Repo
-
-LEGACY_HASH_NAMES = {"md5-dos2unix", "params"}
 
 
-def _get_odb(
-    repo,
-    settings,
-    fs=None,
-    prefix: Optional[Tuple[str, ...]] = None,
-    hash_name: Optional[str] = None,
-    **kwargs,
-):
+def _get_odb(repo, settings, fs=None):
     from dvc.fs import get_cloud_fs
 
     if not settings:
         return None
 
-    cls, config, fs_path = get_cloud_fs(repo.config, **settings)
+    cls, config, fs_path = get_cloud_fs(repo, **settings)
     fs = fs or cls(**config)
-    if prefix:
-        fs_path = fs.path.join(fs_path, *prefix)
-    if hash_name:
-        config["hash_name"] = hash_name
     return get_odb(fs, fs_path, state=repo.state, **config)
 
 
 class CacheManager:
     CACHE_DIR = "cache"
-    FILES_DIR = "files"
-    FS_DIR = "fs"
+    CLOUD_SCHEMES = [
+        Schemes.S3,
+        Schemes.GS,
+        Schemes.SSH,
+        Schemes.HDFS,
+        Schemes.WEBHDFS,
+    ]
 
     def __init__(self, repo):
         self._repo = repo
         self.config = config = repo.config["cache"]
         self._odb = {}
 
+        default = None
+        if repo and repo.local_dvc_dir:
+            default = os.path.join(repo.local_dvc_dir, self.CACHE_DIR)
+
         local = config.get("local")
-        default = self.default_local_cache_dir
 
         if local:
             settings = {"name": local}
@@ -63,96 +53,25 @@ class CacheManager:
         if not isinstance(repo.fs, GitFileSystem):
             kwargs["fs"] = repo.fs
 
-        odb = _get_odb(
-            repo,
-            settings,
-            prefix=(self.FILES_DIR, DEFAULT_ALGORITHM),
-            **kwargs,
-        )
+        odb = _get_odb(repo, settings, **kwargs)
         self._odb["repo"] = odb
         self._odb[Schemes.LOCAL] = odb
-        legacy_odb = _get_odb(repo, settings, hash_name="md5-dos2unix", **kwargs)
-        self._odb["legacy"] = legacy_odb
-
-    @property
-    def fs_cache(self):
-        """Filesystem-based cache.
-
-        Currently used as a temporary location to download files that we don't
-        yet have a regular oid (e.g. md5) for.
-        """
-        from dvc_data.index import FileStorage
-
-        return FileStorage(
-            key=(),
-            fs=self.local.fs,
-            path=self.local.fs.path.join(self.default_local_cache_dir, self.FS_DIR),
-        )
 
     def _init_odb(self, schemes):
         for scheme in schemes:
             remote = self.config.get(scheme)
             settings = {"name": remote} if remote else None
-            self._odb[scheme] = _get_odb(
-                self._repo,
-                settings,
-                prefix=(self.FILES_DIR, DEFAULT_ALGORITHM),
-            )
+            self._odb[scheme] = _get_odb(self._repo, settings)
 
     def __getattr__(self, name):
+        if name not in self._odb and name in self.CLOUD_SCHEMES:
+            self._init_odb([name])
+
         try:
             return self._odb[name]
         except KeyError as exc:
             raise AttributeError from exc
 
     def by_scheme(self):
+        self._init_odb(self.CLOUD_SCHEMES)
         yield from self._odb.items()
-
-    @property
-    def local_cache_dir(self) -> str:
-        """Return base local cache directory without any prefixes.
-
-        (i.e. `dvc cache dir`).
-        """
-        return self.legacy.path
-
-    @property
-    def default_local_cache_dir(self) -> Optional[str]:
-        repo = self._repo
-        if repo and repo.local_dvc_dir:
-            return os.path.join(repo.local_dvc_dir, self.CACHE_DIR)
-        return None
-
-
-def migrate_2_to_3(repo: "Repo", dry: bool = False):
-    """Migrate legacy 2.x objects to 3.x cache.
-
-    Legacy 'md5-dos2unix' objects will be re-hashed with 'md5', added to 3.x cache,
-    and then a link from the legacy 2.x location to the 3.x location will be created.
-    """
-    from dvc.fs.callbacks import TqdmCallback
-    from dvc.ui import ui
-    from dvc_data.hashfile.db.migrate import migrate, prepare
-
-    src = repo.cache.legacy
-    dest = repo.cache.local
-    if dry:
-        oids = list(src._list_oids())  # pylint: disable=protected-access
-        ui.write(
-            f"{len(oids)} files will be re-hashed and migrated to the DVC 3.0 cache "
-            "location."
-        )
-        return
-
-    with TqdmCallback(
-        desc="Computing DVC 3.0 hashes",
-        unit="files",
-    ) as cb:
-        migration = prepare(src, dest, callback=cb)
-
-    with TqdmCallback(
-        desc="Migrating to DVC 3.0 cache",
-        unit="files",
-    ) as cb:
-        count = migrate(migration, callback=cb)
-    ui.write(f"Migrated {count} files to DVC 3.0 cache location.")

dvc/cli/__init__.py

@@ -75,7 +75,7 @@ def _log_exceptions(exc: Exception) -> Optional[int]:
     from dvc.fs import AuthError, ConfigError, RemoteMissingDepsError
 
     if isinstance(exc, RemoteMissingDepsError):
-        from dvc import PKG
+        from dvc.utils.pkg import PKG
 
         proto = exc.protocol
         by_pkg = {
@@ -83,9 +83,9 @@ def _log_exceptions(exc: Exception) -> Optional[int]:
             "conda": f"conda install -c conda-forge dvc-{proto}",
         }
 
-        if PKG in by_pkg:
+        cmd = by_pkg.get(PKG)
+        if cmd:
             link = format_link("https://dvc.org/doc/install")
-            cmd = by_pkg.get(PKG)
             hint = (
                 "To install dvc with those dependencies, run:\n"
                 "\n"
@@ -190,9 +190,10 @@ def main(argv=None):  # noqa: C901, PLR0912, PLR0915
         if level and level <= logging.DEBUG:
             from platform import platform, python_implementation, python_version
 
-            from dvc import PKG, __version__
+            from dvc import __version__
+            from dvc.utils.pkg import PKG
 
-            pyv = f"{python_implementation()} {python_version()}"
+            pyv = " ".join([python_implementation(), python_version()])
             pkg = f" ({PKG})" if PKG else ""
             logger.debug("v%s%s, %s on %s", __version__, pkg, pyv, platform())
             logger.debug("command: %s", " ".join(argv or sys.argv))
@@ -230,7 +231,7 @@ def main(argv=None):  # noqa: C901, PLR0912, PLR0915
         logger.exception("")
     except DvcParserError:
         ret = 254
-    except Exception as exc:  # noqa: BLE001, pylint: disable=broad-except
+    except Exception as exc:  # noqa, pylint: disable=broad-except
         # pylint: disable=no-member
         ret = _log_exceptions(exc) or 255
 

dvc/cli/actions.py

@@ -0,0 +1,20 @@
+from argparse import _AppendAction
+
+
+class CommaSeparatedArgs(_AppendAction):  # pylint: disable=protected-access
+    def __call__(self, parser, namespace, values, option_string=None):  # noqa: ARG002
+        from funcy import ldistinct
+
+        items = getattr(namespace, self.dest) or []
+        items.extend(map(str.strip, values.split(",")))
+        setattr(namespace, self.dest, ldistinct(items))
+
+
+class KeyValueArgs(_AppendAction):
+    def __call__(self, parser, namespace, values, option_string=None):  # noqa: ARG002
+        items = getattr(namespace, self.dest) or {}
+        for value in filter(bool, values):
+            key, _, value = value.partition("=")
+            items[key.strip()] = value
+
+        setattr(namespace, self.dest, items)

dvc/cli/parser.py

@@ -7,7 +7,6 @@ from functools import lru_cache
 from dvc import __version__
 from dvc.commands import (
     add,
-    artifacts,
     cache,
     check_ignore,
     checkout,
@@ -32,6 +31,7 @@ from dvc.commands import (
     install,
     ls,
     ls_url,
+    machine,
     metrics,
     move,
     params,
@@ -41,6 +41,7 @@ from dvc.commands import (
     remove,
     repro,
     root,
+    run,
     stage,
     unprotect,
     update,
@@ -61,6 +62,7 @@ COMMANDS = [
     remove,
     move,
     unprotect,
+    run,
     repro,
     data_sync,
     gc,
@@ -89,8 +91,8 @@ COMMANDS = [
     stage,
     experiments,
     check_ignore,
+    machine,
     data,
-    artifacts,
 ]
 
 
@@ -137,6 +139,7 @@ def get_parent_parser():
     from dvc._debug import add_debugging_flags
 
     parent_parser = argparse.ArgumentParser(add_help=False)
+    add_debugging_flags(parent_parser)
     log_level_group = parent_parser.add_mutually_exclusive_group()
     log_level_group.add_argument(
         "-q", "--quiet", action="count", default=0, help="Be quiet."
@@ -144,7 +147,6 @@ def get_parent_parser():
     log_level_group.add_argument(
         "-v", "--verbose", action="count", default=0, help="Be verbose."
     )
-    add_debugging_flags(parent_parser)
 
     return parent_parser
 

dvc/cli/utils.py

@@ -1,27 +1,3 @@
-import argparse
-
-
-class DictAction(argparse.Action):
-    def __call__(self, parser, args, values, option_string=None):  # noqa: ARG002
-        d = getattr(args, self.dest) or {}
-
-        if isinstance(values, list):
-            kvs = values
-        else:
-            kvs = [values]
-
-        for kv in kvs:
-            key, value = kv.split("=", 1)
-            if not value:
-                raise argparse.ArgumentError(
-                    self,
-                    f'Could not parse argument "{values}" as k1=v1 k2=v2 ... format',
-                )
-            d[key] = value
-
-        setattr(args, self.dest, d)
-
-
 def fix_subparsers(subparsers):
     """Workaround for bug in Python 3. See more info at:
     https://bugs.python.org/issue16308
@@ -40,7 +16,9 @@ def append_doc_link(help_message, path):
     if not path:
         return help_message
     doc_base = "https://man.dvc.org/"
-    return f"{help_message}\nDocumentation: {format_link(doc_base + path)}"
+    return "{message}\nDocumentation: {link}".format(
+        message=help_message, link=format_link(doc_base + path)
+    )
 
 
 def hide_subparsers_from_help(subparsers):

dvc/commands/add.py

@@ -2,56 +2,66 @@ import argparse
 import logging
 
 from dvc.cli import completion
+from dvc.cli.actions import KeyValueArgs
 from dvc.cli.command import CmdBase
 from dvc.cli.utils import append_doc_link
 
 logger = logging.getLogger(__name__)
 
 
+def _add_annotating_args(parser: argparse.ArgumentParser) -> None:
+    parser.add_argument(
+        "--desc",
+        type=str,
+        metavar="<text>",
+        help="User description of the data.",
+    )
+    parser.add_argument(
+        "--meta",
+        metavar="key=value",
+        nargs=1,
+        action=KeyValueArgs,
+        help="Custom metadata to add to the data.",
+    )
+    parser.add_argument(
+        "--label",
+        dest="labels",
+        type=str,
+        action="append",
+        metavar="<str>",
+        help="Label for the data.",
+    )
+    parser.add_argument(
+        "--type",
+        type=str,
+        metavar="<str>",
+        help="Type of the data.",
+    )
+
+
 class CmdAdd(CmdBase):
-    def validate_args(self) -> None:
-        from dvc.exceptions import InvalidArgumentError
-
-        args = self.args
-        invalid_opt = None
-
-        if args.to_remote or args.out:
-            message = "{option} can't be used with "
-            message += "--to-remote" if args.to_remote else "--out"
-            if len(args.targets) != 1:
-                invalid_opt = "multiple targets"
-            elif args.glob:
-                invalid_opt = "--glob option"
-            elif args.no_commit:
-                invalid_opt = "--no-commit option"
-        else:
-            message = "{option} can't be used without --to-remote"
-            if args.remote:
-                invalid_opt = "--remote"
-            elif args.remote_jobs:
-                invalid_opt = "--remote-jobs"
-
-        if invalid_opt is not None:
-            raise InvalidArgumentError(message.format(option=invalid_opt))
-
     def run(self):
-        from dvc.exceptions import DvcException, InvalidArgumentError
+        from dvc.exceptions import DvcException, RecursiveAddingWhileUsingFilename
 
         try:
-            self.validate_args()
-        except InvalidArgumentError:
-            logger.exception("")
-            return 1
+            if len(self.args.targets) > 1 and self.args.file:
+                raise RecursiveAddingWhileUsingFilename()
 
-        try:
             self.repo.add(
                 self.args.targets,
+                recursive=self.args.recursive,
                 no_commit=self.args.no_commit,
+                fname=self.args.file,
+                external=self.args.external,
                 glob=self.args.glob,
+                desc=self.args.desc,
                 out=self.args.out,
+                type=self.args.type,
+                labels=self.args.labels,
+                meta=self.args.meta,
                 remote=self.args.remote,
                 to_remote=self.args.to_remote,
-                remote_jobs=self.args.remote_jobs,
+                jobs=self.args.jobs,
                 force=self.args.force,
             )
         except FileNotFoundError:
@@ -73,18 +83,36 @@ def add_parser(subparsers, parent_parser):
         help=ADD_HELP,
         formatter_class=argparse.RawDescriptionHelpFormatter,
     )
+    parser.add_argument(
+        "-R",
+        "--recursive",
+        action="store_true",
+        default=False,
+        help="Recursively add files under directory targets.",
+    )
     parser.add_argument(
         "--no-commit",
         action="store_true",
         default=False,
         help="Don't put files/directories into cache.",
     )
+    parser.add_argument(
+        "--external",
+        action="store_true",
+        default=False,
+        help="Allow targets that are outside of the DVC repository.",
+    )
     parser.add_argument(
         "--glob",
         action="store_true",
         default=False,
         help="Allows targets containing shell-style wildcards.",
     )
+    parser.add_argument(
+        "--file",
+        help="Specify name of the .dvc file this command will generate.",
+        metavar="<filename>",
+    )
     parser.add_argument(
         "-o",
         "--out",
@@ -104,7 +132,8 @@ def add_parser(subparsers, parent_parser):
         metavar="<name>",
     )
     parser.add_argument(
-        "--remote-jobs",
+        "-j",
+        "--jobs",
         type=int,
         help=(
             "Only used along with '--to-remote'. "
@@ -121,6 +150,8 @@ def add_parser(subparsers, parent_parser):
         default=False,
         help="Override local file or folder if exists.",
     )
+
+    _add_annotating_args(parser)
     parser.add_argument(
         "targets", nargs="+", help="Input files/directories to add."
     ).complete = completion.FILE

dvc/commands/artifacts.py

@@ -1,133 +0,0 @@
-import argparse
-import logging
-
-from dvc.cli import completion
-from dvc.cli.command import CmdBaseNoRepo
-from dvc.cli.utils import DictAction, append_doc_link, fix_subparsers
-from dvc.exceptions import DvcException
-
-logger = logging.getLogger(__name__)
-
-
-class CmdArtifactsGet(CmdBaseNoRepo):
-    def run(self):
-        from dvc.repo.artifacts import Artifacts
-        from dvc.scm import CloneError
-        from dvc.ui import ui
-
-        try:
-            count, out = Artifacts.get(
-                self.args.url,
-                name=self.args.name,
-                version=self.args.rev,
-                stage=self.args.stage,
-                force=self.args.force,
-                config=self.args.config,
-                remote=self.args.remote,
-                remote_config=self.args.remote_config,
-                out=self.args.out,
-            )
-            ui.write(f"Downloaded {count} file(s) to '{out}'")
-            return 0
-        except CloneError:
-            logger.exception("failed to get '%s'", self.args.name)
-            return 1
-        except DvcException:
-            logger.exception(
-                "failed to get '%s' from '%s'", self.args.name, self.args.url
-            )
-            return 1
-
-
-def add_parser(subparsers, parent_parser):
-    ARTIFACTS_HELP = "DVC model registry artifact commands."
-
-    artifacts_parser = subparsers.add_parser(
-        "artifacts",
-        parents=[parent_parser],
-        description=append_doc_link(ARTIFACTS_HELP, "artifacts"),
-        help=ARTIFACTS_HELP,
-        formatter_class=argparse.RawDescriptionHelpFormatter,
-    )
-    artifacts_subparsers = artifacts_parser.add_subparsers(
-        dest="cmd",
-        help="Use `dvc artifacts CMD --help` to display command-specific help.",
-    )
-    fix_subparsers(artifacts_subparsers)
-
-    ARTIFACTS_GET_HELP = "Download an artifact from a DVC project."
-    get_parser = artifacts_subparsers.add_parser(
-        "get",
-        parents=[parent_parser],
-        description=append_doc_link(ARTIFACTS_GET_HELP, "artifacts/get"),
-        help=ARTIFACTS_HELP,
-        formatter_class=argparse.RawDescriptionHelpFormatter,
-    )
-    get_parser.add_argument("url", help="Location of DVC repository to download from")
-    get_parser.add_argument(
-        "name", help="Name of artifact in the repository"
-    ).complete = completion.FILE
-    get_parser.add_argument(
-        "--rev",
-        nargs="?",
-        help="Artifact version",
-        metavar="<version>",
-    )
-    get_parser.add_argument(
-        "--stage",
-        nargs="?",
-        help="Artifact stage",
-        metavar="<stage>",
-    )
-    get_parser.add_argument(
-        "-o",
-        "--out",
-        nargs="?",
-        help="Destination path to download artifact to",
-        metavar="<path>",
-    ).complete = completion.DIR
-    get_parser.add_argument(
-        "-j",
-        "--jobs",
-        type=int,
-        help=(
-            "Number of jobs to run simultaneously. "
-            "The default value is 4 * cpu_count(). "
-        ),
-        metavar="<number>",
-    )
-    get_parser.add_argument(
-        "-f",
-        "--force",
-        action="store_true",
-        default=False,
-        help="Override local file or folder if exists.",
-    )
-    get_parser.add_argument(
-        "--config",
-        type=str,
-        help=(
-            "Path to a config file that will be merged with the config "
-            "in the target repository."
-        ),
-    )
-    get_parser.add_argument(
-        "--remote",
-        type=str,
-        help=(
-            "Remote name to set as a default in the target repository "
-            "(only applicable when downloading from DVC remote)."
-        ),
-    )
-    get_parser.add_argument(
-        "--remote-config",
-        type=str,
-        nargs="*",
-        action=DictAction,
-        help=(
-            "Remote config options to merge with a remote's config (default or one "
-            "specified by '--remote') in the target repository (only applicable "
-            "when downloading from DVC remote)."
-        ),
-    )
-    get_parser.set_defaults(func=CmdArtifactsGet)

dvc/commands/cache.py

@@ -2,7 +2,6 @@ import argparse
 import os
 
 from dvc.cli import completion
-from dvc.cli.command import CmdBase
 from dvc.cli.utils import append_doc_link, fix_subparsers
 from dvc.commands.config import CmdConfig
 from dvc.ui import ui
@@ -37,17 +36,6 @@ class CmdCacheDir(CmdConfig):
         return 0
 
 
-class CmdCacheMigrate(CmdBase):
-    def run(self):
-        from dvc.cachemgr import migrate_2_to_3
-        from dvc.repo.commit import commit_2_to_3
-
-        migrate_2_to_3(self.repo, dry=self.args.dry)
-        if self.args.dvc_files:
-            commit_2_to_3(self.repo, dry=self.args.dry)
-        return 0
-
-
 def add_parser(subparsers, parent_parser):
     from dvc.commands.config import parent_config_parser
 
@@ -66,6 +54,8 @@ def add_parser(subparsers, parent_parser):
         help="Use `dvc cache CMD --help` for command-specific help.",
     )
 
+    fix_subparsers(cache_subparsers)
+
     parent_cache_config_parser = argparse.ArgumentParser(
         add_help=False, parents=[parent_config_parser]
     )
@@ -96,31 +86,3 @@ def add_parser(subparsers, parent_parser):
         nargs="?",
     ).complete = completion.DIR
     cache_dir_parser.set_defaults(func=CmdCacheDir)
-
-    CACHE_MIGRATE_HELP = "Migrate cached files to the DVC 3.0 cache location."
-    cache_migrate_parser = cache_subparsers.add_parser(
-        "migrate",
-        parents=[parent_parser],
-        description=append_doc_link(CACHE_HELP, "cache/migrate"),
-        help=CACHE_MIGRATE_HELP,
-        formatter_class=argparse.RawDescriptionHelpFormatter,
-    )
-    cache_migrate_parser.add_argument(
-        "--dvc-files",
-        help=(
-            "Migrate entries in all existing DVC files in the repository "
-            "to the DVC 3.0 format."
-        ),
-        action="store_true",
-    )
-    cache_migrate_parser.add_argument(
-        "--dry",
-        help=(
-            "Only print actions which would be taken without actually migrating "
-            "any data."
-        ),
-        action="store_true",
-    )
-    cache_migrate_parser.set_defaults(func=CmdCacheMigrate)
-
-    fix_subparsers(cache_subparsers)

dvc/commands/checkout.py

@@ -37,7 +37,6 @@ class CmdCheckout(CmdBase):
                 force=self.args.force,
                 relink=self.args.relink,
                 recursive=self.args.recursive,
-                allow_missing=self.args.allow_missing,
             )
         except CheckoutError as _exc:
             exc = _exc
@@ -102,12 +101,6 @@ def add_parser(subparsers, parent_parser):
         default=False,
         help="Recreate links or copies from cache to workspace.",
     )
-    checkout_parser.add_argument(
-        "--allow-missing",
-        action="store_true",
-        default=False,
-        help="Ignore errors if some of the files or directories are missing.",
-    )
     checkout_parser.add_argument(
         "targets",
         nargs="*",

dvc/commands/commit.py

@@ -47,10 +47,7 @@ def add_parser(subparsers, parent_parser):
         "--force",
         action="store_true",
         default=False,
-        help=(
-            "Commit data even if hash values for dependencies or "
-            "outputs did not change."
-        ),
+        help="Commit even if hash value for dependencies/outputs changed.",
     )
     commit_parser.add_argument(
         "-d",

dvc/commands/completion.py

@@ -9,9 +9,6 @@ from dvc.ui import ui
 logger = logging.getLogger(__name__)
 
 
-SUPPORTED_SHELLS = ["bash", "zsh"]
-
-
 class CmdCompletion(CmdBaseNoRepo):
     def run(self):
         import shtab
@@ -38,6 +35,6 @@ def add_parser(subparsers, parent_parser):
         "--shell",
         help="Shell syntax for completions.",
         default="bash",
-        choices=SUPPORTED_SHELLS,
+        choices=["bash", "zsh"],
     )
     completion_parser.set_defaults(func=CmdCompletion)

dvc/commands/dag.py

@@ -176,6 +176,7 @@ def add_parser(subparsers, parent_parser):
     )
     dag_parser.add_argument(
         "--md",
+        "--show-md",
         action="store_true",
         default=False,
         dest="markdown",

dvc/commands/data.py

@@ -1,11 +1,14 @@
 import argparse
 import logging
-from typing import TYPE_CHECKING
+from operator import itemgetter
+from typing import TYPE_CHECKING, Any, Dict, Iterable, Set
 
 from funcy import chunks, compact, log_durations
 
+from dvc.cli import completion
+from dvc.cli.actions import CommaSeparatedArgs
 from dvc.cli.command import CmdBase
-from dvc.cli.utils import append_doc_link, fix_subparsers
+from dvc.cli.utils import append_doc_link, fix_subparsers, hide_subparsers_from_help
 from dvc.ui import ui
 from dvc.utils import colorize
 
@@ -90,7 +93,9 @@ class CmdDataStatus(CmdBase):
                     ui.write(f"  ({hint})")
 
             if isinstance(stage_status, dict):
-                items = [f"{state}: {file}" for file, state in stage_status.items()]
+                items = [
+                    ": ".join([state, file]) for file, state in stage_status.items()
+                ]
             else:
                 items = stage_status
 
@@ -127,6 +132,63 @@ class CmdDataStatus(CmdBase):
         return self._show_status(status)
 
 
+class CmdDataLs(CmdBase):
+    @staticmethod
+    def _show_table(
+        d: Iterable[Dict[str, Any]],
+        filter_types: Set[str],
+        filter_labels: Set[str],
+        markdown: bool = False,
+    ) -> None:
+        from rich.style import Style
+
+        from dvc.compare import TabularData
+
+        td = TabularData(
+            columns=["Path", "Type", "Labels", "Description"], fill_value="-"
+        )
+        for entry in sorted(d, key=itemgetter("path")):
+            typ = entry.get("type", "")
+            desc = entry.get("desc", "-")
+            labels = entry.get("labels", [])
+
+            if filter_types and typ not in filter_types:
+                continue
+            if filter_labels and filter_labels.isdisjoint(labels):
+                continue
+
+            rich_label = ui.rich_text()
+            for index, label in enumerate(labels):
+                if index:
+                    rich_label.append(",")
+                style = Style(bold=label in filter_labels, color="green")
+                rich_label.append(label, style=style)
+
+            if markdown and desc:
+                desc = desc.partition("\n")[0]
+
+            path = ui.rich_text(entry["path"], style="cyan")
+            type_style = Style(bold=typ in filter_types, color="yellow")
+            typ = ui.rich_text(entry.get("type", ""), style=type_style)
+            td.append([path, typ or "-", rich_label or "-", desc])
+
+        td.render(markdown=markdown, rich_table=True)
+
+    def run(self):
+        from dvc.repo.data import ls
+
+        filter_labels = set(self.args.labels)
+        filter_types = set(self.args.type)
+        d = ls(self.repo, targets=self.args.targets, recursive=self.args.recursive)
+        self._show_table(
+            d,
+            filter_labels=filter_labels,
+            filter_types=filter_types,
+            markdown=self.args.markdown,
+        )
+        return 0
+
+
 def add_parser(subparsers, parent_parser):
     data_parser = subparsers.add_parser(
         "data",
@@ -155,6 +217,13 @@ def add_parser(subparsers, parent_parser):
         default=False,
         help="Show output in JSON format.",
     )
+    data_status_parser.add_argument(
+        "--show-json",
+        action="store_true",
+        default=False,
+        dest="json",
+        help=argparse.SUPPRESS,
+    )
     data_status_parser.add_argument(
         "--granular",
         action="store_true",
@@ -188,3 +257,51 @@ def add_parser(subparsers, parent_parser):
         help="Use cached remote index (don't check remote).",
     )
     data_status_parser.set_defaults(func=CmdDataStatus)
+
+    DATA_LS_HELP = "List data tracked by DVC with its metadata."
+    data_ls_parser = data_subparsers.add_parser(
+        "ls",
+        aliases=["list"],
+        parents=[parent_parser],
+        description=append_doc_link(DATA_LS_HELP, "data/ls"),
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        add_help=False,
+    )
+    data_ls_parser.add_argument(
+        "--md",
+        "--show-md",
+        dest="markdown",
+        action="store_true",
+        default=False,
+        help="Show tabulated output in the Markdown format (GFM).",
+    )
+    data_ls_parser.add_argument(
+        "--type",
+        action=CommaSeparatedArgs,
+        default=[],
+        help="Comma-separated list of type to filter.",
+    )
+    data_ls_parser.add_argument(
+        "--labels",
+        action=CommaSeparatedArgs,
+        default=[],
+        help="Comma-separated list of labels to filter.",
+    )
+    data_ls_parser.add_argument(
+        "-R",
+        "--recursive",
+        action="store_true",
+        default=False,
+        help="Recursively list from the specified directories.",
+    )
+    data_ls_parser.add_argument(
+        "targets",
+        default=None,
+        nargs="*",
+        help=(
+            "Limit command scope to these tracked files/directories, "
+            ".dvc files, or stage names."
+        ),
+    ).complete = completion.DVCFILES_AND_STAGE
+    data_ls_parser.set_defaults(func=CmdDataLs)
+    hide_subparsers_from_help(data_subparsers)

dvc/commands/data_sync.py

@@ -14,10 +14,6 @@ class CmdDataBase(CmdBase):
         from dvc.utils.humanize import get_summary
 
         default_msg = "Everything is up to date."
-
-        if not self.args.remote and not self.repo.config["core"].get("remote"):
-            ui.warn("No remote provided and no default remote set.")
-
         ui.write(get_summary(stats.items()) or default_msg)
 
 
@@ -95,8 +91,6 @@ class CmdDataFetch(CmdDataBase):
                 with_deps=self.args.with_deps,
                 recursive=self.args.recursive,
                 run_cache=self.args.run_cache,
-                max_size=self.args.max_size,
-                types=self.args.types,
             )
             self.log_summary({"fetched": processed_files_count})
         except DvcException:
@@ -328,22 +322,6 @@ def add_parser(subparsers, _parent_parser):
         default=False,
         help="Fetch run history for all stages.",
     )
-    fetch_parser.add_argument(
-        "--max-size",
-        type=int,
-        help="Fetch data files/directories that are each below specified size (bytes).",
-    )
-    fetch_parser.add_argument(
-        "--type",
-        dest="types",
-        action="append",
-        default=[],
-        help=(
-            "Only fetch data files/directories that are of a particular "
-            "type (metrics, plots)."
-        ),
-        choices=["metrics", "plots"],
-    )
     fetch_parser.set_defaults(func=CmdDataFetch)
 
     # Status
@@ -425,6 +403,7 @@ def add_parser(subparsers, _parent_parser):
     )
     status_parser.add_argument(
         "--json",
+        "--show-json",
         action="store_true",
         default=False,
         help="Show status in JSON format.",

dvc/commands/destroy.py

@@ -21,7 +21,7 @@ class CmdDestroy(CmdBase):
             )
 
             if not self.args.force and not ui.confirm(statement):
-                raise DvcException(  # noqa: TRY301
+                raise DvcException(
                     "cannot destroy without a confirmation from the user."
                     " Use `-f` to force."
                 )

dvc/commands/diff.py

@@ -184,6 +184,7 @@ def add_parser(subparsers, parent_parser):
     )
     diff_parser.add_argument(
         "--json",
+        "--show-json",
         help="Format the output into a JSON",
         action="store_true",
         default=False,
@@ -196,6 +197,7 @@ def add_parser(subparsers, parent_parser):
     )
     diff_parser.add_argument(
         "--md",
+        "--show-md",
         help="Show tabulated output in the Markdown format (GFM).",
         action="store_true",
         dest="markdown",

dvc/commands/experiments/__init__.py

@@ -7,12 +7,13 @@ from dvc.commands.experiments import (
     clean,
     diff,
     exec_run,
+    gc,
+    init,
     ls,
     pull,
     push,
     queue_worker,
     remove,
-    rename,
     run,
     save,
     show,
@@ -24,12 +25,13 @@ SUB_COMMANDS = [
     clean,
     diff,
     exec_run,
+    gc,
+    init,
     ls,
     pull,
     push,
     queue_worker,
     remove,
-    rename,
     run,
     save,
     show,

dvc/commands/experiments/apply.py

@@ -4,13 +4,21 @@ import logging
 from dvc.cli import completion
 from dvc.cli.command import CmdBase
 from dvc.cli.utils import append_doc_link
+from dvc.ui import ui
 
 logger = logging.getLogger(__name__)
 
 
 class CmdExperimentsApply(CmdBase):
     def run(self):
-        self.repo.experiments.apply(self.args.experiment, force=self.args.force)
+        if not self.args.force:
+            ui.write(
+                "The --no-force option is deprecated and will be removed in a future"
+                " DVC release. To revert the result of 'exp apply', run:\n"
+                "\n\tgit reset --hard\n"
+                "\tgit stash apply refs/exps/apply/stash\n"
+            )
+        self.repo.experiments.apply(self.args.experiment)
 
         return 0
 
@@ -25,11 +33,10 @@ def add_parser(experiments_subparsers, parent_parser):
         formatter_class=argparse.RawDescriptionHelpFormatter,
     )
     experiments_apply_parser.add_argument(
-        "-f",
-        "--force",
-        action="store_true",
-        default=False,
-        help="Do not prompt when removing working directory files.",
+        "--no-force",
+        action="store_false",
+        dest="force",
+        help="Fail if this command would overwrite conflicting changes.",
     )
     experiments_apply_parser.add_argument(
         "experiment", help="Experiment to be applied."

dvc/commands/experiments/diff.py

@@ -83,12 +83,14 @@ def add_parser(experiments_subparsers, parent_parser):
     )
     experiments_diff_parser.add_argument(
         "--json",
+        "--show-json",
         action="store_true",
         default=False,
         help="Show output in JSON format.",
     )
     experiments_diff_parser.add_argument(
         "--md",
+        "--show-md",
         action="store_true",
         default=False,
         dest="markdown",

dvc/commands/experiments/exec_run.py

@@ -49,7 +49,7 @@ def add_parser(experiments_subparsers, parent_parser):
         ),
     )
     exec_run_parser.add_argument(
-        "-m",
+        "-M",
         "--message",
         type=str,
         default=None,

dvc/commands/experiments/gc.py

@@ -0,0 +1,146 @@
+import argparse
+import logging
+
+from dvc.cli.command import CmdBase
+from dvc.cli.utils import append_doc_link
+from dvc.exceptions import InvalidArgumentError
+from dvc.ui import ui
+
+logger = logging.getLogger(__name__)
+
+
+def _raise_error_if_all_disabled(**kwargs):
+    if not any(kwargs.values()):
+        raise InvalidArgumentError(
+            "Either of `-w|--workspace`, `-a|--all-branches`, `-T|--all-tags`,"
+            " `--all-commits` or `--date` needs to be set."
+        )
+
+
+class CmdExperimentsGC(CmdBase):
+    def run(self):
+        _raise_error_if_all_disabled(
+            all_branches=self.args.all_branches,
+            all_tags=self.args.all_tags,
+            all_commits=self.args.all_commits,
+            commit_date=self.args.commit_date,
+            workspace=self.args.workspace,
+        )
+
+        msg = "This will remove all experiments except those derived from "
+
+        msg += "the workspace"
+        if self.args.all_commits:
+            msg += " and all git commits"
+        else:
+            if self.args.all_branches and self.args.all_tags:
+                msg += " and all git branches and tags"
+            elif self.args.all_branches:
+                msg += " and all git branches"
+            elif self.args.all_tags:
+                msg += " and all git tags"
+
+            if self.args.commit_date:
+                msg += f" and all git commits before date {self.args.commit_date}"
+        msg += " of the current repo."
+
+        if self.args.queued:
+            msg += " Run queued experiments will be preserved."
+        else:
+            msg += " Run queued experiments will be removed."
+
+        logger.warning(msg)
+
+        msg = "Are you sure you want to proceed?"
+        if not self.args.force and not ui.confirm(msg):
+            return 1
+
+        removed = self.repo.experiments.gc(
+            all_branches=self.args.all_branches,
+            all_tags=self.args.all_tags,
+            all_commits=self.args.all_commits,
+            workspace=self.args.workspace,
+            commit_date=self.args.commit_date,
+            queued=self.args.queued,
+        )
+
+        if removed:
+            ui.write(
+                f"Removed {removed} experiments.",
+                "To remove unused cache files",
+                "use 'dvc gc'.",
+            )
+        else:
+            ui.write("No experiments to remove.")
+        return 0
+
+
+def add_parser(experiments_subparsers, parent_parser):
+    EXPERIMENTS_GC_HELP = "Garbage collect unneeded experiments."
+    EXPERIMENTS_GC_DESCRIPTION = (
+        "Removes all experiments which are not derived"
+        " from the specified Git revisions."
+    )
+    experiments_gc_parser = experiments_subparsers.add_parser(
+        "gc",
+        parents=[parent_parser],
+        description=append_doc_link(EXPERIMENTS_GC_DESCRIPTION, "exp/gc"),
+        help=EXPERIMENTS_GC_HELP,
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+    )
+    experiments_gc_parser.add_argument(
+        "-w",
+        "--workspace",
+        action="store_true",
+        default=False,
+        help="Keep experiments derived from the current workspace.",
+    )
+    experiments_gc_parser.add_argument(
+        "-a",
+        "--all-branches",
+        action="store_true",
+        default=False,
+        help="Keep experiments derived from the tips of all Git branches.",
+    )
+    experiments_gc_parser.add_argument(
+        "-T",
+        "--all-tags",
+        action="store_true",
+        default=False,
+        help="Keep experiments derived from all Git tags.",
+    )
+    experiments_gc_parser.add_argument(
+        "-A",
+        "--all-commits",
+        action="store_true",
+        default=False,
+        help="Keep experiments derived from all Git commits.",
+    )
+    experiments_gc_parser.add_argument(
+        "--date",
+        type=str,
+        dest="commit_date",
+        metavar="<YYYY-MM-DD>",
+        default=None,
+        help=(
+            "Keep experiments from the commits after (inclusive) a certain "
+            "date. Date must match the extended ISO 8601 format (YYYY-MM-DD)."
+        ),
+    )
+    experiments_gc_parser.add_argument(
+        "--queued",
+        action="store_true",
+        default=False,
+        help=(
+            "Keep queued experiments (experiments run queue will be cleared "
+            "by default)."
+        ),
+    )
+    experiments_gc_parser.add_argument(
+        "-f",
+        "--force",
+        action="store_true",
+        default=False,
+        help="Force garbage collection - automatically agree to all prompts.",
+    )
+    experiments_gc_parser.set_defaults(func=CmdExperimentsGC)

dvc/commands/experiments/init.py

@@ -0,0 +1,219 @@
+import argparse
+import logging
+from typing import TYPE_CHECKING, List
+
+from funcy import compact
+
+from dvc.cli.command import CmdBase
+from dvc.cli.utils import append_doc_link
+from dvc.exceptions import InvalidArgumentError
+from dvc.ui import ui
+
+if TYPE_CHECKING:
+    from dvc.dependency import Dependency
+    from dvc.stage import PipelineStage
+
+
+logger = logging.getLogger(__name__)
+
+
+class CmdExperimentsInit(CmdBase):
+    DEFAULT_NAME = "train"
+    CODE = "src"
+    DATA = "data"
+    MODELS = "models"
+    DEFAULT_METRICS = "metrics.json"
+    DEFAULT_PARAMS = "params.yaml"
+    PLOTS = "plots"
+    DEFAULTS = {
+        "code": CODE,
+        "data": DATA,
+        "models": MODELS,
+        "metrics": DEFAULT_METRICS,
+        "params": DEFAULT_PARAMS,
+        "plots": PLOTS,
+    }
+
+    def run(self):
+        from dvc.commands.stage import parse_cmd
+
+        cmd = parse_cmd(self.args.command)
+        if not self.args.interactive and not cmd:
+            raise InvalidArgumentError("command is not specified")
+
+        from dvc.repo.experiments.init import init
+
+        defaults = {}
+        if not self.args.explicit:
+            config = self.repo.config["exp"]
+            defaults.update({**self.DEFAULTS, **config})
+
+        cli_args = compact(
+            {
+                "cmd": cmd,
+                "code": self.args.code,
+                "data": self.args.data,
+                "models": self.args.models,
+                "metrics": self.args.metrics,
+                "params": self.args.params,
+                "plots": self.args.plots,
+                "live": self.args.live,
+            }
+        )
+
+        initialized_stage, initialized_deps, initialized_out_dirs = init(
+            self.repo,
+            name=self.args.name,
+            type=self.args.type,
+            defaults=defaults,
+            overrides=cli_args,
+            interactive=self.args.interactive,
+            force=self.args.force,
+        )
+        self._post_init_display(
+            initialized_stage, initialized_deps, initialized_out_dirs
+        )
+        if self.args.run:
+            self.repo.experiments.run(targets=[initialized_stage.addressing])
+        return 0
+
+    def _post_init_display(
+        self,
+        stage: "PipelineStage",
+        new_deps: List["Dependency"],
+        new_out_dirs: List[str],
+    ) -> None:
+        from dvc.utils import humanize
+
+        path_fmt = "[green]{}[/green]".format
+        if new_deps:
+            deps_paths = humanize.join(map(path_fmt, new_deps))
+            ui.write(f"Creating dependencies: {deps_paths}", styled=True)
+
+        if new_out_dirs:
+            out_dirs_paths = humanize.join(map(path_fmt, new_out_dirs))
+            ui.write(f"Creating output directories: {out_dirs_paths}", styled=True)
+
+        ui.write(
+            f"Creating [b]{self.args.name}[/b] stage in [green]dvc.yaml[/]",
+            styled=True,
+        )
+        if stage.outs or not self.args.run:
+            # separate the above status-like messages with help/tips section
+            ui.write(styled=True)
+
+        if stage.outs:
+            outs_paths = humanize.join(map(path_fmt, stage.outs))
+            tips = f"Ensure your experiment command creates {outs_paths}."
+            ui.write(tips, styled=True)
+
+        if not self.args.run:
+            ui.write(
+                'You can now run your experiment using [b]"dvc exp run"[/].',
+                styled=True,
+            )
+        else:
+            # separate between `exp.run` output and `dvc exp init` output
+            ui.write(styled=True)
+
+
+def add_parser(experiments_subparsers, parent_parser):
+    EXPERIMENTS_INIT_HELP = "Quickly setup any project to use experiments."
+    experiments_init_parser = experiments_subparsers.add_parser(
+        "init",
+        parents=[parent_parser],
+        description=append_doc_link(EXPERIMENTS_INIT_HELP, "exp/init"),
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        help=EXPERIMENTS_INIT_HELP,
+    )
+    experiments_init_parser.add_argument(
+        "command",
+        nargs=argparse.REMAINDER,
+        help="Command to execute.",
+        metavar="command",
+    )
+    experiments_init_parser.add_argument(
+        "--run",
+        action="store_true",
+        help="Run the experiment after initializing it",
+    )
+    experiments_init_parser.add_argument(
+        "--interactive",
+        "-i",
+        action="store_true",
+        help="Prompt for values that are not provided",
+    )
+    experiments_init_parser.add_argument(
+        "-f",
+        "--force",
+        action="store_true",
+        default=False,
+        help="Overwrite existing stage",
+    )
+    experiments_init_parser.add_argument(
+        "--explicit",
+        action="store_true",
+        default=False,
+        help="Only use the path values explicitly provided",
+    )
+    experiments_init_parser.add_argument(
+        "--name",
+        "-n",
+        help="Name of the stage to create (default: %(default)s)",
+        default=CmdExperimentsInit.DEFAULT_NAME,
+    )
+    experiments_init_parser.add_argument(
+        "--code",
+        help=(
+            "Path to the source file or directory "
+            "which your experiments depend"
+            f" (default: {CmdExperimentsInit.CODE})"
+        ),
+    )
+    experiments_init_parser.add_argument(
+        "--data",
+        help=(
+            "Path to the data file or directory "
+            "which your experiments depend"
+            f" (default: {CmdExperimentsInit.DATA})"
+        ),
+    )
+    experiments_init_parser.add_argument(
+        "--models",
+        help=(
+            "Path to the model file or directory for your experiments"
+            f" (default: {CmdExperimentsInit.MODELS})"
+        ),
+    )
+    experiments_init_parser.add_argument(
+        "--params",
+        help=(
+            "Path to the parameters file for your experiments"
+            f" (default: {CmdExperimentsInit.DEFAULT_PARAMS})"
+        ),
+    )
+    experiments_init_parser.add_argument(
+        "--metrics",
+        help=(
+            "Path to the metrics file for your experiments"
+            f" (default: {CmdExperimentsInit.DEFAULT_METRICS})"
+        ),
+    )
+    experiments_init_parser.add_argument(
+        "--plots",
+        help=(
+            "Path to the plots file or directory for your experiments"
+            f" (default: {CmdExperimentsInit.PLOTS})"
+        ),
+    )
+    experiments_init_parser.add_argument(
+        "--live",
+        help="Path to log dvclive outputs for your experiments",
+    )
+    experiments_init_parser.add_argument(
+        "--type",
+        choices=["default", "checkpoint"],
+        default="default",
+        help="Select type of stage to create (default: %(default)s)",
+    )
+    experiments_init_parser.set_defaults(func=CmdExperimentsInit)

dvc/commands/experiments/ls.py

@@ -3,7 +3,6 @@ import logging
 
 from dvc.cli.command import CmdBase
 from dvc.cli.utils import append_doc_link
-from dvc.exceptions import InvalidArgumentError
 from dvc.ui import ui
 
 logger = logging.getLogger(__name__)
@@ -12,43 +11,19 @@ logger = logging.getLogger(__name__)
 class CmdExperimentsList(CmdBase):
     def run(self):
         name_only = self.args.name_only
-        sha_only = self.args.sha_only
-        git_remote = self.args.git_remote
-        if sha_only and git_remote:
-            raise InvalidArgumentError("--sha-only not supported with git_remote.")
         exps = self.repo.experiments.ls(
             all_commits=self.args.all_commits,
             rev=self.args.rev,
             num=self.args.num,
-            git_remote=git_remote,
+            git_remote=self.args.git_remote,
         )
 
-        from dvc.repo.experiments.utils import describe
-        from dvc.scm import Git
-
-        if name_only or sha_only:
-            names = {}
-        else:
-            assert isinstance(self.repo.scm, Git)
-            names = describe(
-                self.repo.scm,
-                (baseline for baseline in exps),
-                logger=logger,
-            )
-
         for baseline in exps:
-            if not (name_only or sha_only):
-                name = names.get(baseline) or baseline[:7]
-                ui.write(f"{name}:")
-            for exp_name, rev in exps[baseline]:
-                if name_only:
-                    ui.write(exp_name)
-                elif sha_only:
-                    ui.write(rev)
-                elif rev:
-                    ui.write(f"\t{rev[:7]} [{exp_name}]")
-                else:
-                    ui.write(f"\t{exp_name}")
+            if not name_only:
+                ui.write(f"{baseline}:")
+            for exp_name in exps[baseline]:
+                indent = "" if name_only else "\t"
+                ui.write(f"{indent}{exp_name}")
 
         return 0
 
@@ -59,25 +34,17 @@ def add_parser(experiments_subparsers, parent_parser):
     EXPERIMENTS_LIST_HELP = "List local and remote experiments."
     experiments_list_parser = experiments_subparsers.add_parser(
         "list",
-        aliases=["ls"],
         parents=[parent_parser],
         description=append_doc_link(EXPERIMENTS_LIST_HELP, "exp/list"),
         help=EXPERIMENTS_LIST_HELP,
         formatter_class=argparse.RawDescriptionHelpFormatter,
     )
     add_rev_selection_flags(experiments_list_parser, "List")
-    display_group = experiments_list_parser.add_mutually_exclusive_group()
-    display_group.add_argument(
+    experiments_list_parser.add_argument(
         "--name-only",
         "--names-only",
         action="store_true",
-        help="Only output experiment names (without SHAs or parent commits).",
-    )
-    display_group.add_argument(
-        "--sha-only",
-        "--shas-only",
-        action="store_true",
-        help="Only output experiment commit SHAs (without names or parent commits).",
+        help="Only output experiment names (without parent commits).",
     )
     experiments_list_parser.add_argument(
         "git_remote",

dvc/commands/experiments/pull.py

@@ -3,13 +3,23 @@ import logging
 
 from dvc.cli.command import CmdBase
 from dvc.cli.utils import append_doc_link
+from dvc.exceptions import InvalidArgumentError
 from dvc.ui import ui
 
 logger = logging.getLogger(__name__)
 
 
 class CmdExperimentsPull(CmdBase):
+    def raise_error_if_all_disabled(self):
+        if not any([self.args.experiment, self.args.all_commits, self.args.rev]):
+            raise InvalidArgumentError(
+                "Either provide an `experiment` argument, or use the "
+                "`--rev` or `--all-commits` flag."
+            )
+
     def run(self):
+        self.raise_error_if_all_disabled()
+
         pulled_exps = self.repo.experiments.pull(
             self.args.git_remote,
             self.args.experiment,
@@ -51,7 +61,7 @@ def add_parser(experiments_subparsers, parent_parser):
         help=EXPERIMENTS_PULL_HELP,
         formatter_class=argparse.RawDescriptionHelpFormatter,
     )
-    add_rev_selection_flags(experiments_pull_parser, "Pull", True)
+    add_rev_selection_flags(experiments_pull_parser, "Pull", False)
     experiments_pull_parser.add_argument(
         "-f",
         "--force",

dvc/commands/experiments/push.py

@@ -5,12 +5,20 @@ from typing import Any, Dict
 from dvc.cli import completion
 from dvc.cli.command import CmdBase
 from dvc.cli.utils import append_doc_link
+from dvc.exceptions import InvalidArgumentError
 from dvc.ui import ui
 
 logger = logging.getLogger(__name__)
 
 
 class CmdExperimentsPush(CmdBase):
+    def raise_error_if_all_disabled(self):
+        if not any([self.args.experiment, self.args.all_commits, self.args.rev]):
+            raise InvalidArgumentError(
+                "Either provide an `experiment` argument, or use the "
+                "`--rev` or `--all-commits` flag."
+            )
+
     @staticmethod
     def log_result(result: Dict[str, Any], remote: str):
         from dvc.utils import humanize
@@ -51,6 +59,8 @@ class CmdExperimentsPush(CmdBase):
     def run(self):
         from dvc.repo.experiments.push import UploadError
 
+        self.raise_error_if_all_disabled()
+
         try:
             result = self.repo.experiments.push(
                 self.args.git_remote,
@@ -92,7 +102,7 @@ def add_parser(experiments_subparsers, parent_parser):
         help=EXPERIMENTS_PUSH_HELP,
         formatter_class=argparse.RawDescriptionHelpFormatter,
     )
-    add_rev_selection_flags(experiments_push_parser, "Push", True)
+    add_rev_selection_flags(experiments_push_parser, "Push", False)
     experiments_push_parser.add_argument(
         "-f",
         "--force",

dvc/commands/experiments/remove.py

@@ -50,7 +50,6 @@ def add_parser(experiments_subparsers, parent_parser):
     EXPERIMENTS_REMOVE_HELP = "Remove experiments."
     experiments_remove_parser = experiments_subparsers.add_parser(
         "remove",
-        aliases=["rm"],
         parents=[parent_parser],
         description=append_doc_link(EXPERIMENTS_REMOVE_HELP, "exp/remove"),
         help=EXPERIMENTS_REMOVE_HELP,

dvc/commands/experiments/rename.py

@@ -1,68 +0,0 @@
-import argparse
-import logging
-
-from dvc.cli.command import CmdBase
-from dvc.cli.utils import append_doc_link
-from dvc.exceptions import InvalidArgumentError
-from dvc.ui import ui
-
-logger = logging.getLogger(__name__)
-
-
-class CmdExperimentsRename(CmdBase):
-    def run(self):
-        from dvc.utils import humanize
-
-        if not (self.args.experiment and self.args.name):
-            raise InvalidArgumentError(
-                "An experiment to rename and a new experiment name are required."
-            )
-        renamed = self.repo.experiments.rename(
-            exp_name=self.args.experiment,
-            new_name=self.args.name,
-            git_remote=self.args.git_remote,
-            force=self.args.force,
-        )
-        if renamed:
-            ui.write(f"Renamed experiments: {humanize.join(map(repr, renamed))}")
-        else:
-            ui.write("No experiments to rename.")
-
-        return 0
-
-
-def add_parser(experiments_subparsers, parent_parser):
-    EXPERIMENTS_RENAME_HELP = "Rename experiments."
-    experiments_rename_parser = experiments_subparsers.add_parser(
-        "rename",
-        parents=[parent_parser],
-        description=append_doc_link(EXPERIMENTS_RENAME_HELP, "exp/rename"),
-        help=EXPERIMENTS_RENAME_HELP,
-        formatter_class=argparse.RawDescriptionHelpFormatter,
-    )
-    rename_group = experiments_rename_parser.add_mutually_exclusive_group()
-    rename_group.add_argument(
-        "-g",
-        "--git-remote",
-        metavar="<git_remote>",
-        help="Name or URL of the Git remote to rename the experiment from",
-    )
-    experiments_rename_parser.add_argument(
-        "experiment",
-        help="Experiment to rename.",
-        nargs="?",
-        metavar="<experiment>",
-    )
-    experiments_rename_parser.add_argument(
-        "name",
-        help="New name for the experiment.",
-        metavar="<name>",
-    )
-    experiments_rename_parser.add_argument(
-        "-f",
-        "--force",
-        action="store_true",
-        default=False,
-        help="Replace experiment if it already exists.",
-    )
-    experiments_rename_parser.set_defaults(func=CmdExperimentsRename)

dvc/commands/experiments/run.py

@@ -1,32 +1,56 @@
 import argparse
 import logging
 
+from dvc.cli import completion
 from dvc.cli.utils import append_doc_link
 from dvc.commands.repro import CmdRepro
 from dvc.commands.repro import add_arguments as add_repro_arguments
+from dvc.exceptions import InvalidArgumentError
+from dvc.ui import ui
 
 logger = logging.getLogger(__name__)
 
 
 class CmdExperimentsRun(CmdRepro):
     def run(self):
-        self.repo.experiments.run(
+        from dvc.compare import show_metrics
+
+        if self.args.checkpoint_resume:
+            if self.args.reset:
+                raise InvalidArgumentError("--reset and --rev are mutually exclusive.")
+            if not (self.args.queue or self.args.tmp_dir):
+                raise InvalidArgumentError(
+                    "--rev can only be used in conjunction with --queue or --temp."
+                )
+
+        if self.args.reset:
+            ui.write("Any existing checkpoints will be reset and re-run.")
+
+        results = self.repo.experiments.run(
             name=self.args.name,
             queue=self.args.queue,
             run_all=self.args.run_all,
             jobs=self.args.jobs,
             params=self.args.set_param,
+            checkpoint_resume=self.args.checkpoint_resume,
+            reset=self.args.reset,
             tmp_dir=self.args.tmp_dir,
+            machine=self.args.machine,
             copy_paths=self.args.copy_paths,
             message=self.args.message,
             **self._common_kwargs,
         )
 
+        if self.args.metrics and results:
+            metrics = self.repo.metrics.show(revs=list(results))
+            metrics.pop("workspace", None)
+            show_metrics(metrics)
+
         return 0
 
 
 def add_parser(experiments_subparsers, parent_parser):
-    EXPERIMENTS_RUN_HELP = "Run an experiment."
+    EXPERIMENTS_RUN_HELP = "Run or resume an experiment."
     experiments_run_parser = experiments_subparsers.add_parser(
         "run",
         parents=[parent_parser],
@@ -35,6 +59,22 @@ def add_parser(experiments_subparsers, parent_parser):
         formatter_class=argparse.RawDescriptionHelpFormatter,
     )
     _add_run_common(experiments_run_parser)
+    experiments_run_parser.add_argument(
+        "-r",
+        "--rev",
+        type=str,
+        dest="checkpoint_resume",
+        help=(
+            "Continue the specified checkpoint experiment. Can only be used "
+            "in conjunction with --queue or --temp."
+        ),
+        metavar="<experiment_rev>",
+    ).complete = completion.EXPERIMENT
+    experiments_run_parser.add_argument(
+        "--reset",
+        action="store_true",
+        help="Reset existing checkpoints and restart the experiment.",
+    )
     experiments_run_parser.set_defaults(func=CmdExperimentsRun)
 
 
@@ -89,6 +129,15 @@ def _add_run_common(parser):
             "your workspace."
         ),
     )
+    parser.add_argument(
+        "--machine",
+        default=None,
+        help=argparse.SUPPRESS,
+        # help=(
+        #     "Run this experiment on the specified 'dvc machine' instance."
+        # )
+        # metavar="<name>",
+    )
     parser.add_argument(
         "-C",
         "--copy-paths",
@@ -100,14 +149,9 @@ def _add_run_common(parser):
         ),
     )
     parser.add_argument(
-        "-m",
+        "-M",
         "--message",
         type=str,
         default=None,
         help="Custom commit message to use when committing the experiment.",
     )
-    parser.add_argument(
-        "-M",  # obsolete
-        dest="message",
-        help=argparse.SUPPRESS,
-    )

dvc/commands/experiments/save.py

@@ -27,6 +27,10 @@ class CmdExperimentsSave(CmdBase):
         else:
             name = self.repo.experiments.get_exact_name([ref])[ref]
             ui.write(f"Experiment has been saved as: {name}")
+            ui.write(
+                "\nTo promote an experiment to a Git branch run:\n\n"
+                "\tdvc exp branch <exp> <branch>\n"
+            )
 
         return 0
 
@@ -49,6 +53,7 @@ def add_parser(experiments_subparsers, parent_parser):
     )
     save_parser.add_argument(
         "--json",
+        "--show-json",
         action="store_true",
         default=False,
         help="Show output in JSON format.",
@@ -72,15 +77,10 @@ def add_parser(experiments_subparsers, parent_parser):
         metavar="<path>",
     )
     save_parser.add_argument(
-        "-m",
+        "-M",
         "--message",
         type=str,
         default=None,
         help="Custom commit message to use when committing the experiment.",
     )
-    save_parser.add_argument(
-        "-M",  # obsolete
-        dest="message",
-        help=argparse.SUPPRESS,
-    )
     save_parser.set_defaults(func=CmdExperimentsSave)

dvc/commands/experiments/show.py

@@ -1,11 +1,13 @@
 import argparse
 import logging
+import os
 import re
 from datetime import date, datetime
 from typing import TYPE_CHECKING, Dict, Iterable
 
 from funcy import lmap
 
+from dvc.cli import completion
 from dvc.cli.command import CmdBase
 from dvc.cli.utils import append_doc_link
 from dvc.commands.metrics import DEFAULT_PRECISION
@@ -25,6 +27,9 @@ logger = logging.getLogger(__name__)
 
 
 experiment_types = {
+    "checkpoint_tip": "│ ╓",
+    "checkpoint_commit": "│ ╟",
+    "checkpoint_base": "├─╨",
     "branch_commit": "├──",
     "branch_base": "└──",
     "baseline": "",
@@ -54,7 +59,7 @@ def baseline_styler(typ):
     return {"style": "bold"} if typ == "baseline" else {}
 
 
-def show_experiments(  # noqa: C901
+def show_experiments(  # noqa: C901, PLR0912
     td: "TabularData",
     headers: Dict[str, Iterable[str]],
     keep=None,
@@ -62,6 +67,7 @@ def show_experiments(  # noqa: C901
     pager=True,
     csv=False,
     markdown=False,
+    pcp=False,
     **kwargs,
 ):
     if keep:
@@ -104,23 +110,51 @@ def show_experiments(  # noqa: C901
         }
     )
 
-    if kwargs.get("only_changed", False):
+    if kwargs.get("only_changed", False) or pcp:
         td.drop_duplicates("cols", ignore_empty=False)
 
     cols_to_drop = set()
     if drop is not None:
         cols_to_drop = {col for col in td.keys() if re.match(drop, col)}  # noqa: SIM118
+    if pcp:
+        cols_to_drop.add("Created")
     td.drop(*cols_to_drop)
 
-    td.render(
-        pager=pager,
-        borders="horizontals",
-        rich_table=True,
-        header_styles=styles,
-        row_styles=row_styles,
-        csv=csv,
-        markdown=markdown,
-    )
+    if pcp:
+        subset = {x for x in td.keys() if x != "Experiment"}  # noqa: SIM118
+        td.dropna(
+            "rows",
+            how="all",
+            subset=subset,
+        )
+        td.drop_duplicates("rows", subset=subset)
+        if "Experiment" in td:
+            td.column("Experiment")[:] = [
+                # remove tree characters
+                str(x).encode("ascii", "ignore").strip().decode()
+                for x in td.column("Experiment")
+            ]
+        out = kwargs.get("out") or "dvc_plots"
+        output_file = os.path.join(out, "index.html")
+        ui.write(
+            td.to_parallel_coordinates(
+                output_path=os.path.abspath(output_file),
+                color_by=kwargs.get("sort_by") or "Experiment",
+            )
+        )
+        if kwargs.get("open"):
+            return ui.open_browser(output_file)
+
+    else:
+        td.render(
+            pager=pager,
+            borders="horizontals",
+            rich_table=True,
+            header_styles=styles,
+            row_styles=row_styles,
+            csv=csv,
+            markdown=markdown,
+        )
 
 
 def _normalize_headers(names, count):
@@ -187,6 +221,9 @@ class CmdExperimentsShow(CmdBase):
                 csv=self.args.csv,
                 markdown=self.args.markdown,
                 only_changed=self.args.only_changed,
+                pcp=self.args.pcp,
+                out=self.args.out,
+                open=self.args.open,
             )
         return 0
 
@@ -279,18 +316,21 @@ def add_parser(experiments_subparsers, parent_parser):
     )
     experiments_show_parser.add_argument(
         "--json",
+        "--show-json",
         action="store_true",
         default=False,
         help="Print output in JSON format instead of a human-readable table.",
     )
     experiments_show_parser.add_argument(
         "--csv",
+        "--show-csv",
         action="store_true",
         default=False,
         help="Print output in csv format instead of a human-readable table.",
     )
     experiments_show_parser.add_argument(
         "--md",
+        "--show-md",
         action="store_true",
         default=False,
         dest="markdown",
@@ -305,6 +345,27 @@ def add_parser(experiments_subparsers, parent_parser):
         ),
         metavar="<n>",
     )
+    experiments_show_parser.add_argument(
+        "--parallel-coordinates-plot",
+        "--pcp",
+        dest="pcp",
+        action="store_true",
+        default=False,
+        help="Generate a Parallel Coordinates Plot from the tabulated output.",
+    )
+    experiments_show_parser.add_argument(
+        "-o",
+        "--out",
+        default=None,
+        help="Destination folder to save the Parallel Coordinates Plot to",
+        metavar="<path>",
+    ).complete = completion.DIR
+    experiments_show_parser.add_argument(
+        "--open",
+        action="store_true",
+        default=False,
+        help="Open the Parallel Coordinates Plot directly in the browser.",
+    )
     experiments_show_parser.add_argument(
         "--no-fetch",
         dest="fetch_running",

dvc/commands/gc.py

@@ -81,7 +81,6 @@ class CmdGC(CmdBase):
             rev=self.args.rev,
             num=self.args.num,
             not_in_remote=self.args.not_in_remote,
-            dry=self.args.dry,
         )
         return 0
 
@@ -214,10 +213,4 @@ def add_parser(subparsers, parent_parser):
         ),
         metavar="<paths>",
     )
-    gc_parser.add_argument(
-        "--dry",
-        action="store_true",
-        default=False,
-        help=("Only print what would get removed without actually removing."),
-    )
     gc_parser.set_defaults(func=CmdGC)

dvc/commands/get.py

@@ -3,7 +3,7 @@ import logging
 
 from dvc.cli import completion
 from dvc.cli.command import CmdBaseNoRepo
-from dvc.cli.utils import DictAction, append_doc_link
+from dvc.cli.utils import append_doc_link
 from dvc.exceptions import DvcException
 
 logger = logging.getLogger(__name__)
@@ -37,9 +37,6 @@ class CmdGet(CmdBaseNoRepo):
                 rev=self.args.rev,
                 jobs=self.args.jobs,
                 force=self.args.force,
-                config=self.args.config,
-                remote=self.args.remote,
-                remote_config=self.args.remote_config,
             )
             return 0
         except CloneError:
@@ -105,27 +102,4 @@ def add_parser(subparsers, parent_parser):
         default=False,
         help="Override local file or folder if exists.",
     )
-    get_parser.add_argument(
-        "--config",
-        type=str,
-        help=(
-            "Path to a config file that will be merged with the config "
-            "in the target repository."
-        ),
-    )
-    get_parser.add_argument(
-        "--remote",
-        type=str,
-        help="Remote name to set as a default in the target repository.",
-    )
-    get_parser.add_argument(
-        "--remote-config",
-        type=str,
-        nargs="*",
-        action=DictAction,
-        help=(
-            "Remote config options to merge with a remote's config (default or one "
-            "specified by '--remote') in the target repository."
-        ),
-    )
     get_parser.set_defaults(func=CmdGet)

dvc/commands/get_url.py

@@ -3,7 +3,7 @@ import logging
 
 from dvc.cli import completion
 from dvc.cli.command import CmdBaseNoRepo
-from dvc.cli.utils import DictAction, append_doc_link
+from dvc.cli.utils import append_doc_link
 from dvc.exceptions import DvcException
 
 logger = logging.getLogger(__name__)
@@ -11,7 +11,6 @@ logger = logging.getLogger(__name__)
 
 class CmdGetUrl(CmdBaseNoRepo):
     def run(self):
-        from dvc.config import Config
         from dvc.repo import Repo
 
         try:
@@ -20,8 +19,6 @@ class CmdGetUrl(CmdBaseNoRepo):
                 out=self.args.out,
                 jobs=self.args.jobs,
                 force=self.args.force,
-                fs_config=self.args.fs_config,
-                config=Config.from_cwd(),
             )
             return 0
         except DvcException:
@@ -61,11 +58,4 @@ def add_parser(subparsers, parent_parser):
         default=False,
         help="Override local file or folder if exists.",
     )
-    get_parser.add_argument(
-        "--fs-config",
-        type=str,
-        nargs="*",
-        action=DictAction,
-        help="Config options for the target url.",
-    )
     get_parser.set_defaults(func=CmdGetUrl)

dvc/commands/imp.py

@@ -3,7 +3,7 @@ import logging
 
 from dvc.cli import completion
 from dvc.cli.command import CmdBase
-from dvc.cli.utils import DictAction, append_doc_link
+from dvc.cli.utils import append_doc_link
 from dvc.exceptions import DvcException
 
 logger = logging.getLogger(__name__)
@@ -18,14 +18,15 @@ class CmdImport(CmdBase):
                 self.args.url,
                 self.args.path,
                 out=self.args.out,
+                fname=self.args.file,
                 rev=self.args.rev,
                 no_exec=self.args.no_exec,
                 no_download=self.args.no_download,
+                desc=self.args.desc,
+                type=self.args.type,
+                labels=self.args.labels,
+                meta=self.args.meta,
                 jobs=self.args.jobs,
-                config=self.args.config,
-                remote=self.args.remote,
-                remote_config=self.args.remote_config,
-                force=self.args.force,
             )
         except CloneError:
             logger.exception("failed to import '%s'", self.args.path)
@@ -41,6 +42,8 @@ class CmdImport(CmdBase):
 
 
 def add_parser(subparsers, parent_parser):
+    from .add import _add_annotating_args
+
     IMPORT_HELP = (
         "Download file or directory tracked by DVC or by Git "
         "into the workspace, and track it."
@@ -66,19 +69,17 @@ def add_parser(subparsers, parent_parser):
         help="Destination path to download files to",
         metavar="<path>",
     ).complete = completion.DIR
-    import_parser.add_argument(
-        "-f",
-        "--force",
-        action="store_true",
-        default=False,
-        help="Override destination file or folder if exists.",
-    )
     import_parser.add_argument(
         "--rev",
         nargs="?",
         help="Git revision (e.g. SHA, branch, tag)",
         metavar="<commit>",
     )
+    import_parser.add_argument(
+        "--file",
+        help="Specify name of the .dvc file this command will generate.",
+        metavar="<filename>",
+    )
     no_download_exec_group = import_parser.add_mutually_exclusive_group()
     no_download_exec_group.add_argument(
         "--no-exec",
@@ -105,27 +106,6 @@ def add_parser(subparsers, parent_parser):
         ),
         metavar="<number>",
     )
-    import_parser.add_argument(
-        "--config",
-        type=str,
-        help=(
-            "Path to a config file that will be merged with the config "
-            "in the target repository."
-        ),
-    )
-    import_parser.add_argument(
-        "--remote",
-        type=str,
-        help="Remote name to set as a default in the target repository.",
-    )
-    import_parser.add_argument(
-        "--remote-config",
-        type=str,
-        nargs="*",
-        action=DictAction,
-        help=(
-            "Remote config options to merge with a remote's config (default or one "
-            "specified by '--remote') in the target repository."
-        ),
-    )
+
+    _add_annotating_args(import_parser)
     import_parser.set_defaults(func=CmdImport)

dvc/commands/imp_url.py

@@ -3,7 +3,7 @@ import logging
 
 from dvc.cli import completion
 from dvc.cli.command import CmdBase
-from dvc.cli.utils import DictAction, append_doc_link
+from dvc.cli.utils import append_doc_link
 from dvc.exceptions import DvcException
 
 logger = logging.getLogger(__name__)
@@ -15,14 +15,18 @@ class CmdImportUrl(CmdBase):
             self.repo.imp_url(
                 self.args.url,
                 out=self.args.out,
+                fname=self.args.file,
                 no_exec=self.args.no_exec,
                 no_download=self.args.no_download,
                 remote=self.args.remote,
                 to_remote=self.args.to_remote,
+                desc=self.args.desc,
+                type=self.args.type,
+                labels=self.args.labels,
+                meta=self.args.meta,
                 jobs=self.args.jobs,
                 force=self.args.force,
                 version_aware=self.args.version_aware,
-                fs_config=self.args.fs_config,
             )
         except DvcException:
             logger.exception(
@@ -37,6 +41,8 @@ class CmdImportUrl(CmdBase):
 
 
 def add_parser(subparsers, parent_parser):
+    from .add import _add_annotating_args
+
     IMPORT_HELP = "Download or copy file from URL and take it under DVC control."
 
     import_parser = subparsers.add_parser(
@@ -64,6 +70,11 @@ def add_parser(subparsers, parent_parser):
     import_parser.add_argument(
         "out", nargs="?", help="Destination path to put files to."
     ).complete = completion.DIR
+    import_parser.add_argument(
+        "--file",
+        help="Specify name of the .dvc file this command will generate.",
+        metavar="<filename>",
+    ).complete = completion.DIR
     import_parser.add_argument(
         "--to-remote",
         action="store_true",
@@ -115,11 +126,5 @@ def add_parser(subparsers, parent_parser):
         default=False,
         help="Import using cloud versioning. Implied if the URL contains a version ID.",
     )
-    import_parser.add_argument(
-        "--fs-config",
-        type=str,
-        nargs="*",
-        action=DictAction,
-        help="Config options for the target url.",
-    )
+    _add_annotating_args(import_parser)
     import_parser.set_defaults(func=CmdImportUrl)

dvc/commands/ls/__init__.py

@@ -3,7 +3,7 @@ import logging
 
 from dvc.cli import completion
 from dvc.cli.command import CmdBaseNoRepo
-from dvc.cli.utils import DictAction, append_doc_link
+from dvc.cli.utils import append_doc_link
 from dvc.commands.ls.ls_colors import LsColors
 from dvc.exceptions import DvcException
 from dvc.ui import ui
@@ -11,18 +11,7 @@ from dvc.ui import ui
 logger = logging.getLogger(__name__)
 
 
-def _format_entry(entry, fmt):
-    from dvc.utils.humanize import naturalsize
-
-    size = entry.get("size")
-    if size is None:
-        size = ""
-    else:
-        size = naturalsize(size)
-    return size, fmt(entry)
-
-
-def show_entries(entries, with_color=False, with_size=False):
+def _prettify(entries, with_color=False):
     if with_color:
         ls_colors = LsColors()
         fmt = ls_colors.format
@@ -31,12 +20,7 @@ def show_entries(entries, with_color=False, with_size=False):
         def fmt(entry):
             return entry["path"]
 
-    if with_size:
-        ui.table([_format_entry(entry, fmt) for entry in entries])
-        return
-
-    # NOTE: this is faster than ui.table for very large number of entries
-    ui.write("\n".join(fmt(entry) for entry in entries))
+    return [fmt(entry) for entry in entries]
 
 
 class CmdList(CmdBaseNoRepo):
@@ -50,14 +34,12 @@ class CmdList(CmdBaseNoRepo):
                 rev=self.args.rev,
                 recursive=self.args.recursive,
                 dvc_only=self.args.dvc_only,
-                config=self.args.config,
-                remote=self.args.remote,
-                remote_config=self.args.remote_config,
             )
             if self.args.json:
                 ui.write_json(entries)
             elif entries:
-                show_entries(entries, with_color=True, with_size=self.args.size)
+                entries = _prettify(entries, with_color=True)
+                ui.write("\n".join(entries))
             return 0
         except DvcException:
             logger.exception("failed to list '%s'", self.args.url)
@@ -89,6 +71,7 @@ def add_parser(subparsers, parent_parser):
     )
     list_parser.add_argument(
         "--json",
+        "--show-json",
         action="store_true",
         help="Show output in JSON format.",
     )
@@ -98,34 +81,6 @@ def add_parser(subparsers, parent_parser):
         help="Git revision (e.g. SHA, branch, tag)",
         metavar="<commit>",
     )
-    list_parser.add_argument(
-        "--config",
-        type=str,
-        help=(
-            "Path to a config file that will be merged with the config "
-            "in the target repository."
-        ),
-    )
-    list_parser.add_argument(
-        "--remote",
-        type=str,
-        help="Remote name to set as a default in the target repository.",
-    )
-    list_parser.add_argument(
-        "--remote-config",
-        type=str,
-        nargs="*",
-        action=DictAction,
-        help=(
-            "Remote config options to merge with a remote's config (default or one "
-            "specified by '--remote') in the target repository."
-        ),
-    )
-    list_parser.add_argument(
-        "--size",
-        action="store_true",
-        help="Show sizes.",
-    )
     list_parser.add_argument(
         "path",
         nargs="?",

dvc/commands/ls_url.py

@@ -2,26 +2,22 @@ import argparse
 import logging
 
 from dvc.cli.command import CmdBaseNoRepo
-from dvc.cli.utils import DictAction, append_doc_link
+from dvc.cli.utils import append_doc_link
+from dvc.ui import ui
 
-from .ls import show_entries
+from .ls import _prettify
 
 logger = logging.getLogger(__name__)
 
 
 class CmdListUrl(CmdBaseNoRepo):
     def run(self):
-        from dvc.config import Config
         from dvc.repo import Repo
 
-        entries = Repo.ls_url(
-            self.args.url,
-            recursive=self.args.recursive,
-            fs_config=self.args.fs_config,
-            config=Config.from_cwd(),
-        )
+        entries = Repo.ls_url(self.args.url, recursive=self.args.recursive)
         if entries:
-            show_entries(entries, with_color=True, with_size=self.args.size)
+            entries = _prettify(entries, with_color=True)
+            ui.write("\n".join(entries))
         return 0
 
 
@@ -44,16 +40,4 @@ def add_parser(subparsers, parent_parser):
         action="store_true",
         help="Recursively list files.",
     )
-    lsurl_parser.add_argument(
-        "--size",
-        action="store_true",
-        help="Show sizes.",
-    )
-    lsurl_parser.add_argument(
-        "--fs-config",
-        type=str,
-        nargs="*",
-        action=DictAction,
-        help="Config options for the target url.",
-    )
     lsurl_parser.set_defaults(func=CmdListUrl)

dvc/commands/machine.py

@@ -0,0 +1,490 @@
+import argparse
+from typing import Dict, List
+
+from dvc.cli.command import CmdBase
+from dvc.cli.utils import append_doc_link, fix_subparsers
+from dvc.commands.config import CmdConfig
+from dvc.compare import TabularData
+from dvc.config import ConfigError
+from dvc.exceptions import DvcException
+from dvc.ui import ui
+from dvc.utils import format_link
+
+
+class MachineDisabledError(ConfigError):
+    def __init__(self):
+        super().__init__("Machine feature is disabled")
+
+
+class CmdMachineConfig(CmdConfig):
+    def __init__(self, args):
+        super().__init__(args)
+        if not self.config["feature"].get("machine", False):
+            raise MachineDisabledError
+
+        if getattr(self.args, "name", None):
+            self.args.name = self.args.name.lower()
+
+    def _check_exists(self, conf):
+        if self.args.name not in conf["machine"]:
+            raise ConfigError(f"machine '{self.args.name}' doesn't exist.")
+
+
+class CmdMachineAdd(CmdMachineConfig):
+    def run(self):
+        from dvc.machine import validate_name
+
+        validate_name(self.args.name)
+
+        if self.args.default:
+            ui.write(f"Setting '{self.args.name}' as a default machine.")
+
+        with self.config.edit(self.args.level) as conf:
+            if self.args.name in conf["machine"] and not self.args.force:
+                raise ConfigError(
+                    "machine '{}' already exists. Use `-f|--force` to "
+                    "overwrite it.".format(self.args.name)
+                )
+
+            conf["machine"][self.args.name] = {"cloud": self.args.cloud}
+            if self.args.default:
+                conf["core"]["machine"] = self.args.name
+
+        return 0
+
+
+class CmdMachineRemove(CmdMachineConfig):
+    def run(self):
+        with self.config.edit(self.args.level) as conf:
+            self._check_exists(conf)
+            del conf["machine"][self.args.name]
+
+        up_to_level = self.args.level or "repo"
+        # Remove core.machine refs to this machine in any shadowing configs
+        for level in reversed(self.config.LEVELS):
+            with self.config.edit(level) as conf:
+                if conf["core"].get("machine") == self.args.name:
+                    del conf["core"]["machine"]
+
+            if level == up_to_level:
+                break
+
+        return 0
+
+
+class CmdMachineList(CmdMachineConfig):
+    TABLE_COLUMNS = [
+        "name",
+        "cloud",
+        "region",
+        "image",
+        "spot",
+        "spot_price",
+        "instance_hdd_size",
+        "instance_type",
+        "ssh_private",
+        "startup_script",
+    ]
+
+    PRIVATE_COLUMNS = ["ssh_private", "startup_script"]
+
+    def _hide_private(self, conf):
+        for machine in conf:
+            for column in self.PRIVATE_COLUMNS:
+                if column in conf[machine]:
+                    conf[machine][column] = "***"
+
+    def _show_origin(self):
+        levels = [self.args.level] if self.args.level else self.config.LEVELS
+        for level in levels:
+            conf = self.config.read(level)["machine"]
+            if self.args.name:
+                conf = conf.get(self.args.name, {})
+            self._hide_private(conf)
+            prefix = self._config_file_prefix(True, self.config, level)
+            configs = list(self._format_config(conf, prefix))
+            if configs:
+                ui.write("\n".join(configs))
+
+    def _show_table(self):
+        td = TabularData(self.TABLE_COLUMNS, fill_value="-")
+        conf = self.config.read()["machine"]
+        if self.args.name:
+            conf = {self.args.name: conf.get(self.args.name, {})}
+        self._hide_private(conf)
+        for machine, machine_config in conf.items():
+            machine_config["name"] = machine
+            td.row_from_dict(machine_config)
+        td.dropna("cols", "all")
+        td.render()
+
+    def run(self):
+        if self.args.show_origin:
+            self._show_origin()
+        else:
+            self._show_table()
+        return 0
+
+
+class CmdMachineModify(CmdMachineConfig):
+    def run(self):
+        from dvc.config import merge
+
+        with self.config.edit(self.args.level) as conf:
+            merged = self.config.load_config_to_level(self.args.level)
+            merge(merged, conf)
+            self._check_exists(merged)
+
+            if self.args.name not in conf["machine"]:
+                conf["machine"][self.args.name] = {}
+            section = conf["machine"][self.args.name]
+            if self.args.unset:
+                section.pop(self.args.option, None)
+            else:
+                section[self.args.option] = self.args.value
+        return 0
+
+
+class CmdMachineRename(CmdBase):
+    def _check_exists(self, conf):
+        if self.args.name not in conf["machine"]:
+            raise ConfigError(f"machine '{self.args.name}' doesn't exist.")
+
+    def _rename_default(self, conf):
+        if conf["core"].get("machine") == self.args.name:
+            conf["core"]["machine"] = self.args.new
+
+    def _check_before_rename(self):
+        from dvc.machine import validate_name
+
+        validate_name(self.args.new)
+
+        all_config = self.config.load_config_to_level(None)
+        if self.args.new in all_config.get("machine", {}):
+            raise ConfigError(
+                f"Rename failed. Machine '{self.args.new}' already exists."
+            )
+        ui.write(f"Rename machine '{self.args.name}' to '{self.args.new}'.")
+
+    def run(self):
+        self._check_before_rename()
+
+        with self.config.edit(self.args.level) as conf:
+            self._check_exists(conf)
+            conf["machine"][self.args.new] = conf["machine"][self.args.name]
+            try:
+                assert self.repo.machine
+                self.repo.machine.rename(self.args.name, self.args.new)
+            except DvcException as error:
+                del conf["machine"][self.args.new]
+                raise ConfigError("terraform rename failed") from error
+            del conf["machine"][self.args.name]
+            self._rename_default(conf)
+
+        up_to_level = self.args.level or "repo"
+        for level in reversed(self.config.LEVELS):
+            if level == up_to_level:
+                break
+            with self.config.edit(level) as level_conf:
+                self._rename_default(level_conf)
+
+        return 0
+
+
+class CmdMachineDefault(CmdMachineConfig):
+    def run(self):
+        if self.args.name is None and not self.args.unset:
+            conf = self.config.read(self.args.level)
+            try:
+                ui.write(conf["core"]["machine"])
+            except KeyError:
+                ui.write("No default machine set")
+                return 1
+        else:
+            with self.config.edit(self.args.level) as conf:
+                if self.args.unset:
+                    conf["core"].pop("machine", None)
+                else:
+                    merged_conf = self.config.load_config_to_level(self.args.level)
+                    if (
+                        self.args.name in conf["machine"]
+                        or self.args.name in merged_conf["machine"]
+                    ):
+                        conf["core"]["machine"] = self.args.name
+                    else:
+                        raise ConfigError(
+                            "default machine must be present in machine list."
+                        )
+        return 0
+
+
+class CmdMachineCreate(CmdBase):
+    def run(self):
+        if self.repo.machine is None:
+            raise MachineDisabledError
+
+        self.repo.machine.create(self.args.name)
+        return 0
+
+
+class CmdMachineStatus(CmdBase):
+    INSTANCE_FIELD = ["name", "instance", "status"]
+    SHOWN_FIELD = [
+        "cloud",
+        "instance_ip",
+        "instance_type",
+        "instance_hdd_size",
+        "instance_gpu",
+    ]
+    FILL_VALUE = "-"
+
+    def _add_row(
+        self,
+        name: str,
+        all_status: List[Dict],
+        td: TabularData,
+    ):
+        if not all_status:
+            row = [
+                name,
+                self.FILL_VALUE,
+                "offline",
+            ]  # back to `None` after #7167
+            td.append(row)
+        for i, status in enumerate(all_status, start=1):
+            row = [name, f"num_{i}", "running" if status else "offline"]
+            for field in self.SHOWN_FIELD:
+                value = str(status.get(field, ""))
+                row.append(value)
+            td.append(row)
+
+    def run(self):
+        if self.repo.machine is None:
+            raise MachineDisabledError
+
+        td = TabularData(
+            self.INSTANCE_FIELD + self.SHOWN_FIELD, fill_value=self.FILL_VALUE
+        )
+
+        if self.args.name:
+            all_status = list(self.repo.machine.status(self.args.name))
+            self._add_row(self.args.name, all_status, td)
+        else:
+            name_set = set()
+            for level in self.repo.config.LEVELS:
+                conf = self.repo.config.read(level)["machine"]
+                name_set.update(conf.keys())
+            name_list = list(name_set)
+            for name in sorted(name_list):
+                all_status = list(self.repo.machine.status(name))
+                self._add_row(name, all_status, td)
+
+        td.dropna("cols", "all")
+        td.render()
+        return 0
+
+
+class CmdMachineDestroy(CmdBase):
+    def run(self):
+        if self.repo.machine is None:
+            raise MachineDisabledError
+
+        self.repo.machine.destroy(self.args.name)
+        return 0
+
+
+class CmdMachineSsh(CmdBase):
+    def run(self):
+        if self.repo.machine is None:
+            raise MachineDisabledError
+
+        self.repo.machine.run_shell(self.args.name)
+        return 0
+
+
+def add_parser(subparsers, parent_parser):  # noqa: PLR0915
+    from dvc.commands.config import parent_config_parser
+
+    machine_HELP = "Set up and manage cloud machines."
+    machine_parser = subparsers.add_parser(
+        "machine",
+        parents=[parent_parser],
+        description=append_doc_link(machine_HELP, "machine"),
+        # NOTE: suppress help during development to hide command
+        # help=machine_HELP,
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+    )
+
+    machine_subparsers = machine_parser.add_subparsers(
+        dest="cmd",
+        help="Use `dvc machine CMD --help` for command-specific help.",
+    )
+
+    fix_subparsers(machine_subparsers)
+
+    machine_ADD_HELP = "Add a new data machine."
+    machine_add_parser = machine_subparsers.add_parser(
+        "add",
+        parents=[parent_config_parser, parent_parser],
+        description=append_doc_link(machine_ADD_HELP, "machine/add"),
+        help=machine_ADD_HELP,
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+    )
+    machine_add_parser.add_argument("name", help="Name of the machine")
+    machine_add_parser.add_argument(
+        "cloud",
+        help="Machine cloud. See full list of supported clouds at {}".format(
+            format_link(
+                "https://github.com/iterative/terraform-provider-iterative#machine"
+            )
+        ),
+    )
+    machine_add_parser.add_argument(
+        "-d",
+        "--default",
+        action="store_true",
+        default=False,
+        help="Set as default machine.",
+    )
+    machine_add_parser.add_argument(
+        "-f",
+        "--force",
+        action="store_true",
+        default=False,
+        help="Force overwriting existing configs",
+    )
+    machine_add_parser.set_defaults(func=CmdMachineAdd)
+
+    machine_DEFAULT_HELP = "Set/unset the default machine."
+    machine_default_parser = machine_subparsers.add_parser(
+        "default",
+        parents=[parent_config_parser, parent_parser],
+        description=append_doc_link(machine_DEFAULT_HELP, "machine/default"),
+        help=machine_DEFAULT_HELP,
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+    )
+    machine_default_parser.add_argument("name", nargs="?", help="Name of the machine")
+    machine_default_parser.add_argument(
+        "-u",
+        "--unset",
+        action="store_true",
+        default=False,
+        help="Unset default machine.",
+    )
+    machine_default_parser.set_defaults(func=CmdMachineDefault)
+
+    machine_LIST_HELP = "List the configuration of one/all machines."
+    machine_list_parser = machine_subparsers.add_parser(
+        "list",
+        parents=[parent_config_parser, parent_parser],
+        description=append_doc_link(machine_LIST_HELP, "machine/list"),
+        help=machine_LIST_HELP,
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+    )
+    machine_list_parser.add_argument(
+        "--show-origin",
+        default=False,
+        action="store_true",
+        help="Show the source file containing each config value.",
+    )
+    machine_list_parser.add_argument(
+        "name",
+        nargs="?",
+        type=str,
+        help="name of machine to specify",
+    )
+    machine_list_parser.set_defaults(func=CmdMachineList)
+    machine_MODIFY_HELP = "Modify the configuration of an machine."
+    machine_modify_parser = machine_subparsers.add_parser(
+        "modify",
+        parents=[parent_config_parser, parent_parser],
+        description=append_doc_link(machine_MODIFY_HELP, "machine/modify"),
+        help=machine_MODIFY_HELP,
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+    )
+    machine_modify_parser.add_argument("name", help="Name of the machine")
+    machine_modify_parser.add_argument("option", help="Name of the option to modify.")
+    machine_modify_parser.add_argument(
+        "value", nargs="?", help="(optional) Value of the option."
+    )
+    machine_modify_parser.add_argument(
+        "-u",
+        "--unset",
+        default=False,
+        action="store_true",
+        help="Unset option.",
+    )
+    machine_modify_parser.set_defaults(func=CmdMachineModify)
+
+    machine_RENAME_HELP = "Rename a machine "
+    machine_rename_parser = machine_subparsers.add_parser(
+        "rename",
+        parents=[parent_config_parser, parent_parser],
+        description=append_doc_link(machine_RENAME_HELP, "remote/rename"),
+        help=machine_RENAME_HELP,
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+    )
+    machine_rename_parser.add_argument("name", help="Machine to be renamed")
+    machine_rename_parser.add_argument("new", help="New name of the machine")
+    machine_rename_parser.set_defaults(func=CmdMachineRename)
+
+    machine_REMOVE_HELP = "Remove an machine."
+    machine_remove_parser = machine_subparsers.add_parser(
+        "remove",
+        parents=[parent_config_parser, parent_parser],
+        description=append_doc_link(machine_REMOVE_HELP, "machine/remove"),
+        help=machine_REMOVE_HELP,
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+    )
+    machine_remove_parser.add_argument("name", help="Name of the machine to remove.")
+    machine_remove_parser.set_defaults(func=CmdMachineRemove)
+
+    machine_CREATE_HELP = "Create and start a machine instance."
+    machine_create_parser = machine_subparsers.add_parser(
+        "create",
+        parents=[parent_parser],
+        description=append_doc_link(machine_CREATE_HELP, "machine/create"),
+        help=machine_CREATE_HELP,
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+    )
+    machine_create_parser.add_argument("name", help="Name of the machine to create.")
+    machine_create_parser.set_defaults(func=CmdMachineCreate)
+
+    machine_STATUS_HELP = "List the status of running instances for one/all machines."
+    machine_status_parser = machine_subparsers.add_parser(
+        "status",
+        parents=[parent_parser],
+        description=append_doc_link(machine_STATUS_HELP, "machine/status"),
+        help=machine_STATUS_HELP,
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+    )
+    machine_status_parser.add_argument(
+        "name", nargs="?", help="(optional) Name of the machine."
+    )
+    machine_status_parser.set_defaults(func=CmdMachineStatus)
+
+    machine_DESTROY_HELP = "Destroy an machine instance."
+    machine_destroy_parser = machine_subparsers.add_parser(
+        "destroy",
+        parents=[parent_parser],
+        description=append_doc_link(machine_DESTROY_HELP, "machine/destroy"),
+        help=machine_DESTROY_HELP,
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+    )
+    machine_destroy_parser.add_argument(
+        "name", help="Name of the machine instance to destroy."
+    )
+    machine_destroy_parser.set_defaults(func=CmdMachineDestroy)
+
+    machine_SSH_HELP = "Connect to a machine via SSH."
+    machine_ssh_parser = machine_subparsers.add_parser(
+        "ssh",
+        parents=[parent_parser],
+        description=append_doc_link(machine_SSH_HELP, "machine/ssh"),
+        help=machine_SSH_HELP,
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+    )
+    machine_ssh_parser.add_argument(
+        "name", help="Name of the machine instance to connect to."
+    )
+    machine_ssh_parser.set_defaults(func=CmdMachineSsh)

dvc/commands/metrics.py

@@ -4,6 +4,7 @@ import logging
 from dvc.cli import completion
 from dvc.cli.command import CmdBase
 from dvc.cli.utils import append_doc_link, fix_subparsers
+from dvc.exceptions import DvcException
 from dvc.ui import ui
 from dvc.utils.serialize import encode_exception
 
@@ -19,25 +20,17 @@ class CmdMetricsBase(CmdBase):
 
 class CmdMetricsShow(CmdMetricsBase):
     def run(self):
-        from dvc.repo.metrics.show import to_relpath
-        from dvc.utils import errored_revisions
-
-        metrics = self.repo.metrics.show(
-            self.args.targets,
-            all_branches=self.args.all_branches,
-            all_tags=self.args.all_tags,
-            all_commits=self.args.all_commits,
-        )
-        metrics = {
-            k: to_relpath(self.repo.fs, self.repo.root_dir, v)
-            for k, v in metrics.items()
-        }
-
-        if errored := errored_revisions(metrics):
-            ui.error_write(
-                "DVC failed to load some metrics for following revisions:"
-                f" '{', '.join(errored)}'."
+        try:
+            metrics = self.repo.metrics.show(
+                self.args.targets,
+                all_branches=self.args.all_branches,
+                all_tags=self.args.all_tags,
+                all_commits=self.args.all_commits,
+                recursive=self.args.recursive,
             )
+        except DvcException:
+            logger.exception("")
+            return 1
 
         if self.args.json:
             ui.write_json(metrics, default=encode_exception)
@@ -59,26 +52,17 @@ class CmdMetricsShow(CmdMetricsBase):
 
 class CmdMetricsDiff(CmdMetricsBase):
     def run(self):
-        import os
-        from os.path import relpath
-
-        diff_result = self.repo.metrics.diff(
-            a_rev=self.args.a_rev,
-            b_rev=self.args.b_rev,
-            targets=self.args.targets,
-            all=self.args.all,
-        )
-
-        errored = [rev for rev, err in diff_result.get("errors", {}).items() if err]
-        if errored:
-            ui.error_write(
-                "DVC failed to load some metrics for following revisions:"
-                f" '{', '.join(errored)}'."
+        try:
+            diff = self.repo.metrics.diff(
+                a_rev=self.args.a_rev,
+                b_rev=self.args.b_rev,
+                targets=self.args.targets,
+                recursive=self.args.recursive,
+                all=self.args.all,
             )
-
-        start = relpath(os.getcwd(), self.repo.root_dir)
-        diff = diff_result.get("diff", {})
-        diff = {relpath(path, start): result for path, result in diff.items()}
+        except DvcException:
+            logger.exception("failed to show metrics diff")
+            return 1
 
         if self.args.json:
             ui.write_json(diff)
@@ -156,12 +140,14 @@ def add_parser(subparsers, parent_parser):
     )
     metrics_show_parser.add_argument(
         "--json",
+        "--show-json",
         action="store_true",
         default=False,
         help="Show output in JSON format.",
     )
     metrics_show_parser.add_argument(
         "--md",
+        "--show-md",
         action="store_true",
         default=False,
         dest="markdown",
@@ -200,14 +186,10 @@ def add_parser(subparsers, parent_parser):
         formatter_class=argparse.RawDescriptionHelpFormatter,
     )
     metrics_diff_parser.add_argument(
-        "a_rev",
-        nargs="?",
-        help="Old Git commit to compare (defaults to HEAD)",
-        default="HEAD",
+        "a_rev", nargs="?", help="Old Git commit to compare (defaults to HEAD)"
     )
     metrics_diff_parser.add_argument(
         "b_rev",
-        default="workspace",
         nargs="?",
         help="New Git commit to compare (defaults to the current workspace)",
     )
@@ -241,12 +223,14 @@ def add_parser(subparsers, parent_parser):
     )
     metrics_diff_parser.add_argument(
         "--json",
+        "--show-json",
         action="store_true",
         default=False,
         help="Show output in JSON format.",
     )
     metrics_diff_parser.add_argument(
         "--md",
+        "--show-md",
         action="store_true",
         default=False,
         dest="markdown",

dvc/commands/move.py

@@ -30,7 +30,6 @@ def add_parser(subparsers, parent_parser):
 
     move_parser = subparsers.add_parser(
         "move",
-        aliases=["mv"],
         parents=[parent_parser],
         description=append_doc_link(MOVE_DESCRIPTION, "move"),
         help=MOVE_HELP,

dvc/commands/params.py

@@ -4,6 +4,7 @@ import logging
 from dvc.cli import completion
 from dvc.cli.command import CmdBase
 from dvc.cli.utils import append_doc_link, fix_subparsers
+from dvc.exceptions import DvcException
 from dvc.ui import ui
 
 logger = logging.getLogger(__name__)
@@ -13,27 +14,17 @@ class CmdParamsDiff(CmdBase):
     UNINITIALIZED = True
 
     def run(self):
-        import os
-        from os.path import relpath
-
-        diff_result = self.repo.params.diff(
-            a_rev=self.args.a_rev,
-            b_rev=self.args.b_rev,
-            targets=self.args.targets,
-            all=self.args.all,
-            deps_only=self.args.deps,
-        )
-
-        errored = [rev for rev, err in diff_result.get("errors", {}).items() if err]
-        if errored:
-            ui.error_write(
-                "DVC failed to load some metrics for following revisions:"
-                f" '{', '.join(errored)}'."
+        try:
+            diff = self.repo.params.diff(
+                a_rev=self.args.a_rev,
+                b_rev=self.args.b_rev,
+                targets=self.args.targets,
+                all=self.args.all,
+                deps=self.args.deps,
             )
-
-        start = relpath(os.getcwd(), self.repo.root_dir)
-        diff = diff_result.get("diff", {})
-        diff = {relpath(path, start): result for path, result in diff.items()}
+        except DvcException:
+            logger.exception("failed to show params diff")
+            return 1
 
         if self.args.json:
             ui.write_json(diff)
@@ -83,14 +74,10 @@ def add_parser(subparsers, parent_parser):
         formatter_class=argparse.RawDescriptionHelpFormatter,
     )
     params_diff_parser.add_argument(
-        "a_rev",
-        nargs="?",
-        default="HEAD",
-        help="Old Git commit to compare (defaults to HEAD)",
+        "a_rev", nargs="?", help="Old Git commit to compare (defaults to HEAD)"
     )
     params_diff_parser.add_argument(
         "b_rev",
-        default="workspace",
         nargs="?",
         help="New Git commit to compare (defaults to the current workspace)",
     )
@@ -118,12 +105,14 @@ def add_parser(subparsers, parent_parser):
     )
     params_diff_parser.add_argument(
         "--json",
+        "--show-json",
         action="store_true",
         default=False,
         help="Show output in JSON format.",
     )
     params_diff_parser.add_argument(
         "--md",
+        "--show-md",
         action="store_true",
         default=False,
         dest="markdown",

dvc/commands/plots.py

@@ -430,6 +430,7 @@ def _add_ui_arguments(parser):
     )
     parser.add_argument(
         "--json",
+        "--show-json",
         action="store_true",
         default=False,
         help=argparse.SUPPRESS,

dvc/commands/remote.py

@@ -30,8 +30,8 @@ class CmdRemoteAdd(CmdRemote):
         with self.config.edit(self.args.level) as conf:
             if self.args.name in conf["remote"] and not self.args.force:
                 raise ConfigError(
-                    f"remote '{self.args.name}' already exists. Use `-f|--force` to "
-                    "overwrite it."
+                    "remote '{}' already exists. Use `-f|--force` to "
+                    "overwrite it.".format(self.args.name)
                 )
 
             conf["remote"][self.args.name] = {"url": self.args.url}
@@ -127,7 +127,9 @@ class CmdRemoteRename(CmdRemote):
         all_config = self.config.load_config_to_level(None)
         if self.args.new in all_config.get("remote", {}):
             raise ConfigError(
-                f"Rename failed. Remote name {self.args.new!r} already exists."
+                "Rename failed. Remote name '{}' already exists.".format(
+                    {self.args.new}
+                )
             )
 
         with self.config.edit(self.args.level) as conf:

dvc/commands/remove.py

@@ -26,7 +26,6 @@ def add_parser(subparsers, parent_parser):
     )
     remove_parser = subparsers.add_parser(
         "remove",
-        aliases=["rm"],
         parents=[parent_parser],
         description=append_doc_link(REMOVE_HELP, "remove"),
         help=REMOVE_HELP,

dvc/commands/repro.py

@@ -16,6 +16,12 @@ class CmdRepro(CmdBase):
         else:
             ui.write("Use `dvc push` to send your updates to remote storage.")
 
+        if self.args.metrics:
+            from dvc.compare import show_metrics
+
+            metrics = self.repo.metrics.show()
+            show_metrics(metrics)
+
         return 0
 
     @property
@@ -33,7 +39,6 @@ class CmdRepro(CmdBase):
             "force_downstream": self.args.force_downstream,
             "pull": self.args.pull,
             "allow_missing": self.args.allow_missing,
-            "on_error": self.args.on_error,
         }
 
     @property
@@ -100,6 +105,13 @@ and then the stage name name.
         default=False,
         help="Reproduce all stages in the specified directory.",
     )
+    repro_parser.add_argument(
+        "-m",
+        "--metrics",
+        action="store_true",
+        default=False,
+        help="Show metrics after reproduction.",
+    )
     repro_parser.add_argument(
         "--downstream",
         action="store_true",
@@ -138,26 +150,6 @@ and then the stage name name.
             "Only print the commands that would be executed without actually executing."
         ),
     )
-    repro_parser.add_argument(
-        "-k",
-        "--keep-going",
-        action="store_const",
-        default="fail",
-        const="keep-going",
-        dest="on_error",
-        help=(
-            "Continue executing, skipping stages having dependencies "
-            "on the failed stages"
-        ),
-    )
-    repro_parser.add_argument(
-        "--ignore-errors",
-        action="store_const",
-        default="fail",
-        const="ignore",
-        dest="on_error",
-        help="Ignore errors from stages.",
-    )
 
 
 def add_parser(subparsers, parent_parser):

dvc/commands/run.py

@@ -0,0 +1,96 @@
+import argparse
+import logging
+
+from dvc.cli.command import CmdBase
+from dvc.cli.utils import append_doc_link
+from dvc.commands.stage import parse_cmd
+from dvc.exceptions import DvcException
+
+logger = logging.getLogger(__name__)
+
+
+class CmdRun(CmdBase):
+    def run(self):
+        if not any(
+            [
+                self.args.deps,
+                self.args.outs,
+                self.args.outs_no_cache,
+                self.args.metrics,
+                self.args.metrics_no_cache,
+                self.args.plots,
+                self.args.plots_no_cache,
+                self.args.outs_persist,
+                self.args.outs_persist_no_cache,
+                self.args.checkpoints,
+                self.args.params,
+                self.args.command,
+            ]
+        ):  # pragma: no cover
+            logger.error(
+                "too few arguments. Specify at least one: `-d`, `-o`, `-O`, "
+                "`-m`, `-M`, `-p`, `--plots`, `--plots-no-cache`, "
+                "`--outs-persist`, `--outs-persist-no-cache`, `command`."
+            )
+            return 1
+
+        kwargs = vars(self.args)
+        kwargs.update(
+            {
+                "cmd": parse_cmd(self.args.command),
+                "fname": kwargs.pop("file"),
+                "no_exec": self.args.no_exec or bool(self.args.checkpoints),
+                "run_cache": not kwargs.pop("no_run_cache"),
+            }
+        )
+        try:
+            self.repo.run(**kwargs)
+        except DvcException:
+            logger.exception("")
+            return 1
+
+        return 0
+
+
+def add_parser(subparsers, parent_parser):
+    from dvc.commands.stage import _add_common_args
+
+    RUN_HELP = "Generate a dvc.yaml file from a command and execute the command."
+    run_parser = subparsers.add_parser(
+        "run",
+        parents=[parent_parser],
+        description=append_doc_link(RUN_HELP, "run"),
+        help=RUN_HELP,
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+    )
+    run_parser.add_argument("-n", "--name", help="Stage name.")
+    run_parser.add_argument("--file", metavar="<filename>", help=argparse.SUPPRESS)
+    run_parser.add_argument(
+        "--single-stage",
+        action="store_true",
+        default=False,
+        help=argparse.SUPPRESS,
+    )
+    _add_common_args(run_parser)
+    run_parser.add_argument(
+        "--no-exec",
+        action="store_true",
+        default=False,
+        help="Only create dvc.yaml without actually running it.",
+    )
+    run_parser.add_argument(
+        "--no-commit",
+        action="store_true",
+        default=False,
+        help="Don't put files/directories into cache.",
+    )
+    run_parser.add_argument(
+        "--no-run-cache",
+        action="store_true",
+        default=False,
+        help=(
+            "Execute the command even if this stage has already been run "
+            "with the same command/dependencies/outputs/etc before."
+        ),
+    )
+    run_parser.set_defaults(func=CmdRun)

dvc/commands/stage.py

@@ -195,6 +195,23 @@ def _add_common_args(parser):
         help="Declare output file or directory (do not put into DVC cache).",
         metavar="<filename>",
     ).complete = completion.FILE
+    parser.add_argument(
+        "-c",
+        "--checkpoints",
+        action="append",
+        default=[],
+        help=(
+            "Declare checkpoint output file or directory for 'dvc exp run'. "
+            "Not compatible with 'dvc repro'."
+        ),
+        metavar="<filename>",
+    ).complete = completion.FILE
+    parser.add_argument(
+        "--external",
+        action="store_true",
+        default=False,
+        help="Allow outputs that are outside of the DVC repository.",
+    )
     parser.add_argument(
         "--outs-persist",
         action="append",

dvc/compare.py

@@ -22,6 +22,7 @@ from typing import (
 from funcy import reraise
 
 if TYPE_CHECKING:
+    from dvc.types import StrPath
     from dvc.ui.table import CellT
 
 
@@ -57,7 +58,7 @@ class TabularData(MutableSequence[Sequence["CellT"]]):
         return self._columns[name]
 
     def items(self) -> ItemsView[str, Column]:
-        projection = {k: self.column(k) for k in self.keys()}
+        projection = {k: self.column(k) for k in self.keys()}  # noqa: SIM118
         return projection.items()
 
     def keys(self) -> List[str]:
@@ -160,6 +161,24 @@ class TabularData(MutableSequence[Sequence["CellT"]]):
             writer.writerow(row)
         return buff.getvalue()
 
+    def to_parallel_coordinates(
+        self, output_path: "StrPath", color_by: Optional[str] = None
+    ) -> "StrPath":
+        from dvc_render.html import render_html
+        from dvc_render.plotly import ParallelCoordinatesRenderer
+
+        render_html(
+            renderers=[
+                ParallelCoordinatesRenderer(
+                    self.as_dict(),
+                    color_by=color_by,
+                    fill_value=self._fill_value,
+                )
+            ],
+            output_file=output_path,
+        )
+        return output_path
+
     def add_column(self, name: str) -> None:
         self._columns[name] = Column([self._fill_value] * len(self))
         self._keys.append(name)
@@ -171,7 +190,8 @@ class TabularData(MutableSequence[Sequence["CellT"]]):
                 self.add_column(key)
 
         row: List["CellT"] = [
-            with_value(d.get(key), self._fill_value) for key in self.keys()
+            with_value(d.get(key), self._fill_value)
+            for key in self.keys()  # noqa: SIM118
         ]
         self.append(row)
 
@@ -226,7 +246,7 @@ class TabularData(MutableSequence[Sequence["CellT"]]):
             to_drop -= match_line
 
         if axis == "rows":
-            for name in self.keys():
+            for name in self.keys():  # noqa: SIM118
                 self._columns[name] = Column(
                     [x for n, x in enumerate(self._columns[name]) if n not in to_drop]
                 )
@@ -274,7 +294,7 @@ class TabularData(MutableSequence[Sequence["CellT"]]):
                 else:
                     unique_rows.append(tuple_row)
 
-            for name in self.keys():
+            for name in self.keys():  # noqa: SIM118
                 self._columns[name] = Column(
                     [
                         x

dvc/config.py

@@ -90,30 +90,20 @@ class Config(dict):
     def __init__(
         self,
         dvc_dir: Optional["StrPath"] = None,
-        local_dvc_dir: Optional["StrPath"] = None,
         validate: bool = True,
         fs: Optional["FileSystem"] = None,
         config: Optional["DictStrAny"] = None,
-        remote: Optional[str] = None,
-        remote_config: Optional["DictStrAny"] = None,
     ):  # pylint: disable=super-init-not-called
         from dvc.fs import LocalFileSystem
 
-        dvc_dir = os.fspath(dvc_dir) if dvc_dir else None
         self.dvc_dir = dvc_dir
         self.wfs = LocalFileSystem()
         self.fs = fs or self.wfs
 
         if dvc_dir:
-            self.dvc_dir = self.fs.path.abspath(dvc_dir)
+            self.dvc_dir = self.fs.path.abspath(self.fs.path.realpath(dvc_dir))
 
-        self.local_dvc_dir = local_dvc_dir
-        if not fs and not local_dvc_dir:
-            self.local_dvc_dir = dvc_dir
-
-        self.load(
-            validate=validate, config=config, remote=remote, remote_config=remote_config
-        )
+        self.load(validate=validate, config=config)
 
     @classmethod
     def from_cwd(cls, fs: Optional["FileSystem"] = None, **kwargs):
@@ -146,9 +136,7 @@ class Config(dict):
 
         if self.dvc_dir is not None:
             files["repo"] = self.fs.path.join(self.dvc_dir, self.CONFIG)
-
-        if self.local_dvc_dir is not None:
-            files["local"] = self.wfs.path.join(self.local_dvc_dir, self.CONFIG_LOCAL)
+            files["local"] = self.fs.path.join(self.dvc_dir, self.CONFIG_LOCAL)
 
         return files
 
@@ -166,16 +154,7 @@ class Config(dict):
         with open(config_file, "w+", encoding="utf-8"):
             return Config(dvc_dir)
 
-    def merge(self, config):
-        merge(self, config)
-
-    def load(
-        self,
-        validate: bool = True,
-        config: Optional["DictStrAny"] = None,
-        remote: Optional[str] = None,
-        remote_config: Optional["DictStrAny"] = None,
-    ):
+    def load(self, validate: bool = True, config: Optional["DictStrAny"] = None):
         """Loads config from all the config files.
 
         Raises:
@@ -190,17 +169,6 @@ class Config(dict):
             conf = self.validate(conf)
 
         self.clear()
-
-        if remote:
-            conf["core"]["remote"] = remote
-
-        if remote_config:
-            remote = remote or conf["core"].get("remote")
-            if not remote:
-                raise ValueError("Missing remote name")
-
-            merge(conf, {"remote": {remote: remote_config}})
-
         self.update(conf)
 
     def _get_fs(self, level):
@@ -208,32 +176,23 @@ class Config(dict):
         # the repo.
         return self.fs if level == "repo" else self.wfs
 
-    @staticmethod
-    def load_file(path, fs=None) -> dict:
+    def _load_config(self, level):
         from configobj import ConfigObj, ConfigObjError
 
-        from dvc.fs import localfs
-
-        fs = fs or localfs
-
-        with fs.open(path) as fobj:
-            try:
-                conf_obj = ConfigObj(fobj)
-            except UnicodeDecodeError as exc:
-                raise ConfigError(str(exc)) from exc
-            except ConfigObjError as exc:
-                raise ConfigError(str(exc)) from exc
-
-        return _parse_named(_lower_keys(conf_obj.dict()))
-
-    def _load_config(self, level):
         filename = self.files[level]
         fs = self._get_fs(level)
 
-        try:
-            return self.load_file(filename, fs=fs)
-        except FileNotFoundError:
-            return {}
+        if fs.exists(filename):
+            with fs.open(filename) as fobj:
+                try:
+                    conf_obj = ConfigObj(fobj)
+                except UnicodeDecodeError as exc:
+                    raise ConfigError(str(exc)) from exc
+                except ConfigObjError as exc:
+                    raise ConfigError(str(exc)) from exc
+        else:
+            conf_obj = ConfigObj()
+        return _parse_named(_lower_keys(conf_obj.dict()))
 
     def _save_config(self, level, conf_dict):
         from configobj import ConfigObj
@@ -261,30 +220,21 @@ class Config(dict):
         return conf
 
     @staticmethod
-    def _resolve(conf_dir, path):
-        from .config_schema import ExpPath, RelPath
+    def _load_paths(conf, filename):
+        abs_conf_dir = os.path.abspath(os.path.dirname(filename))
 
-        if re.match(r"\w+://", path):
-            return path
+        def resolve(path):
+            from .config_schema import RelPath
 
-        if os.path.isabs(path):
-            return path
+            if os.path.isabs(path) or re.match(r"\w+://", path):
+                return path
 
-        # on windows convert slashes to backslashes
-        # to have path compatible with abs_conf_dir
-        if os.path.sep == "\\" and "/" in path:
-            path = path.replace("/", "\\")
+            # on windows convert slashes to backslashes
+            # to have path compatible with abs_conf_dir
+            if os.path.sep == "\\" and "/" in path:
+                path = path.replace("/", "\\")
 
-        expanded = os.path.expanduser(path)
-        if os.path.isabs(expanded):
-            return ExpPath(expanded, path)
-
-        return RelPath(os.path.abspath(os.path.join(conf_dir, path)))
-
-    @classmethod
-    def _load_paths(cls, conf, filename):
-        conf_dir = os.path.abspath(os.path.dirname(filename))
-        resolve = partial(cls._resolve, conf_dir)
+            return RelPath(os.path.join(abs_conf_dir, path))
 
         return Config._map_dirs(conf, resolve)
 
@@ -293,17 +243,11 @@ class Config(dict):
         from dvc.fs import localfs
         from dvc.utils import relpath
 
-        from .config_schema import ExpPath, RelPath
+        from .config_schema import RelPath
 
         if re.match(r"\w+://", path):
             return path
 
-        if isinstance(path, ExpPath):
-            return path.def_path
-
-        if os.path.expanduser(path) != path:
-            return localfs.path.as_posix(path)
-
         if isinstance(path, RelPath) or not os.path.isabs(path):
             path = relpath(path, conf_dir)
             return localfs.path.as_posix(path)

dvc/config_schema.py

@@ -8,7 +8,6 @@ from voluptuous import (
     All,
     Any,
     Coerce,
-    Exclusive,
     Invalid,
     Lower,
     Optional,
@@ -75,19 +74,8 @@ def ByUrl(mapping):  # noqa: N802
     return validate
 
 
-class ExpPath(str):
-    __slots__ = ("def_path",)
-
-    def_path: str
-
-    def __new__(cls, string, def_path):
-        ret = super().__new__(cls, string)
-        ret.def_path = def_path
-        return ret
-
-
 class RelPath(str):
-    __slots__ = ()
+    pass
 
 
 class FeatureSchema(Schema):
@@ -166,13 +154,13 @@ SCHEMA = {
         "machine": Lower,
     },
     "cache": {
-        "local": str,  # obsoleted
-        "s3": str,  # obsoleted
-        "gs": str,  # obsoleted
-        "hdfs": str,  # obsoleted
-        "webhdfs": str,  # obsoleted
-        "ssh": str,  # obsoleted
-        "azure": str,  # obsoleted
+        "local": str,
+        "s3": str,
+        "gs": str,
+        "hdfs": str,
+        "webhdfs": str,
+        "ssh": str,
+        "azure": str,
         # This is for default local cache
         "dir": str,
         **LOCAL_COMMON,
@@ -336,8 +324,7 @@ SCHEMA = {
     },
     "hydra": {
         Optional("enabled", default=False): Bool,
-        Exclusive("config_dir", "config_source"): str,
-        Exclusive("config_module", "config_source"): str,
+        "config_dir": str,
         "config_name": str,
     },
     "studio": {

dvc/daemon.py

@@ -3,6 +3,7 @@
 import inspect
 import logging
 import os
+import platform
 import sys
 from subprocess import Popen  # nosec B404
 from typing import List
@@ -27,9 +28,7 @@ def _popen(cmd, **kwargs) -> Popen:
             os.path.abspath(os.path.dirname(__file__)), "__main__.py"
         )
         prefix += [main_entrypoint]
-    return Popen(
-        prefix + cmd, close_fds=True, shell=False, **kwargs  # nosec B603  # noqa: S603
-    )
+    return Popen(prefix + cmd, close_fds=True, shell=False, **kwargs)  # nosec B603
 
 
 def _spawn_windows(cmd, env):
@@ -92,8 +91,13 @@ def _spawn_posix(cmd, env):
     sys.stderr.close()
     os.closerange(0, 3)
 
-    os.environ.update(env)
-    main(cmd)
+    if platform.system() == "Darwin":
+        # workaround for MacOS bug
+        # https://github.com/iterative/dvc/issues/4294
+        _popen(cmd, env=env).communicate()
+    else:
+        os.environ.update(env)
+        main(cmd)
 
     os._exit(0)  # pylint: disable=protected-access
 

dvc/dagascii.py

@@ -209,30 +209,6 @@ def draw(vertices, edges):
     Args:
         vertices (list): list of graph vertices.
         edges (list): list of graph edges.
-
-    Returns:
-        str: ASCII representation
-
-    Example:
-        >>> from dvc.dagascii import draw
-        >>> vertices = [1, 2, 3, 4]
-        >>> edges = [(1, 2), (2, 3), (2, 4), (1, 4)]
-        >>> print(draw(vertices, edges))
-        +---+     +---+
-        | 3 |     | 4 |
-        +---+    *+---+
-          *    **   *
-          *  **     *
-          * *       *
-        +---+       *
-        | 2 |      *
-        +---+     *
-             *    *
-              *  *
-               **
-             +---+
-             | 1 |
-             +---+
     """
     # pylint: disable=too-many-locals
     # NOTE: coordinates might me negative, so we need to shift

dvc/data_cloud.py

@@ -1,19 +1,18 @@
 """Manages dvc remotes that user can use with push/pull/status commands."""
 
 import logging
-from typing import TYPE_CHECKING, Iterable, Optional, Set, Tuple
+from typing import TYPE_CHECKING, Iterable, Optional
 
 from dvc.config import NoRemoteError, RemoteConfigError
-from dvc.fs.callbacks import Callback
 from dvc.utils.objects import cached_property
 from dvc_data.hashfile.db import get_index
-from dvc_data.hashfile.transfer import TransferResult
 
 if TYPE_CHECKING:
     from dvc.fs import FileSystem
     from dvc_data.hashfile.db import HashFileDB
     from dvc_data.hashfile.hash_info import HashInfo
     from dvc_data.hashfile.status import CompareStatusResult
+    from dvc_data.hashfile.transfer import TransferResult
 
 logger = logging.getLogger(__name__)
 
@@ -30,40 +29,13 @@ class Remote:
 
     @cached_property
     def odb(self) -> "HashFileDB":
-        from dvc.cachemgr import CacheManager
         from dvc_data.hashfile.db import get_odb
-        from dvc_data.hashfile.hash import DEFAULT_ALGORITHM
 
         path = self.path
         if self.worktree:
-            path = self.fs.path.join(
-                path, ".dvc", CacheManager.FILES_DIR, DEFAULT_ALGORITHM
-            )
-        else:
-            path = self.fs.path.join(path, CacheManager.FILES_DIR, DEFAULT_ALGORITHM)
-        return get_odb(self.fs, path, hash_name=DEFAULT_ALGORITHM, **self.config)
+            path = self.fs.path.join(path, ".dvc", "cache")
 
-    @cached_property
-    def legacy_odb(self) -> "HashFileDB":
-        from dvc_data.hashfile.db import get_odb
-
-        path = self.path
-        return get_odb(self.fs, path, hash_name="md5-dos2unix", **self.config)
-
-
-def _split_legacy_hash_infos(
-    hash_infos: Iterable["HashInfo"],
-) -> Tuple[Set["HashInfo"], Set["HashInfo"]]:
-    from dvc.cachemgr import LEGACY_HASH_NAMES
-
-    legacy = set()
-    default = set()
-    for hi in hash_infos:
-        if hi.name in LEGACY_HASH_NAMES:
-            legacy.add(hi)
-        else:
-            default.add(hi)
-    return legacy, default
+        return get_odb(self.fs, path, hash_name="md5", **self.config)
 
 
 class DataCloud:
@@ -91,7 +63,7 @@ class DataCloud:
         if name:
             from dvc.fs import get_cloud_fs
 
-            cls, config, fs_path = get_cloud_fs(self.repo.config, name=name)
+            cls, config, fs_path = get_cloud_fs(self.repo, name=name)
 
             if config.get("worktree"):
                 version_aware = config.get("version_aware")
@@ -129,17 +101,12 @@ class DataCloud:
         self,
         name: Optional[str] = None,
         command: str = "<command>",
-        hash_name: str = "md5",
     ) -> "HashFileDB":
-        from dvc.cachemgr import LEGACY_HASH_NAMES
-
         remote = self.get_remote(name=name, command=command)
         if remote.fs.version_aware or remote.worktree:
-            raise RemoteConfigError(
+            raise NoRemoteError(
                 f"'{command}' is unsupported for cloud versioned remotes"
             )
-        if hash_name in LEGACY_HASH_NAMES:
-            return remote.legacy_odb
         return remote.odb
 
     def _log_missing(self, status: "CompareStatusResult"):
@@ -183,47 +150,16 @@ class DataCloud:
                 By default remote from core.remote config option is used.
             odb: optional ODB to push to. Overrides remote.
         """
-        if odb is not None:
-            return self._push(objs, jobs=jobs, odb=odb)
-        legacy_objs, default_objs = _split_legacy_hash_infos(objs)
-        result = TransferResult(set(), set())
-        if legacy_objs:
-            odb = self.get_remote_odb(remote, "push", hash_name="md5-dos2unix")
-            t, f = self._push(legacy_objs, jobs=jobs, odb=odb)
-            result.transferred.update(t)
-            result.failed.update(f)
-        if default_objs:
-            odb = self.get_remote_odb(remote, "push")
-            t, f = self._push(default_objs, jobs=jobs, odb=odb)
-            result.transferred.update(t)
-            result.failed.update(f)
-        return result
-
-    def _push(
-        self,
-        objs: Iterable["HashInfo"],
-        *,
-        jobs: Optional[int] = None,
-        odb: "HashFileDB",
-    ) -> "TransferResult":
-        if odb.hash_name == "md5-dos2unix":
-            cache = self.repo.cache.legacy
-        else:
-            cache = self.repo.cache.local
-        with Callback.as_tqdm_callback(
-            desc=f"Pushing to {odb.fs.unstrip_protocol(odb.path)}",
-            unit="file",
-        ) as cb:
-            return self.transfer(
-                cache,
-                odb,
-                objs,
-                jobs=jobs,
-                dest_index=get_index(odb),
-                cache_odb=cache,
-                validate_status=self._log_missing,
-                callback=cb,
-            )
+        odb = odb or self.get_remote_odb(remote, "push")
+        return self.transfer(
+            self.repo.cache.local,
+            odb,
+            objs,
+            jobs=jobs,
+            dest_index=get_index(odb),
+            cache_odb=self.repo.cache.local,
+            validate_status=self._log_missing,
+        )
 
     def pull(
         self,
@@ -241,49 +177,17 @@ class DataCloud:
                 By default remote from core.remote config option is used.
             odb: optional ODB to pull from. Overrides remote.
         """
-        if odb is not None:
-            return self._pull(objs, jobs=jobs, odb=odb)
-        legacy_objs, default_objs = _split_legacy_hash_infos(objs)
-        result = TransferResult(set(), set())
-        if legacy_objs:
-            odb = self.get_remote_odb(remote, "pull", hash_name="md5-dos2unix")
-            assert odb.hash_name == "md5-dos2unix"
-            t, f = self._pull(legacy_objs, jobs=jobs, odb=odb)
-            result.transferred.update(t)
-            result.failed.update(f)
-        if default_objs:
-            odb = self.get_remote_odb(remote, "pull")
-            t, f = self._pull(default_objs, jobs=jobs, odb=odb)
-            result.transferred.update(t)
-            result.failed.update(f)
-        return result
-
-    def _pull(
-        self,
-        objs: Iterable["HashInfo"],
-        *,
-        jobs: Optional[int] = None,
-        odb: "HashFileDB",
-    ) -> "TransferResult":
-        if odb.hash_name == "md5-dos2unix":
-            cache = self.repo.cache.legacy
-        else:
-            cache = self.repo.cache.local
-        with Callback.as_tqdm_callback(
-            desc=f"Fetching from {odb.fs.unstrip_protocol(odb.path)}",
-            unit="file",
-        ) as cb:
-            return self.transfer(
-                odb,
-                cache,
-                objs,
-                jobs=jobs,
-                src_index=get_index(odb),
-                cache_odb=cache,
-                verify=odb.verify,
-                validate_status=self._log_missing,
-                callback=cb,
-            )
+        odb = odb or self.get_remote_odb(remote, "pull")
+        return self.transfer(
+            odb,
+            self.repo.cache.local,
+            objs,
+            jobs=jobs,
+            src_index=get_index(odb),
+            cache_odb=self.repo.cache.local,
+            verify=odb.verify,
+            validate_status=self._log_missing,
+        )
 
     def status(
         self,
@@ -302,49 +206,17 @@ class DataCloud:
                 is used.
             odb: optional ODB to check status from. Overrides remote.
         """
-        from dvc_data.hashfile.status import CompareStatusResult
-
-        if odb is not None:
-            return self._status(objs, jobs=jobs, odb=odb)
-        result = CompareStatusResult(set(), set(), set(), set())
-        legacy_objs, default_objs = _split_legacy_hash_infos(objs)
-        if legacy_objs:
-            odb = self.get_remote_odb(remote, "status", hash_name="md5-dos2unix")
-            assert odb.hash_name == "md5-dos2unix"
-            o, m, n, d = self._status(legacy_objs, jobs=jobs, odb=odb)
-            result.ok.update(o)
-            result.missing.update(m)
-            result.new.update(n)
-            result.deleted.update(d)
-        if default_objs:
-            odb = self.get_remote_odb(remote, "status")
-            o, m, n, d = self._status(default_objs, jobs=jobs, odb=odb)
-            result.ok.update(o)
-            result.missing.update(m)
-            result.new.update(n)
-            result.deleted.update(d)
-        return result
-
-    def _status(
-        self,
-        objs: Iterable["HashInfo"],
-        *,
-        jobs: Optional[int] = None,
-        odb: "HashFileDB",
-    ):
         from dvc_data.hashfile.status import compare_status
 
-        if odb.hash_name == "md5-dos2unix":
-            cache = self.repo.cache.legacy
-        else:
-            cache = self.repo.cache.local
+        if not odb:
+            odb = self.get_remote_odb(remote, "status")
         return compare_status(
-            cache,
+            self.repo.cache.local,
             odb,
             objs,
             jobs=jobs,
             dest_index=get_index(odb),
-            cache_odb=cache,
+            cache_odb=self.repo.cache.local,
         )
 
     def get_url_for(self, remote, checksum):

dvc/dependency/__init__.py

@@ -1,5 +1,5 @@
 from collections import defaultdict
-from typing import Any, Dict, List, Mapping, Set
+from typing import Any, Mapping, Set
 
 from dvc.output import ARTIFACT_SCHEMA, DIR_FILES_SCHEMA, Output
 
@@ -14,8 +14,8 @@ from .repo import RepoDependency
 SCHEMA: Mapping[str, Any] = {
     **ARTIFACT_SCHEMA,
     **RepoDependency.REPO_SCHEMA,
+    **ParamsDependency.PARAM_SCHEMA,
     Output.PARAM_FILES: [DIR_FILES_SCHEMA],
-    Output.PARAM_FS_CONFIG: dict,
 }
 
 
@@ -36,11 +36,7 @@ def loadd_from(stage, d_list):
     for d in d_list:
         p = d.pop(Output.PARAM_PATH, None)
         files = d.pop(Output.PARAM_FILES, None)
-        hash_name = d.pop(Output.PARAM_HASH, None)
-        fs_config = d.pop(Output.PARAM_FS_CONFIG, None)
-        ret.append(
-            _get(stage, p, d, files=files, hash_name=hash_name, fs_config=fs_config)
-        )
+        ret.append(_get(stage, p, d, files=files))
     return ret
 
 
@@ -58,7 +54,7 @@ def loads_from(stage, s_list, erepo=None, fs_config=None):
     ]
 
 
-def _merge_params(s_list) -> Dict[str, List[str]]:
+def _merge_params(s_list):
     d = defaultdict(list)
     default_file = ParamsDependency.DEFAULT_PARAMS_FILE
 

dvc/dependency/base.py

@@ -44,10 +44,13 @@ class Dependency(Output):
         if self.fs.version_aware:
             self.fs_path = self.fs.path.version_path(self.fs_path, rev)
             self.meta = self.get_meta()
+            self.def_path = self.fs.path.version_path(
+                self.def_path, self.meta.version_id
+            )
             self.fs_path = self.fs.path.version_path(self.fs_path, self.meta.version_id)
 
     def download(self, to, jobs=None):
-        fs_download(self.fs, self.fs_path, to.fs_path, jobs=jobs)
+        fs_download(self.fs, self.fs_path, to, jobs=jobs)
 
     def save(self):
         super().save()

dvc/dependency/param.py

@@ -2,9 +2,10 @@ import logging
 import os
 import typing
 from collections import defaultdict
-from typing import TYPE_CHECKING, Any, Dict, List, Optional
+from typing import Dict
 
 import dpath
+from voluptuous import Any
 
 from dvc.exceptions import DvcException
 from dvc.utils.serialize import ParseError, load_path
@@ -12,9 +13,6 @@ from dvc_data.hashfile.hash_info import HashInfo
 
 from .base import Dependency
 
-if TYPE_CHECKING:
-    from dvc.fs import FileSystem
-
 logger = logging.getLogger(__name__)
 
 
@@ -34,39 +32,9 @@ class BadParamFileError(DvcException):
     pass
 
 
-def read_param_file(
-    fs: "FileSystem",
-    path: str,
-    key_paths: Optional[List[str]] = None,
-    flatten: bool = False,
-    **load_kwargs,
-) -> Any:
-    config = load_path(path, fs, **load_kwargs)
-    if not key_paths:
-        return config
-
-    ret = {}
-    if flatten:
-        for key_path in key_paths:
-            try:
-                ret[key_path] = dpath.get(config, key_path, separator=".")
-            except KeyError:
-                continue
-        return ret
-
-    from dpath import merge
-
-    for key_path in key_paths:
-        merge(
-            ret,
-            dpath.search(config, key_path, separator="."),
-            separator=".",
-        )
-    return ret
-
-
 class ParamsDependency(Dependency):
     PARAM_PARAMS = "params"
+    PARAM_SCHEMA = {PARAM_PARAMS: Any(dict, list, None)}
     DEFAULT_PARAMS_FILE = "params.yaml"
 
     def __init__(self, stage, path, params=None, repo=None):
@@ -80,7 +48,6 @@ class ParamsDependency(Dependency):
         repo = repo or stage.repo
         path = path or os.path.join(repo.root_dir, self.DEFAULT_PARAMS_FILE)
         super().__init__(stage, path, repo=repo)
-        self.hash_name = self.PARAM_PARAMS
         self.hash_info = hash_info
 
     def dumpd(self, **kwargs):
@@ -109,19 +76,31 @@ class ParamsDependency(Dependency):
         self, flatten: bool = True, **kwargs: typing.Any
     ) -> Dict[str, typing.Any]:
         try:
-            self.validate_filepath()
+            config = self.read_file()
         except MissingParamsFile:
-            return {}
+            config = {}
 
-        try:
-            return read_param_file(
-                self.repo.fs,
-                self.fs_path,
-                list(self.params) if self.params else None,
-                flatten=flatten,
+        if not self.params:
+            return config
+
+        ret = {}
+        if flatten:
+            for param in self.params:
+                try:
+                    ret[param] = dpath.get(config, param, separator=".")
+                except KeyError:
+                    continue
+            return ret
+
+        from dpath import merge
+
+        for param in self.params:
+            merge(
+                ret,
+                dpath.search(config, param, separator="."),
+                separator=".",
             )
-        except ParseError as exc:
-            raise BadParamFileError(f"Unable to read parameters from '{self}'") from exc
+        return ret
 
     def workspace_status(self):
         if not self.exists:
@@ -171,6 +150,13 @@ class ParamsDependency(Dependency):
                 f"'{self}' is a directory, expected a parameters file"
             )
 
+    def read_file(self):
+        self.validate_filepath()
+        try:
+            return load_path(self.fs_path, self.repo.fs)
+        except ParseError as exc:
+            raise BadParamFileError(f"Unable to read parameters from '{self}'") from exc
+
     def get_hash(self):
         info = self.read_params()
 

dvc/dependency/repo.py

@@ -1,7 +1,6 @@
-from copy import deepcopy
 from typing import TYPE_CHECKING, Dict, Optional, Union
 
-from voluptuous import Any, Required
+from voluptuous import Required
 
 from dvc.utils import as_posix
 
@@ -17,20 +16,16 @@ class RepoDependency(Dependency):
     PARAM_URL = "url"
     PARAM_REV = "rev"
     PARAM_REV_LOCK = "rev_lock"
-    PARAM_CONFIG = "config"
-    PARAM_REMOTE = "remote"
 
     REPO_SCHEMA = {
         PARAM_REPO: {
             Required(PARAM_URL): str,
             PARAM_REV: str,
             PARAM_REV_LOCK: str,
-            PARAM_CONFIG: Any(str, dict),
-            PARAM_REMOTE: Any(str, dict),
         }
     }
 
-    def __init__(self, def_repo: Dict[str, Any], stage: "Stage", *args, **kwargs):
+    def __init__(self, def_repo: Dict[str, str], stage: "Stage", *args, **kwargs):
         self.def_repo = def_repo
         super().__init__(stage, *args, **kwargs)
 
@@ -65,28 +60,7 @@ class RepoDependency(Dependency):
             self.def_repo[self.PARAM_REV_LOCK] = rev
 
     def dumpd(self, **kwargs) -> Dict[str, Union[str, Dict[str, str]]]:
-        repo = {self.PARAM_URL: self.def_repo[self.PARAM_URL]}
-
-        rev = self.def_repo.get(self.PARAM_REV)
-        if rev:
-            repo[self.PARAM_REV] = self.def_repo[self.PARAM_REV]
-
-        rev_lock = self.def_repo.get(self.PARAM_REV_LOCK)
-        if rev_lock:
-            repo[self.PARAM_REV_LOCK] = rev_lock
-
-        config = self.def_repo.get(self.PARAM_CONFIG)
-        if config:
-            repo[self.PARAM_CONFIG] = config
-
-        remote = self.def_repo.get(self.PARAM_REMOTE)
-        if remote:
-            repo[self.PARAM_REMOTE] = remote
-
-        return {
-            self.PARAM_PATH: self.def_path,
-            self.PARAM_REPO: repo,
-        }
+        return {self.PARAM_PATH: self.def_path, self.PARAM_REPO: self.def_repo}
 
     def update(self, rev: Optional[str] = None):
         if rev:
@@ -103,33 +77,16 @@ class RepoDependency(Dependency):
     def _make_fs(
         self, rev: Optional[str] = None, locked: bool = True
     ) -> "DVCFileSystem":
-        from dvc.config import Config
         from dvc.fs import DVCFileSystem
 
-        rem = self.def_repo.get("remote")
-        if isinstance(rem, dict):
-            remote = None
-            remote_config = rem
-        else:
-            remote = rem
-            remote_config = None
-
-        conf = self.def_repo.get("config", {})
-        if isinstance(conf, dict):
-            config = deepcopy(conf)
-        else:
-            config = Config.load_file(conf)
-
-        config["cache"] = self.repo.config["cache"]
-        config["cache"]["dir"] = self.repo.cache.local_cache_dir
+        config = {"cache": self.repo.config["cache"]}
+        config["cache"]["dir"] = self.repo.cache.local.path
 
         return DVCFileSystem(
             url=self.def_repo[self.PARAM_URL],
             rev=rev or self._get_rev(locked=locked),
             subrepos=True,
             config=config,
-            remote=remote,
-            remote_config=remote_config,
         )
 
     def _get_rev(self, locked: bool = True):

dvc/dvcfile.py

@@ -14,6 +14,7 @@ from typing import (
 )
 
 from dvc.exceptions import DvcException
+from dvc.parsing.versions import LOCKFILE_VERSION, SCHEMA_KWD
 from dvc.stage import serialize
 from dvc.stage.exceptions import (
     StageFileBadNameError,
@@ -35,6 +36,7 @@ if TYPE_CHECKING:
 logger = logging.getLogger(__name__)
 _T = TypeVar("_T")
 
+DVC_FILE = "Dvcfile"
 DVC_FILE_SUFFIX = ".dvc"
 PROJECT_FILE = "dvc.yaml"
 LOCK_FILE = "dvc.lock"
@@ -54,7 +56,10 @@ class ParametrizedDumpError(DvcException):
 
 
 def is_valid_filename(path):
-    return path.endswith(DVC_FILE_SUFFIX) or os.path.basename(path) == PROJECT_FILE
+    return path.endswith(DVC_FILE_SUFFIX) or os.path.basename(path) in [
+        DVC_FILE,
+        PROJECT_FILE,
+    ]
 
 
 def is_dvc_file(path):
@@ -97,7 +102,9 @@ class FileMixin:
         self.verify = verify
 
     def __repr__(self):
-        return f"{self.__class__.__name__}: {relpath(self.path, self.repo.root_dir)}"
+        return "{}: {}".format(
+            self.__class__.__name__, relpath(self.path, self.repo.root_dir)
+        )
 
     def __hash__(self):
         return hash(self.path)
@@ -351,8 +358,36 @@ class ProjectFile(FileMixin):
         raise NotImplementedError
 
 
+def get_lockfile_schema(d):
+    from dvc.schema import COMPILED_LOCKFILE_V1_SCHEMA, COMPILED_LOCKFILE_V2_SCHEMA
+
+    schema = {
+        LOCKFILE_VERSION.V1: COMPILED_LOCKFILE_V1_SCHEMA,
+        LOCKFILE_VERSION.V2: COMPILED_LOCKFILE_V2_SCHEMA,
+    }
+
+    version = LOCKFILE_VERSION.from_dict(d)
+    return schema[version]
+
+
+def migrate_lock_v1_to_v2(d, version_info):
+    stages = dict(d)
+
+    for key in stages:
+        d.pop(key)
+
+    # forcing order, meta should always be at the top
+    d.update(version_info)
+    d["stages"] = stages
+
+
+def lockfile_schema(data: _T) -> _T:
+    schema = get_lockfile_schema(data)
+    return schema(data)
+
+
 class Lockfile(FileMixin):
-    from dvc.schema import COMPILED_LOCKFILE_SCHEMA as SCHEMA
+    SCHEMA = staticmethod(lockfile_schema)  # type: ignore[assignment]
 
     def _verify_filename(self):
         pass  # lockfile path is hardcoded, so no need to verify here
@@ -366,12 +401,21 @@ class Lockfile(FileMixin):
             self._check_gitignored()
             return {}, ""
 
+    @property
+    def latest_version_info(self):
+        version = LOCKFILE_VERSION.V2.value  # pylint:disable=no-member
+        return {SCHEMA_KWD: version}
+
     def dump(self, stage, **kwargs):
         stage_data = serialize.to_lockfile(stage, **kwargs)
 
         with modify_yaml(self.path, fs=self.repo.fs) as data:
-            if not data:
-                data.update({"schema": "2.0"})
+            version = LOCKFILE_VERSION.from_dict(data)
+            if version == LOCKFILE_VERSION.V1:
+                logger.info("Migrating lock file '%s' from v1 to v2", self.relpath)
+                migrate_lock_v1_to_v2(data, self.latest_version_info)
+            elif not data:
+                data.update(self.latest_version_info)
                 # order is important, meta should always be at the top
                 logger.info("Generating lock file '%s'", self.relpath)
 
@@ -392,7 +436,8 @@ class Lockfile(FileMixin):
             return
 
         d, _ = self._load_yaml(round_trip=True)
-        data = d.get("stages", {})
+        version = LOCKFILE_VERSION.from_dict(d)
+        data = d if version == LOCKFILE_VERSION.V1 else d.get("stages", {})
         if stage.name not in data:
             return
 

dvc/env.py

@@ -1,3 +1,5 @@
+DVCLIVE_RESUME = "DVCLIVE_RESUME"
+DVC_CHECKPOINT = "DVC_CHECKPOINT"
 DVC_DAEMON = "DVC_DAEMON"
 DVC_EXP_AUTO_PUSH = "DVC_EXP_AUTO_PUSH"
 DVC_EXP_BASELINE_REV = "DVC_EXP_BASELINE_REV"

dvc/exceptions.py

@@ -1,12 +1,9 @@
 """Exceptions raised by the dvc."""
 import errno
-from typing import TYPE_CHECKING, Dict, List, Optional, Set
+from typing import Dict, List
 
 from dvc.utils import format_link
 
-if TYPE_CHECKING:
-    from dvc.stage import Stage
-
 
 class DvcException(Exception):
     """Base class for all dvc exceptions."""
@@ -20,10 +17,6 @@ class DvcException(Exception):
 class InvalidArgumentError(ValueError, DvcException):
     """Thrown if arguments are invalid."""
 
-    def __init__(self, msg, *args):
-        self.msg = msg
-        super().__init__(msg, *args)
-
 
 class OutputDuplicationError(DvcException):
     """Thrown if a file/directory is specified as an output in more than one
@@ -34,25 +27,24 @@ class OutputDuplicationError(DvcException):
         stages (list): list of paths to stages.
     """
 
-    def __init__(self, output: str, stages: Set["Stage"]):
+    def __init__(self, output, stages):
         from funcy import first
 
         assert isinstance(output, str)
         assert all(hasattr(stage, "relpath") for stage in stages)
+        msg = ""
+        stage_names = [s.addressing for s in stages]
+        stages_str = " ".join(stage_names)
         if len(stages) == 1:
-            stage = first(stages)
-            msg = (
-                f"output '{output}' is already specified in {stage}."
-                f"\nUse `dvc remove {stage.addressing}` to stop tracking the "
-                "overlapping output."
-            )
+            stage_name = first(stages)
+            msg = f"output '{output}' is already specified in {stage_name}."
         else:
-            stage_names = "\n".join(["\t- " + s.addressing for s in stages])
-            msg = (
-                f"output '{output}' is specified in:\n{stage_names}"
-                "\nUse `dvc remove` with any of the above targets to stop tracking the "
-                "overlapping output."
+            msg = "output '{}' is already specified in stages:\n{}".format(
+                output, "\n".join(f"\t- {s}" for s in stage_names)
             )
+        msg += (
+            f"\nUse `dvc remove {stages_str}` to stop tracking the overlapping output."
+        )
         super().__init__(msg)
         self.stages = stages
         self.output = output
@@ -71,14 +63,12 @@ class OutputNotFoundError(DvcException):
         self.output = output
         self.repo = repo
         super().__init__(
-            f"Unable to find DVC file with output {relpath(self.output)!r}"
+            "Unable to find DVC file with output '{path}'".format(
+                path=relpath(self.output)
+            )
         )
 
 
-class StageNotFoundError(DvcException):
-    pass
-
-
 class StagePathAsOutputError(DvcException):
     """Thrown if directory that stage is going to be saved in is specified as
     an output of another stage.
@@ -90,7 +80,11 @@ class StagePathAsOutputError(DvcException):
 
     def __init__(self, stage, output):
         assert isinstance(output, str)
-        super().__init__(f"{stage} is within an output {output!r} of another stage")
+        super().__init__(
+            "{stage} is within an output '{output}' of another stage".format(
+                stage=stage, output=output
+            )
+        )
 
 
 class CircularDependencyError(DvcException):
@@ -162,7 +156,9 @@ class CyclicGraphError(DvcException):
 class ConfirmRemoveError(DvcException):
     def __init__(self, path):
         super().__init__(
-            f"unable to remove {path!r} without a confirmation. Use `-f` to force."
+            "unable to remove '{}' without a confirmation. Use `-f` to force.".format(
+                path
+            )
         )
 
 
@@ -171,7 +167,9 @@ class InitError(DvcException):
 
 
 class ReproductionError(DvcException):
-    pass
+    def __init__(self, name):
+        self.name = name
+        super().__init__(f"failed to reproduce '{name}'")
 
 
 class BadMetricError(DvcException):
@@ -184,6 +182,11 @@ class BadMetricError(DvcException):
         )
 
 
+class RecursiveAddingWhileUsingFilename(DvcException):
+    def __init__(self):
+        super().__init__("cannot use `fname` with multiple targets or `-R|--recursive`")
+
+
 class OverlappingOutputPathsError(DvcException):
     def __init__(self, parent, overlapping_out, message):
         self.parent = parent
@@ -200,7 +203,7 @@ class ETagMismatchError(DvcException):
     def __init__(self, etag, cached_etag):
         super().__init__(
             "ETag mismatch detected when copying file to cache! "
-            f"(expected: '{etag}', actual: '{cached_etag}')"
+            "(expected: '{}', actual: '{}')".format(etag, cached_etag)
         )
 
 
@@ -301,7 +304,22 @@ class URLMissingError(DvcException):
         super().__init__(f"The path '{url}' does not exist")
 
 
-class IsADirectoryError(DvcException):  # noqa: A001,pylint:disable=redefined-builtin
+class RemoteCacheRequiredError(DvcException):
+    def __init__(self, scheme, fs_path):
+        super().__init__(
+            (
+                "Current operation was unsuccessful because '{}' requires "
+                "existing cache on '{}' remote. See {} for information on how "
+                "to set up remote cache."
+            ).format(
+                fs_path,
+                scheme,
+                format_link("https://man.dvc.org/config#cache"),
+            )
+        )
+
+
+class IsADirectoryError(DvcException):  # noqa,pylint:disable=redefined-builtin
     """Raised when a file operation is requested on a directory."""
 
 
@@ -336,24 +354,3 @@ class CacheLinkError(DvcException):
 class PrettyDvcException(DvcException):
     def __pretty_exc__(self, **kwargs):
         """Print prettier exception message."""
-
-
-class ArtifactNotFoundError(DvcException):
-    """Thrown if an artifact is not found in the DVC repo.
-
-    Args:
-        name (str): artifact name.
-    """
-
-    def __init__(
-        self,
-        name: str,
-        version: Optional[str] = None,
-        stage: Optional[str] = None,
-    ):
-        self.name = name
-        self.version = version
-        self.stage = stage
-
-        desc = f" @ {stage or version}" if (stage or version) else ""
-        super().__init__(f"Unable to find artifact '{name}{desc}'")

dvc/fs/__init__.py

@@ -1,4 +1,3 @@
-from typing import Optional
 from urllib.parse import urlparse
 
 from dvc_http import HTTPFileSystem, HTTPSFileSystem  # noqa: F401
@@ -19,7 +18,7 @@ from dvc_objects.fs import (  # noqa: F401
     system,
     utils,
 )
-from dvc_objects.fs.base import AnyFSPath, FileSystem  # noqa: F401, TCH001
+from dvc_objects.fs.base import AnyFSPath, FileSystem  # noqa: F401
 from dvc_objects.fs.errors import (  # noqa: F401
     AuthError,
     ConfigError,
@@ -49,50 +48,19 @@ known_implementations.update(
 # pylint: enable=unused-import
 
 
-def download(
-    fs: "FileSystem", fs_path: str, to: str, jobs: Optional[int] = None
-) -> int:
+def download(fs, fs_path, to, jobs=None):
     with Callback.as_tqdm_callback(
         desc=f"Downloading {fs.path.name(fs_path)}",
         unit="files",
     ) as cb:
-        # NOTE: We use dvc-objects generic.copy over fs.get since it makes file
-        # download atomic and avoids fsspec glob/regex path expansion.
-        if fs.isdir(fs_path):
-            from_infos = [
-                path
-                for path in fs.find(fs_path)
-                if not path.endswith(fs.path.flavour.sep)
-            ]
-            if not from_infos:
-                localfs.makedirs(to, exist_ok=True)
-                return 0
-            to_infos = [
-                localfs.path.join(to, *fs.path.relparts(info, fs_path))
-                for info in from_infos
-            ]
-        else:
-            from_infos = [fs_path]
-            to_infos = [to]
-
-        cb.set_size(len(from_infos))
-        jobs = jobs or fs.jobs
-        generic.copy(
-            fs,
-            from_infos,
-            localfs,
-            to_infos,
-            callback=cb,
-            batch_size=jobs,
-        )
-        return len(to_infos)
+        fs.get(fs_path, to.fs_path, batch_size=jobs, callback=cb)
 
 
-def parse_external_url(url, fs_config=None, config=None):
-    remote_config = dict(fs_config) if fs_config else {}
+def parse_external_url(url, config=None):
+    remote_config = dict(config) if config else {}
     remote_config["url"] = url
-    fs_cls, resolved_fs_config, fs_path = get_cloud_fs(config, **remote_config)
-    fs = fs_cls(**resolved_fs_config)
+    fs_cls, fs_config, fs_path = get_cloud_fs(None, **remote_config)
+    fs = fs_cls(**fs_config)
     return fs, fs_path
 
 
@@ -137,14 +105,18 @@ def _resolve_remote_refs(config, remote_conf):
         return remote_conf
 
     base = get_fs_config(config, name=parsed.netloc)
-    cls, _, _ = get_cloud_fs(config, **base)
+    cls, _, _ = _get_cloud_fs(config, **base)
     relpath = parsed.path.lstrip("/").replace("/", cls.sep)
     url = cls.sep.join((base["url"], relpath))
     return {**base, **remote_conf, "url": url}
 
 
-def get_cloud_fs(repo_config, **kwargs):
-    repo_config = repo_config or {}
+def get_cloud_fs(repo, **kwargs):
+    repo_config = repo.config if repo else {}
+    return _get_cloud_fs(repo_config, **kwargs)
+
+
+def _get_cloud_fs(repo_config, **kwargs):
     core_config = repo_config.get("core", {})
 
     remote_conf = get_fs_config(repo_config, **kwargs)

dvc/fs/callbacks.py

@@ -2,9 +2,12 @@
 from contextlib import ExitStack
 from typing import TYPE_CHECKING, Any, BinaryIO, Dict, Optional, Union
 
-from dvc.progress import Tqdm
 from dvc.utils.objects import cached_property
-from dvc_objects.fs.callbacks import DEFAULT_CALLBACK, Callback  # noqa: F401
+from dvc_objects.fs.callbacks import (  # noqa: F401
+    DEFAULT_CALLBACK,
+    Callback,
+    TqdmCallback,
+)
 
 if TYPE_CHECKING:
     from rich.progress import TaskID
@@ -12,59 +15,6 @@ if TYPE_CHECKING:
     from dvc.ui._rich_progress import RichTransferProgress
 
 
-# NOTE: this is very similar to dvc-objects.fs.callbacks.TqdmCallback,
-# but it works with our own Tqdm instance.
-class TqdmCallback(Callback):
-    def __init__(
-        self,
-        size: Optional[int] = None,
-        value: int = 0,
-        progress_bar: Optional["Tqdm"] = None,
-        **tqdm_kwargs,
-    ):
-        tqdm_kwargs["total"] = size or -1
-        self._tqdm_kwargs = tqdm_kwargs
-        self._progress_bar = progress_bar
-        self._stack = ExitStack()
-        super().__init__(size=size, value=value)
-
-    @cached_property
-    def progress_bar(self):
-        progress_bar = (
-            self._progress_bar
-            if self._progress_bar is not None
-            else Tqdm(**self._tqdm_kwargs)
-        )
-        return self._stack.enter_context(progress_bar)
-
-    def __enter__(self):
-        return self
-
-    def close(self):
-        self._stack.close()
-
-    def set_size(self, size):
-        # Tqdm tries to be smart when to refresh,
-        # so we try to force it to re-render.
-        super().set_size(size)
-        self.progress_bar.refresh()
-
-    def call(self, hook_name=None, **kwargs):  # noqa: ARG002
-        self.progress_bar.update_to(self.value, total=self.size)
-
-    def branch(
-        self,
-        path_1: "Union[str, BinaryIO]",
-        path_2: str,
-        kwargs: Dict[str, Any],
-        child: Optional[Callback] = None,
-    ):
-        child = child or TqdmCallback(
-            bytes=True, desc=path_1 if isinstance(path_1, str) else path_2
-        )
-        return super().branch(path_1, path_2, kwargs, child=child)
-
-
 class RichCallback(Callback):
     def __init__(
         self,

dvc/fs/dvc.py

@@ -5,7 +5,7 @@ import ntpath
 import os
 import posixpath
 import threading
-from contextlib import ExitStack, suppress
+from contextlib import suppress
 from typing import TYPE_CHECKING, Any, Callable, Dict, Optional, Tuple, Type, Union
 
 from fsspec.spec import AbstractFileSystem
@@ -18,7 +18,7 @@ from .data import DataFileSystem
 
 if TYPE_CHECKING:
     from dvc.repo import Repo
-    from dvc.types import DictStrAny, StrPath
+    from dvc.types import StrPath
 
 logger = logging.getLogger(__name__)
 
@@ -38,24 +38,17 @@ def _is_dvc_file(fname):
     return is_valid_filename(fname) or fname == DvcIgnore.DVCIGNORE_FILE
 
 
-def _merge_info(repo, key, fs_info, dvc_info):
+def _merge_info(repo, fs_info, dvc_info):
     from . import utils
 
     ret = {"repo": repo}
 
     if dvc_info:
-        dvc_info["isout"] = any(
-            (len(out_key) <= len(key) and key[: len(out_key)] == out_key)
-            for out_key in repo.index.data_keys["repo"]
-        )
-        dvc_info["isdvc"] = dvc_info["isout"]
         ret["dvc_info"] = dvc_info
         ret["type"] = dvc_info["type"]
         ret["size"] = dvc_info["size"]
         if not fs_info and "md5" in dvc_info:
             ret["md5"] = dvc_info["md5"]
-        if not fs_info and "md5-dos2unix" in dvc_info:
-            ret["md5-dos2unix"] = dvc_info["md5-dos2unix"]
 
     if fs_info:
         ret["type"] = fs_info["type"]
@@ -76,22 +69,14 @@ class _DVCFileSystem(AbstractFileSystem):  # pylint:disable=abstract-method
     cachable = False
     root_marker = "/"
 
-    def __init__(  # noqa: PLR0913
+    def __init__(
         self,
         url: Optional[str] = None,
         rev: Optional[str] = None,
         repo: Optional["Repo"] = None,
         subrepos: bool = False,
         repo_factory: Optional[RepoFactory] = None,
-        fo: Optional[str] = None,
-        # pylint:disable-next=unused-argument
-        target_options: Optional[Dict[str, Any]] = None,  # noqa: ARG002
-        # pylint:disable-next=unused-argument
-        target_protocol: Optional[str] = None,  # noqa: ARG002
-        config: Optional["DictStrAny"] = None,
-        remote: Optional[str] = None,
-        remote_config: Optional["DictStrAny"] = None,
-        **kwargs,
+        **repo_kwargs: Any,
     ) -> None:
         """DVC + git-tracked files fs.
 
@@ -111,9 +96,6 @@ class _DVCFileSystem(AbstractFileSystem):  # pylint:disable=abstract-method
                 By default, it ignores subrepos.
             repo_factory (callable): A function to initialize subrepo with.
                 The default is `Repo`.
-            config (dict): Repo config to be passed into `repo_factory`.
-            remote (str): Remote name to be passed into `repo_factory`.
-            remote_config(dict): Remote config to be passed into `repo_factory`.
 
         Examples:
             - Opening a filesystem from repo in current working directory
@@ -134,21 +116,11 @@ class _DVCFileSystem(AbstractFileSystem):  # pylint:disable=abstract-method
         from pygtrie import Trie
 
         super().__init__()
-        self._repo_stack = ExitStack()
         if repo is None:
-            url = url if url is not None else fo
-            repo = self._make_repo(
-                url=url,
-                rev=rev,
-                subrepos=subrepos,
-                config=config,
-                remote=remote,
-                remote_config=remote_config,
-            )
+            repo = self._make_repo(url=url, rev=rev, subrepos=subrepos, **repo_kwargs)
             assert repo is not None
             # pylint: disable=protected-access
             repo_factory = repo._fs_conf["repo_factory"]
-            self._repo_stack.enter_context(repo)
 
         if not repo_factory:
             from dvc.repo import Repo
@@ -158,7 +130,7 @@ class _DVCFileSystem(AbstractFileSystem):  # pylint:disable=abstract-method
             self.repo_factory = repo_factory
 
         def _getcwd():
-            relparts: Tuple[str, ...] = ()
+            relparts = ()
             assert repo is not None
             if repo.fs.path.isin(repo.fs.path.getcwd(), repo.root_dir):
                 relparts = repo.fs.path.relparts(repo.fs.path.getcwd(), repo.root_dir)
@@ -181,26 +153,13 @@ class _DVCFileSystem(AbstractFileSystem):  # pylint:disable=abstract-method
         if hasattr(repo, "dvc_dir"):
             self._datafss[key] = DataFileSystem(index=repo.index.data["repo"])
 
-    @functools.cached_property
-    def fsid(self) -> str:
-        from fsspec.utils import tokenize
-
-        from dvc.scm import NoSCM
-
-        return "dvcfs_" + tokenize(
-            self.repo.url or self.repo.root_dir,
-            self.repo.get_rev() if not isinstance(self.repo.scm, NoSCM) else None,
-        )
-
     def _get_key(self, path: "StrPath") -> Key:
-        path = os.fspath(path)
         parts = self.repo.fs.path.relparts(path, self.repo.root_dir)
         if parts == (os.curdir,):
             return ()
         return parts
 
     def _get_key_from_relative(self, path) -> Key:
-        path = self._strip_protocol(path)
         parts = self.path.relparts(path, self.root_marker)
         if parts and parts[0] == os.curdir:
             return parts[1:]
@@ -250,7 +209,6 @@ class _DVCFileSystem(AbstractFileSystem):  # pylint:disable=abstract-method
                     scm=self.repo.scm,
                     repo_factory=self.repo_factory,
                 )
-                self._repo_stack.enter_context(repo)
                 self._datafss[key] = DataFileSystem(index=repo.index.data["repo"])
             self._subrepos_trie[key] = repo
 
@@ -293,19 +251,22 @@ class _DVCFileSystem(AbstractFileSystem):  # pylint:disable=abstract-method
         try:
             return self.repo.fs.open(fs_path, mode=mode)
         except FileNotFoundError:
-            _, dvc_fs, subkey = self._get_subrepo_info(key)
+            repo, dvc_fs, subkey = self._get_subrepo_info(key)
             if not dvc_fs:
                 raise
 
         dvc_path = _get_dvc_path(dvc_fs, subkey)
-        return dvc_fs.open(dvc_path, mode=mode, cache=kwargs.get("cache", False))
+        kw = {}
+        if kwargs.get("cache_remote_stream", False):
+            kw["cache_odb"] = repo.cache.local
+        return dvc_fs.open(dvc_path, mode=mode, **kw)
 
     def isdvc(self, path, **kwargs) -> bool:
         """Is this entry dvc-tracked?"""
-        try:
-            return self.info(path).get("dvc_info", {}).get("isout", False)
-        except FileNotFoundError:
-            return False
+        key = self._get_key_from_relative(path)
+        _, dvc_fs, subkey = self._get_subrepo_info(key)
+        dvc_path = _get_dvc_path(dvc_fs, subkey)
+        return dvc_fs is not None and dvc_fs.isdvc(dvc_path, **kwargs)
 
     def ls(  # pylint: disable=arguments-differ # noqa: C901
         self, path, detail=True, dvc_only=False, **kwargs
@@ -317,7 +278,7 @@ class _DVCFileSystem(AbstractFileSystem):  # pylint:disable=abstract-method
         dvc_infos = {}
         if dvc_fs:
             dvc_path = _get_dvc_path(dvc_fs, subkey)
-            with suppress(FileNotFoundError, NotADirectoryError):
+            with suppress(FileNotFoundError):
                 for info in dvc_fs.ls(dvc_path, detail=True):
                     dvc_infos[dvc_fs.path.name(info["name"])] = info
             dvc_exists = bool(dvc_infos) or dvc_fs.exists(dvc_path)
@@ -353,9 +314,7 @@ class _DVCFileSystem(AbstractFileSystem):  # pylint:disable=abstract-method
                 continue
 
             entry_path = self.path.join(path, name)
-            info = _merge_info(
-                repo, (*subkey, name), fs_infos.get(name), dvc_infos.get(name)
-            )
+            info = _merge_info(repo, fs_infos.get(name), dvc_infos.get(name))
             info["name"] = entry_path
             infos.append(info)
             paths.append(entry_path)
@@ -381,7 +340,7 @@ class _DVCFileSystem(AbstractFileSystem):  # pylint:disable=abstract-method
                 dvc_info = dvc_fs.fs.index.info(subkey)
                 dvc_path = _get_dvc_path(dvc_fs, subkey)
                 dvc_info["name"] = dvc_path
-            except KeyError:
+            except FileNotFoundError:
                 pass
 
         fs_info = None
@@ -411,7 +370,7 @@ class _DVCFileSystem(AbstractFileSystem):  # pylint:disable=abstract-method
         if not dvc_info and not fs_info:
             raise FileNotFoundError
 
-        info = _merge_info(repo, subkey, fs_info, dvc_info)
+        info = _merge_info(repo, fs_info, dvc_info)
         info["name"] = path
         return info
 
@@ -428,9 +387,6 @@ class _DVCFileSystem(AbstractFileSystem):  # pylint:disable=abstract-method
         dvc_path = _get_dvc_path(dvc_fs, subkey)
         return dvc_fs.get_file(dvc_path, lpath, **kwargs)
 
-    def close(self):
-        self._repo_stack.close()
-
 
 class DVCFileSystem(FileSystem):
     protocol = "local"
@@ -441,13 +397,9 @@ class DVCFileSystem(FileSystem):
 
     @functools.cached_property
     # pylint: disable-next=invalid-overridden-method
-    def fs(self) -> "_DVCFileSystem":
+    def fs(self) -> "DVCFileSystem":
         return _DVCFileSystem(**self.fs_args)
 
-    @property
-    def fsid(self) -> str:
-        return self.fs.fsid
-
     def isdvc(self, path, **kwargs) -> bool:
         return self.fs.isdvc(path, **kwargs)
 
@@ -468,7 +420,3 @@ class DVCFileSystem(FileSystem):
             path = os.path.relpath(path, self.repo.root_dir)
 
         return as_posix(path)
-
-    def close(self):
-        if "fs" in self.__dict__:
-            self.fs.close()

dvc/ignore.py

@@ -148,9 +148,7 @@ class DvcIgnorePatterns(DvcIgnore):
         return bool(self.pattern_list)
 
 
-CheckIgnoreResult = namedtuple(  # noqa: PYI024
-    "CheckIgnoreResult", ["file", "match", "patterns"]
-)
+CheckIgnoreResult = namedtuple("CheckIgnoreResult", ["file", "match", "patterns"])
 
 
 def _no_match(path):

dvc/info.py

@@ -6,12 +6,13 @@ import platform
 
 import psutil
 
-from dvc import PKG, __version__
+from dvc import __version__
 from dvc.exceptions import NotDvcRepoError
 from dvc.fs import Schemes, generic, get_fs_cls, get_fs_config, registry
 from dvc.repo import Repo
 from dvc.scm import SCMError
 from dvc.utils import error_link
+from dvc.utils.pkg import PKG
 
 SUBPROJECTS = (
     "dvc_data",
@@ -67,7 +68,7 @@ def _get_caches(cache):
     caches = (
         cache_type
         for cache_type, cache_instance in cache.by_scheme()
-        if cache_instance and cache_type not in ("repo", "legacy")
+        if cache_instance and cache_type != "repo"
     )
 
     # Caches will be always non-empty including the local cache

dvc/logger.py

@@ -56,7 +56,7 @@ def add_logging_level(level_name, level_num, method_name=None):
 
 class LoggingException(Exception):
     def __init__(self, record):
-        msg = f"failed to log {record!s}"
+        msg = f"failed to log {str(record)}"
         super().__init__(msg)
 
 
@@ -160,7 +160,7 @@ class LoggerHandler(logging.StreamHandler):
             self.flush()
         except (BrokenPipeError, RecursionError):
             raise
-        except Exception:  # noqa: BLE001, pylint: disable=broad-except
+        except Exception:  # noqa, pylint: disable=broad-except
             self.handleError(record)
 
 

dvc/machine/__init__.py

@@ -0,0 +1,227 @@
+import logging
+import os
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    Dict,
+    Iterable,
+    Iterator,
+    Mapping,
+    Optional,
+    Tuple,
+    Type,
+)
+
+from dvc.exceptions import DvcException
+
+if TYPE_CHECKING:
+    from dvc.repo import Repo
+    from dvc.types import StrPath
+
+    from .backend.base import BaseMachineBackend
+
+    BackendCls = Type[BaseMachineBackend]
+
+logger = logging.getLogger(__name__)
+
+
+RESERVED_NAMES = {"local", "localhost"}
+
+DEFAULT_STARTUP_SCRIPT = """#!/bin/bash
+sudo apt-get update
+sudo apt-get install --yes python3 python3-pip
+python3 -m pip install --upgrade pip
+
+pushd /etc/apt/sources.list.d
+sudo wget https://dvc.org/deb/dvc.list
+sudo apt-get update
+sudo apt-get install --yes dvc
+popd
+
+sudo echo "OK" > /var/log/dvc-machine-init.log
+"""
+
+
+def validate_name(name: str):
+    from dvc.exceptions import InvalidArgumentError
+
+    name = name.lower()
+    if name in RESERVED_NAMES:
+        raise InvalidArgumentError(
+            f"Machine name '{name}' is reserved for internal DVC use."
+        )
+
+
+class MachineBackends(Mapping):
+    try:
+        from .backend.terraform import TerraformBackend
+    except ImportError:
+        TerraformBackend = None  # type: ignore[assignment, misc]
+
+    DEFAULT: Dict[str, Optional["BackendCls"]] = {
+        "terraform": TerraformBackend,
+    }
+
+    def __getitem__(self, key: str) -> "BaseMachineBackend":
+        """Lazily initialize backends and cache it afterwards"""
+        initialized = self.initialized.get(key)
+        if not initialized:
+            backend = self.backends[key]
+            initialized = backend(os.path.join(self.tmp_dir, key), **self.kwargs)
+            self.initialized[key] = initialized
+        return initialized
+
+    def __init__(
+        self,
+        selected: Optional[Iterable[str]],
+        tmp_dir: "StrPath",
+        **kwargs,
+    ) -> None:
+        selected = selected or list(self.DEFAULT)
+        self.backends: Dict[str, "BackendCls"] = {}
+        for key in selected:
+            cls = self.DEFAULT.get(key)
+            if cls is None:
+                raise DvcException(
+                    f"'dvc machine' backend '{key}' is missing required "
+                    "dependencies. Install them with:\n"
+                    f"\tpip install dvc[{key}]"
+                )
+            self.backends[key] = cls
+
+        self.initialized: Dict[str, "BaseMachineBackend"] = {}
+
+        self.tmp_dir = tmp_dir
+        self.kwargs = kwargs
+
+    def __iter__(self):
+        return iter(self.backends)
+
+    def __len__(self) -> int:
+        return len(self.backends)
+
+    def close_initialized(self) -> None:
+        for backend in self.initialized.values():
+            backend.close()
+
+
+class MachineManager:
+    """Class that manages dvc cloud machines.
+
+    Args:
+        repo (dvc.repo.Repo): repo instance that belongs to the repo that
+            we are working on.
+
+    Raises:
+        config.ConfigError: thrown when config has invalid format.
+    """
+
+    CLOUD_BACKENDS = {
+        "aws": "terraform",
+        "azure": "terraform",
+    }
+
+    def __init__(
+        self, repo: "Repo", backends: Optional[Iterable[str]] = None, **kwargs
+    ):
+        self.repo = repo
+        assert self.repo.tmp_dir
+        tmp_dir = os.path.join(self.repo.tmp_dir, "machine")
+        self.backends = MachineBackends(backends, tmp_dir=tmp_dir, **kwargs)
+
+    def get_config_and_backend(
+        self,
+        name: Optional[str] = None,
+    ) -> Tuple[dict, "BaseMachineBackend"]:
+        from dvc.config import NoMachineError
+
+        if not name:
+            name = self.repo.config["core"].get("machine")
+
+        if name:
+            config = self._get_config(name=name)
+            backend = self._get_backend(config["cloud"])
+            return config, backend
+
+        if bool(self.repo.config["machine"]):
+            error_msg = (
+                "no machine specified. Setup default machine with\n"
+                "    dvc machine default <name>\n"
+            )
+        else:
+            error_msg = (
+                "no machine specified. Create a default machine with\n"
+                "    dvc machine add -d <name> <cloud>"
+            )
+
+        raise NoMachineError(error_msg)
+
+    def _get_config(self, **kwargs):
+        config = self.repo.config
+        name = kwargs.get("name")
+        if name:
+            try:
+                conf = config["machine"][name.lower()]
+                conf["name"] = name
+            except KeyError:
+                from dvc.config import MachineNotFoundError
+
+                raise MachineNotFoundError(  # noqa: B904
+                    f"machine '{name}' doesn't exist"
+                )
+        else:
+            conf = kwargs
+        return conf
+
+    def _get_backend(self, cloud: str) -> "BaseMachineBackend":
+        from dvc.config import NoMachineError
+
+        try:
+            backend = self.CLOUD_BACKENDS[cloud]
+            return self.backends[backend]
+        except KeyError:
+            raise NoMachineError(  # noqa: B904
+                f"Machine platform '{cloud}' unsupported"
+            )
+
+    def create(self, name: Optional[str]):
+        """Create and start the specified machine instance."""
+        config, backend = self.get_config_and_backend(name)
+        if "startup_script" in config:
+            with open(config["startup_script"], encoding="utf-8") as fobj:
+                startup_script = fobj.read()
+        else:
+            startup_script = DEFAULT_STARTUP_SCRIPT
+        config["startup_script"] = startup_script
+        config.pop("setup_script", None)
+        return backend.create(**config)
+
+    def destroy(self, name: Optional[str]):
+        """Destroy the specified machine instance."""
+        config, backend = self.get_config_and_backend(name)
+        return backend.destroy(**config)
+
+    def get_sshfs(self, name: Optional[str]):
+        config, backend = self.get_config_and_backend(name)
+        return backend.get_sshfs(**config)
+
+    def run_shell(self, name: Optional[str]):
+        config, backend = self.get_config_and_backend(name)
+        return backend.run_shell(**config)
+
+    def status(self, name: str) -> Iterator[Dict[Any, Any]]:
+        config, backend = self.get_config_and_backend(name)
+        return backend.instances(**config)
+
+    def rename(self, name: str, new: str):
+        """move configuration to a new location if the machine is running."""
+        config, backend = self.get_config_and_backend(name)
+        return backend.rename(new=new, **config)
+
+    def get_executor_kwargs(self, name: Optional[str]):
+        config, backend = self.get_config_and_backend(name)
+        return backend.get_executor_kwargs(**config)
+
+    def get_setup_script(self, name: Optional[str]) -> Optional[str]:
+        config, _backend = self.get_config_and_backend(name)
+        return config.get("setup_script")

dvc/machine/backend/base.py

@@ -0,0 +1,50 @@
+from abc import ABC, abstractmethod
+from contextlib import contextmanager
+from typing import TYPE_CHECKING, Iterator, Optional
+
+if TYPE_CHECKING:
+    from dvc_ssh import SSHFileSystem
+
+    from dvc.types import StrPath
+
+
+class BaseMachineBackend(ABC):
+    def __init__(self, tmp_dir: "StrPath", **kwargs):
+        self.tmp_dir = tmp_dir
+
+    @abstractmethod
+    def create(self, name: Optional[str] = None, **config):
+        """Create and start an instance of the specified machine."""
+
+    @abstractmethod
+    def destroy(self, name: Optional[str] = None, **config):
+        """Stop and destroy all instances of the specified machine."""
+
+    @abstractmethod
+    def instances(self, name: Optional[str] = None, **config) -> Iterator[dict]:
+        """Iterate over status of all instances of the specified machine."""
+
+    def close(self):  # noqa: B027
+        pass
+
+    @abstractmethod
+    def run_shell(self, name: Optional[str] = None, **config):
+        """Spawn an interactive SSH shell for the specified machine."""
+
+    @abstractmethod
+    def get_executor_kwargs(self, name: str, **config) -> dict:
+        """Return SSHExecutor kwargs which can be used for DVC
+        experiment/pipeline execution on the specified machine.
+        """
+
+    @abstractmethod
+    @contextmanager
+    def get_sshfs(
+        self, name: Optional[str] = None, **config
+    ) -> Iterator["SSHFileSystem"]:
+        """Return an sshfs instance for the default directory on the
+        specified machine."""
+
+    @abstractmethod
+    def rename(self, name: str, new: str, **config):
+        """Rename a machine instance."""

dvc/machine/backend/terraform.py

@@ -0,0 +1,99 @@
+import os
+from contextlib import contextmanager
+from functools import partial, partialmethod
+from typing import TYPE_CHECKING, Iterator, Optional
+
+from dvc_ssh import DEFAULT_PORT, SSHFileSystem
+
+from dvc.exceptions import DvcException
+
+from .base import BaseMachineBackend
+
+if TYPE_CHECKING:
+    from dvc.types import StrPath
+
+
+@contextmanager
+def _sshfs(resource: dict):
+    from tpi import TerraformProviderIterative
+
+    with TerraformProviderIterative.pemfile(resource) as pem:
+        fs = SSHFileSystem(
+            host=resource["instance_ip"],
+            user="ubuntu",
+            keyfile=pem,
+        )
+        yield fs
+
+
+class TerraformBackend(BaseMachineBackend):
+    def __init__(self, tmp_dir: "StrPath", **kwargs):
+        super().__init__(tmp_dir, **kwargs)
+        os.makedirs(tmp_dir, exist_ok=True)
+
+    @contextmanager
+    def make_tpi(self, name: str):
+        from tpi import TPIError
+        from tpi.terraform import TerraformBackend as TPIBackend
+
+        try:
+            working_dir = os.path.join(self.tmp_dir, name)
+            os.makedirs(working_dir, exist_ok=True)
+            yield TPIBackend(working_dir=working_dir)
+        except TPIError as exc:
+            raise DvcException("TPI operation failed") from exc
+
+    def _tpi_func(self, fname, name: Optional[str] = None, **config):
+        from tpi import TPIError
+
+        assert name
+        with self.make_tpi(name) as tpi:
+            func = getattr(tpi, fname)
+            try:
+                return func(name=name, **config)
+            except TPIError as exc:
+                raise DvcException(f"TPI {fname} failed") from exc
+
+    create = partialmethod(_tpi_func, "create")  # type: ignore[assignment]
+    destroy = partialmethod(_tpi_func, "destroy")  # type: ignore[assignment]
+    instances = partialmethod(_tpi_func, "instances")  # type: ignore[assignment]
+    run_shell = partialmethod(_tpi_func, "run_shell")  # type: ignore[assignment]
+
+    def get_executor_kwargs(self, name: str, **config) -> dict:
+        with self.make_tpi(name) as tpi:
+            resource = tpi.default_resource(name)
+        return {
+            "host": resource["instance_ip"],
+            "port": DEFAULT_PORT,
+            "username": "ubuntu",
+            "fs_factory": partial(_sshfs, dict(resource)),
+        }
+
+    @contextmanager
+    def get_sshfs(  # pylint: disable=unused-argument
+        self, name: Optional[str] = None, **config
+    ) -> Iterator["SSHFileSystem"]:
+        assert name
+        with self.make_tpi(name) as tpi:
+            resource = tpi.default_resource(name)
+        with _sshfs(resource) as fs:
+            yield fs
+
+    def rename(self, name: str, new: str, **config):
+        """rename a dvc machine instance to a new name"""
+        import shutil
+
+        mtype = "iterative_machine"
+
+        new_dir = os.path.join(self.tmp_dir, new)
+        old_dir = os.path.join(self.tmp_dir, name)
+        if os.path.exists(new_dir):
+            raise DvcException(f"rename failed: path {new_dir} already exists")
+
+        if not os.path.exists(old_dir):
+            return
+
+        with self.make_tpi(name) as tpi:
+            tpi.state_mv(f"{mtype}.{name}", f"{mtype}.{new}", **config)
+
+        shutil.move(old_dir, new_dir)

dvc/main.py

@@ -0,0 +1,2 @@
+# TODO: remove in 3.0, kept for backward compatibility
+from .cli import main  # noqa: F401, pylint: disable=unused-import

dvc/output.py

@@ -19,15 +19,14 @@ from dvc.exceptions import (
     ConfirmRemoveError,
     DvcException,
     MergeError,
+    RemoteCacheRequiredError,
 )
-from dvc.utils import format_link
 from dvc.utils.objects import cached_property
 from dvc_data.hashfile import check as ocheck
 from dvc_data.hashfile import load as oload
 from dvc_data.hashfile.build import build
 from dvc_data.hashfile.checkout import checkout
 from dvc_data.hashfile.db import HashFileDB, add_update_tree
-from dvc_data.hashfile.hash import DEFAULT_ALGORITHM
 from dvc_data.hashfile.hash_info import HashInfo
 from dvc_data.hashfile.istextfile import istextfile
 from dvc_data.hashfile.meta import Meta
@@ -44,6 +43,7 @@ from .utils.fs import path_isin
 if TYPE_CHECKING:
     from dvc_data.hashfile.obj import HashFile
     from dvc_data.index import DataIndexKey
+    from dvc_objects.db import ObjectDB
 
     from .ignore import DvcIgnoreFilter
 
@@ -64,7 +64,7 @@ CASE_SENSITIVE_CHECKSUM_SCHEMA = Any(
 
 # NOTE: currently there are only 3 possible checksum names:
 #
-#    1) md5 (LOCAL, SSH) (actually DVC 2.x md5-dos2unix)
+#    1) md5 (LOCAL, SSH);
 #    2) etag (S3, GS, OSS, AZURE, HTTP);
 #    3) checksum (HDFS);
 #
@@ -73,7 +73,7 @@ CASE_SENSITIVE_CHECKSUM_SCHEMA = Any(
 HDFS_PARAM_CHECKSUM = "checksum"
 S3_PARAM_CHECKSUM = "etag"
 CHECKSUMS_SCHEMA = {
-    "md5": CHECKSUM_SCHEMA,  # DVC 2.x md5-dos2unix
+    LocalFileSystem.PARAM_CHECKSUM: CHECKSUM_SCHEMA,
     HDFS_PARAM_CHECKSUM: CHECKSUM_SCHEMA,
     S3_PARAM_CHECKSUM: CASE_SENSITIVE_CHECKSUM_SCHEMA,
 }
@@ -91,12 +91,11 @@ def loadd_from(stage, d_list):
         metric = d.pop(Output.PARAM_METRIC, False)
         plot = d.pop(Output.PARAM_PLOT, False)
         persist = d.pop(Output.PARAM_PERSIST, False)
+        checkpoint = d.pop(Output.PARAM_CHECKPOINT, False)
         remote = d.pop(Output.PARAM_REMOTE, None)
         annot = {field: d.pop(field, None) for field in ANNOTATION_FIELDS}
         files = d.pop(Output.PARAM_FILES, None)
         push = d.pop(Output.PARAM_PUSH, True)
-        hash_name = d.pop(Output.PARAM_HASH, None)
-        fs_config = d.pop(Output.PARAM_FS_CONFIG, None)
         ret.append(
             _get(
                 stage,
@@ -106,12 +105,11 @@ def loadd_from(stage, d_list):
                 metric=metric,
                 plot=plot,
                 persist=persist,
+                checkpoint=checkpoint,
                 remote=remote,
                 **annot,
                 files=files,
                 push=push,
-                hash_name=hash_name,
-                fs_config=fs_config,
             )
         )
     return ret
@@ -124,6 +122,7 @@ def loads_from(
     metric=False,
     plot=False,
     persist=False,
+    checkpoint=False,
     remote=None,
     push=True,
 ):
@@ -136,6 +135,7 @@ def loads_from(
             metric=metric,
             plot=plot,
             persist=persist,
+            checkpoint=checkpoint,
             remote=remote,
             push=push,
         )
@@ -191,6 +191,7 @@ def load_from_pipeline(stage, data, typ="outs"):
             [
                 Output.PARAM_CACHE,
                 Output.PARAM_PERSIST,
+                Output.PARAM_CHECKPOINT,
                 Output.PARAM_REMOTE,
                 Output.PARAM_PUSH,
                 *ANNOTATION_FIELDS,
@@ -231,29 +232,17 @@ def merge_file_meta_from_cloud(entry: Dict) -> Dict:
     return entry
 
 
-def _serialize_tree_obj_to_files(obj: Tree) -> List[Dict[str, Any]]:
+def _serialize_tree_obj_to_files(obj: "Tree") -> List[Dict[str, Any]]:
     key = obj.PARAM_RELPATH
     return sorted(
         (
-            {
-                key: posixpath.sep.join(parts),
-                **_serialize_hi_to_dict(hi),
-                **meta.to_dict(),
-            }
+            {key: posixpath.sep.join(parts), **hi.to_dict(), **meta.to_dict()}
             for parts, meta, hi in obj
         ),
         key=itemgetter(key),
     )
 
 
-def _serialize_hi_to_dict(hash_info: Optional[HashInfo]) -> Dict[str, Any]:
-    if hash_info:
-        if hash_info.name == "md5-dos2unix":
-            return {"md5": hash_info.value}
-        return hash_info.to_dict()
-    return {}
-
-
 class OutputDoesNotExistError(DvcException):
     def __init__(self, path):
         msg = f"output '{path}' does not exist"
@@ -297,6 +286,7 @@ class Output:
 
     PARAM_PATH = "path"
     PARAM_CACHE = "cache"
+    PARAM_CHECKPOINT = "checkpoint"
     PARAM_FILES = "files"
     PARAM_METRIC = "metric"
     PARAM_METRIC_TYPE = "type"
@@ -313,8 +303,15 @@ class Output:
     PARAM_REMOTE = "remote"
     PARAM_PUSH = "push"
     PARAM_CLOUD = "cloud"
-    PARAM_HASH = "hash"
-    PARAM_FS_CONFIG = "fs_config"
+
+    METRIC_SCHEMA = Any(
+        None,
+        bool,
+        {
+            PARAM_METRIC_TYPE: Any(str, None),
+            PARAM_METRIC_XPATH: Any(str, None),
+        },
+    )
 
     DoesNotExistError: Type[DvcException] = OutputDoesNotExistError
     IsNotFileOrDirError: Type[DvcException] = OutputIsNotFileOrDirError
@@ -330,6 +327,7 @@ class Output:
         metric=False,
         plot=False,
         persist=False,
+        checkpoint=False,
         desc=None,
         type=None,  # noqa: A002, pylint: disable=redefined-builtin
         labels=None,
@@ -339,7 +337,6 @@ class Output:
         fs_config=None,
         files: Optional[List[Dict[str, Any]]] = None,
         push: bool = True,
-        hash_name: Optional[str] = DEFAULT_ALGORITHM,
     ):
         self.annot = Annotation(
             desc=desc, type=type, labels=labels or [], meta=meta or {}
@@ -353,15 +350,10 @@ class Output:
         if meta.version_id or files:
             fs_kwargs["version_aware"] = True
 
-        self.def_fs_config = fs_config
         if fs_config is not None:
             fs_kwargs.update(**fs_config)
 
-        fs_cls, fs_config, fs_path = get_cloud_fs(
-            self.repo.config if self.repo else {},
-            url=path,
-            **fs_kwargs,
-        )
+        fs_cls, fs_config, fs_path = get_cloud_fs(self.repo, url=path, **fs_kwargs)
         self.fs = fs_cls(**fs_config)
 
         if (
@@ -402,6 +394,7 @@ class Output:
         self.metric = False if self.IS_DEPENDENCY else metric
         self.plot = False if self.IS_DEPENDENCY else plot
         self.persist = persist
+        self.checkpoint = checkpoint
         self.can_push = push
 
         self.fs_path = self._parse_path(self.fs, fs_path)
@@ -416,29 +409,16 @@ class Output:
             )
             self.meta.version_id = version_id
 
-        self.hash_name, self.hash_info = self._compute_hash_info_from_meta(hash_name)
-        self._compute_meta_hash_info_from_files()
-
-    def _compute_hash_info_from_meta(
-        self, hash_name: Optional[str]
-    ) -> Tuple[str, HashInfo]:
         if self.is_in_repo:
-            if hash_name is None:
-                # Legacy 2.x output, use "md5-dos2unix" but read "md5" from
-                # file meta
-                hash_name = "md5-dos2unix"
-                meta_name = "md5"
-            else:
-                meta_name = hash_name
+            self.hash_name = "md5"
         else:
-            hash_name = meta_name = self.fs.PARAM_CHECKSUM
-        assert hash_name
+            self.hash_name = self.fs.PARAM_CHECKSUM
 
-        hash_info = HashInfo(
-            name=hash_name,
-            value=getattr(self.meta, meta_name, None),
+        self.hash_info = HashInfo(
+            name=self.hash_name,
+            value=getattr(self.meta, self.hash_name, None),
         )
-        return hash_name, hash_info
+        self._compute_meta_hash_info_from_files()
 
     def _compute_meta_hash_info_from_files(self) -> None:
         if self.files:
@@ -454,7 +434,7 @@ class Output:
             self.meta.remote = first(f.get("remote") for f in self.files)
         elif self.meta.nfiles or self.hash_info and self.hash_info.isdir:
             self.meta.isdir = True
-            if not self.hash_info and self.hash_name not in ("md5", "md5-dos2unix"):
+            if not self.hash_info and self.hash_name != "md5":
                 md5 = getattr(self.meta, "md5", None)
                 if md5:
                     self.hash_info = HashInfo("md5", md5)
@@ -478,7 +458,9 @@ class Output:
         return fs.path.abspath(fs.path.normpath(fs_path))
 
     def __repr__(self):
-        return f"{type(self).__name__}: {self.def_path!r}"
+        return "{class_name}: '{def_path}'".format(
+            class_name=type(self).__name__, def_path=self.def_path
+        )
 
     def __str__(self):
         if self.fs.protocol != "local":
@@ -491,9 +473,6 @@ class Output:
         ):
             return str(self.def_path)
 
-        if not self.fs.path.isin(self.fs_path, self.repo.root_dir):
-            return self.fs_path
-
         cur_dir = self.fs.path.getcwd()
         if self.fs.path.isin(cur_dir, self.repo.root_dir):
             return self.fs.path.relpath(self.fs_path, cur_dir)
@@ -519,7 +498,7 @@ class Output:
             return False
 
         return self.repo and self.fs.path.isin(
-            self.fs_path,
+            self.fs.path.realpath(self.fs_path),
             self.repo.root_dir,
         )
 
@@ -532,19 +511,11 @@ class Output:
 
     @property
     def cache(self):
-        from dvc.cachemgr import LEGACY_HASH_NAMES
-
-        assert self.is_in_repo
-        odb_name = "legacy" if self.hash_name in LEGACY_HASH_NAMES else "repo"
-        return getattr(self.repo.cache, odb_name)
-
-    @property
-    def local_cache(self):
-        from dvc.cachemgr import LEGACY_HASH_NAMES
-
-        if self.hash_name in LEGACY_HASH_NAMES:
-            return self.repo.cache.legacy
-        return self.repo.cache.local
+        odb_name = "repo" if self.is_in_repo else self.protocol
+        odb = getattr(self.repo.cache, odb_name)
+        if self.use_cache and odb is None:
+            raise RemoteCacheRequiredError(self.fs.protocol, self.fs_path)
+        return odb
 
     @property
     def cache_path(self):
@@ -556,24 +527,12 @@ class Output:
         _, hash_info = self._get_hash_meta()
         return hash_info
 
-    def _build(
-        self, *args, no_progress_bar=False, **kwargs
-    ) -> Tuple["HashFileDB", "Meta", "HashFile"]:
-        from dvc.ui import ui
-
-        with ui.progress(
-            unit="file",
-            desc=f"Collecting files and computing hashes in {self}",
-            disable=no_progress_bar,
-        ) as pb:
-            return build(*args, callback=pb.as_callback(), **kwargs)
-
     def _get_hash_meta(self):
         if self.use_cache:
             odb = self.cache
         else:
-            odb = self.local_cache
-        _, meta, obj = self._build(
+            odb = self.repo.cache.local
+        _, meta, obj = build(
             odb,
             self.fs_path,
             self.fs,
@@ -699,14 +658,6 @@ class Output:
     # pylint: enable=no-member
 
     def save(self) -> None:
-        if self.use_cache and not self.is_in_repo:
-            raise DvcException(
-                f"Saving cached external output {self!s} is not supported "
-                "since DVC 3.0. See "
-                f"{format_link('https://dvc.org/doc/user-guide/upgrade')} "
-                "for more info."
-            )
-
         if not self.exists:
             raise self.DoesNotExistError(self)
 
@@ -721,9 +672,8 @@ class Output:
         if self.metric:
             self.verify_metric()
 
-        self.update_legacy_hash_name()
         if self.use_cache:
-            _, self.meta, self.obj = self._build(
+            _, self.meta, self.obj = build(
                 self.cache,
                 self.fs_path,
                 self.fs,
@@ -731,8 +681,8 @@ class Output:
                 ignore=self.dvcignore,
             )
         else:
-            _, self.meta, self.obj = self._build(
-                self.local_cache,
+            _, self.meta, self.obj = build(
+                self.repo.cache.local,
                 self.fs_path,
                 self.fs,
                 self.hash_name,
@@ -745,10 +695,6 @@ class Output:
         self.hash_info = self.obj.hash_info
         self.files = None
 
-    def update_legacy_hash_name(self, force: bool = False):
-        if self.hash_name == "md5-dos2unix" and (force or self.changed_checksum()):
-            self.hash_name = "md5"
-
     def set_exec(self) -> None:
         if self.isfile() and self.meta.isexec:
             self.cache.set_exec(self.fs_path)
@@ -783,25 +729,20 @@ class Output:
             if granular:
                 obj = self._commit_granular_dir(filter_info, hardlink)
             else:
-                staging, _, obj = self._build(
+                staging, _, obj = build(
                     self.cache,
                     filter_info or self.fs_path,
                     self.fs,
                     self.hash_name,
                     ignore=self.dvcignore,
                 )
-                with Callback.as_tqdm_callback(
-                    desc=f"Committing {self} to cache",
-                    unit="file",
-                ) as cb:
-                    otransfer(
-                        staging,
-                        self.cache,
-                        {obj.hash_info},
-                        shallow=False,
-                        hardlink=hardlink,
-                        callback=cb,
-                    )
+                otransfer(
+                    staging,
+                    self.cache,
+                    {obj.hash_info},
+                    shallow=False,
+                    hardlink=hardlink,
+                )
             if relink:
                 rel = self.fs.path.relpath(filter_info or self.fs_path)
                 with CheckoutCallback(desc=f"Checking out {rel}", unit="files") as cb:
@@ -819,7 +760,7 @@ class Output:
 
     def _commit_granular_dir(self, filter_info, hardlink) -> Optional["HashFile"]:
         prefix = self.fs.path.parts(self.fs.path.relpath(filter_info, self.fs_path))
-        staging, _, obj = self._build(
+        staging, _, obj = build(
             self.cache,
             self.fs_path,
             self.fs,
@@ -830,23 +771,16 @@ class Output:
         save_obj = obj.filter(prefix)
         assert isinstance(save_obj, Tree)
         checkout_obj = save_obj.get_obj(self.cache, prefix)
-        with Callback.as_tqdm_callback(
-            desc=f"Committing {self} to cache",
-            unit="file",
-        ) as cb:
-            otransfer(
-                staging,
-                self.cache,
-                {save_obj.hash_info} | {oid for _, _, oid in save_obj},
-                shallow=True,
-                hardlink=hardlink,
-                callback=cb,
-            )
+        otransfer(
+            staging,
+            self.cache,
+            {save_obj.hash_info} | {oid for _, _, oid in save_obj},
+            shallow=True,
+            hardlink=hardlink,
+        )
         return checkout_obj
 
     def dumpd(self, **kwargs):  # noqa: C901, PLR0912
-        from dvc.cachemgr import LEGACY_HASH_NAMES
-
         ret: Dict[str, Any] = {}
         with_files = (
             (not self.IS_DEPENDENCY or self.stage.is_import)
@@ -857,12 +791,7 @@ class Output:
         if not with_files:
             meta_d = self.meta.to_dict()
             meta_d.pop("isdir", None)
-            if self.hash_name in LEGACY_HASH_NAMES:
-                # 2.x checksums get serialized with file meta
-                name = "md5" if self.hash_name == "md5-dos2unix" else self.hash_name
-                ret.update({name: self.hash_info.value})
-            else:
-                ret.update(self.hash_info.to_dict())
+            ret.update(self.hash_info.to_dict())
             ret.update(split_file_meta_from_cloud(meta_d))
 
         if self.is_in_repo:
@@ -870,14 +799,8 @@ class Output:
         else:
             path = self.def_path
 
-        if self.hash_name not in LEGACY_HASH_NAMES:
-            ret[self.PARAM_HASH] = "md5"
-
         ret[self.PARAM_PATH] = path
 
-        if self.def_fs_config:
-            ret[self.PARAM_FS_CONFIG] = self.def_fs_config
-
         if not self.IS_DEPENDENCY:
             ret.update(self.annot.to_dict())
             if not self.use_cache:
@@ -899,6 +822,9 @@ class Output:
             if self.persist:
                 ret[self.PARAM_PERSIST] = self.persist
 
+            if self.checkpoint:
+                ret[self.PARAM_CHECKPOINT] = self.checkpoint
+
             if self.remote:
                 ret[self.PARAM_REMOTE] = self.remote
 
@@ -968,6 +894,7 @@ class Output:
         relink: bool = False,
         filter_info: Optional[str] = None,
         allow_missing: bool = False,
+        checkpoint_reset: bool = False,
         **kwargs,
     ) -> Optional[Tuple[bool, Optional[bool]]]:
         # callback passed act as a aggregate callback.
@@ -987,6 +914,11 @@ class Output:
             # backward compatibility
             return None
 
+        if self.checkpoint and checkpoint_reset:
+            if self.exists:
+                self.remove()
+            return None
+
         added = not self.exists
 
         try:
@@ -1003,17 +935,14 @@ class Output:
                 **kwargs,
             )
         except CheckoutError:
-            if allow_missing:
+            if allow_missing or self.checkpoint:
                 return None
             raise
         self.set_exec()
         return added, False if added else modified
 
     def remove(self, ignore_remove=False):
-        try:
-            self.fs.remove(self.fs_path, recursive=True)
-        except FileNotFoundError:
-            pass
+        self.fs.remove(self.fs_path, recursive=True)
         if self.protocol != Schemes.LOCAL:
             return
 
@@ -1040,9 +969,7 @@ class Output:
         if odb is None:
             odb = self.cache
 
-        cls, config, from_info = get_cloud_fs(
-            self.repo.config if self.repo else {}, url=source
-        )
+        cls, config, from_info = get_cloud_fs(self.repo, url=source)
         from_fs = cls(**config)
 
         # When running import-url --to-remote / add --to-remote/-o ... we
@@ -1056,27 +983,22 @@ class Output:
 
         upload = not (update and from_fs.isdir(from_info))
         jobs = jobs or min((from_fs.jobs, odb.fs.jobs))
-        staging, self.meta, obj = self._build(
+        staging, self.meta, obj = build(
             odb,
             from_info,
             from_fs,
-            DEFAULT_ALGORITHM,
+            "md5",
             upload=upload,
             no_progress_bar=no_progress_bar,
         )
-        with Callback.as_tqdm_callback(
-            desc=f"Transferring to {odb.fs.unstrip_protocol(odb.path)}",
-            unit="file",
-        ) as cb:
-            otransfer(
-                staging,
-                odb,
-                {obj.hash_info},
-                jobs=jobs,
-                hardlink=False,
-                shallow=False,
-                callback=cb,
-            )
+        otransfer(
+            staging,
+            odb,
+            {obj.hash_info},
+            jobs=jobs,
+            hardlink=False,
+            shallow=False,
+        )
 
         self.hash_info = obj.hash_info
         self.files = None
@@ -1096,7 +1018,7 @@ class Output:
         return len(obj) if obj else 0
 
     def unprotect(self):
-        if self.exists and self.use_cache:
+        if self.exists:
             self.cache.unprotect(self.fs_path)
 
     def get_dir_cache(self, **kwargs) -> Optional["Tree"]:
@@ -1148,7 +1070,7 @@ class Output:
             if not force and not prompt.confirm(msg.format(self.fs_path)):
                 raise CollectCacheError(  # noqa: B904
                     "unable to fully collect used cache"
-                    f" without cache for directory '{self}'"
+                    " without cache for directory '{}'".format(self)
                 )
             return None
 
@@ -1160,11 +1082,10 @@ class Output:
             return obj.filter(prefix)
         return obj
 
-    def get_used_objs(  # noqa: C901, PLR0911
+    def get_used_objs(  # noqa: C901
         self, **kwargs
-    ) -> Dict[Optional["HashFileDB"], Set["HashInfo"]]:
+    ) -> Dict[Optional["ObjectDB"], Set["HashInfo"]]:
         """Return filtered set of used object IDs for this out."""
-        from dvc.cachemgr import LEGACY_HASH_NAMES
 
         if not self.use_cache:
             return {}
@@ -1178,15 +1099,19 @@ class Output:
 
         if not self.hash_info:
             msg = (
-                f"Output '{self}'({self.stage}) is missing version info. "
+                "Output '{}'({}) is missing version info. "
                 "Cache for it will not be collected. "
-                "Use `dvc repro` to get your pipeline up to date."
+                "Use `dvc repro` to get your pipeline up to date.".format(
+                    self, self.stage
+                )
             )
             if self.exists:
                 msg += (
                     "\n"
-                    f"You can also use `dvc commit {self.stage.addressing}` "
-                    f"to associate existing '{self}' with {self.stage}."
+                    "You can also use `dvc commit {stage.addressing}` "
+                    "to associate existing '{out}' with {stage}.".format(
+                        out=self, stage=self.stage
+                    )
                 )
             logger.warning(msg)
             return {}
@@ -1203,17 +1128,11 @@ class Output:
             return {}
 
         if self.remote:
-            remote_odb = self.repo.cloud.get_remote_odb(
-                name=self.remote, hash_name=self.hash_name
-            )
-            other_odb = self.repo.cloud.get_remote_odb(
-                name=self.remote,
-                hash_name=(
-                    "md5" if self.hash_name in LEGACY_HASH_NAMES else "md5-dos2unix"
-                ),
-            )
-            return {remote_odb: self._named_obj_ids(obj), other_odb: set()}
-        return {None: self._named_obj_ids(obj)}
+            remote = self.repo.cloud.get_remote_odb(name=self.remote)
+        else:
+            remote = None
+
+        return {remote: self._named_obj_ids(obj)}
 
     def _named_obj_ids(self, obj):
         name = str(self)
@@ -1248,14 +1167,13 @@ class Output:
             self.hash_name,
             Meta.PARAM_SIZE,
             Meta.PARAM_NFILES,
-            Output.PARAM_HASH,
         ]
 
         for opt in ignored:
             my.pop(opt, None)
             other.pop(opt, None)
 
-        if my != other or self.hash_name != out.hash_name:
+        if my != other:
             raise MergeError("unable to auto-merge outputs with different options")
 
         if not out.is_dir_checksum:
@@ -1320,7 +1238,7 @@ class Output:
             raise FileNotFoundError(  # noqa: B904
                 errno.ENOENT,
                 os.strerror(errno.ENOENT),
-                path,
+                self.fs.path.relpath(path),
             )
 
         new = tree.from_trie(trie)
@@ -1391,14 +1309,13 @@ class Output:
             )
 
         assert self.repo
-        self.update_legacy_hash_name()
-        cache = self.cache if self.use_cache else self.local_cache
+        cache = self.cache if self.use_cache else self.repo.cache.local
         assert isinstance(cache, HashFileDB)
 
         new: "HashFile"
         try:
             assert self.hash_name
-            staging, meta, obj = self._build(
+            staging, meta, obj = build(
                 cache,
                 path,
                 self.fs,
@@ -1440,23 +1357,11 @@ class Output:
 
         assert staging
         assert obj.hash_info
-        with Callback.as_tqdm_callback(
-            desc=f"Adding {self} to cache",
-            unit="file",
-        ) as cb:
-            otransfer(
-                staging,
-                self.cache,
-                {obj.hash_info},
-                hardlink=relink,
-                shallow=False,
-                callback=cb,
-            )
+        otransfer(staging, self.cache, {obj.hash_info}, hardlink=relink, shallow=False)
 
         if relink:
-            with CheckoutCallback(
-                desc=f"Checking out {path}", unit="files"
-            ) as callback:
+            rel = self.fs.path.relpath(path)
+            with CheckoutCallback(desc=f"Checking out {rel}", unit="files") as callback:
                 self._checkout(
                     path,
                     self.fs,
@@ -1529,9 +1434,10 @@ ARTIFACT_SCHEMA = {
     **CHECKSUMS_SCHEMA,
     **META_SCHEMA,
     Required(Output.PARAM_PATH): str,
+    Output.PARAM_PLOT: bool,
     Output.PARAM_PERSIST: bool,
+    Output.PARAM_CHECKPOINT: bool,
     Output.PARAM_CLOUD: CLOUD_SCHEMA,
-    Output.PARAM_HASH: str,
 }
 
 DIR_FILES_SCHEMA: Dict[str, Any] = {
@@ -1545,8 +1451,8 @@ SCHEMA = {
     **ARTIFACT_SCHEMA,
     **ANNOTATION_SCHEMA,
     Output.PARAM_CACHE: bool,
+    Output.PARAM_METRIC: Output.METRIC_SCHEMA,
     Output.PARAM_REMOTE: str,
     Output.PARAM_PUSH: bool,
     Output.PARAM_FILES: [DIR_FILES_SCHEMA],
-    Output.PARAM_FS_CONFIG: dict,
 }

dvc/parsing/__init__.py

@@ -2,7 +2,6 @@ import logging
 import os
 from collections.abc import Mapping, Sequence
 from copy import deepcopy
-from itertools import product
 from typing import (
     TYPE_CHECKING,
     Any,
@@ -52,7 +51,6 @@ VARS_KWD = "vars"
 WDIR_KWD = "wdir"
 PARAMS_KWD = "params"
 FOREACH_KWD = "foreach"
-MATRIX_KWD = "matrix"
 DO_KWD = "do"
 
 DEFAULT_PARAMS_FILE = "params.yaml"
@@ -107,7 +105,7 @@ def is_map_or_seq(data: Any) -> bool:
     return not isinstance(data, str) and _is_map_or_seq(data)
 
 
-def split_group_name(name: str) -> Tuple[str, Optional[str]]:
+def split_foreach_name(name: str) -> Tuple[str, Optional[str]]:
     group, *keys = name.rsplit(JOIN, maxsplit=1)
     return group, first(keys)
 
@@ -122,15 +120,13 @@ def check_interpolations(data: "DictStrAny", where: str, path: str):
     return recurse(func)(data)
 
 
-Definition = Union["ForeachDefinition", "EntryDefinition", "MatrixDefinition"]
+Definition = Union["ForeachDefinition", "EntryDefinition"]
 
 
 def make_definition(
     resolver: "DataResolver", name: str, definition: "DictStrAny", **kwargs
 ) -> Definition:
     args = resolver, resolver.context, name, definition
-    if MATRIX_KWD in definition:
-        return MatrixDefinition(*args, **kwargs)
     if FOREACH_KWD in definition:
         return ForeachDefinition(*args, **kwargs)
     return EntryDefinition(*args, **kwargs)
@@ -139,7 +135,6 @@ def make_definition(
 class DataResolver:
     def __init__(self, repo: "Repo", wdir: str, d: dict):
         self.fs = fs = repo.fs
-        self.parsing_config = repo.config.get("parsing", {})
 
         if os.path.isabs(wdir):
             wdir = fs.path.relpath(wdir)
@@ -163,8 +158,7 @@ class DataResolver:
         self.tracked_vars: Dict[str, Mapping] = {}
 
         stages_data = d.get(STAGES_KWD, {})
-        # we wrap the definitions into:
-        # ForeachDefinition, MatrixDefinition, and EntryDefinition
+        # we wrap the definitions into ForeachDefinition and EntryDefinition,
         # that helps us to optimize, cache and selectively load each one of
         # them as we need, and simplify all of this DSL/parsing logic.
         self.definitions: Dict[str, Definition] = {
@@ -173,13 +167,12 @@ class DataResolver:
         }
 
     def resolve_one(self, name: str):
-        group, key = split_group_name(name)
+        group, key = split_foreach_name(name)
 
         if not self._has_group_and_key(group, key):
             raise EntryNotFound(f"Could not find '{name}'")
 
-        # all of the checks for `key` not being None for
-        # `ForeachDefinition`/`MatrixDefinition`
+        # all of the checks for `key` not being None for `ForeachDefinition`
         # and/or `group` not existing in the `interim`, etc. should be
         # handled by the `self.has_key()` above.
         definition = self.definitions[group]
@@ -196,7 +189,7 @@ class DataResolver:
         return {STAGES_KWD: data}
 
     def has_key(self, key: str):
-        return self._has_group_and_key(*split_group_name(key))
+        return self._has_group_and_key(*split_foreach_name(key))
 
     def _has_group_and_key(self, group: str, key: Optional[str] = None):
         try:
@@ -204,14 +197,16 @@ class DataResolver:
         except KeyError:
             return False
 
-        if not isinstance(definition, (ForeachDefinition, MatrixDefinition)):
-            return key is None
-        return key is not None and definition.has_member(key)
+        if key:
+            return isinstance(definition, ForeachDefinition) and definition.has_member(
+                key
+            )
+        return not isinstance(definition, ForeachDefinition)
 
     @collecting
     def get_keys(self):
         for name, definition in self.definitions.items():
-            if isinstance(definition, (ForeachDefinition, MatrixDefinition)):
+            if isinstance(definition, ForeachDefinition):
                 yield from definition.get_generated_names()
                 continue
             yield name
@@ -260,9 +255,8 @@ class EntryDefinition:
         name = self.name
         if not skip_checks:
             # we can check for syntax errors as we go for interpolated entries,
-            # but for foreach and matrix generated ones, once is enough, which it does
-            # that itself. See `ForeachDefinition.template`
-            # and `MatrixDefinition.template`.
+            # but for foreach-generated ones, once is enough, which it does
+            # that itself. See `ForeachDefinition.do_definition`.
             check_syntax_errors(self.definition, name, self.relpath)
 
         # we need to pop vars from generated/evaluated data
@@ -307,10 +301,7 @@ class EntryDefinition:
     ) -> "DictStrAny":
         try:
             return context.resolve(
-                value,
-                skip_interpolation_checks=skip_checks,
-                key=key,
-                config=self.resolver.parsing_config,
+                value, skip_interpolation_checks=skip_checks, key=key
             )
         except (ParseError, KeyNotInContext) as exc:
             format_and_raise(exc, f"'{self.where}.{self.name}.{key}'", self.relpath)
@@ -336,18 +327,17 @@ class ForeachDefinition:
         self.name = name
 
         assert DO_KWD in definition
-        assert MATRIX_KWD not in definition
         self.foreach_data = definition[FOREACH_KWD]
-        self._template = definition[DO_KWD]
+        self._do_definition = definition[DO_KWD]
 
         self.pair = IterationPair()
         self.where = where
 
     @cached_property
-    def template(self):
+    def do_definition(self):
         # optimization: check for syntax errors only once for `foreach` stages
-        check_syntax_errors(self._template, self.name, self.relpath)
-        return self._template
+        check_syntax_errors(self._do_definition, self.name, self.relpath)
+        return self._do_definition
 
     @cached_property
     def resolved_iterable(self):
@@ -450,111 +440,16 @@ class ForeachDefinition:
             # i.e. quadratic complexity).
             generated = self._generate_name(key)
             entry = EntryDefinition(
-                self.resolver, self.context, generated, self.template
+                self.resolver, self.context, generated, self.do_definition
             )
             try:
                 # optimization: skip checking for syntax errors on each foreach
-                # generated stages. We do it once when accessing template.
+                # generated stages. We do it once when accessing do_definition.
                 return entry.resolve_stage(skip_checks=True)
             except ContextError as exc:
                 format_and_raise(exc, f"stage '{generated}'", self.relpath)
 
-
-class MatrixDefinition:
-    def __init__(
-        self,
-        resolver: DataResolver,
-        context: Context,
-        name: str,
-        definition: "DictStrAny",
-        where: str = STAGES_KWD,
-    ):
-        self.resolver = resolver
-        self.relpath = self.resolver.relpath
-        self.context = context
-        self.name = name
-
-        assert MATRIX_KWD in definition
-        assert DO_KWD not in definition
-        assert FOREACH_KWD not in definition
-
-        self._template = definition.copy()
-        self.matrix_data = self._template.pop(MATRIX_KWD)
-
-        self.pair = IterationPair()
-        self.where = where
-
-    @cached_property
-    def template(self) -> "DictStrAny":
-        # optimization: check for syntax errors only once for `matrix` stages
-        check_syntax_errors(self._template, self.name, self.relpath)
-        return self._template
-
-    @cached_property
-    def resolved_iterable(self) -> Dict[str, List]:
-        return self._resolve_matrix_data()
-
-    def _resolve_matrix_data(self) -> Dict[str, List]:
-        try:
-            iterable = self.context.resolve(self.matrix_data, unwrap=False)
-        except (ContextError, ParseError) as exc:
-            format_and_raise(exc, f"'{self.where}.{self.name}.matrix'", self.relpath)
-        return iterable
-
-    @cached_property
-    def normalized_iterable(self) -> Dict[str, "DictStrAny"]:
-        """Convert sequence to Mapping with keys normalized."""
-        iterable = self.resolved_iterable
-        assert isinstance(iterable, Mapping)
-
-        ret: Dict[str, "DictStrAny"] = {}
-        matrix = {key: enumerate(v) for key, v in iterable.items()}
-        for combination in product(*matrix.values()):
-            d: "DictStrAny" = {}
-            fragments: List[str] = []
-            for k, (i, v) in zip(matrix.keys(), combination):
-                d[k] = v
-                fragments.append(f"{k}{i}" if is_map_or_seq(v) else to_str(v))
-
-            key = "-".join(fragments)
-            ret[key] = d
-        return ret
-
-    def has_member(self, key: str) -> bool:
-        return key in self.normalized_iterable
-
-    def get_generated_names(self) -> List[str]:
-        return list(map(self._generate_name, self.normalized_iterable))
-
-    def _generate_name(self, key: str) -> str:
-        return f"{self.name}{JOIN}{key}"
-
-    def resolve_all(self) -> "DictStrAny":
-        return join(map(self.resolve_one, self.normalized_iterable))
-
-    def resolve_one(self, key: str) -> "DictStrAny":
-        return self._each_iter(key)
-
-    def _each_iter(self, key: str) -> "DictStrAny":
-        err_message = f"Could not find '{key}' in matrix group '{self.name}'"
-        with reraise(KeyError, EntryNotFound(err_message)):
-            value = self.normalized_iterable[key]
-
-        temp_dict = {self.pair.value: value}
-        with self.context.set_temporarily(temp_dict, reserve=True):
-            # optimization: item and key can be removed on __exit__() as they
-            # are top-level values, and are not merged recursively.
-            # This helps us avoid cloning context, which is slower
-            # (increasing the size of the context might increase
-            # the no. of items to be generated which means more cloning,
-            # i.e. quadratic complexity).
-            generated = self._generate_name(key)
-            entry = EntryDefinition(
-                self.resolver, self.context, generated, self.template
-            )
-            try:
-                # optimization: skip checking for syntax errors on each matrix
-                # generated stages. We do it once when accessing template.
-                return entry.resolve_stage(skip_checks=True)
-            except ContextError as exc:
-                format_and_raise(exc, f"stage '{generated}'", self.relpath)
+            # let mypy know that this state is unreachable as format_and_raise
+            # does not return at all (it's not able to understand it for some
+            # reason)
+            raise AssertionError("unreachable")

dvc/parsing/context.py

@@ -495,12 +495,7 @@ class Context(CtxDict):
                 self.data.pop(key, None)
 
     def resolve(
-        self,
-        src,
-        unwrap=True,
-        skip_interpolation_checks=False,
-        key=None,
-        config=None,
+        self, src, unwrap=True, skip_interpolation_checks=False, key=None
     ) -> Any:
         """Recursively resolves interpolation and returns resolved data.
 
@@ -516,15 +511,10 @@ class Context(CtxDict):
         {'lst': [1, 2, 3]}
         """
         func = recurse(self.resolve_str)
-        return func(src, unwrap, skip_interpolation_checks, key, config)
+        return func(src, unwrap, skip_interpolation_checks, key)
 
     def resolve_str(
-        self,
-        src: str,
-        unwrap=True,
-        skip_interpolation_checks=False,
-        key=None,
-        config=None,
+        self, src: str, unwrap=True, skip_interpolation_checks=False, key=None
     ) -> str:
         """Resolves interpolated string to it's original value,
         or in case of multiple interpolations, a combined string.
@@ -545,12 +535,7 @@ class Context(CtxDict):
             return value
         # but not "${num} days"
         return str_interpolate(
-            src,
-            matches,
-            self,
-            skip_checks=skip_interpolation_checks,
-            key=key,
-            config=config,
+            src, matches, self, skip_checks=skip_interpolation_checks, key=key
         )
 
 

dvc/parsing/interpolate.py

@@ -82,18 +82,20 @@ def escape_str(value):
 
 
 @singledispatch
-def to_str(obj, config=None) -> str:  # noqa: ARG001, pylint: disable=unused-argument
+def to_str(obj) -> str:
     return str(obj)
 
 
 @to_str.register(bool)
-def _(obj: bool, config=None):  # noqa: ARG001, pylint: disable=unused-argument
+def _(obj: bool):
     return "true" if obj else "false"
 
 
 @to_str.register(dict)
-def _(obj: dict, config=None):  # noqa: C901
-    config = config or {}
+def _(obj: dict):  # noqa: C901
+    from dvc.config import Config
+
+    config = Config.from_cwd().get("parsing", {})
 
     result = ""
     for k, v in flatten(obj).items():
@@ -209,7 +211,6 @@ def str_interpolate(
     context: "Context",
     skip_checks: bool = False,
     key=None,
-    config=None,
 ):
     index, buf = 0, ""
     for match in matches:
@@ -217,7 +218,7 @@ def str_interpolate(
         expr = get_expression(match, skip_checks=skip_checks)
         value = context.select(expr, unwrap=True)
         validate_value(value, key)
-        buf += template[index:start] + to_str(value, config=config)
+        buf += template[index:start] + to_str(value)
         index = end
     buf += template[index:]
     # regex already backtracks and avoids any `${` starting with

dvc/parsing/versions.py

@@ -0,0 +1,39 @@
+import enum
+from collections.abc import Mapping
+
+from voluptuous import validators
+
+SCHEMA_KWD = "schema"
+META_KWD = "meta"
+
+
+def lockfile_version_schema(value):
+    expected = [LOCKFILE_VERSION.V2.value]  # pylint: disable=no-member
+    msg = f"invalid schema version {value}, expected one of {expected}"
+    return validators.Any(*expected, msg=msg)(value)
+
+
+class VersionEnum(str, enum.Enum):
+    @classmethod
+    def all_versions(cls):
+        return [v.value for v in cls]
+
+
+class LOCKFILE_VERSION(VersionEnum):  # noqa: N801
+    V1 = "1.0"
+    V2 = "2.0"
+
+    @classmethod
+    def from_dict(cls, data):
+        # 1) if it's empty or or is not a dict, use the latest one (V2).
+        # 2) use the `schema` identifier if it exists and is a supported
+        # version
+        # 3) if it's not in any of the supported version, use the latest one
+        # 4) if there's no identifier, it's a V1
+        if not data or not isinstance(data, Mapping):
+            return cls(cls.V2)
+
+        version = data.get(SCHEMA_KWD)
+        if version:
+            return cls(version if version in cls.all_versions() else cls.V2)
+        return cls(cls.V1)

dvc/pathspec_math.py

@@ -8,7 +8,7 @@ from pathspec.util import normalize_file
 
 from dvc.utils import relpath
 
-PatternInfo = namedtuple("PatternInfo", ["patterns", "file_info"])  # noqa: PYI024
+PatternInfo = namedtuple("PatternInfo", ["patterns", "file_info"])
 
 
 def _not_ignore(rule):

dvc/progress.py

@@ -2,16 +2,12 @@
 import logging
 import sys
 from threading import RLock
-from typing import TYPE_CHECKING
 
 from tqdm import tqdm
 
 from dvc.env import DVC_IGNORE_ISATTY
 from dvc.utils import env2bool
 
-if TYPE_CHECKING:
-    from dvc.fs.callbacks import TqdmCallback
-
 logger = logging.getLogger(__name__)
 tqdm.set_lock(RLock())
 
@@ -162,8 +158,3 @@ class Tqdm(tqdm):
             d["ncols_desc"] = d["ncols_info"] = 1
             d["prefix"] = ""
         return d
-
-    def as_callback(self) -> "TqdmCallback":
-        from dvc.fs.callbacks import TqdmCallback
-
-        return TqdmCallback(progress_bar=self)

dvc/render/match.py

@@ -1,4 +1,3 @@
-import logging
 import os
 from collections import defaultdict
 from typing import TYPE_CHECKING, DefaultDict, Dict, List, NamedTuple, Optional
@@ -8,7 +7,7 @@ import dpath.options
 from funcy import get_in, last
 
 from dvc.repo.plots import _normpath, infer_data_sources
-from dvc.utils.plots import group_definitions_by_id
+from dvc.utils.plots import get_plot_id
 
 from .convert import _get_converter
 
@@ -18,7 +17,6 @@ if TYPE_CHECKING:
 
 
 dpath.options.ALLOW_EMPTY_STRING_KEYS = True
-logger = logging.getLogger(__name__)
 
 
 def _squash_plots_properties(data: List) -> Dict:
@@ -36,9 +34,14 @@ class PlotsData:
     def group_definitions(self):
         groups = defaultdict(list)
         for rev, rev_content in self.data.items():
-            definitions = rev_content.get("definitions", {}).get("data", {})
-            for plot_id, definition in group_definitions_by_id(definitions).items():
-                groups[plot_id].append((rev, *definition))
+            for config_file, config_file_content in (
+                rev_content.get("definitions", {}).get("data", {}).items()
+            ):
+                for plot_id, plot_definition in config_file_content.get(
+                    "data", {}
+                ).items():
+                    full_id = get_plot_id(plot_id, config_file)
+                    groups[full_id].append((rev, plot_id, plot_definition))
         return dict(groups)
 
     def get_definition_data(self, target_files, rev):
@@ -110,7 +113,6 @@ def match_defs_renderers(  # noqa: C901, PLR0912
             try:
                 dps, rev_props = converter.flat_datapoints(rev)
             except Exception as e:  # noqa: BLE001, pylint: disable=broad-except
-                logger.warning("In %r, %s", rev, str(e).lower())
                 def_errors[rev] = e
                 continue