schema: add strict schema validation for top-level plots (#8289)

schema: add strict schema validation for plots

.github/CODEOWNERS

@@ -1 +0,0 @@
-*       @iterative/dvc

.github/workflows/packages.yaml

@@ -6,152 +6,92 @@ on:
   release:
     types: [released, prereleased]
   workflow_dispatch:
+
 jobs:
-  deb:
-    runs-on: ubuntu-18.04
+  binary:
+    strategy:
+      matrix:
+        include:
+         - {pkg: "deb",  os: "ubuntu-18.04", asset: "dvc_${{ github.event.release.tag_name }}_amd64.deb"}
+         - {pkg: "rpm", os: "ubuntu-18.04", asset: "dvc-${{ github.event.release.tag_name }}-1.x86_64.rpm"}
+         - {pkg: "osxpkg", os: "macos-10.15", 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.9
       uses: actions/setup-python@v4
       with:
         python-version: 3.9
-    - name: Set up Ruby 2.4
-      uses: actions/[email protected]
+        cache: pip
+        cache-dependency-path: |
+          setup.cfg
+          scripts/build-requirements.txt
+
+    - name: Set up Ruby 2.6
+      uses: ruby/setup-ruby@v1
+      if: matrix.pkg != 'exe'
       with:
-        ruby-version: 2.4
-    - name: Install deps
-      run: |
-        pip install .[all]
-        pip install -r scripts/build-requirements.txt
-        gem install --no-document fpm
-    - name: Build deb
-      run: python scripts/build.py deb
-    - name: Publish deb
-      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/fpm/dvc_${{ github.event.release.tag_name }}_amd64.deb
-        asset_name: dvc_${{ github.event.release.tag_name }}_amd64.deb
-        asset_content_type: binary/octet-stream
-  rpm:
-    runs-on: ubuntu-18.04
-    steps:
-    - uses: actions/checkout@v3
-      with:
-        fetch-depth: 0
-    - name: Set up Python 3.9
-      uses: actions/setup-python@v4
-      with:
-        python-version: 3.9
-    - name: Set up Ruby 2.4
-      uses: actions/[email protected]
-      with:
-        ruby-version: 2.4
-    - name: Install deps
-      run: |
-        pip install .[all]
-        pip install -r scripts/build-requirements.txt
-        gem install --no-document fpm
-    - name: Build rpm
-      run: python scripts/build.py rpm
-    - name: Publish rpm
-      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/fpm/dvc-${{ github.event.release.tag_name }}-1.x86_64.rpm
-        asset_name: dvc-${{ github.event.release.tag_name }}-1.x86_64.rpm
-        asset_content_type: binary/octet-stream
-  osxpkg:
-    runs-on: macos-10.15
-    steps:
-    - uses: actions/checkout@v3
-      with:
-        fetch-depth: 0
-    - name: Set up Python 3.9
-      uses: actions/setup-python@v4
-      with:
-        python-version: 3.9
-    - name: Set up Ruby 2.4
-      uses: actions/[email protected]
-      with:
-        ruby-version: 2.4
-    - name: Install deps
-      run: |
-        # available lxml (webdav dependency) wheels are built with an old
-        # SDK, which breaks osxpkg notarization. Building from scratch
-        # instead.
-        pip install .[all] --no-binary lxml
-        pip install -r scripts/build-requirements.txt
-        gem install --no-document fpm
-    - name: Build
-      run: python scripts/build.py osxpkg
-    - name: Publish
-      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/fpm/dvc-${{ github.event.release.tag_name }}.pkg
-        asset_name: dvc-${{ github.event.release.tag_name }}.pkg
-        asset_content_type: binary/octet-stream
-  exe:
-    runs-on: windows-2019
-    steps:
-    - uses: actions/checkout@v3
-      with:
-        fetch-depth: 0
-    - name: Set up Python 3.9
-      uses: actions/setup-python@v4
-      with:
-        python-version: 3.9
+        ruby-version: '2.6'
+
+    - name: Install fpm
+      if: matrix.pkg != 'exe'
+      run: gem install --no-document fpm
+
     - name: Install deps
       run: |
+        pip install -U wheel pip setuptools
         pip install .[all]
         pip install -r scripts/build-requirements.txt
+
     - name: Pull images
-      run: |
-        dvc pull
-    - name: Build
-      run: python scripts\build.py exe
-      shell: cmd
-    - name: Publish
+      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 }}
-      uses: actions/[email protected]
       with:
         upload_url: ${{ github.event.release.upload_url }}
-        asset_path: scripts/innosetup/dvc-${{ github.event.release.tag_name }}.exe
-        asset_name: dvc-${{ github.event.release.tag_name }}.exe
+        asset_path: scripts/${{ matrix.pkg == 'exe' && 'innosetup' || 'fpm' }}/${{ matrix.asset }}
+        asset_name: ${{ matrix.asset }}
         asset_content_type: binary/octet-stream
+
   pip:
-    runs-on: ubuntu-18.04
+    runs-on: ubuntu-20.04
     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
+        cache: pip
+        cache-dependency-path: setup.cfg
+
     - name: Install
-      run: pip install ".[all,tests]"
+      run: |
+        pip install -U wheel pip build setuptools
+        pip install ".[all,tests]"
+
     - name: Build packages
       run: |
         pip install -U pip
         ./scripts/build_package.sh
+
     - name: Publish packages to PyPI
       if: github.event_name == 'release'
-      uses: pypa/gh-action-pypi-publish@master
+      uses: pypa/gh-action-pypi-publish@release/v1
       with:
-        user: __token__
         password: ${{ secrets.PYPI_TOKEN }}

.github/workflows/tests.yaml

@@ -43,6 +43,9 @@ jobs:
       matrix:
         os: [ubuntu-20.04, windows-latest, macos-latest]
         pyv: ["3.8", "3.9", "3.10"]
+        include:
+        - {os: ubuntu-latest, pyv: "3.11-dev"}
+
     steps:
     - uses: actions/checkout@v3
       with:
@@ -68,6 +71,8 @@ jobs:
       run: |
         pip install --upgrade pip setuptools wheel
         pip install -e ".[dev]"
+      env:
+        AIOHTTP_NO_EXTENSIONS: ${{ matrix.pyv == '3.11-dev' && '1' }}
     - name: run tests
       timeout-minutes: 40
       run: >-

README.rst

@@ -11,7 +11,7 @@
 • `Contributing`_
 • `Community and Support`_
 
-|CI| |Maintainability| |Coverage| |VS Code| |DOI|
+|CI| |Python Version| |Coverage| |VS Code| |DOI|
 
 |PyPI| |Packages| |Brew| |Conda| |Choco| |Snap|
 
@@ -248,6 +248,10 @@ Barrak, A., Eghan, E.E. and Adams, B. `On the Co-evolution of ML Pipelines and S
    :target: https://codeclimate.com/github/iterative/dvc
    :alt: Code Climate
 
+.. |Python Version| image:: https://img.shields.io/pypi/pyversions/dvc
+   :target: https://pypi.org/project/dvc
+   :alt: Python Version
+
 .. |Coverage| image:: https://codecov.io/gh/iterative/dvc/branch/main/graph/badge.svg
    :target: https://codecov.io/gh/iterative/dvc
    :alt: Codecov

dvc/annotations.py

@@ -0,0 +1,35 @@
+from dataclasses import asdict, dataclass, field, fields
+from typing import Any, ClassVar, Dict, List, Optional
+
+from funcy import compact
+
+
+@dataclass
+class Annotation:
+    PARAM_DESC: ClassVar[str] = "desc"
+    PARAM_TYPE: ClassVar[str] = "type"
+    PARAM_LABELS: ClassVar[str] = "labels"
+    PARAM_META: ClassVar[str] = "meta"
+
+    desc: Optional[str] = None
+    type: Optional[str] = None
+    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))
+
+
+ANNOTATION_FIELDS = [field.name for field in fields(Annotation)]
+ANNOTATION_SCHEMA = {
+    Annotation.PARAM_DESC: str,
+    Annotation.PARAM_TYPE: str,
+    Annotation.PARAM_LABELS: [str],
+    Annotation.PARAM_META: object,
+}

dvc/api/__init__.py

@@ -1,9 +1,15 @@
-from .data import (  # noqa, pylint: disable=redefined-builtin
-    get_url,
-    open,
-    read,
-)
+from dvc.fs.dvc import _DvcFileSystem as DvcFileSystem
+
+from .data import open  # pylint: disable=redefined-builtin
+from .data import get_url, read
 from .experiments import make_checkpoint
 from .params import params_show
 
-__all__ = ["get_url", "make_checkpoint", "open", "params_show", "read"]
+__all__ = [
+    "get_url",
+    "make_checkpoint",
+    "open",
+    "params_show",
+    "read",
+    "DvcFileSystem",
+]

dvc/api/params.py

@@ -37,6 +37,10 @@ def params_show(
             stages to retrieve parameters from.
             Defaults to `None`.
             If `None`, all parameters from all stages will be retrieved.
+            If this method is called from a different location to the one where
+            the `dvc.yaml` is found, the relative path to the `dvc.yaml` must
+            be provided as a prefix with the syntax `{relpath}:{stage}`.
+            For example: `subdir/dvc.yaml:stage-0` or `../dvc.yaml:stage-1`.
         rev (str, optional): Name of the `Git revision`_ to retrieve parameters
             from.
             Defaults to `None`.

dvc/cli/__init__.py

@@ -121,7 +121,7 @@ def _log_exceptions(exc: Exception) -> Optional[int]:
         )
         return None
 
-    from dvc_data.build import IgnoreInCollectedDirError
+    from dvc_data.hashfile.build import IgnoreInCollectedDirError
 
     if isinstance(exc, IgnoreInCollectedDirError):
         logger.exception("")

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):
+        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):
+        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/commands/add.py

@@ -2,12 +2,43 @@ 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 run(self):
         from dvc.exceptions import (
@@ -28,6 +59,9 @@ class CmdAdd(CmdBase):
                 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,
                 jobs=self.args.jobs,
@@ -109,15 +143,8 @@ def add_parser(subparsers, parent_parser):
         ),
         metavar="<number>",
     )
-    parser.add_argument(
-        "--desc",
-        type=str,
-        metavar="<text>",
-        help=(
-            "User description of the data (optional). "
-            "This doesn't affect any DVC operations."
-        ),
-    )
+
+    _add_annotating_args(parser)
     parser.add_argument(
         "targets", nargs="+", help="Input files/directories to add."
     ).complete = completion.FILE

dvc/commands/data.py

@@ -1,9 +1,12 @@
 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.ui import ui
@@ -31,15 +34,22 @@ class CmdDataStatus(CmdBase):
         "unchanged": "DVC unchanged files",
     }
     HINTS = {
-        "not_in_cache": 'use "dvc pull <file>..." '
-        "to update your local storage",
-        "committed": "git commit the corresponding dvc files "
-        "to update the repo",
-        "uncommitted": 'use "dvc commit <file>..." to track changes',
-        "untracked": 'use "git add <file> ..." or '
-        'dvc add <file>..." to commit to git or to dvc',
-        "git_dirty": "there are {}changes not tracked by dvc, "
-        'use "git status" to see',
+        "not_in_cache": ('use "dvc fetch <file>..." to download files',),
+        "committed": (
+            "git commit the corresponding dvc files to update the repo",
+        ),
+        "uncommitted": (
+            'use "dvc commit <file>..." to track changes',
+            'use "dvc checkout <file>..." to discard changes',
+        ),
+        "untracked": (
+            'use "git add <file> ..." or '
+            '"dvc add <file>..." to commit to git or to dvc',
+        ),
+        "git_dirty": (
+            "there are {}changes not tracked by dvc, "
+            'use "git status" to see',
+        ),
     }
 
     @staticmethod
@@ -76,8 +86,9 @@ class CmdDataStatus(CmdBase):
             color = cls.COLORS.get(stage, None)
 
             ui.write(header)
-            if hint := cls.HINTS.get(stage):
-                ui.write(f"  ({hint})")
+            if hints := cls.HINTS.get(stage):
+                for hint in hints:
+                    ui.write(f"  ({hint})")
 
             if isinstance(stage_status, dict):
                 items = [
@@ -92,9 +103,10 @@ class CmdDataStatus(CmdBase):
                 out = "\n".join(tabs + item for item in chunk)
                 ui.write(colorize(out, color))
 
-        if (hint := cls.HINTS.get("git_dirty")) and git_info.get("is_dirty"):
-            message = hint.format("other " if result else "")
-            ui.write(f"[blue]({message})[/]", styled=True)
+        if (hints := cls.HINTS.get("git_dirty")) and git_info.get("is_dirty"):
+            for hint in hints:
+                message = hint.format("other " if result else "")
+                ui.write(f"[blue]({message})[/]", styled=True)
         return 0
 
     def run(self) -> int:
@@ -102,7 +114,6 @@ class CmdDataStatus(CmdBase):
             status = self.repo.data_status(
                 granular=self.args.granular,
                 untracked_files=self.args.untracked_files,
-                with_dirs=self.args.with_dirs,
             )
 
         if not self.args.unchanged:
@@ -116,6 +127,65 @@ 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",
@@ -172,10 +242,52 @@ def add_parser(subparsers, parent_parser):
         nargs="?",
         help="Show untracked files.",
     )
-    data_status_parser.add_argument(
-        "--with-dirs",
+    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,
+        help=DATA_LS_HELP,
+    )
+    data_ls_parser.add_argument(
+        "--md",
+        "--show-md",
+        dest="markdown",
         action="store_true",
         default=False,
-        help=argparse.SUPPRESS,
+        help="Show tabulated output in the Markdown format (GFM).",
     )
-    data_status_parser.set_defaults(func=CmdDataStatus)
+    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)

dvc/commands/data_sync.py

@@ -43,7 +43,8 @@ class CmdDataPull(CmdDataBase):
             )
             self.log_summary(stats)
         except (CheckoutError, DvcException) as exc:
-            self.log_summary(getattr(exc, "stats", {}))
+            if stats := getattr(exc, "stats", {}):
+                self.log_summary(stats)
             logger.exception("failed to pull data from the cloud")
             return 1
 

dvc/commands/experiments/diff.py

@@ -27,7 +27,7 @@ class CmdExperimentsDiff(CmdBase):
 
         if self.args.json:
             ui.write_json(diff)
-        else:
+        elif diff:
             from dvc.compare import show_diff
 
             precision = self.args.precision or DEFAULT_PRECISION

dvc/commands/experiments/remove.py

@@ -10,23 +10,22 @@ logger = logging.getLogger(__name__)
 
 
 class CmdExperimentsRemove(CmdBase):
-    def raise_error_if_all_disabled(self):
+    def check_arguments(self):
         if not any(
             [
-                self.args.experiment,
                 self.args.all_commits,
                 self.args.rev,
                 self.args.queue,
             ]
-        ):
+        ) ^ bool(self.args.experiment):
             raise InvalidArgumentError(
                 "Either provide an `experiment` argument, or use the "
-                "`--rev` or `--all-commits` flag."
+                "`--rev` or `--all-commits` or `--queue` flag."
             )
 
     def run(self):
 
-        self.raise_error_if_all_disabled()
+        self.check_arguments()
 
         removed_list = self.repo.experiments.remove(
             exp_names=self.args.experiment,

dvc/commands/imp.py

@@ -19,7 +19,11 @@ class CmdImport(CmdBase):
                 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,
             )
         except DvcException:
@@ -33,6 +37,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."
@@ -69,20 +75,19 @@ def add_parser(subparsers, parent_parser):
         help="Specify name of the .dvc file this command will generate.",
         metavar="<filename>",
     )
-    import_parser.add_argument(
+    no_download_exec_group = import_parser.add_mutually_exclusive_group()
+    no_download_exec_group.add_argument(
         "--no-exec",
         action="store_true",
         default=False,
-        help="Only create .dvc file without actually downloading it.",
+        help="Only create .dvc file without actually importing target data.",
     )
-    import_parser.add_argument(
-        "--desc",
-        type=str,
-        metavar="<text>",
-        help=(
-            "User description of the data (optional). "
-            "This doesn't affect any DVC operations."
-        ),
+    no_download_exec_group.add_argument(
+        "--no-download",
+        action="store_true",
+        default=False,
+        help="Create .dvc file including target data hash value(s)"
+        " but do not actually download the file(s).",
     )
     import_parser.add_argument(
         "-j",
@@ -94,4 +99,6 @@ def add_parser(subparsers, parent_parser):
         ),
         metavar="<number>",
     )
+
+    _add_annotating_args(import_parser)
     import_parser.set_defaults(func=CmdImport)

dvc/commands/imp_url.py

@@ -17,9 +17,13 @@ class CmdImportUrl(CmdBase):
                 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,
             )
         except DvcException:
@@ -34,6 +38,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."
     )
@@ -66,11 +72,19 @@ def add_parser(subparsers, parent_parser):
         help="Specify name of the .dvc file this command will generate.",
         metavar="<filename>",
     ).complete = completion.DIR
-    import_parser.add_argument(
+    no_download_exec_group = import_parser.add_mutually_exclusive_group()
+    no_download_exec_group.add_argument(
         "--no-exec",
         action="store_true",
         default=False,
-        help="Only create .dvc file without actually downloading it.",
+        help="Only create .dvc file without actually importing target data.",
+    )
+    no_download_exec_group.add_argument(
+        "--no-download",
+        action="store_true",
+        default=False,
+        help="Create .dvc file including target data hash value(s)"
+        " but do not actually download the file(s).",
     )
     import_parser.add_argument(
         "--to-remote",
@@ -94,13 +108,5 @@ def add_parser(subparsers, parent_parser):
         ),
         metavar="<number>",
     )
-    import_parser.add_argument(
-        "--desc",
-        type=str,
-        metavar="<text>",
-        help=(
-            "User description of the data (optional). "
-            "This doesn't affect any DVC operations."
-        ),
-    )
+    _add_annotating_args(import_parser)
     import_parser.set_defaults(func=CmdImportUrl)

dvc/commands/plots.py

@@ -155,11 +155,6 @@ class CmdPlots(CmdBase):
                 out=renderers_out,
                 templates_dir=self.repo.plots.templates_dir,
             )
-            if self.args.show_vega:
-                renderer = first(filter(lambda r: r.TYPE == "vega", renderers))
-                if renderer:
-                    ui.write_json(json.loads(renderer.get_filled_template()))
-                return 0
             if self.args.json:
                 renderers = _filter_unhandled_renderers(renderers)
                 _show_json(renderers, self.args.split)
@@ -167,6 +162,12 @@ class CmdPlots(CmdBase):
 
             _adjust_vega_renderers(renderers)
 
+            if self.args.show_vega:
+                renderer = first(filter(lambda r: r.TYPE == "vega", renderers))
+                if renderer:
+                    ui.write_json(json.loads(renderer.get_filled_template()))
+                return 0
+
             output_file: Path = (Path.cwd() / out).resolve() / "index.html"
 
             if renderers:
@@ -222,31 +223,22 @@ class CmdPlotsModify(CmdPlots):
 
 
 class CmdPlotsTemplates(CmdBase):
-    TEMPLATES_CHOICES = [
-        "simple",
-        "linear",
-        "confusion",
-        "confusion_normalized",
-        "scatter",
-        "smooth",
-        "bar_horizontal_sorted",
-        "bar_horizontal",
-    ]
-
     def run(self):
-        from dvc_render.vega_templates import dump_templates
+        from dvc.exceptions import InvalidArgumentError
+        from dvc_render.vega_templates import TEMPLATES
 
         try:
-            out = (
-                os.path.join(os.getcwd(), self.args.out)
-                if self.args.out
-                else self.repo.plots.templates_dir
-            )
+            target = self.args.template
+            if target:
+                for template in TEMPLATES:
+                    if target == template.DEFAULT_NAME:
+                        ui.write_json(template.DEFAULT_CONTENT)
+                        return 0
+                raise InvalidArgumentError(f"Unexpected template: {target}.")
 
-            targets = [self.args.target] if self.args.target else None
-            dump_templates(output=out, targets=targets)
-            templates_path = os.path.relpath(out, os.getcwd())
-            ui.write(f"Templates have been written into '{templates_path}'.")
+            else:
+                for template in TEMPLATES:
+                    ui.write(template.DEFAULT_NAME)
 
             return 0
         except DvcException:
@@ -356,8 +348,7 @@ def add_parser(subparsers, parent_parser):
     plots_modify_parser.set_defaults(func=CmdPlotsModify)
 
     TEMPLATES_HELP = (
-        "Write built-in plots templates to a directory "
-        "(.dvc/plots by default)."
+        "List built-in plots templates or show JSON specification for one."
     )
     plots_templates_parser = plots_subparsers.add_parser(
         "templates",
@@ -367,13 +358,14 @@ def add_parser(subparsers, parent_parser):
         formatter_class=argparse.RawDescriptionHelpFormatter,
     )
     plots_templates_parser.add_argument(
-        "target",
+        "template",
         default=None,
         nargs="?",
-        choices=CmdPlotsTemplates.TEMPLATES_CHOICES,
-        help="Template to write. Writes all templates by default.",
+        help=(
+            "Template for which to show JSON specification. "
+            "List all template names by default."
+        ),
     )
-    _add_output_argument(plots_templates_parser, typ="templates")
     plots_templates_parser.set_defaults(func=CmdPlotsTemplates)
 
 

dvc/commands/queue/remove.py

@@ -3,6 +3,7 @@ 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__)
@@ -11,14 +12,40 @@ logger = logging.getLogger(__name__)
 class CmdQueueRemove(CmdBase):
     """Remove exp in queue."""
 
-    def run(self):
-        removed_list = self.repo.experiments.celery_queue.remove(
-            revs=self.args.task,
-            all_=self.args.all,
-            success=self.args.success,
-            queued=self.args.queued,
-            failed=self.args.failed,
+    def check_arguments(self):
+        clear_flag = any(
+            [
+                self.args.all,
+                self.args.queued,
+                self.args.failed,
+                self.args.success,
+            ]
         )
+        if not (clear_flag ^ bool(self.args.task)):
+            raise InvalidArgumentError(
+                "Either provide an `tasks` argument, or use the "
+                "`--all`, `--queued`, `--failed`, `--success` flag."
+            )
+
+    def run(self):
+
+        self.check_arguments()
+
+        if self.args.all:
+            self.args.queued = True
+            self.args.failed = True
+            self.args.success = True
+
+        if self.args.queued or self.args.failed or self.args.success:
+            removed_list = self.repo.experiments.celery_queue.clear(
+                success=self.args.success,
+                queued=self.args.queued,
+                failed=self.args.failed,
+            )
+        else:
+            removed_list = self.repo.experiments.celery_queue.remove(
+                revs=self.args.task,
+            )
 
         if removed_list:
             removed = ", ".join(removed_list)

dvc/commands/stage.py

@@ -76,7 +76,7 @@ class CmdStageList(CmdBase):
         # removing duplicates while maintaining order
         collected = chain.from_iterable(
             self.repo.stage.collect(
-                target=target, recursive=self.args.recursive, accept_group=True
+                target=target, recursive=self.args.recursive
             )
             for target in self.args.targets
         )

dvc/commands/update.py

@@ -18,6 +18,7 @@ class CmdUpdate(CmdBase):
                 rev=self.args.rev,
                 recursive=self.args.recursive,
                 to_remote=self.args.to_remote,
+                no_download=self.args.no_download,
                 remote=self.args.remote,
                 jobs=self.args.jobs,
             )
@@ -55,6 +56,13 @@ def add_parser(subparsers, parent_parser):
         default=False,
         help="Update all stages in the specified directory.",
     )
+    update_parser.add_argument(
+        "--no-download",
+        action="store_true",
+        default=False,
+        help="Update .dvc file hash value(s)"
+        " but do not download the file(s).",
+    )
     update_parser.add_argument(
         "--to-remote",
         action="store_true",

dvc/config_schema.py

@@ -78,7 +78,9 @@ REMOTE_COMMON = {
     "url": str,
     "checksum_jobs": All(Coerce(int), Range(1)),
     "jobs": All(Coerce(int), Range(1)),
+    Optional("worktree"): Bool,
     Optional("no_traverse"): Bool,  # obsoleted
+    Optional("version_aware"): Bool,
 }
 LOCAL_COMMON = {
     "type": supported_cache_type,
@@ -168,6 +170,7 @@ SCHEMA = {
                 "gs": {
                     "projectname": str,
                     "credentialpath": str,
+                    "endpointurl": str,
                     Optional("verify", default=False): Bool,
                     **REMOTE_COMMON,
                 },
@@ -288,4 +291,9 @@ SCHEMA = {
         "bool": All(Lower, Choices("store_true", "boolean_optional")),
         "list": All(Lower, Choices("nargs", "append")),
     },
+    "hydra": {
+        Optional("enabled", default=False): Bool,
+        "config_dir": str,
+        "config_name": str,
+    },
 }

dvc/data_cloud.py

@@ -3,16 +3,37 @@
 import logging
 from typing import TYPE_CHECKING, Iterable, Optional
 
-from dvc_data.db import get_index
+from funcy import cached_property
+
+from dvc_data.hashfile.db import get_index
 
 if TYPE_CHECKING:
     from dvc_data.hashfile.db import HashFileDB
     from dvc_data.hashfile.hash_info import HashInfo
-    from dvc_data.status import CompareStatusResult
+    from dvc_data.hashfile.status import CompareStatusResult
 
 logger = logging.getLogger(__name__)
 
 
+class Remote:
+    def __init__(self, path, fs, **config):
+        self.path = path
+        self.fs = fs
+
+        self.worktree = config.pop("worktree", False)
+        self.config = config
+
+    @cached_property
+    def odb(self):
+        from dvc_data.hashfile.db import get_odb
+
+        path = self.path
+        if self.worktree:
+            path = self.fs.path.join(path, ".dvc", "cache")
+
+        return get_odb(self.fs, path, **self.config)
+
+
 class DataCloud:
     """Class that manages dvc remotes.
 
@@ -27,18 +48,23 @@ class DataCloud:
     def __init__(self, repo):
         self.repo = repo
 
-    def get_remote_odb(
+    def get_remote(
         self,
         name: Optional[str] = None,
         command: str = "<command>",
-    ) -> "HashFileDB":
+    ) -> "Remote":
         from dvc.config import NoRemoteError
 
         if not name:
             name = self.repo.config["core"].get("remote")
 
         if name:
-            return self._init_odb(name)
+            from dvc.fs import get_cloud_fs
+
+            cls, config, fs_path = get_cloud_fs(self.repo, name=name)
+            fs = cls(**config)
+            config["tmp_dir"] = self.repo.index_db_dir
+            return Remote(fs_path, fs, **config)
 
         if bool(self.repo.config["remote"]):
             error_msg = (
@@ -55,13 +81,13 @@ class DataCloud:
 
         raise NoRemoteError(error_msg)
 
-    def _init_odb(self, name):
-        from dvc.fs import get_cloud_fs
-        from dvc_data.db import get_odb
-
-        cls, config, fs_path = get_cloud_fs(self.repo, name=name)
-        config["tmp_dir"] = self.repo.index_db_dir
-        return get_odb(cls(**config), fs_path, **config)
+    def get_remote_odb(
+        self,
+        name: Optional[str] = None,
+        command: str = "<command>",
+    ) -> "HashFileDB":
+        remote = self.get_remote(name=name, command=command)
+        return remote.odb
 
     def _log_missing(self, status: "CompareStatusResult"):
         if status.missing:
@@ -82,7 +108,7 @@ class DataCloud:
         **kwargs,
     ):
         from dvc.exceptions import FileTransferError
-        from dvc_data.transfer import TransferError, transfer
+        from dvc_data.hashfile.transfer import TransferError, transfer
 
         try:
             return transfer(src_odb, dest_odb, objs, **kwargs)
@@ -164,7 +190,7 @@ class DataCloud:
             log_missing: log warning messages if file doesn't exist
                 neither in cache, neither in cloud.
         """
-        from dvc_data.status import compare_status
+        from dvc_data.hashfile.status import compare_status
 
         if not odb:
             odb = self.get_remote_odb(remote, "status")

dvc/dependency/__init__.py

@@ -18,7 +18,7 @@ SCHEMA: Mapping[str, Any] = {
 }
 
 
-def _get(stage, p, info):
+def _get(stage, p, info, fs_config=None):
     if info and info.get(RepoDependency.PARAM_REPO):
         repo = info.pop(RepoDependency.PARAM_REPO)
         return RepoDependency(repo, stage, p, info)
@@ -27,7 +27,7 @@ def _get(stage, p, info):
         params = info.pop(ParamsDependency.PARAM_PARAMS)
         return ParamsDependency(stage, p, params)
 
-    return Dependency(stage, p, info)
+    return Dependency(stage, p, info, fs_config=fs_config)
 
 
 def loadd_from(stage, d_list):
@@ -38,10 +38,18 @@ def loadd_from(stage, d_list):
     return ret
 
 
-def loads_from(stage, s_list, erepo=None):
+def loads_from(stage, s_list, erepo=None, fs_config=None):
     assert isinstance(s_list, list)
     info = {RepoDependency.PARAM_REPO: erepo} if erepo else {}
-    return [_get(stage, s, info.copy()) for s in s_list]
+    return [
+        _get(
+            stage,
+            s,
+            info.copy(),
+            fs_config=fs_config,
+        )
+        for s in s_list
+    ]
 
 
 def _merge_params(s_list):

dvc/dependency/param.py

@@ -8,7 +8,7 @@ import dpath.util
 from voluptuous import Any
 
 from dvc.exceptions import DvcException
-from dvc.utils.serialize import LOADERS, ParseError
+from dvc.utils.serialize import ParseError, load_path
 from dvc_data.hashfile.hash_info import HashInfo
 
 from .base import Dependency
@@ -39,14 +39,15 @@ class ParamsDependency(Dependency):
 
     def __init__(self, stage, path, params=None, repo=None):
         self.params = list(params) if params else []
-        info = (
-            {self.PARAM_PARAMS: params} if isinstance(params, dict) else None
-        )
+        hash_info = HashInfo()
+        if isinstance(params, dict):
+            hash_info = HashInfo(self.PARAM_PARAMS, params)
         repo = repo or stage.repo
         path = path or os.path.join(repo.root_dir, self.DEFAULT_PARAMS_FILE)
-        super().__init__(stage, path, info=info, repo=repo)
+        super().__init__(stage, path, repo=repo)
+        self.hash_info = hash_info
 
-    def dumpd(self):
+    def dumpd(self, **kwargs):
         ret = super().dumpd()
         if not self.hash_info:
             ret[self.PARAM_PARAMS] = self.params or {}
@@ -139,12 +140,9 @@ class ParamsDependency(Dependency):
             )
 
     def read_file(self):
-        _, ext = os.path.splitext(self.fs_path)
-        loader = LOADERS[ext]
-
         self.validate_filepath()
         try:
-            return loader(self.fs_path, fs=self.repo.fs)
+            return load_path(self.fs_path, self.repo.fs)
         except ParseError as exc:
             raise BadParamFileError(
                 f"Unable to read parameters from '{self}'"

dvc/dependency/repo.py

@@ -59,11 +59,11 @@ class RepoDependency(Dependency):
     def save(self):
         pass
 
-    def dumpd(self):
+    def dumpd(self, **kwargs):
         return {self.PARAM_PATH: self.def_path, self.PARAM_REPO: self.def_repo}
 
     def download(self, to, jobs=None):
-        from dvc_data.checkout import checkout
+        from dvc_data.hashfile.checkout import checkout
 
         for odb, objs in self.get_used_objs().items():
             self.repo.cloud.pull(objs, jobs=jobs, odb=odb)
@@ -103,14 +103,12 @@ class RepoDependency(Dependency):
         from dvc.config import NoRemoteError
         from dvc.exceptions import NoOutputOrStageError, PathMissingError
         from dvc.utils import as_posix
-        from dvc_data.build import build
-        from dvc_data.objects.tree import Tree, TreeError
+        from dvc_data.hashfile.build import build
+        from dvc_data.hashfile.tree import Tree, TreeError
 
         local_odb = self.repo.odb.local
         locked = kwargs.pop("locked", True)
-        with self._make_repo(
-            locked=locked, cache_dir=local_odb.cache_dir
-        ) as repo:
+        with self._make_repo(locked=locked, cache_dir=local_odb.path) as repo:
             used_obj_ids = defaultdict(set)
             rev = repo.get_rev()
             if locked and self.def_repo.get(self.PARAM_REV_LOCK) is None:
@@ -155,8 +153,8 @@ class RepoDependency(Dependency):
     def _check_circular_import(self, odb, obj_ids):
         from dvc.exceptions import CircularImportError
         from dvc.fs.dvc import DvcFileSystem
-        from dvc_data.db.reference import ReferenceHashFileDB
-        from dvc_data.objects.tree import Tree
+        from dvc_data.hashfile.db.reference import ReferenceHashFileDB
+        from dvc_data.hashfile.tree import Tree
 
         if not isinstance(odb, ReferenceHashFileDB):
             return

dvc/dvcfile.py

@@ -198,7 +198,7 @@ class SingleStageFile(FileMixin):
         if self.verify:
             check_dvcfile_path(self.repo, self.path)
         logger.debug("Saving information to '%s'.", relpath(self.path))
-        dump_yaml(self.path, serialize.to_single_stage_file(stage))
+        dump_yaml(self.path, serialize.to_single_stage_file(stage, **kwargs))
         self.repo.scm_context.track_file(self.relpath)
 
     def remove_stage(self, stage):  # pylint: disable=unused-argument
@@ -243,9 +243,11 @@ class PipelineFile(FileMixin):
         self._lockfile.dump(stage)
 
     @staticmethod
-    def _check_if_parametrized(stage):
+    def _check_if_parametrized(stage, action: str = "dump") -> None:
         if stage.raw_data.parametrized:
-            raise ParametrizedDumpError(f"cannot dump a parametrized {stage}")
+            raise ParametrizedDumpError(
+                f"cannot {action} a parametrized {stage}"
+            )
 
     def _dump_pipeline_file(self, stage):
         self._check_if_parametrized(stage)
@@ -291,6 +293,7 @@ class PipelineFile(FileMixin):
         self._lockfile.remove()
 
     def remove_stage(self, stage):
+        self._check_if_parametrized(stage, "remove")
         self._lockfile.remove_stage(stage)
         if not self.exists():
             return

dvc/external_repo.py

@@ -145,7 +145,7 @@ def _get_remote_config(url):
             name = "auto-generated-upstream"
             return {
                 "core": {"remote": name},
-                "remote": {name: {"url": repo.odb.local.cache_dir}},
+                "remote": {name: {"url": repo.odb.local.path}},
             }
 
         # Use original remote to make sure that we are using correct url,

dvc/fs/__init__.py

@@ -1,26 +1,18 @@
 from urllib.parse import urlparse
 
+from dvc_http import HTTPFileSystem, HTTPSFileSystem  # noqa: F401
+
 # pylint: disable=unused-import
 from dvc_objects.fs import utils  # noqa: F401
 from dvc_objects.fs import (  # noqa: F401
-    FS_MAP,
-    AzureFileSystem,
-    GDriveFileSystem,
-    GSFileSystem,
-    HDFSFileSystem,
-    HTTPFileSystem,
-    HTTPSFileSystem,
     LocalFileSystem,
     MemoryFileSystem,
-    OSSFileSystem,
-    S3FileSystem,
     Schemes,
-    SSHFileSystem,
-    WebDAVFileSystem,
-    WebDAVSFileSystem,
-    WebHDFSFileSystem,
     generic,
     get_fs_cls,
+    known_implementations,
+    localfs,
+    registry,
     system,
 )
 from dvc_objects.fs.base import AnyFSPath, FileSystem  # noqa: F401
@@ -29,17 +21,26 @@ from dvc_objects.fs.errors import (  # noqa: F401
     ConfigError,
     RemoteMissingDepsError,
 )
-from dvc_objects.fs.implementations.azure import AzureAuthError  # noqa: F401
-from dvc_objects.fs.implementations.local import localfs  # noqa: F401
-from dvc_objects.fs.implementations.ssh import (  # noqa: F401
-    DEFAULT_PORT as DEFAULT_SSH_PORT,
-)
 from dvc_objects.fs.path import Path  # noqa: F401
 
 from .data import DataFileSystem  # noqa: F401
 from .dvc import DvcFileSystem  # noqa: F401
 from .git import GitFileSystem  # noqa: F401
 
+known_implementations.update(
+    {
+        "dvc": {
+            "class": "dvc.fs.dvc.DvcFileSystem",
+            "err": "dvc is supported, but requires 'dvc' to be installed",
+        },
+        "git": {
+            "class": "dvc.fs.git.GitFileSystem",
+            "err": "git is supported, but requires 'dvc' to be installed",
+        },
+    }
+)
+
+
 # pylint: enable=unused-import
 
 
@@ -110,11 +111,8 @@ def get_cloud_fs(repo, **kwargs):
 
     cls = get_fs_cls(remote_conf)
 
-    if cls == GDriveFileSystem and repo:
-        remote_conf["gdrive_credentials_tmp_dir"] = repo.tmp_dir
-
     url = remote_conf.pop("url")
-    if issubclass(cls, WebDAVFileSystem):
+    if cls.protocol in ["webdav", "webdavs"]:
         # For WebDAVFileSystem, provided url is the base path itself, so it
         # should be treated as being a root path.
         fs_path = cls.root_marker

dvc/fs/data.py

@@ -1,183 +1,16 @@
 import logging
+import os
 import threading
-import typing
 
-from fsspec import AbstractFileSystem
 from funcy import cached_property, wrap_prop
 
+from dvc.utils import as_posix
+from dvc_data.fs import DataFileSystem as _DataFileSystem
 from dvc_objects.fs.base import FileSystem
-from dvc_objects.fs.callbacks import DEFAULT_CALLBACK
-
-if typing.TYPE_CHECKING:
-    from dvc.types import AnyPath
 
 logger = logging.getLogger(__name__)
 
 
-class _DataFileSystem(AbstractFileSystem):  # pylint:disable=abstract-method
-    """DVC repo fs.
-
-    Args:
-        repo: DVC repo.
-    """
-
-    root_marker = "/"
-
-    def __init__(self, workspace=None, **kwargs):
-        super().__init__(**kwargs)
-        self.repo = kwargs["repo"]
-        self.workspace = workspace or "repo"
-
-    @cached_property
-    def path(self):
-        from . import Path
-
-        def _getcwd():
-            return self.root_marker
-
-        return Path(self.sep, getcwd=_getcwd)
-
-    @property
-    def config(self):
-        raise NotImplementedError
-
-    def _get_key(self, path):
-        if self.workspace != "repo":
-            from . import get_cloud_fs
-
-            cls, kwargs, fs_path = get_cloud_fs(None, url=path)
-            fs = cls(**kwargs)
-            return (self.workspace, *fs.path.parts(fs_path))
-
-        path = self.path.abspath(path)
-        if path == self.root_marker:
-            return (self.workspace,)
-
-        key = self.path.relparts(path, self.root_marker)
-        if key == (".") or key == (""):
-            key = ()
-
-        return (self.workspace, *key)
-
-    def _get_fs_path(self, path: "AnyPath", remote=None):
-        from dvc.config import NoRemoteError
-
-        info = self.info(path)
-        if info["type"] == "directory":
-            raise IsADirectoryError
-
-        value = info.get("md5")
-        if not value:
-            raise FileNotFoundError
-
-        cache_path = self.repo.odb.local.oid_to_path(value)
-
-        if self.repo.odb.local.fs.exists(cache_path):
-            return self.repo.odb.local.fs, cache_path
-
-        try:
-            remote_odb = self.repo.cloud.get_remote_odb(remote)
-        except NoRemoteError as exc:
-            raise FileNotFoundError from exc
-        remote_fs_path = remote_odb.oid_to_path(value)
-        return remote_odb.fs, remote_fs_path
-
-    def open(  # type: ignore
-        self, path: str, mode="r", encoding=None, **kwargs
-    ):  # pylint: disable=arguments-renamed, arguments-differ
-        fs, fspath = self._get_fs_path(path, **kwargs)
-        return fs.open(fspath, mode=mode, encoding=encoding)
-
-    def ls(self, path, detail=True, **kwargs):
-        info = self.info(path)
-        if info["type"] != "directory":
-            return [info] if detail else [path]
-
-        root_key = self._get_key(path)
-        try:
-            entries = [
-                self.sep.join((path, name)) if path else name
-                for name in self.repo.index.tree.ls(prefix=root_key)
-            ]
-        except KeyError as exc:
-            raise FileNotFoundError from exc
-
-        if not detail:
-            return entries
-
-        return [self.info(epath) for epath in entries]
-
-    def isdvc(self, path, recursive=False, strict=True):
-        try:
-            info = self.info(path)
-        except FileNotFoundError:
-            return False
-
-        recurse = recursive or not strict
-        return bool(info.get("outs") if recurse else info.get("isout"))
-
-    def info(self, path, **kwargs):
-        from dvc_data.hashfile.meta import Meta
-
-        key = self._get_key(path)
-
-        try:
-            outs = list(self.repo.index.tree.iteritems(key))  # noqa: B301
-        except KeyError as exc:
-            raise FileNotFoundError from exc
-
-        ret = {
-            "type": "file",
-            "size": 0,
-            "isexec": False,
-            "isdvc": False,
-            "outs": outs,
-            "name": path,
-        }
-
-        if len(outs) > 1 and outs[0][0] != key:
-            shortest = self.repo.index.tree.shortest_prefix(key)
-            if shortest:
-                assert shortest[1][1].isdir
-                if len(shortest[0]) <= len(key):
-                    ret["isdvc"] = True
-
-            ret["type"] = "directory"
-            return ret
-
-        item_key, (meta, hash_info) = outs[0]
-
-        meta = meta or Meta()
-
-        if key != item_key:
-            assert item_key[: len(key)] == key
-            ret["type"] = "directory"
-            return ret
-
-        ret["size"] = meta.size
-        ret["isexec"] = meta.isexec
-        ret[hash_info.name] = hash_info.value
-        ret["isdvc"] = True
-        ret["isout"] = True
-        ret["meta"] = meta
-        if hash_info and hash_info.isdir:
-            ret["type"] = "directory"
-        return ret
-
-    def get_file(  # pylint: disable=arguments-differ
-        self, rpath, lpath, callback=DEFAULT_CALLBACK, **kwargs
-    ):
-        fs, path = self._get_fs_path(rpath)
-        fs.get_file(path, lpath, callback=callback, **kwargs)
-
-    def checksum(self, path):
-        info = self.info(path)
-        md5 = info.get("md5")
-        if md5:
-            return md5
-        raise NotImplementedError
-
-
 class DataFileSystem(FileSystem):
     protocol = "local"
 
@@ -194,6 +27,8 @@ class DataFileSystem(FileSystem):
     def isdvc(self, path, **kwargs):
         return self.fs.isdvc(path, **kwargs)
 
-    @property
-    def repo(self):
-        return self.fs.repo
+    def from_os_path(self, path):
+        if os.path.isabs(path):
+            path = os.path.splitdrive(path)[1]
+
+        return as_posix(path)

dvc/fs/dvc.py

@@ -4,8 +4,7 @@ import os
 import posixpath
 import threading
 from contextlib import suppress
-from itertools import takewhile
-from typing import TYPE_CHECKING, Callable, Optional, Tuple, Type, Union
+from typing import TYPE_CHECKING, Any, Callable, Optional, Tuple, Type, Union
 
 from fsspec.spec import AbstractFileSystem
 from funcy import cached_property, wrap_prop, wrap_with
@@ -22,29 +21,19 @@ if TYPE_CHECKING:
 logger = logging.getLogger(__name__)
 
 RepoFactory = Union[Callable[[str], "Repo"], Type["Repo"]]
+Key = Tuple[str, ...]
 
 
 def as_posix(path: str) -> str:
     return path.replace(ntpath.sep, posixpath.sep)
 
 
-def _wrap_walk(dvc_fs, *args, **kwargs):
-    for root, dnames, fnames in dvc_fs.walk(*args, **kwargs):
-        yield dvc_fs.path.join(dvc_fs.repo.root_dir, root), dnames, fnames
+# NOT the same as dvc.dvcfile.is_dvc_file()!
+def _is_dvc_file(fname):
+    from dvc.dvcfile import is_valid_filename
+    from dvc.ignore import DvcIgnore
 
-
-def _ls(fs, path):
-    dnames = []
-    fnames = []
-
-    for entry in fs.ls(path, detail=True):
-        name = fs.path.name(entry["name"])
-        if entry["type"] == "directory":
-            dnames.append(name)
-        else:
-            fnames.append(name)
-
-    return dnames, fnames
+    return is_valid_filename(fname) or fname == DvcIgnore.DVCIGNORE_FILE
 
 
 def _merge_info(repo, fs_info, dvc_info):
@@ -70,6 +59,10 @@ def _merge_info(repo, fs_info, dvc_info):
     return ret
 
 
+def _get_dvc_path(dvc_fs, subkey):
+    return dvc_fs.path.join(*subkey) if subkey else ""
+
+
 class _DvcFileSystem(AbstractFileSystem):  # pylint:disable=abstract-method
     """DVC + git-tracked files fs.
 
@@ -82,28 +75,25 @@ class _DvcFileSystem(AbstractFileSystem):  # pylint:disable=abstract-method
 
     root_marker = "/"
 
-    PARAM_REPO_URL = "repo_url"
-    PARAM_REPO_ROOT = "repo_root"
-    PARAM_REV = "rev"
-    PARAM_CACHE_DIR = "cache_dir"
-    PARAM_CACHE_TYPES = "cache_types"
-    PARAM_SUBREPOS = "subrepos"
-
     def __init__(
         self,
+        url: Optional[str] = None,
+        rev: Optional[str] = None,
         repo: Optional["Repo"] = None,
-        subrepos=False,
-        repo_factory: RepoFactory = None,
-        **kwargs,
-    ):
-        super().__init__()
-
+        subrepos: bool = False,
+        repo_factory: Optional[RepoFactory] = None,
+        **repo_kwargs: Any,
+    ) -> None:
         from pygtrie import Trie
 
+        super().__init__()
         if repo is None:
-            repo, repo_factory = self._repo_from_fs_config(
-                subrepos=subrepos, **kwargs
+            repo = self._make_repo(
+                url=url, rev=rev, subrepos=subrepos, **repo_kwargs
             )
+            assert repo
+            # pylint: disable=protected-access
+            repo_factory = repo._fs_conf["repo_factory"]
 
         if not repo_factory:
             from dvc.repo import Repo
@@ -135,82 +125,37 @@ class _DvcFileSystem(AbstractFileSystem):  # pylint:disable=abstract-method
         """Keep a datafs instance of each repo."""
 
         if hasattr(repo, "dvc_dir"):
-            self._datafss[key] = DataFileSystem(repo=repo)
+            self._datafss[key] = DataFileSystem(index=repo.index.data["repo"])
 
-    def _get_key(self, path):
+    def _get_key(self, path) -> Key:
         parts = self.repo.fs.path.relparts(path, self.repo.root_dir)
         if parts == (".",):
             parts = ()
         return parts
 
+    def _get_key_from_relative(self, path) -> Key:
+        parts = self.path.relparts(path, self.root_marker)
+        if parts and parts[0] == os.curdir:
+            parts = parts[1:]
+        return parts
+
+    def _from_key(self, parts: Key) -> str:
+        return self.repo.fs.path.join(self.repo.root_dir, *parts)
+
     @property
     def repo_url(self):
         if self.repo is None:
             return None
         return self.repo.url
 
-    @property
-    def config(self):
-        return {
-            self.PARAM_REPO_URL: self.repo_url,
-            self.PARAM_REPO_ROOT: self.repo.root_dir,
-            self.PARAM_REV: getattr(self.repo.fs, "rev", None),
-            self.PARAM_CACHE_DIR: os.path.abspath(
-                self.repo.odb.local.cache_dir
-            ),
-            self.PARAM_CACHE_TYPES: self.repo.odb.local.cache_types,
-            self.PARAM_SUBREPOS: self._traverse_subrepos,
-        }
-
     @classmethod
-    def _repo_from_fs_config(
-        cls, **config
-    ) -> Tuple["Repo", Optional["RepoFactory"]]:
-        from dvc.external_repo import erepo_factory, external_repo
+    def _make_repo(cls, **kwargs) -> "Repo":
         from dvc.repo import Repo
 
-        url = config.get(cls.PARAM_REPO_URL)
-        root = config.get(cls.PARAM_REPO_ROOT)
-        assert url or root
+        with Repo.open(uninitialized=True, **kwargs) as repo:
+            return repo
 
-        def _open(*args, **kwargs):
-            # NOTE: if original repo was an erepo (and has a URL),
-            # we cannot use Repo.open() since it will skip erepo
-            # cache/remote setup for local URLs
-            if url is None:
-                return Repo.open(*args, **kwargs)
-            return external_repo(*args, **kwargs)
-
-        cache_dir = config.get(cls.PARAM_CACHE_DIR)
-        cache_config = (
-            {}
-            if not cache_dir
-            else {
-                "cache": {
-                    "dir": cache_dir,
-                    "type": config.get(cls.PARAM_CACHE_TYPES),
-                }
-            }
-        )
-        repo_kwargs: dict = {
-            "rev": config.get(cls.PARAM_REV),
-            "subrepos": config.get(cls.PARAM_SUBREPOS, False),
-            "uninitialized": True,
-        }
-        factory: Optional["RepoFactory"] = None
-        if url is None:
-            repo_kwargs["config"] = cache_config
-        else:
-            repo_kwargs["cache_dir"] = cache_dir
-            factory = erepo_factory(url, root, cache_config)
-
-        with _open(
-            url if url else root,
-            **repo_kwargs,
-        ) as repo:
-            return repo, factory
-
-    def _get_repo(self, path: str) -> "Repo":
+    def _get_repo(self, key: Key) -> "Repo":
         """Returns repo that the path falls in, using prefix.
 
         If the path is already tracked/collected, it just returns the repo.
@@ -218,33 +163,21 @@ class _DvcFileSystem(AbstractFileSystem):  # pylint:disable=abstract-method
         Otherwise, it collects the repos that might be in the path's parents
         and then returns the appropriate one.
         """
-        if not self.repo.fs.path.isin_or_eq(path, self.repo.root_dir):
-            # outside of repo
-            return self.repo
-
-        key = self._get_key(path)
         repo = self._subrepos_trie.get(key)
         if repo:
             return repo
 
         prefix_key, repo = self._subrepos_trie.longest_prefix(key)
-        prefix = self.repo.fs.path.join(
-            self.repo.root_dir,
-            *prefix_key,  # pylint: disable=not-an-iterable
-        )
-
-        parents = (parent for parent in self.repo.fs.path.parents(path))
-        dirs = [path] + list(takewhile(lambda p: p != prefix, parents))
-        dirs.reverse()
-        self._update(dirs, starting_repo=repo)
+        dir_keys = (key[:i] for i in range(len(prefix_key) + 1, len(key) + 1))
+        self._update(dir_keys, starting_repo=repo)
         return self._subrepos_trie.get(key) or self.repo
 
     @wrap_with(threading.Lock())
-    def _update(self, dirs, starting_repo):
+    def _update(self, dir_keys, starting_repo):
         """Checks for subrepo in directories and updates them."""
         repo = starting_repo
-        for d in dirs:
-            key = self._get_key(d)
+        for key in dir_keys:
+            d = self._from_key(key)
             if self._is_dvc_repo(d):
                 repo = self.repo_factory(
                     d,
@@ -252,7 +185,9 @@ class _DvcFileSystem(AbstractFileSystem):  # pylint:disable=abstract-method
                     scm=self.repo.scm,
                     repo_factory=self.repo_factory,
                 )
-                self._datafss[key] = DataFileSystem(repo=repo)
+                self._datafss[key] = DataFileSystem(
+                    index=repo.index.data["repo"]
+                )
             self._subrepos_trie[key] = repo
 
     def _is_dvc_repo(self, dir_path):
@@ -265,79 +200,64 @@ class _DvcFileSystem(AbstractFileSystem):  # pylint:disable=abstract-method
         repo_path = self.repo.fs.path.join(dir_path, Repo.DVC_DIR)
         return self.repo.fs.isdir(repo_path)
 
-    def _get_fs_pair(
-        self, path
-    ) -> Tuple[
-        Optional[FileSystem],
-        Optional[str],
-        Optional[DataFileSystem],
-        Optional[str],
-    ]:
+    def _get_subrepo_info(
+        self, key: Key
+    ) -> Tuple["Repo", Optional[DataFileSystem], Key]:
         """
-        Returns a pair of fss based on repo the path falls in, using prefix.
+        Returns information about the subrepo the key is part of.
         """
-        parts = self.path.relparts(path, self.root_marker)
-        if parts and parts[0] == os.curdir:
-            parts = parts[1:]
-
-        fs_path = self.repo.fs.path.join(self.repo.root_dir, *parts)
-        repo = self._get_repo(fs_path)
-        fs = repo.fs
-
-        repo_parts = fs.path.relparts(repo.root_dir, self.repo.root_dir)
-        if repo_parts[0] == os.curdir:
-            repo_parts = repo_parts[1:]
-
-        dvc_parts = parts[len(repo_parts) :]
-        if dvc_parts and dvc_parts[0] == os.curdir:
-            dvc_parts = dvc_parts[1:]
-
-        key = self._get_key(repo.root_dir)
-        dvc_fs = self._datafss.get(key)
-        if dvc_fs:
-            dvc_path = dvc_fs.path.join(*dvc_parts) if dvc_parts else ""
+        repo = self._get_repo(key)
+        repo_key: Key
+        if repo is self.repo:
+            repo_key = ()
+            subkey = key
         else:
-            dvc_path = None
+            repo_key = self._get_key(repo.root_dir)
+            subkey = key[len(repo_key) :]
 
-        return fs, fs_path, dvc_fs, dvc_path
+        dvc_fs = self._datafss.get(repo_key)
+        return repo, dvc_fs, subkey
 
-    def open(
-        self, path, mode="r", encoding="utf-8", **kwargs
+    def _open(
+        self, path, mode="rb", **kwargs
     ):  # pylint: disable=arguments-renamed, arguments-differ
-        if "b" in mode:
-            encoding = None
-
-        fs, fs_path, dvc_fs, dvc_path = self._get_fs_pair(path)
+        key = self._get_key_from_relative(path)
+        fs_path = self._from_key(key)
         try:
-            return fs.open(fs_path, mode=mode, encoding=encoding)
+            return self.repo.fs.open(fs_path, mode=mode)
         except FileNotFoundError:
+            _, dvc_fs, subkey = self._get_subrepo_info(key)
             if not dvc_fs:
                 raise
 
-        return dvc_fs.open(dvc_path, mode=mode, encoding=encoding, **kwargs)
+        dvc_path = _get_dvc_path(dvc_fs, subkey)
+        return dvc_fs.open(dvc_path, mode=mode)
 
     def isdvc(self, path, **kwargs):
-        _, _, dvc_fs, dvc_path = self._get_fs_pair(path)
+        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
         self, path, detail=True, dvc_only=False, **kwargs
     ):
-        fs, fs_path, dvc_fs, dvc_path = self._get_fs_pair(path)
-
-        repo = dvc_fs.repo if dvc_fs else self.repo
-        dvcignore = repo.dvcignore
-        ignore_subrepos = kwargs.get("ignore_subrepos", True)
+        key = self._get_key_from_relative(path)
+        repo, dvc_fs, subkey = self._get_subrepo_info(key)
 
         names = set()
         if dvc_fs:
             with suppress(FileNotFoundError):
+                dvc_path = _get_dvc_path(dvc_fs, subkey)
                 for entry in dvc_fs.ls(dvc_path, detail=False):
                     names.add(dvc_fs.path.name(entry))
 
-        if not dvc_only and fs:
+        ignore_subrepos = kwargs.get("ignore_subrepos", True)
+        if not dvc_only:
+            fs = self.repo.fs
+            fs_path = self._from_key(key)
             try:
-                for entry in dvcignore.ls(
+                for entry in repo.dvcignore.ls(
                     fs, fs_path, detail=False, ignore_subrepos=ignore_subrepos
                 ):
                     names.add(fs.path.name(entry))
@@ -345,26 +265,21 @@ class _DvcFileSystem(AbstractFileSystem):  # pylint:disable=abstract-method
                 pass
 
         dvcfiles = kwargs.get("dvcfiles", False)
-
-        def _func(fname):
-            from dvc.dvcfile import is_valid_filename
-            from dvc.ignore import DvcIgnore
-
-            if dvcfiles:
-                return True
-
-            return not (
-                is_valid_filename(fname) or fname == DvcIgnore.DVCIGNORE_FILE
-            )
-
-        names = filter(_func, names)
+        if not dvcfiles:
+            names = (name for name in names if not _is_dvc_file(name))
 
         infos = []
         paths = []
         for name in names:
             entry_path = self.path.join(path, name)
+            entry_key = key + (name,)
             try:
-                info = self.info(entry_path, ignore_subrepos=ignore_subrepos)
+                info = self._info(
+                    entry_key,
+                    entry_path,
+                    ignore_subrepos=ignore_subrepos,
+                    check_ignored=False,
+                )
             except FileNotFoundError:
                 continue
             infos.append(info)
@@ -378,46 +293,52 @@ class _DvcFileSystem(AbstractFileSystem):  # pylint:disable=abstract-method
     def get_file(  # pylint: disable=arguments-differ
         self, rpath, lpath, callback=DEFAULT_CALLBACK, **kwargs
     ):
-        fs, fs_path, dvc_fs, dvc_path = self._get_fs_pair(rpath)
-
-        if fs:
-            try:
-                fs.get_file(fs_path, lpath, callback=callback, **kwargs)
-                return
-            except FileNotFoundError:
-                if not dvc_fs:
-                    raise
+        key = self._get_key_from_relative(rpath)
+        fs_path = self._from_key(key)
+        fs = self.repo.fs
+        try:
+            fs.get_file(fs_path, lpath, callback=callback, **kwargs)
+            return
+        except FileNotFoundError:
+            _, dvc_fs, subkey = self._get_subrepo_info(key)
+            if not dvc_fs:
+                raise
+        dvc_path = _get_dvc_path(dvc_fs, subkey)
         dvc_fs.get_file(dvc_path, lpath, callback=callback, **kwargs)
 
     def info(self, path, **kwargs):
-        fs, fs_path, dvc_fs, dvc_path = self._get_fs_pair(path)
-
-        repo = dvc_fs.repo if dvc_fs else self.repo
-        dvcignore = repo.dvcignore
+        key = self._get_key_from_relative(path)
         ignore_subrepos = kwargs.get("ignore_subrepos", True)
+        return self._info(key, path, ignore_subrepos=ignore_subrepos)
+
+    def _info(self, key, path, ignore_subrepos=True, check_ignored=True):
+        repo, dvc_fs, subkey = self._get_subrepo_info(key)
 
         dvc_info = None
         if dvc_fs:
             try:
-                dvc_info = dvc_fs.info(dvc_path)
+                dvc_info = dvc_fs.fs.index.info(subkey)
+                dvc_path = _get_dvc_path(dvc_fs, subkey)
+                dvc_info["name"] = dvc_path
             except FileNotFoundError:
                 pass
 
         fs_info = None
-        if fs:
-            try:
-                fs_info = fs.info(fs_path)
-                if dvcignore.is_ignored(
-                    fs, fs_path, ignore_subrepos=ignore_subrepos
-                ):
-                    fs_info = None
-            except (FileNotFoundError, NotADirectoryError):
-                if not dvc_info:
-                    raise
+        fs = self.repo.fs
+        fs_path = self._from_key(key)
+        try:
+            fs_info = fs.info(fs_path)
+            if check_ignored and repo.dvcignore.is_ignored(
+                fs, fs_path, ignore_subrepos=ignore_subrepos
+            ):
+                fs_info = None
+        except (FileNotFoundError, NotADirectoryError):
+            if not dvc_info:
+                raise
 
         # NOTE: if some parent in fs_path turns out to be a file, it means
         # that the whole repofs branch doesn't exist.
-        if fs and not fs_info and dvc_info:
+        if dvc_info and not fs_info:
             for parent in fs.path.parents(fs_path):
                 try:
                     if fs.info(parent)["type"] != "directory":
@@ -433,14 +354,6 @@ class _DvcFileSystem(AbstractFileSystem):  # pylint:disable=abstract-method
         info["name"] = path
         return info
 
-    def checksum(self, path):
-        fs, fs_path, dvc_fs, dvc_path = self._get_fs_pair(path)
-
-        try:
-            return fs.checksum(fs_path)
-        except FileNotFoundError:
-            return dvc_fs.checksum(dvc_path)
-
 
 class DvcFileSystem(FileSystem):
     protocol = "local"
@@ -469,10 +382,6 @@ class DvcFileSystem(FileSystem):
     def repo_url(self):
         return self.fs.repo_url
 
-    @property
-    def config(self):
-        return self.fs.config
-
     def from_os_path(self, path):
         if os.path.isabs(path):
             path = os.path.relpath(path, self.repo.root_dir)

dvc/fs/git.py

@@ -15,6 +15,7 @@ class GitFileSystem(FileSystem):  # pylint:disable=abstract-method
     """Proxies the repo file access methods to Git objects"""
 
     protocol = "local"
+    PARAM_CHECKSUM = "md5"
 
     def __init__(
         self,

dvc/info.py

@@ -8,12 +8,20 @@ import psutil
 
 from dvc import __version__
 from dvc.exceptions import NotDvcRepoError
-from dvc.fs import FS_MAP, generic, get_fs_cls, get_fs_config
+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",
+    "dvc_objects",
+    "dvc_render",
+    "dvc_task",
+    "dvclive",
+    "scmrepo",
+)
 package = "" if PKG is None else f"({PKG})"
 
 
@@ -23,6 +31,7 @@ def get_dvc_info():
         "---------------------------------",
         f"Platform: Python {platform.python_version()} on "
         f"{platform.platform()}",
+        f"Subprojects:{_get_subprojects()}",
         f"Supports:{_get_supported_remotes()}",
     ]
 
@@ -32,9 +41,9 @@ def get_dvc_info():
             # can't auto-create it, as it might cause issues if the user
             # later decides to enable shared cache mode with
             # `dvc config cache.shared group`.
-            if os.path.exists(repo.odb.local.cache_dir):
+            if os.path.exists(repo.odb.local.path):
                 info.append(f"Cache types: {_get_linktype_support_info(repo)}")
-                fs_type = get_fs_type(repo.odb.local.cache_dir)
+                fs_type = get_fs_type(repo.odb.local.path)
                 info.append(f"Cache directory: {fs_type}")
             else:
                 info.append("Cache types: " + error_link("no-dvc-cache"))
@@ -58,7 +67,7 @@ def _get_caches(cache):
     caches = (
         cache_type
         for cache_type, cache_instance in cache.by_scheme()
-        if cache_instance
+        if cache_instance and cache_type != "repo"
     )
 
     # Caches will be always non-empty including the local cache
@@ -88,9 +97,29 @@ def _get_linktype_support_info(repo):
     return ", ".join(links)
 
 
+def _get_subprojects():
+    subprojects = []
+    for subproject in SUBPROJECTS:
+        try:
+            version = importlib_metadata.version(subproject)
+            subprojects.append(f"{subproject} = {version}")
+        except ImportError:
+            pass
+
+    return "\n\t" + "\n\t".join(subprojects)
+
+
 def _get_supported_remotes():
     supported_remotes = []
-    for scheme, fs_cls in FS_MAP.items():
+    for scheme in registry:
+        if scheme in [Schemes.LOCAL, Schemes.MEMORY, "dvc", "git"]:
+            continue
+
+        try:
+            fs_cls = registry[scheme]
+        except ImportError:
+            continue
+
         if not fs_cls.get_missing_deps():
             dependencies = []
             for requirement in fs_cls.REQUIRES:

dvc/lock.py

@@ -70,6 +70,8 @@ class LockNoop(LockBase):
         self._lock = True
 
     def unlock(self):
+        if not self.is_locked:
+            raise DvcException("Unlock called on an unlocked lock")
         self._lock = False
 
     @property
@@ -93,6 +95,7 @@ class Lock(LockBase):
         super().__init__(lockfile)
         self._friendly = friendly
         self._lock = None
+        self._lock_failed = False
 
     @property
     def files(self):
@@ -100,6 +103,7 @@ class Lock(LockBase):
 
     def _do_lock(self):
         try:
+            self._lock_failed = False
             with Tqdm(
                 bar_format="{desc}",
                 disable=not self._friendly,
@@ -111,6 +115,7 @@ class Lock(LockBase):
             ):
                 self._lock = zc.lockfile.LockFile(self._lockfile)
         except zc.lockfile.LockError:
+            self._lock_failed = True
             raise LockError(FAILED_TO_LOCK_MESSAGE)
 
     def lock(self):
@@ -120,6 +125,12 @@ class Lock(LockBase):
         lock_retry()
 
     def unlock(self):
+        if self._lock_failed:
+            assert self._lock is None
+            return
+
+        if not self.is_locked:
+            raise DvcException("Unlock called on an unlocked lock")
         self._lock.close()
         self._lock = None
 

dvc/machine/backend/base.py

@@ -3,7 +3,8 @@ from contextlib import contextmanager
 from typing import TYPE_CHECKING, Iterator, Optional
 
 if TYPE_CHECKING:
-    from dvc.fs import SSHFileSystem
+    from dvc_ssh import SSHFileSystem
+
     from dvc.types import StrPath
 
 

dvc/machine/backend/terraform.py

@@ -3,8 +3,9 @@ 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 dvc.fs import DEFAULT_SSH_PORT, SSHFileSystem
 from dvc.utils.fs import makedirs
 
 from .base import BaseMachineBackend
@@ -68,7 +69,7 @@ class TerraformBackend(BaseMachineBackend):
             resource = tpi.default_resource(name)
         return {
             "host": resource["instance_ip"],
-            "port": DEFAULT_SSH_PORT,
+            "port": DEFAULT_PORT,
             "username": "ubuntu",
             "fs_factory": partial(_sshfs, dict(resource)),
         }

dvc/odbmgr.py

@@ -1,8 +1,8 @@
-from dvc.fs import Schemes
-from dvc_data.db import get_odb
+from dvc.fs import GitFileSystem, Schemes
+from dvc_data.hashfile.db import get_odb
 
 
-def _get_odb(repo, settings):
+def _get_odb(repo, settings, fs=None):
     from dvc.fs import get_cloud_fs
 
     if not settings:
@@ -10,7 +10,8 @@ def _get_odb(repo, settings):
 
     cls, config, fs_path = get_cloud_fs(repo, **settings)
     config["tmp_dir"] = repo.tmp_dir
-    return get_odb(cls(**config), fs_path, state=repo.state, **config)
+    fs = fs or cls(**config)
+    return get_odb(fs, fs_path, state=repo.state, **config)
 
 
 class ODBManager:
@@ -24,7 +25,7 @@ class ODBManager:
     ]
 
     def __init__(self, repo):
-        self.repo = repo
+        self._repo = repo
         self.config = config = repo.config["cache"]
         self._odb = {}
 
@@ -42,13 +43,19 @@ class ODBManager:
                 if opt in config:
                     settings[str(opt)] = config.get(opt)
 
-        self._odb[Schemes.LOCAL] = _get_odb(repo, settings)
+        kwargs = {}
+        if not isinstance(repo.fs, GitFileSystem):
+            kwargs["fs"] = repo.fs
+
+        odb = _get_odb(repo, settings, **kwargs)
+        self._odb["repo"] = odb
+        self._odb[Schemes.LOCAL] = odb
 
     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)
+            self._odb[scheme] = _get_odb(self._repo, settings)
 
     def __getattr__(self, name):
         if name not in self._odb and name in self.CLOUD_SCHEMES:

dvc/output.py

@@ -1,10 +1,10 @@
 import logging
 import os
 from collections import defaultdict
-from typing import TYPE_CHECKING, Dict, Optional, Set, Type
+from typing import TYPE_CHECKING, Dict, List, Optional, Set, Tuple, Type
 from urllib.parse import urlparse
 
-from funcy import collecting, project
+from funcy import cached_property, collecting, project
 from voluptuous import And, Any, Coerce, Length, Lower, Required, SetTo
 
 from dvc import prompt
@@ -17,29 +17,25 @@ from dvc.exceptions import (
     MergeError,
     RemoteCacheRequiredError,
 )
-from dvc_data import Tree
-from dvc_data import check as ocheck
-from dvc_data import load as oload
-from dvc_data.build import build
-from dvc_data.checkout import checkout
+from dvc_data.hashfile import Tree
+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.hash_info import HashInfo
 from dvc_data.hashfile.istextfile import istextfile
 from dvc_data.hashfile.meta import Meta
-from dvc_data.transfer import transfer as otransfer
+from dvc_data.hashfile.transfer import transfer as otransfer
 from dvc_objects.errors import ObjectFormatError
 
-from .fs import (
-    HDFSFileSystem,
-    LocalFileSystem,
-    RemoteMissingDepsError,
-    S3FileSystem,
-    Schemes,
-    get_cloud_fs,
-)
+from .annotations import ANNOTATION_FIELDS, ANNOTATION_SCHEMA, Annotation
+from .fs import LocalFileSystem, RemoteMissingDepsError, Schemes, get_cloud_fs
 from .utils import relpath
 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
 
 logger = logging.getLogger(__name__)
@@ -65,10 +61,12 @@ CASE_SENSITIVE_CHECKSUM_SCHEMA = Any(
 #
 # so when a few types of outputs share the same name, we only need
 # specify it once.
+HDFS_PARAM_CHECKSUM = "checksum"
+S3_PARAM_CHECKSUM = "etag"
 CHECKSUMS_SCHEMA = {
     LocalFileSystem.PARAM_CHECKSUM: CHECKSUM_SCHEMA,
-    HDFSFileSystem.PARAM_CHECKSUM: CHECKSUM_SCHEMA,
-    S3FileSystem.PARAM_CHECKSUM: CASE_SENSITIVE_CHECKSUM_SCHEMA,
+    HDFS_PARAM_CHECKSUM: CHECKSUM_SCHEMA,
+    S3_PARAM_CHECKSUM: CASE_SENSITIVE_CHECKSUM_SCHEMA,
 }
 
 
@@ -85,9 +83,10 @@ def loadd_from(stage, d_list):
         plot = d.pop(Output.PARAM_PLOT, False)
         persist = d.pop(Output.PARAM_PERSIST, False)
         checkpoint = d.pop(Output.PARAM_CHECKPOINT, False)
-        desc = d.pop(Output.PARAM_DESC, False)
         live = d.pop(Output.PARAM_LIVE, 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)
         ret.append(
             _get(
                 stage,
@@ -98,9 +97,10 @@ def loadd_from(stage, d_list):
                 plot=plot,
                 persist=persist,
                 checkpoint=checkpoint,
-                desc=desc,
                 live=live,
                 remote=remote,
+                **annot,
+                files=files,
             )
         )
     return ret
@@ -192,6 +192,7 @@ def load_from_pipeline(stage, data, typ="outs"):
                 Output.PARAM_PERSIST,
                 Output.PARAM_CHECKPOINT,
                 Output.PARAM_REMOTE,
+                *ANNOTATION_FIELDS,
             ],
         )
 
@@ -245,6 +246,7 @@ class Output:
     PARAM_PATH = "path"
     PARAM_CACHE = "cache"
     PARAM_CHECKPOINT = "checkpoint"
+    PARAM_FILES = "files"
     PARAM_METRIC = "metric"
     PARAM_METRIC_TYPE = "type"
     PARAM_METRIC_XPATH = "xpath"
@@ -257,7 +259,6 @@ class Output:
     PARAM_PLOT_TITLE = "title"
     PARAM_PLOT_HEADER = "header"
     PARAM_PERSIST = "persist"
-    PARAM_DESC = "desc"
     PARAM_LIVE = "live"
     PARAM_LIVE_SUMMARY = "summary"
     PARAM_LIVE_HTML = "html"
@@ -289,11 +290,29 @@ class Output:
         checkpoint=False,
         live=False,
         desc=None,
+        type=None,  # pylint: disable=redefined-builtin
+        labels=None,
+        meta=None,
         remote=None,
         repo=None,
+        fs_config=None,
+        files: List[Dict[str, Any]] = None,
     ):
+        self.annot = Annotation(
+            desc=desc, type=type, labels=labels or [], meta=meta or {}
+        )
         self.repo = stage.repo if not repo and stage else repo
-        fs_cls, fs_config, fs_path = get_cloud_fs(self.repo, url=path)
+        meta = Meta.from_dict(info or {})
+        # NOTE: when version_aware is not passed into get_cloud_fs, it will be
+        # set based on whether or not path is versioned
+        fs_kwargs = {"version_aware": True} if meta.version_id else {}
+
+        if fs_config is not None:
+            fs_kwargs.update(**fs_config)
+
+        fs_cls, fs_config, fs_path = get_cloud_fs(
+            self.repo, url=path, **fs_kwargs
+        )
         self.fs = fs_cls(**fs_config)
 
         if (
@@ -325,38 +344,55 @@ class Output:
         # By resolved path, which contains actual location,
         # should be absolute and don't contain remote:// refs.
         self.stage = stage
-        self.meta = Meta.from_dict(info)
-        self.hash_info = HashInfo.from_dict(info)
+        self.meta = meta
+        self._files = files
         self.use_cache = False if self.IS_DEPENDENCY else cache
         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.live = live
-        self.desc = desc
 
         self.fs_path = self._parse_path(self.fs, fs_path)
-        self.obj = None
+        self.obj: Optional["HashFile"] = None
 
         self.remote = remote
 
-    def _parse_path(self, fs, fs_path):
-        if fs.protocol != "local":
-            return fs_path
+        if self.fs.version_aware:
+            _, version_id = self.fs.path.coalesce_version(
+                self.def_path, self.meta.version_id
+            )
+            self.meta.version_id = version_id
 
+        if self.is_in_repo:
+            self.hash_name = "md5"
+        else:
+            self.hash_name = self.fs.PARAM_CHECKSUM
+
+        self.hash_info = HashInfo(
+            name=self.hash_name,
+            value=getattr(self.meta, self.hash_name, None),
+        )
+        if self.hash_info and self.hash_info.isdir:
+            self.meta.isdir = True
+
+    def _parse_path(self, fs, fs_path):
         parsed = urlparse(self.def_path)
-        if parsed.scheme != "remote":
+        if (
+            parsed.scheme != "remote"
+            and self.stage
+            and self.stage.repo.fs == fs
+            and not fs.path.isabs(fs_path)
+        ):
             # NOTE: we can path either from command line or .dvc file,
             # so we should expect both posix and windows style paths.
             # paths accepts both, i.e. / works everywhere, \ only on win.
             #
             # FIXME: if we have Windows path containing / or posix one with \
             # then we have #2059 bug and can't really handle that.
-            if self.stage and not os.path.isabs(fs_path):
-                fs_path = fs.path.join(self.stage.wdir, fs_path)
+            fs_path = fs.path.join(self.stage.wdir, fs_path)
 
-        abs_p = fs.path.abspath(fs.path.normpath(fs_path))
-        return abs_p
+        return fs.path.abspath(fs.path.normpath(fs_path))
 
     def __repr__(self):
         return "{class_name}: '{def_path}'".format(
@@ -380,15 +416,18 @@ class Output:
 
         return self.fs.path.relpath(self.fs_path, self.repo.root_dir)
 
+    def clear(self):
+        self.hash_info = HashInfo.from_dict({})
+        self.meta = Meta.from_dict({})
+        self.obj = None
+        self._files = None
+
     @property
     def protocol(self):
         return self.fs.protocol
 
     @property
     def is_in_repo(self):
-        if self.fs.protocol != "local":
-            return False
-
         if urlparse(self.def_path).scheme == "remote":
             return False
 
@@ -409,7 +448,8 @@ class Output:
 
     @property
     def odb(self):
-        odb = getattr(self.repo.odb, self.protocol)
+        odb_name = "repo" if self.is_in_repo else self.protocol
+        odb = getattr(self.repo.odb, odb_name)
         if self.use_cache and odb is None:
             raise RemoteCacheRequiredError(self.fs.protocol, self.fs_path)
         return odb
@@ -421,21 +461,27 @@ class Output:
         )
 
     def get_hash(self):
+        _, hash_info = self._get_hash_meta()
+        return hash_info
+
+    def _get_hash_meta(self):
         if self.use_cache:
             odb = self.odb
-            name = self.odb.fs.PARAM_CHECKSUM
         else:
             odb = self.repo.odb.local
-            name = self.fs.PARAM_CHECKSUM
-        _, _, obj = build(
+        _, meta, obj = build(
             odb,
             self.fs_path,
             self.fs,
-            name,
+            self.hash_name,
             ignore=self.dvcignore,
             dry_run=not self.use_cache,
         )
-        return obj.hash_info
+        return meta, obj.hash_info
+
+    def get_meta(self) -> Meta:
+        meta, _ = self._get_hash_meta()
+        return meta
 
     @property
     def is_dir_checksum(self):
@@ -454,6 +500,17 @@ class Output:
 
         return self.fs.exists(self.fs_path)
 
+    @cached_property
+    def index_key(self) -> Tuple[str, "DataIndexKey"]:
+        if self.is_in_repo:
+            workspace = "repo"
+            key = self.repo.fs.path.relparts(self.fs_path, self.repo.root_dir)
+        else:
+            workspace = self.fs.protocol
+            no_drive = self.fs.path.flavour.splitdrive(self.fs_path)[1]
+            key = self.fs.path.parts(no_drive)[1:]
+        return workspace, key
+
     def changed_checksum(self):
         return self.hash_info != self.get_hash()
 
@@ -471,6 +528,11 @@ class Output:
         except (FileNotFoundError, ObjectFormatError):
             return True
 
+    def changed_meta(self) -> bool:
+        if self.fs.version_aware and self.meta.version_id:
+            return self.meta.version_id == self.get_meta().version_id
+        return False
+
     def workspace_status(self):
         if not self.exists:
             return {str(self): "deleted"}
@@ -545,7 +607,7 @@ class Output:
 
         self.ignore()
 
-        if self.metric or self.plot:
+        if self.metric:
             self.verify_metric()
 
         if not self.use_cache:
@@ -553,11 +615,12 @@ class Output:
                 self.repo.odb.local,
                 self.fs_path,
                 self.fs,
-                self.fs.PARAM_CHECKSUM,
+                self.hash_name,
                 ignore=self.dvcignore,
                 dry_run=True,
             )
             self.hash_info = obj.hash_info
+            self._files = None
             if not self.IS_DEPENDENCY:
                 logger.debug(
                     "Output '%s' doesn't use cache. Skipping saving.", self
@@ -570,18 +633,19 @@ class Output:
             self.odb,
             self.fs_path,
             self.fs,
-            self.odb.fs.PARAM_CHECKSUM,
+            self.hash_name,
             ignore=self.dvcignore,
         )
         self.hash_info = self.obj.hash_info
+        self._files = None
 
     def set_exec(self):
         if self.isfile() and self.meta.isexec:
             self.odb.set_exec(self.fs_path)
 
     def _checkout(self, *args, **kwargs):
-        from dvc_data.checkout import CheckoutError as _CheckoutError
-        from dvc_data.checkout import LinkError, PromptError
+        from dvc_data.hashfile.checkout import CheckoutError as _CheckoutError
+        from dvc_data.hashfile.checkout import LinkError, PromptError
 
         kwargs.setdefault("ignore", self.dvcignore)
         try:
@@ -612,7 +676,7 @@ class Output:
                     self.odb,
                     filter_info or self.fs_path,
                     self.fs,
-                    self.odb.fs.PARAM_CHECKSUM,
+                    self.hash_name,
                     ignore=self.dvcignore,
                 )
                 otransfer(
@@ -641,7 +705,7 @@ class Output:
             self.odb,
             self.fs_path,
             self.fs,
-            self.odb.fs.PARAM_CHECKSUM,
+            self.hash_name,
             ignore=self.dvcignore,
         )
         save_obj = save_obj.filter(prefix)
@@ -655,8 +719,10 @@ class Output:
         )
         return checkout_obj
 
-    def dumpd(self):
-        ret = {**self.hash_info.to_dict(), **self.meta.to_dict()}
+    def dumpd(self, **kwargs):
+        meta = self.meta.to_dict()
+        meta.pop("isdir", None)
+        ret = {**self.hash_info.to_dict(), **meta}
 
         if self.is_in_repo:
             path = self.fs.path.as_posix(
@@ -670,9 +736,7 @@ class Output:
         if self.IS_DEPENDENCY:
             return ret
 
-        if self.desc:
-            ret[self.PARAM_DESC] = self.desc
-
+        ret.update(self.annot.to_dict())
         if not self.use_cache:
             ret[self.PARAM_CACHE] = self.use_cache
 
@@ -701,6 +765,18 @@ class Output:
         if self.remote:
             ret[self.PARAM_REMOTE] = self.remote
 
+        if (
+            self.use_cache
+            and self.is_in_repo
+            and self.hash_info.isdir
+            and (kwargs.get("with_files") or self._files is not None)
+        ):
+            if self.obj:
+                obj = self.obj
+            else:
+                obj = self.get_obj()
+            ret[self.PARAM_FILES] = obj.as_list(with_meta=True)
+
         return ret
 
     def verify_metric(self):
@@ -708,22 +784,21 @@ class Output:
             raise DvcException(
                 f"verify metric is not supported for {self.protocol}"
             )
-
-        if not self.metric or self.plot:
+        if not self.metric:
             return
 
         if not os.path.exists(self.fs_path):
             return
 
-        name = "metrics" if self.metric else "plot"
         if os.path.isdir(self.fs_path):
             msg = "directory '%s' cannot be used as %s."
-            logger.debug(msg, str(self), name)
+            logger.debug(msg, str(self), "metrics")
             return
 
         if not istextfile(self.fs_path, self.fs):
-            msg = "binary file '{}' cannot be used as {}."
-            raise DvcException(msg.format(self.fs_path, name))
+            raise DvcException(
+                f"binary file '{self.fs_path}' cannot be used as metrics."
+            )
 
     def download(self, to, jobs=None):
         from dvc.fs.callbacks import Callback
@@ -734,14 +809,22 @@ class Output:
         ) as cb:
             self.fs.get(self.fs_path, to.fs_path, batch_size=jobs, callback=cb)
 
-    def get_obj(self, filter_info=None, **kwargs):
+    def get_obj(
+        self, filter_info: Optional[str] = None, **kwargs
+    ) -> Optional["HashFile"]:
+        obj: Optional["HashFile"] = None
         if self.obj:
             obj = self.obj
         elif self.hash_info:
-            try:
-                obj = oload(self.odb, self.hash_info)
-            except FileNotFoundError:
-                return None
+            if self._files:
+                tree = Tree.from_list(self._files, hash_name=self.hash_name)
+                tree.digest()
+                obj = tree
+            else:
+                try:
+                    obj = oload(self.odb, self.hash_info)
+                except (FileNotFoundError, ObjectFormatError):
+                    return None
         else:
             return None
 
@@ -861,6 +944,7 @@ class Output:
         )
 
         self.hash_info = obj.hash_info
+        self._files = None
         return obj
 
     def get_files_number(self, filter_info=None):
@@ -931,6 +1015,7 @@ class Output:
 
         obj = self.get_obj()
         if filter_info and filter_info != self.fs_path:
+            assert obj
             prefix = self.fs.path.parts(
                 self.fs.path.relpath(filter_info, self.fs_path)
             )
@@ -1023,7 +1108,7 @@ class Output:
         other = out.dumpd()
 
         ignored = [
-            self.fs.PARAM_CHECKSUM,
+            self.hash_name,
             Meta.PARAM_SIZE,
             Meta.PARAM_NFILES,
         ]
@@ -1043,8 +1128,8 @@ class Output:
             )
 
     def merge(self, ancestor, other):
-        from dvc_data.objects.tree import MergeError as TreeMergeError
-        from dvc_data.objects.tree import du, merge
+        from dvc_data.hashfile.tree import MergeError as TreeMergeError
+        from dvc_data.hashfile.tree import du, merge
 
         assert other
 
@@ -1067,6 +1152,7 @@ class Output:
         self.odb.add(merged.path, merged.fs, merged.oid)
 
         self.hash_info = merged.hash_info
+        self._files = None
         self.meta = Meta(
             size=du(self.odb, merged),
             nfiles=len(merged),
@@ -1089,21 +1175,33 @@ class Output:
         return bool(self.plot) or bool(self.live)
 
 
+META_SCHEMA = {
+    Meta.PARAM_SIZE: int,
+    Meta.PARAM_NFILES: int,
+    Meta.PARAM_ISEXEC: bool,
+    Meta.PARAM_VERSION_ID: str,
+}
+
 ARTIFACT_SCHEMA = {
     **CHECKSUMS_SCHEMA,
+    **META_SCHEMA,
     Required(Output.PARAM_PATH): str,
     Output.PARAM_PLOT: bool,
     Output.PARAM_PERSIST: bool,
     Output.PARAM_CHECKPOINT: bool,
-    Meta.PARAM_SIZE: int,
-    Meta.PARAM_NFILES: int,
-    Meta.PARAM_ISEXEC: bool,
+}
+
+DIR_FILES_SCHEMA: Dict[str, Any] = {
+    **CHECKSUMS_SCHEMA,
+    **META_SCHEMA,
+    Required(Tree.PARAM_RELPATH): str,
 }
 
 SCHEMA = {
     **ARTIFACT_SCHEMA,
+    **ANNOTATION_SCHEMA,
     Output.PARAM_CACHE: bool,
     Output.PARAM_METRIC: Output.METRIC_SCHEMA,
-    Output.PARAM_DESC: str,
     Output.PARAM_REMOTE: str,
+    Output.PARAM_FILES: [DIR_FILES_SCHEMA],
 }

dvc/parsing/context.py

@@ -1,5 +1,4 @@
 import logging
-import os
 from abc import ABC, abstractmethod
 from collections import defaultdict
 from collections.abc import Mapping, MutableMapping, MutableSequence, Sequence
@@ -160,7 +159,7 @@ class Value(Node):
 PRIMITIVES = (int, float, str, bytes, bool)
 
 
-class Container(Node, ABC):
+class Container(Node, ABC):  # noqa: B024
     meta: Meta
     data: Union[list, dict]
     _key_transform = staticmethod(identity)
@@ -357,17 +356,14 @@ class Context(CtxDict):
     def load_from(
         cls, fs, path: str, select_keys: List[str] = None
     ) -> "Context":
-        from dvc.utils.serialize import LOADERS
+        from dvc.utils.serialize import load_path
 
         if not fs.exists(path):
             raise ParamsLoadError(f"'{path}' does not exist")
         if fs.isdir(path):
             raise ParamsLoadError(f"'{path}' is a directory")
 
-        _, ext = os.path.splitext(path)
-        loader = LOADERS[ext]
-
-        data = loader(path, fs=fs)
+        data = load_path(path, fs)
         if not isinstance(data, Mapping):
             typ = type(data).__name__
             raise ParamsLoadError(

dvc/repo/__init__.py

@@ -3,7 +3,7 @@ import os
 from collections import defaultdict
 from contextlib import contextmanager
 from functools import wraps
-from typing import TYPE_CHECKING, Callable, Optional
+from typing import TYPE_CHECKING, Callable, List, Optional
 
 from funcy import cached_property
 
@@ -18,6 +18,7 @@ if TYPE_CHECKING:
     from dvc.fs import FileSystem
     from dvc.repo.scm_context import SCMContext
     from dvc.scm import Base
+    from dvc.stage import Stage
 
 logger = logging.getLogger(__name__)
 
@@ -128,19 +129,17 @@ class Repo:
 
         import hashlib
 
-        from dvc.utils.fs import makedirs
-
         root_dir_hash = hashlib.sha224(
             self.root_dir.encode("utf-8")
         ).hexdigest()
 
-        db_dir = os.path.join(
+        db_dir = self.fs.path.join(
             base_db_dir,
             self.DVC_DIR,
-            f"{os.path.basename(self.root_dir)}-{root_dir_hash[0:7]}",
+            f"{self.fs.path.name(self.root_dir)}-{root_dir_hash[0:7]}",
         )
 
-        makedirs(db_dir, exist_ok=True)
+        self.fs.makedirs(db_dir, exist_ok=True)
         return db_dir
 
     def __init__(
@@ -157,7 +156,7 @@ class Repo:
     ):
         from dvc.config import Config
         from dvc.data_cloud import DataCloud
-        from dvc.fs import GitFileSystem, localfs
+        from dvc.fs import GitFileSystem, LocalFileSystem, localfs
         from dvc.lock import LockNoop, make_lock
         from dvc.odbmgr import ODBManager
         from dvc.repo.metrics import Metrics
@@ -200,18 +199,23 @@ class Repo:
             self.odb = ODBManager(self)
             self.tmp_dir = None
         else:
-            from dvc.utils.fs import makedirs
+            self.fs.makedirs(self.tmp_dir, exist_ok=True)
 
-            makedirs(self.tmp_dir, exist_ok=True)
-            self.lock = make_lock(
-                os.path.join(self.tmp_dir, "lock"),
-                tmp_dir=self.tmp_dir,
-                hardlink_lock=self.config["core"].get("hardlink_lock", False),
-                friendly=True,
-            )
+            if isinstance(self.fs, LocalFileSystem):
+                self.lock = make_lock(
+                    self.fs.path.join(self.tmp_dir, "lock"),
+                    tmp_dir=self.tmp_dir,
+                    hardlink_lock=self.config["core"].get(
+                        "hardlink_lock", False
+                    ),
+                    friendly=True,
+                )
+                state_db_dir = self._get_database_dir("state")
+                self.state = State(self.root_dir, state_db_dir, self.dvcignore)
+            else:
+                self.lock = LockNoop()
+                self.state = StateNoop()
 
-            state_db_dir = self._get_database_dir("state")
-            self.state = State(self.root_dir, state_db_dir, self.dvcignore)
             self.odb = ODBManager(self)
 
             self.stage_cache = StageCache(self)
@@ -364,13 +368,13 @@ class Repo:
         )
 
     def unprotect(self, target):
-        return self.odb.local.unprotect(target)
+        return self.odb.repo.unprotect(target)
 
     def _ignore(self):
         flist = [self.config.files["local"], self.tmp_dir]
 
-        if path_isin(self.odb.local.cache_dir, self.root_dir):
-            flist += [self.odb.local.cache_dir]
+        if path_isin(self.odb.repo.path, self.root_dir):
+            flist += [self.odb.repo.path]
 
         for file in flist:
             self.scm_context.ignore(file)
@@ -441,6 +445,44 @@ class Repo:
 
         return used
 
+    def partial_imports(
+        self,
+        targets=None,
+        all_branches=False,
+        all_tags=False,
+        all_commits=False,
+        all_experiments=False,
+        commit_date: Optional[str] = None,
+        recursive=False,
+        revs=None,
+        num=1,
+    ) -> List["Stage"]:
+        """Get the stages related to the given target and collect dependencies
+        which are missing outputs.
+
+        This is useful to retrieve files which have been imported to the repo
+        using --no-download.
+
+        Returns:
+            A list of partially imported stages
+        """
+        from itertools import chain
+
+        partial_imports = chain.from_iterable(
+            self.index.partial_imports(targets, recursive=recursive)
+            for _ in self.brancher(
+                revs=revs,
+                all_branches=all_branches,
+                all_tags=all_tags,
+                all_commits=all_commits,
+                all_experiments=all_experiments,
+                commit_date=commit_date,
+                num=num,
+            )
+        )
+
+        return list(partial_imports)
+
     @property
     def stages(self):  # obsolete, only for backward-compatibility
         return self.index.stages
@@ -480,7 +522,7 @@ class Repo:
     def datafs(self):
         from dvc.fs.data import DataFileSystem
 
-        return DataFileSystem(repo=self)
+        return DataFileSystem(index=self.index.data["repo"])
 
     @cached_property
     def dvcfs(self):
@@ -501,18 +543,23 @@ class Repo:
         from dvc.fs.dvc import DvcFileSystem
 
         if os.path.isabs(path):
-            fs = DataFileSystem(repo=self, workspace="local")
+            fs = DataFileSystem(index=self.index.data["local"])
             fs_path = path
         else:
             fs = DvcFileSystem(repo=self, subrepos=True)
             fs_path = fs.from_os_path(path)
 
         try:
+            if remote:
+                remote_odb = self.cloud.get_remote_odb(name=remote)
+                oid = fs.info(fs_path)["dvc_info"]["md5"]
+                fs = remote_odb.fs
+                fs_path = remote_odb.oid_to_path(oid)
+
             with fs.open(
                 fs_path,
                 mode=mode,
                 encoding=encoding,
-                remote=remote,
             ) as fobj:
                 yield fobj
         except FileNotFoundError as exc:

dvc/repo/add.py

@@ -264,6 +264,7 @@ def create_stages(
             outs=[out],
             external=external,
         )
-        if kwargs.get("desc"):
-            stage.outs[0].desc = kwargs["desc"]
+
+        out_obj = stage.outs[0]
+        out_obj.annot.update(**kwargs)
         yield stage

dvc/repo/data.py

@@ -1,7 +1,21 @@
 import os
+import posixpath
 from collections import defaultdict
-from typing import TYPE_CHECKING, Any, Dict, List, Optional, TypedDict, cast
+from itertools import chain
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    Dict,
+    Iterable,
+    Iterator,
+    List,
+    Optional,
+    Tuple,
+    TypedDict,
+    cast,
+)
 
+from dvc.fs.git import GitFileSystem
 from dvc.ui import ui
 
 if TYPE_CHECKING:
@@ -10,19 +24,20 @@ if TYPE_CHECKING:
     from dvc.output import Output
     from dvc.repo import Repo
     from dvc_data.hashfile.db import HashFileDB
+    from dvc_data.hashfile.hash_info import HashInfo
     from dvc_data.hashfile.obj import HashFile
 
 
-def _in_cache(obj: Optional["HashFile"], cache: "HashFileDB") -> bool:
+def posixpath_to_os_path(path: str) -> str:
+    return path.replace(posixpath.sep, os.path.sep)
+
+
+def _in_cache(obj: "HashInfo", cache: "HashFileDB") -> bool:
     from dvc_objects.errors import ObjectFormatError
 
-    if not obj:
-        return False
-    if not obj.hash_info.value:
-        return False
-
+    assert obj.value
     try:
-        cache.check(obj.hash_info.value)
+        cache.check(obj.value)
         return True
     except (FileNotFoundError, ObjectFormatError):
         return False
@@ -30,31 +45,30 @@ def _in_cache(obj: Optional["HashFile"], cache: "HashFileDB") -> bool:
 
 def _shallow_diff(
     root: str,
-    old_obj: Optional["HashFile"],
-    new_obj: Optional["HashFile"],
+    old: Optional["HashInfo"],
+    new: Optional["HashInfo"],
     cache: "HashFileDB",
 ) -> Dict[str, List[str]]:
-    # TODO: add support for shallow diff in dvc-data
-    # TODO: we may want to recursively do in_cache check
     d = {}
 
-    from dvc_data.objects.tree import Tree
+    old_root = new_root = root
+    if old and old.isdir:
+        old_root = os.path.sep.join([root, ""])
+    if new and new.isdir:
+        new_root = os.path.sep.join([root, ""])
 
-    if isinstance(new_obj, Tree):
-        root = os.path.sep.join([root, ""])
+    if old and not _in_cache(old, cache):
+        d["not_in_cache"] = [old_root]
 
-    if not _in_cache(old_obj, cache):
-        d["not_in_cache"] = [root]
-
-    if old_obj is None and new_obj is None:
+    if not old and not new:
         return d
-    if old_obj is None:
-        return {"added": [root], **d}
-    if new_obj is None:
-        return {"deleted": [root], **d}
-    if old_obj.hash_info != new_obj.hash_info:
-        return {"modified": [root], **d}
-    return {"unchanged": [root], **d}
+    if not new:
+        return {"deleted": [old_root], **d}
+    if not old:
+        return {"added": [new_root], **d}
+    if old != new:
+        return {"modified": [new_root], **d}
+    return {"unchanged": [new_root], **d}
 
 
 def _granular_diff(
@@ -62,55 +76,60 @@ def _granular_diff(
     old_obj: Optional["HashFile"],
     new_obj: Optional["HashFile"],
     cache: "HashFileDB",
-    with_dirs: bool = False,
 ) -> Dict[str, List[str]]:
-    from dvc_data.diff import ROOT
-    from dvc_data.diff import diff as odiff
-    from dvc_data.objects.tree import Tree
+    from dvc_data.hashfile.diff import ROOT
+    from dvc_data.hashfile.diff import diff as odiff
 
-    def path_join(root: str, *paths: str) -> str:
-        if not isinstance(new_obj, Tree):
+    def path_join(root: str, *paths: str, isdir: bool = False) -> str:
+        if not isdir and paths == ROOT:
             return root
         return os.path.sep.join([root, *paths])
 
     diff_data = odiff(old_obj, new_obj, cache)
-    drop_root = not with_dirs and isinstance(new_obj, Tree)
 
     output: Dict[str, List[str]] = defaultdict(list)
     for state in ("added", "deleted", "modified", "unchanged"):
         items = getattr(diff_data, state)
-        output[state].extend(
-            path_join(root, *item.new.key)
-            for item in items
-            if not (drop_root and item.new.key == ROOT)
-        )
-        # TODO: PERF: diff is checking not_in_cache for each even if we only
-        # need it for the index.
-        # BUG: not_in_cache file also shows up as modified in staged and
-        # unstaged. We currently don't know if it is really modified.
-        output["not_in_cache"].extend(
-            path_join(root, *item.new.key)
-            for item in items
-            if not item.old.in_cache
-            and not (drop_root and item.new.key == ROOT)
-            and state != "added"
-        )
-    return output
+        for item in items:  # pylint: disable=not-an-iterable
+            entry = item.old if state == "deleted" else item.new
+            isdir = entry.oid.isdir if entry.oid else False
+
+            path = path_join(root, *entry.key, isdir=isdir)
+            output[state].append(path)
+            if not item.old.in_cache and state != "added":
+                output["not_in_cache"].append(path)
+    return dict(output)
+
+
+def _get_obj_items(root: str, obj: Optional["HashFile"]) -> List[str]:
+    if not obj:
+        return []
+
+    from dvc_data.hashfile.tree import Tree
+
+    sep = os.path.sep
+    if isinstance(obj, Tree):
+        return [sep.join([root, *key]) for key, _, _ in obj]
+    return [root]
 
 
 def _diff(
     root: str,
+    old_oid: Optional["HashInfo"],
     old_obj: Optional["HashFile"],
+    new_oid: Optional["HashInfo"],
     new_obj: Optional["HashFile"],
-    cache: "HashFileDB",
+    odb: "HashFileDB",
     granular: bool = False,
-    with_dirs: bool = False,
 ) -> Dict[str, List[str]]:
-    if granular:
-        return _granular_diff(
-            root, old_obj, new_obj, cache, with_dirs=with_dirs
-        )
-    return _shallow_diff(root, old_obj, new_obj, cache)
+    if not granular:
+        return _shallow_diff(root, old_oid, new_oid, odb)
+    if (old_oid and not old_obj) or (new_oid and not new_obj):
+        # we don't have enough information to give full details
+        unknown = _get_obj_items(root, new_obj)
+        shallow_diff = _shallow_diff(root, old_oid, new_oid, odb)
+        return {**shallow_diff, "unknown": unknown}
+    return _granular_diff(root, old_obj, new_obj, odb)
 
 
 class GitInfo(TypedDict, total=False):
@@ -137,6 +156,8 @@ def _git_info(scm: "Base", untracked_files: str = "all") -> GitInfo:
         empty_repo = False
 
     staged, unstaged, untracked = scm.status(untracked_files=untracked_files)
+    if os.name == "nt":
+        untracked = [posixpath_to_os_path(path) for path in untracked]
     # NOTE: order is important here.
     return GitInfo(
         staged=staged,
@@ -148,7 +169,7 @@ def _git_info(scm: "Base", untracked_files: str = "all") -> GitInfo:
 
 
 def _diff_index_to_wtree(repo: "Repo", **kwargs: Any) -> Dict[str, List[str]]:
-    from dvc_data.build import build
+    from dvc_data.hashfile.build import build
 
     unstaged_diff = defaultdict(list)
     for out in repo.index.outs:
@@ -168,11 +189,21 @@ def _diff_index_to_wtree(repo: "Repo", **kwargs: Any) -> Dict[str, List[str]]:
         except FileNotFoundError:
             new = None
 
-        cache = repo.odb.local
+        cache = repo.odb.repo
         root = str(out)
         old = out.get_obj()
+
         with ui.status(f"Calculating diff for {root} between index/workspace"):
-            d = _diff(root, old, new, cache, **kwargs)
+            d = _diff(
+                root,
+                out.hash_info,
+                old,
+                new.hash_info if new else None,
+                new,
+                cache,
+                **kwargs,
+            )
+
         for state, items in d.items():
             if not items:
                 continue
@@ -184,7 +215,9 @@ def _diff_head_to_index(
     repo: "Repo", head: str = "HEAD", **kwargs: Any
 ) -> Dict[str, List[str]]:
     # we need to store objects from index and the HEAD to diff later
-    objs: Dict[str, Dict[str, "HashFile"]] = defaultdict(dict)
+    objs: Dict[str, Dict[str, Tuple["HashFile", "HashInfo"]]]
+    objs = defaultdict(dict)
+
     staged_diff = defaultdict(list)
     for rev in repo.brancher(revs=[head]):
         for out in repo.index.outs:
@@ -193,15 +226,20 @@ def _diff_head_to_index(
                 continue
 
             root = str(out)
+            if isinstance(out.fs, GitFileSystem):
+                root = posixpath_to_os_path(root)
             typ = "index" if rev == "workspace" else head
-            objs[root][typ] = out.get_obj()
+            objs[root][typ] = (out.get_obj(), out.hash_info)
 
-    cache = repo.odb.local
+    cache = repo.odb.repo
     for root, obj_d in objs.items():
-        old = obj_d.get(head, None)
-        new = obj_d.get("index", None)
+        old_obj, old_oid = obj_d.get(head, (None, None))
+        new_obj, new_oid = obj_d.get("index", (None, None))
         with ui.status(f"Calculating diff for {root} between head/index"):
-            d = _diff(root, old, new, cache, **kwargs)
+            d = _diff(
+                root, old_oid, old_obj, new_oid, new_obj, cache, **kwargs
+            )
+
         for state, items in d.items():
             if not items:
                 continue
@@ -212,28 +250,36 @@ def _diff_head_to_index(
 
 class Status(TypedDict):
     not_in_cache: List[str]
-    committed: Dict[str, Any]
-    uncommitted: Dict[str, Any]
+    committed: Dict[str, List[str]]
+    uncommitted: Dict[str, List[str]]
     untracked: List[str]
     unchanged: List[str]
     git: GitInfo
 
 
-def _transform_git_paths_to_dvc(repo: "Repo", files: List[str]):
+def _transform_git_paths_to_dvc(
+    repo: "Repo", files: Iterable[str]
+) -> List[str]:
     """Transform files rel. to Git root to DVC root, and drop outside files."""
     rel = repo.fs.path.relpath(repo.root_dir, repo.scm.root_dir).rstrip("/")
-    if rel in (os.curdir, ""):
-        return files
 
-    prefix = rel + os.sep
-    length = len(prefix)
-    return [file[length:] for file in files if file.startswith(prefix)]
+    # if we have repo root in a different location than scm's root,
+    # i.e. subdir repo, all git_paths need to be transformed rel. to the DVC
+    # repo root and anything outside need to be filtered out.
+    if rel not in (os.curdir, ""):
+        prefix = rel + os.sep
+        length = len(prefix)
+        files = (file[length:] for file in files if file.startswith(prefix))
+
+    start = repo.fs.path.relpath(repo.fs.path.getcwd(), repo.root_dir)
+    if start in (os.curdir, ""):
+        return list(files)
+    # we need to convert repo relative paths to curdir relative.
+    return [repo.fs.path.relpath(file, start) for file in files]
 
 
 def status(repo: "Repo", untracked_files: str = "no", **kwargs: Any) -> Status:
-    from scmrepo.exceptions import SCMError
-
-    from dvc.scm import NoSCMError
+    from dvc.scm import NoSCMError, SCMError
 
     head = kwargs.pop("head", "HEAD")
     uncommitted_diff = _diff_index_to_wtree(repo, **kwargs)
@@ -261,3 +307,18 @@ def status(repo: "Repo", untracked_files: str = "no", **kwargs: Any) -> Status:
         unchanged=list(unchanged),
         git=git_info,
     )
+
+
+def ls(
+    repo: "Repo",
+    targets: List[Optional[str]] = None,
+    recursive: bool = False,
+) -> Iterator[Dict[str, Any]]:
+    targets = targets or [None]
+    pairs = chain.from_iterable(
+        repo.stage.collect_granular(target, recursive=recursive)
+        for target in targets
+    )
+    for stage, filter_info in pairs:
+        for out in stage.filter_outs(filter_info):
+            yield {"path": str(out), **out.annot.to_dict()}

dvc/repo/diff.py

@@ -115,7 +115,7 @@ def _paths_checksums(repo, targets):
 
 def _output_paths(repo, targets):
     from dvc.fs import LocalFileSystem
-    from dvc_data.build import build
+    from dvc_data.hashfile.build import build
 
     on_working_fs = isinstance(repo.fs, LocalFileSystem)
 
@@ -140,9 +140,9 @@ def _output_paths(repo, targets):
 
             if on_working_fs:
                 _, _, obj = build(
-                    repo.odb.local,
+                    repo.odb.repo,
                     output.fs_path,
-                    repo.odb.local.fs,
+                    repo.odb.repo.fs,
                     "md5",
                     dry_run=True,
                     ignore=output.dvcignore,
@@ -186,11 +186,12 @@ def _filter_missing(dvcfs, paths):
         fs_path = dvcfs.from_os_path(path)
         try:
             info = dvcfs.info(fs_path)
-            dvc_info = info.get("dvc_info")
+            dvc_info = info.get("dvc_info", {})
+            entry = dvc_info.get("entry")
             if (
-                dvc_info
+                entry
                 and info["type"] == "directory"
-                and not dvc_info["meta"].obj
+                and not entry.odb.exists(entry.hash_info.value)
             ):
                 yield path
         except FileNotFoundError:

dvc/repo/experiments/__init__.py

@@ -214,7 +214,7 @@ class Experiments:
         for rev in revs:
             name = self.get_exact_name(rev)
             names.append(name if name else rev[:7])
-        ui.write("\nReproduced experiment(s): {}".format(", ".join(names)))
+        ui.write("\nRan experiment(s): {}".format(", ".join(names)))
         if tmp_dir:
             ui.write(
                 "To apply the results of an experiment to your workspace "

dvc/repo/experiments/executor/local.py

@@ -112,7 +112,7 @@ class TempDirExecutor(BaseLocalExecutor):
 
     def init_cache(self, repo: "Repo", rev: str, run_cache: bool = True):
         """Initialize DVC cache."""
-        self._config(repo.odb.local.cache_dir)
+        self._config(repo.odb.repo.path)
 
     def cleanup(self):
         super().cleanup()

dvc/repo/experiments/executor/manager/base.py

@@ -21,7 +21,7 @@ if TYPE_CHECKING:
 logger = logging.getLogger(__name__)
 
 
-class BaseExecutorManager(ABC, Mapping):
+class BaseExecutorManager(ABC, Mapping):  # noqa: B024
     """Manages executors for a collection of experiments to be run."""
 
     EXECUTOR_CLS: Type = BaseExecutor

dvc/repo/experiments/executor/ssh.py

@@ -5,10 +5,9 @@ import sys
 from contextlib import contextmanager
 from typing import TYPE_CHECKING, Callable, Iterable, Optional
 
+from dvc_ssh import SSHFileSystem
 from funcy import first
 
-from dvc.fs import SSHFileSystem
-
 from ..refs import (
     EXEC_BRANCH,
     EXEC_CHECKPOINT,

dvc/repo/experiments/queue/base.py

@@ -1,5 +1,6 @@
 import logging
 import os
+import sys
 from abc import ABC, abstractmethod
 from dataclasses import asdict, dataclass
 from typing import (
@@ -19,7 +20,7 @@ from typing import (
 
 from funcy import cached_property
 
-from dvc.dependency.param import MissingParamsError
+from dvc.dependency import ParamsDependency
 from dvc.env import DVCLIVE_RESUME
 from dvc.exceptions import DvcException
 from dvc.ui import ui
@@ -185,9 +186,12 @@ class BaseStashQueue(ABC):
 
         def _format_entry(
             entry: QueueEntry,
+            exp_result: Optional[ExecutorResult] = None,
             status: str = "Unknown",
         ) -> Dict[str, Any]:
             name = entry.name
+            if not name and exp_result and exp_result.ref_info:
+                name = exp_result.ref_info.name
             # NOTE: We fallback to Unknown status for experiments
             # generated in prior (incompatible) DVC versions
             return {
@@ -210,8 +214,8 @@ class BaseStashQueue(ABC):
             for queue_entry, _ in self.iter_failed()
         )
         result.extend(
-            _format_entry(queue_entry, status="Success")
-            for queue_entry, _ in self.iter_success()
+            _format_entry(queue_entry, exp_result=exp_result, status="Success")
+            for queue_entry, exp_result in self.iter_success()
         )
         return result
 
@@ -283,7 +287,7 @@ class BaseStashQueue(ABC):
     def _stash_exp(
         self,
         *args,
-        params: Optional[dict] = None,
+        params: Optional[Dict[str, List[str]]] = None,
         resume_rev: Optional[str] = None,
         baseline_rev: Optional[str] = None,
         branch: Optional[str] = None,
@@ -292,10 +296,9 @@ class BaseStashQueue(ABC):
     ) -> QueueEntry:
         """Stash changes from the workspace as an experiment.
 
-        Arguments:
-            params: Optional dictionary of parameter values to be used.
-                Values take priority over any parameters specified in the
-                user's workspace.
+        Args:
+            params: Dict mapping paths to `Hydra Override`_ patterns,
+                provided via `exp run --set-param`.
             resume_rev: Optional checkpoint resume rev.
             baseline_rev: Optional baseline rev for this experiment, defaults
                 to the current SCM rev.
@@ -305,6 +308,9 @@ class BaseStashQueue(ABC):
             name: Optional experiment name. If specified this will be used as
                 the human-readable name in the experiment branch ref. Has no
                 effect of branch is specified.
+
+        .. _Hydra Override:
+            https://hydra.cc/docs/next/advanced/override_grammar/basic/
         """
         with self.scm.detach_head(client="dvc") as orig_head:
             stash_head = orig_head
@@ -508,22 +514,44 @@ class BaseStashQueue(ABC):
             f"from '{config_path}': {param_list}"
         )
 
-    def _update_params(self, params: dict):
-        """Update experiment params files with the specified values."""
-        from dvc.utils.collections import NewParamsFound, merge_params
-        from dvc.utils.serialize import MODIFIERS
+    def _update_params(self, params: Dict[str, List[str]]):
+        """Update param files with the provided `Hydra Override`_ patterns.
 
+        Args:
+            params: Dict mapping paths to `Hydra Override`_ patterns,
+                provided via `exp run --set-param`.
+
+        .. _Hydra Override:
+            https://hydra.cc/docs/advanced/override_grammar/basic/
+        """
         logger.debug("Using experiment params '%s'", params)
 
-        for path in params:
-            suffix = self.repo.fs.path.suffix(path).lower()
-            modify_data = MODIFIERS[suffix]
-            with modify_data(path, fs=self.repo.fs) as data:
-                try:
-                    merge_params(data, params[path], allow_new=False)
-                except NewParamsFound as e:
-                    msg = self._format_new_params_msg(e.new_params, path)
-                    raise MissingParamsError(msg)
+        try:
+            from dvc.utils.hydra import apply_overrides, compose_and_dump
+        except ValueError:
+            if sys.version_info >= (3, 11):
+                raise DvcException(
+                    "--set-param is not supported in Python >= 3.11"
+                )
+            raise
+
+        hydra_config = self.repo.config.get("hydra", {})
+        hydra_enabled = hydra_config.get("enabled", False)
+        hydra_output_file = ParamsDependency.DEFAULT_PARAMS_FILE
+        for path, overrides in params.items():
+            if hydra_enabled and path == hydra_output_file:
+                config_dir = os.path.join(
+                    self.repo.root_dir, hydra_config.get("config_dir", "conf")
+                )
+                config_name = hydra_config.get("config_name", "config")
+                compose_and_dump(
+                    path,
+                    config_dir,
+                    config_name,
+                    overrides,
+                )
+            else:
+                apply_overrides(path, overrides)
 
         # Force params file changes to be staged in git
         # Otherwise in certain situations the changes to params file may be

dvc/repo/experiments/queue/celery.py

@@ -14,6 +14,7 @@ from typing import (
     Set,
 )
 
+from celery.result import AsyncResult
 from funcy import cached_property
 from kombu.message import Message
 
@@ -23,7 +24,6 @@ from dvc.ui import ui
 
 from ..exceptions import UnresolvedQueueExpNamesError
 from ..executor.base import EXEC_TMP_DIR, ExecutorInfo, ExecutorResult
-from ..stash import ExpStashEntry
 from .base import BaseStashQueue, QueueDoneResult, QueueEntry, QueueGetResult
 from .tasks import run_exp
 
@@ -41,7 +41,7 @@ class _MessageEntry(NamedTuple):
 
 
 class _TaskEntry(NamedTuple):
-    task_id: str
+    async_result: AsyncResult
     entry: QueueEntry
 
 
@@ -192,30 +192,37 @@ class LocalCeleryQueue(BaseStashQueue):
             yield _MessageEntry(msg, QueueEntry.from_dict(entry_dict))
 
     def _iter_active_tasks(self) -> Generator[_TaskEntry, None, None]:
-        from celery.result import AsyncResult
 
         for msg, entry in self._iter_processed():
             task_id = msg.headers["id"]
             result: AsyncResult = AsyncResult(task_id)
             if not result.ready():
-                yield _TaskEntry(task_id, entry)
+                yield _TaskEntry(result, entry)
 
     def _iter_done_tasks(self) -> Generator[_TaskEntry, None, None]:
-        from celery.result import AsyncResult
 
         for msg, entry in self._iter_processed():
             task_id = msg.headers["id"]
             result: AsyncResult = AsyncResult(task_id)
             if result.ready():
-                yield _TaskEntry(task_id, entry)
+                yield _TaskEntry(result, entry)
 
     def iter_active(self) -> Generator[QueueEntry, None, None]:
         for _, entry in self._iter_active_tasks():
             yield entry
 
     def iter_done(self) -> Generator[QueueDoneResult, None, None]:
-        for _, entry in self._iter_done_tasks():
-            yield QueueDoneResult(entry, self.get_result(entry))
+        for result, entry in self._iter_done_tasks():
+            try:
+                exp_result = self.get_result(entry)
+            except FileNotFoundError:
+                if result.status == "SUCCESS":
+                    raise DvcException(
+                        f"Invalid experiment '{entry.stash_rev[:7]}'."
+                    )
+                elif result.status == "FAILURE":
+                    exp_result = None
+            yield QueueDoneResult(entry, exp_result)
 
     def iter_success(self) -> Generator[QueueDoneResult, None, None]:
         for queue_entry, exp_result in self.iter_done():
@@ -223,14 +230,8 @@ class LocalCeleryQueue(BaseStashQueue):
                 yield QueueDoneResult(queue_entry, exp_result)
 
     def iter_failed(self) -> Generator[QueueDoneResult, None, None]:
-        failed_revs: Dict[str, ExpStashEntry] = (
-            dict(self.failed_stash.stash_revs)
-            if self.failed_stash is not None
-            else {}
-        )
-
         for queue_entry, exp_result in self.iter_done():
-            if exp_result is None and queue_entry.stash_rev in failed_revs:
+            if exp_result is None:
                 yield QueueDoneResult(queue_entry, exp_result)
 
     def reproduce(self) -> Mapping[str, Mapping[str, str]]:
@@ -240,7 +241,6 @@ class LocalCeleryQueue(BaseStashQueue):
         self, entry: QueueEntry, timeout: Optional[float] = None
     ) -> Optional[ExecutorResult]:
         from celery.exceptions import TimeoutError as _CeleryTimeout
-        from celery.result import AsyncResult
 
         def _load_info(rev: str) -> ExecutorInfo:
             infofile = self.get_infofile_path(rev)
@@ -261,11 +261,12 @@ class LocalCeleryQueue(BaseStashQueue):
         for queue_entry in self.iter_queued():
             if entry.stash_rev == queue_entry.stash_rev:
                 raise DvcException("Experiment has not been started.")
-        for task_id, active_entry in self._iter_active_tasks():
+        for result, active_entry in self._iter_active_tasks():
             if entry.stash_rev == active_entry.stash_rev:
-                logger.debug("Waiting for exp task '%s' to complete", task_id)
+                logger.debug(
+                    "Waiting for exp task '%s' to complete", result.id
+                )
                 try:
-                    result: AsyncResult = AsyncResult(task_id)
                     result.get(timeout=timeout)
                 except _CeleryTimeout as exc:
                     raise DvcException(
@@ -277,11 +278,7 @@ class LocalCeleryQueue(BaseStashQueue):
         # NOTE: It's possible for an exp to complete while iterating through
         # other queued and active tasks, in which case the exp will get moved
         # out of the active task list, and needs to be loaded here.
-        try:
-            return _load_collected(entry.stash_rev)
-        except FileNotFoundError:
-            pass
-        raise DvcException(f"Invalid experiment '{entry.stash_rev[:7]}'.")
+        return _load_collected(entry.stash_rev)
 
     def kill(self, revs: Collection[str]) -> None:
         to_kill: Set[QueueEntry] = set()

dvc/repo/experiments/queue/remove.py

@@ -1,38 +1,37 @@
-from typing import (
-    TYPE_CHECKING,
-    Collection,
-    Dict,
-    Iterable,
-    List,
-    Optional,
-    Set,
-    Union,
-)
+from typing import TYPE_CHECKING, Collection, Dict, Iterable, List, Set, Union
 
 from dvc.repo.experiments.exceptions import UnresolvedExpNamesError
 from dvc.repo.experiments.queue.base import QueueDoneResult
 
 if TYPE_CHECKING:
     from dvc.repo.experiments.queue.base import QueueEntry
-    from dvc.repo.experiments.queue.local import LocalCeleryQueue
+    from dvc.repo.experiments.queue.celery import LocalCeleryQueue
     from dvc.repo.experiments.stash import ExpStashEntry
 
 
-def _remove_queued_tasks(
+def remove_tasks(
     celery_queue: "LocalCeleryQueue",
-    queue_entries: Iterable[Optional["QueueEntry"]],
+    queue_entries: Iterable["QueueEntry"],
 ):
     """Remove tasks from task queue.
 
     Arguments:
-        queue_entries: An iterable list of queued task to remove
+        queue_entries: An iterable list of task to remove
     """
+    from celery.result import AsyncResult
+
     stash_revs: Dict[str, "ExpStashEntry"] = {}
+    failed_stash_revs: List["ExpStashEntry"] = []
+    done_entry_set: Set["QueueEntry"] = set()
+    stash_rev_all = celery_queue.stash.stash_revs
+    failed_rev_all = celery_queue.failed_stash.stash_revs
     for entry in queue_entries:
-        if entry:
-            stash_revs[entry.stash_rev] = celery_queue.stash.stash_revs[
-                entry.stash_rev
-            ]
+        if entry.stash_rev in stash_rev_all:
+            stash_revs[entry.stash_rev] = stash_rev_all[entry.stash_rev]
+        else:
+            done_entry_set.add(entry)
+            if entry.stash_rev in failed_rev_all:
+                failed_stash_revs.append(failed_rev_all[entry.stash_rev])
 
     try:
         for (
@@ -44,28 +43,6 @@ def _remove_queued_tasks(
     finally:
         celery_queue.stash.remove_revs(list(stash_revs.values()))
 
-
-def _remove_done_tasks(
-    celery_queue: "LocalCeleryQueue",
-    queue_entries: Iterable[Optional["QueueEntry"]],
-):
-    """Remove done tasks.
-
-    Arguments:
-        queue_entries: An iterable list of done task to remove
-    """
-    from celery.result import AsyncResult
-
-    failed_stash_revs: List["ExpStashEntry"] = []
-    queue_entry_set: Set["QueueEntry"] = set()
-    for entry in queue_entries:
-        if entry:
-            queue_entry_set.add(entry)
-            if entry.stash_rev in celery_queue.failed_stash.stash_revs:
-                failed_stash_revs.append(
-                    celery_queue.failed_stash.stash_revs[entry.stash_rev]
-                )
-
     try:
         for (
             msg,
@@ -73,7 +50,7 @@ def _remove_done_tasks(
         ) in (
             celery_queue._iter_processed()  # pylint: disable=protected-access
         ):
-            if queue_entry not in queue_entry_set:
+            if queue_entry not in done_entry_set:
                 continue
             task_id = msg.headers["id"]
             result: AsyncResult = AsyncResult(task_id)
@@ -98,7 +75,12 @@ def _get_names(entries: Iterable[Union["QueueEntry", "QueueDoneResult"]]):
     return names
 
 
-def celery_clear(self: "LocalCeleryQueue", **kwargs) -> List[str]:
+def celery_clear(
+    self: "LocalCeleryQueue",
+    queued: bool = False,
+    failed: bool = False,
+    success: bool = False,
+) -> List[str]:
     """Remove entries from the queue.
 
     Arguments:
@@ -109,24 +91,23 @@ def celery_clear(self: "LocalCeleryQueue", **kwargs) -> List[str]:
     Returns:
         Revisions which were removed.
     """
-    queued = kwargs.pop("queued", False)
-    failed = kwargs.get("failed", False)
-    success = kwargs.get("success", False)
 
-    removed = []
+    removed: List[str] = []
+    entry_list: List["QueueEntry"] = []
     if queued:
-        queue_entries = list(self.iter_queued())
-        _remove_queued_tasks(self, queue_entries)
+        queue_entries: List["QueueEntry"] = list(self.iter_queued())
+        entry_list.extend(queue_entries)
         removed.extend(_get_names(queue_entries))
-    if failed or success:
-        done_tasks: List["QueueDoneResult"] = []
-        if failed:
-            done_tasks.extend(self.iter_failed())
-        if success:
-            done_tasks.extend(self.iter_success())
-        done_entries = [result.entry for result in done_tasks]
-        _remove_done_tasks(self, done_entries)
-        removed.extend(_get_names(done_tasks))
+    if failed:
+        failed_tasks: List["QueueDoneResult"] = list(self.iter_failed())
+        entry_list.extend([result.entry for result in failed_tasks])
+        removed.extend(_get_names(failed_tasks))
+    if success:
+        success_tasks: List["QueueDoneResult"] = list(self.iter_success())
+        entry_list.extend([result.entry for result in success_tasks])
+        removed.extend(_get_names(success_tasks))
+
+    remove_tasks(self, entry_list)
 
     return removed
 
@@ -134,58 +115,34 @@ def celery_clear(self: "LocalCeleryQueue", **kwargs) -> List[str]:
 def celery_remove(
     self: "LocalCeleryQueue",
     revs: Collection[str],
-    queued: bool = False,
-    failed: bool = False,
-    success: bool = False,
-    all_: bool = False,
 ) -> List[str]:
     """Remove the specified entries from the queue.
 
     Arguments:
         revs: Stash revisions or queued exp names to be removed.
-        queued: Remove all queued tasks.
-        failed: Remove all failed tasks.
-        success: Remove all success tasks.
-        all_: Remove all tasks.
 
     Returns:
         Revisions (or names) which were removed.
     """
-    if all_:
-        queued = failed = success = True
-    if queued or failed or success:
-        return self.clear(failed=failed, success=success, queued=queued)
 
-    # match_queued
-    queue_match_results = self.match_queue_entry_by_name(
-        revs, self.iter_queued()
+    match_results = self.match_queue_entry_by_name(
+        revs, self.iter_queued(), self.iter_done()
     )
 
-    done_match_results = self.match_queue_entry_by_name(revs, self.iter_done())
-
     remained: List[str] = []
     removed: List[str] = []
-    queued_to_remove: List["QueueEntry"] = []
-    done_to_remove: List["QueueEntry"] = []
-    for name in revs:
-        done_match = done_match_results[name]
-        if done_match:
-            done_to_remove.append(done_match)
+    entry_to_remove: List["QueueEntry"] = []
+    for name, entry in match_results.items():
+        if entry:
+            entry_to_remove.append(entry)
             removed.append(name)
-            continue
-        queue_match = queue_match_results[name]
-        if queue_match:
-            queued_to_remove.append(queue_match)
-            removed.append(name)
-            continue
-        remained.append(name)
+        else:
+            remained.append(name)
 
     if remained:
         raise UnresolvedExpNamesError(remained)
 
-    if done_to_remove:
-        _remove_done_tasks(self, done_to_remove)
-    if queued_to_remove:
-        _remove_queued_tasks(self, queued_to_remove)
+    if entry_to_remove:
+        remove_tasks(self, entry_to_remove)
 
     return removed

dvc/repo/experiments/remove.py

@@ -1,30 +1,79 @@
 import logging
-from typing import TYPE_CHECKING, Dict, List, Mapping, Optional, Union
+from typing import (
+    TYPE_CHECKING,
+    Dict,
+    Iterable,
+    List,
+    NamedTuple,
+    Optional,
+    Union,
+)
 
 from dvc.repo import locked
 from dvc.repo.scm_context import scm_context
 from dvc.scm import iter_revs
 
 from .exceptions import UnresolvedExpNamesError
-from .queue.base import QueueEntry
 from .refs import ExpRefInfo
-from .utils import (
-    exp_refs,
-    exp_refs_by_baseline,
-    push_refspec,
-    remove_exp_refs,
-    resolve_name,
-)
+from .utils import exp_refs, exp_refs_by_baseline, push_refspec
 
 if TYPE_CHECKING:
     from dvc.repo import Repo
-    from dvc.repo.experiments.queue.local import LocalCeleryQueue
+    from dvc.repo.experiments.queue.celery import LocalCeleryQueue
     from dvc.scm import Git
 
+    from .queue.base import QueueEntry
+
 
 logger = logging.getLogger(__name__)
 
 
+class ExpRefAndQueueEntry(NamedTuple):
+    exp_ref_list: List["ExpRefInfo"]
+    queue_entry_list: List["QueueEntry"]
+    removed: List["str"]
+
+
+def _get_ref_and_entry_by_names(
+    exp_names: Union[str, List[str]],
+    scm: "Git",
+    celery_queue: "LocalCeleryQueue",
+    git_remote: Optional[str],
+) -> ExpRefAndQueueEntry:
+    from .utils import resolve_name
+
+    exp_ref_list: List["ExpRefInfo"] = []
+    queue_entry_list: List["QueueEntry"] = []
+    removed: List[str] = []
+    if isinstance(exp_names, str):
+        exp_names = [exp_names]
+    exp_ref_match: Dict[str, Optional["ExpRefInfo"]] = resolve_name(
+        scm, exp_names, git_remote
+    )
+    if not git_remote:
+        queue_entry_match: Dict[
+            str, Optional["QueueEntry"]
+        ] = celery_queue.match_queue_entry_by_name(
+            exp_names, celery_queue.iter_queued(), celery_queue.iter_done()
+        )
+
+    remained = []
+    for exp_name in exp_names:
+        exp_ref = exp_ref_match[exp_name]
+        queue_entry = None if git_remote else queue_entry_match[exp_name]
+        if exp_ref or queue_entry:
+            if exp_ref:
+                exp_ref_list.append(exp_ref)
+            if queue_entry:
+                queue_entry_list.append(queue_entry)
+            removed.append(exp_name)
+        else:
+            remained.append(exp_name)
+    if remained:
+        raise UnresolvedExpNamesError(remained)
+    return ExpRefAndQueueEntry(exp_ref_list, queue_entry_list, removed)
+
+
 @locked
 @scm_context
 def remove(
@@ -39,106 +88,66 @@ def remove(
     removed: List[str] = []
     if not any([exp_names, queue, all_commits, rev]):
         return removed
+    celery_queue: "LocalCeleryQueue" = repo.experiments.celery_queue
 
     if queue:
-        removed.extend(_clear_queue(repo))
+        removed.extend(celery_queue.clear(queued=True))
     if all_commits:
-        removed.extend(_clear_all_commits(repo, git_remote))
+        removed.extend(
+            _remove_commited_exps(
+                repo.scm, list(exp_refs(repo.scm, git_remote)), git_remote
+            )
+        )
         return removed
 
-    commit_ref_dict: Dict[ExpRefInfo, str] = {}
-    queue_entry_dict: Dict[str, QueueEntry] = {}
+    exp_ref_list: List["ExpRefInfo"] = []
+    queue_entry_list: List["QueueEntry"] = []
     if exp_names:
-        _resolve_exp_by_name(
-            repo, exp_names, commit_ref_dict, queue_entry_dict, git_remote
+        result = _get_ref_and_entry_by_names(
+            exp_names, repo.scm, celery_queue, git_remote
         )
+        removed.extend(result.removed)
+        exp_ref_list.extend(result.exp_ref_list)
+        queue_entry_list.extend(result.queue_entry_list)
+    elif rev:
+        exp_ref_dict = _resolve_exp_by_baseline(repo, rev, num, git_remote)
+        removed.extend(exp_ref_dict.keys())
+        exp_ref_list.extend(exp_ref_dict.values())
 
-    if rev:
-        _resolve_exp_by_baseline(repo, rev, num, commit_ref_dict, git_remote)
+    if exp_ref_list:
+        _remove_commited_exps(repo.scm, exp_ref_list, git_remote)
 
-    if commit_ref_dict:
-        removed.extend(
-            _remove_commited_exps(repo.scm, commit_ref_dict, git_remote)
-        )
+    if queue_entry_list:
+        from .queue.remove import remove_tasks
 
-    if queue_entry_dict:
-        removed.extend(_remove_queued_exps(repo, queue_entry_dict))
+        remove_tasks(celery_queue, queue_entry_list)
 
     return removed
 
 
-def _resolve_exp_by_name(
-    repo: "Repo",
-    exp_names: Union[str, List[str]],
-    commit_ref_dict: Dict["ExpRefInfo", str],
-    queue_entry_dict: Dict[str, QueueEntry],
-    git_remote: Optional[str],
-):
-    remained = set()
-    if isinstance(exp_names, str):
-        exp_names = [exp_names]
-
-    exp_ref_dict = resolve_name(repo.scm, exp_names, git_remote)
-    for exp_name, exp_ref in exp_ref_dict.items():
-        if exp_ref is None:
-            remained.add(exp_name)
-        else:
-            commit_ref_dict[exp_ref] = exp_name
-
-    if not git_remote:
-        celery_queue: "LocalCeleryQueue" = repo.experiments.celery_queue
-
-        _named_entries = celery_queue.match_queue_entry_by_name(
-            remained, celery_queue.iter_queued(), celery_queue.iter_active()
-        )
-        for exp_name, entry in _named_entries.items():
-            if entry is not None:
-                queue_entry_dict[exp_name] = entry
-                remained.remove(exp_name)
-
-    if remained:
-        raise UnresolvedExpNamesError(remained)
-
-
 def _resolve_exp_by_baseline(
     repo,
     rev: str,
     num: int,
-    commit_ref_dict: Dict[ExpRefInfo, str],
     git_remote: Optional[str] = None,
-):
+) -> Dict[str, "ExpRefInfo"]:
+    commit_ref_dict: Dict[str, "ExpRefInfo"] = {}
     rev_dict = iter_revs(repo.scm, [rev], num)
     rev_set = set(rev_dict.keys())
     ref_info_dict = exp_refs_by_baseline(repo.scm, rev_set, git_remote)
-
     for _, ref_info_list in ref_info_dict.items():
         for ref_info in ref_info_list:
-            if ref_info not in commit_ref_dict:
-                commit_ref_dict[ref_info] = ref_info.name
-
-
-def _clear_queue(repo: "Repo") -> List[str]:
-    removed_name_list = []
-    for entry in repo.experiments.celery_queue.iter_queued():
-        removed_name_list.append(entry.name or entry.stash_rev[:7])
-    repo.experiments.celery_queue.clear(queued=True)
-    return removed_name_list
-
-
-def _clear_all_commits(repo, git_remote) -> List:
-    ref_infos = {
-        ref_info: ref_info.name for ref_info in exp_refs(repo.scm, git_remote)
-    }
-    return _remove_commited_exps(repo.scm, ref_infos, git_remote)
+            commit_ref_dict[ref_info.name] = ref_info
+    return commit_ref_dict
 
 
 def _remove_commited_exps(
-    scm: "Git", exp_ref_dict: Mapping[ExpRefInfo, str], remote: Optional[str]
+    scm: "Git", exp_refs_list: Iterable[ExpRefInfo], remote: Optional[str]
 ) -> List[str]:
     if remote:
         from dvc.scm import TqdmGit
 
-        for ref_info in exp_ref_dict:
+        for ref_info in exp_refs_list:
             with TqdmGit(desc="Pushing git refs") as pbar:
                 push_refspec(
                     scm,
@@ -148,13 +157,7 @@ def _remove_commited_exps(
                     progress=pbar.update_git,
                 )
     else:
-        remove_exp_refs(scm, exp_ref_dict)
-    return list(exp_ref_dict.values())
+        from .utils import remove_exp_refs
 
-
-def _remove_queued_exps(
-    repo: "Repo", named_entries: Mapping[str, QueueEntry]
-) -> List[str]:
-    stash_rev_list = [entry.stash_rev for entry in named_entries.values()]
-    repo.experiments.celery_queue.remove(stash_rev_list)
-    return list(named_entries.keys())
+        remove_exp_refs(scm, exp_refs_list)
+    return [exp_ref.name for exp_ref in exp_refs_list]

dvc/repo/experiments/run.py

@@ -1,9 +1,11 @@
 import logging
 from typing import Dict, Iterable, Optional
 
+from dvc.dependency.param import ParamsDependency
+from dvc.exceptions import InvalidArgumentError
 from dvc.repo import locked
 from dvc.ui import ui
-from dvc.utils.cli_parse import loads_param_overrides
+from dvc.utils.cli_parse import to_path_overrides
 
 logger = logging.getLogger(__name__)
 
@@ -26,26 +28,59 @@ def run(
     Returns a dict mapping new experiment SHAs to the results
     of `repro` for that experiment.
     """
+    from dvc.utils.hydra import to_hydra_overrides
+
     if run_all:
         entries = list(repo.experiments.celery_queue.iter_queued())
         return repo.experiments.reproduce_celery(entries, jobs=jobs)
 
     if params:
-        params = loads_param_overrides(params)
+        path_overrides = to_path_overrides(params)
+    else:
+        path_overrides = {}
 
-    if queue:
-        if not kwargs.get("checkpoint_resume", None):
-            kwargs["reset"] = True
+    hydra_enabled = repo.config.get("hydra", {}).get("enabled", False)
+    hydra_output_file = ParamsDependency.DEFAULT_PARAMS_FILE
+    if hydra_enabled and hydra_output_file not in path_overrides:
+        # Force `_update_params` even if `--set-param` was not used
+        path_overrides[hydra_output_file] = []
+
+    hydra_sweep = any(
+        x.is_sweep_override()
+        for param_file in path_overrides
+        for x in to_hydra_overrides(path_overrides[param_file])
+    )
+
+    if hydra_sweep and not queue:
+        raise InvalidArgumentError(
+            "Sweep overrides can't be used without `--queue`"
+        )
+
+    if not queue:
+        return repo.experiments.reproduce_one(
+            targets=targets, params=path_overrides, tmp_dir=tmp_dir, **kwargs
+        )
+
+    if hydra_sweep:
+        from dvc.utils.hydra import get_hydra_sweeps
+
+        sweeps = get_hydra_sweeps(path_overrides)
+    else:
+        sweeps = [path_overrides]
+
+    if not kwargs.get("checkpoint_resume", None):
+        kwargs["reset"] = True
+
+    for sweep_overrides in sweeps:
         queue_entry = repo.experiments.queue_one(
             repo.experiments.celery_queue,
             targets=targets,
-            params=params,
+            params=sweep_overrides,
             **kwargs,
         )
+        if sweep_overrides:
+            ui.write(f"Queueing with overrides '{sweep_overrides}'.")
         name = queue_entry.name or queue_entry.stash_rev[:7]
         ui.write(f"Queued experiment '{name}' for future execution.")
-        return {}
 
-    return repo.experiments.reproduce_one(
-        targets=targets, params=params, tmp_dir=tmp_dir, **kwargs
-    )
+    return {}

dvc/repo/experiments/show.py

@@ -142,6 +142,9 @@ def show(
     fetch_running: bool = True,
 ):
 
+    if repo.scm.no_commits:
+        return {}
+
     if onerror is None:
         onerror = onerror_collect
 

dvc/repo/fetch.py

@@ -1,6 +1,8 @@
 import logging
+from contextlib import suppress
 from typing import TYPE_CHECKING, Optional
 
+from dvc.config import NoRemoteError
 from dvc.exceptions import DownloadError, FileTransferError
 from dvc.fs import Schemes
 
@@ -12,6 +14,36 @@ if TYPE_CHECKING:
 logger = logging.getLogger(__name__)
 
 
+def _fetch_worktree(repo, remote):
+    from dvc_data.index import save
+
+    index = repo.index.data["repo"]
+    for key, entry in index.iteritems():
+        entry.fs = remote.fs
+        entry.path = remote.fs.path.join(
+            remote.path,
+            *key,
+        )
+    save(index)
+
+    for stage in repo.index.stages:
+        for out in stage.outs:
+            if not out.use_cache:
+                continue
+
+            if not out.is_in_repo:
+                continue
+
+            workspace, key = out.index_key
+            entry = repo.index.data[workspace][key]
+            out.hash_info = entry.hash_info
+            out.meta = entry.meta
+
+        stage.dvcfile.dump(stage)
+
+    return len(index)
+
+
 @locked
 def fetch(
     self,
@@ -42,6 +74,11 @@ def fetch(
     if isinstance(targets, str):
         targets = [targets]
 
+    with suppress(NoRemoteError):
+        _remote = self.cloud.get_remote(name=remote)
+        if _remote.worktree:
+            return _fetch_worktree(self, _remote)
+
     used = self.used_objs(
         targets,
         all_branches=all_branches,
@@ -93,6 +130,18 @@ def fetch(
             downloaded += d
             failed += f
 
+    d, f = _fetch_partial_imports(
+        self,
+        targets,
+        all_branches=all_branches,
+        all_tags=all_tags,
+        all_commits=all_commits,
+        recursive=recursive,
+        revs=revs,
+    )
+    downloaded += d
+    failed += f
+
     if failed:
         raise DownloadError(failed)
 
@@ -107,3 +156,33 @@ def _fetch(repo, obj_ids, **kwargs):
     except FileTransferError as exc:
         failed += exc.amount
     return downloaded, failed
+
+
+def _fetch_partial_imports(repo, targets, **kwargs):
+    from dvc.stage.exceptions import DataSourceChanged
+
+    downloaded = 0
+    failed = 0
+    for stage in repo.partial_imports(targets, **kwargs):
+        dep = stage.deps[0]
+        out = stage.outs[0]
+        try:
+            if dep.changed_checksum():
+                raise DataSourceChanged(f"{stage} ({dep})")
+
+            logger.info("Importing '%s' -> '%s'", dep, out)
+            out.transfer(
+                dep.def_path, jobs=kwargs.get("jobs"), odb=repo.odb.local
+            )
+        except DataSourceChanged as exc:
+            logger.warning(f"{exc}")
+            failed += 1
+            continue
+        if not any(
+            kwargs.get(kw, None)
+            for kw in ("all_branches", "all_tags", "all_commits", "revs")
+        ):
+            stage.dump()
+
+        downloaded += 1
+    return downloaded, failed

dvc/repo/gc.py

@@ -60,8 +60,8 @@ def gc(
     from contextlib import ExitStack
 
     from dvc.repo import Repo
-    from dvc_data.db import get_index
-    from dvc_data.gc import gc as ogc
+    from dvc_data.hashfile.db import get_index
+    from dvc_data.hashfile.gc import gc as ogc
 
     if not repos:
         repos = []

dvc/repo/get.py

@@ -54,8 +54,8 @@ def get(url, path, out=None, rev=None, jobs=None):
             if os.path.isabs(path):
                 from dvc.fs.data import DataFileSystem
 
-                fs = DataFileSystem(repo=repo, workspace="local")
-                fs_path = path
+                fs = DataFileSystem(index=repo.index.data["local"])
+                fs_path = fs.from_os_path(path)
             else:
                 fs = repo.dvcfs
                 fs_path = fs.from_os_path(path)

dvc/repo/imp_url.py

@@ -17,11 +17,16 @@ def imp_url(
     fname=None,
     erepo=None,
     frozen=True,
+    no_download=False,
     no_exec=False,
     remote=None,
     to_remote=False,
     desc=None,
+    type=None,  # pylint: disable=redefined-builtin
+    labels=None,
+    meta=None,
     jobs=None,
+    fs_config=None,
 ):
     from dvc.dvcfile import Dvcfile
     from dvc.stage import Stage, create_stage, restore_fields
@@ -31,9 +36,9 @@ def imp_url(
         self, out, always_local=to_remote and not out
     )
 
-    if to_remote and no_exec:
+    if to_remote and (no_exec or no_download):
         raise InvalidArgumentError(
-            "--no-exec can't be combined with --to-remote"
+            "--no-exec/--no-download cannot be combined with --to-remote"
         )
 
     if not to_remote and remote:
@@ -57,12 +62,12 @@ def imp_url(
         deps=[url],
         outs=[out],
         erepo=erepo,
+        fs_config=fs_config,
     )
     restore_fields(stage)
 
-    if desc:
-        stage.outs[0].desc = desc
-
+    out_obj = stage.outs[0]
+    out_obj.annot.update(desc=desc, type=type, labels=labels, meta=meta)
     dvcfile = Dvcfile(self, stage.path)
     dvcfile.remove()
 
@@ -80,7 +85,7 @@ def imp_url(
         stage.save_deps()
         stage.md5 = stage.compute_md5()
     else:
-        stage.run(jobs=jobs)
+        stage.run(jobs=jobs, no_download=no_download)
 
     stage.frozen = frozen
 

dvc/repo/index.py

@@ -25,8 +25,8 @@ if TYPE_CHECKING:
     from dvc.repo.stage import StageLoad
     from dvc.stage import Stage
     from dvc.types import StrPath, TargetType
-    from dvc_data import Tree
     from dvc_data.hashfile.hash_info import HashInfo
+    from dvc_data.index import DataIndex
     from dvc_objects.db import ObjectDB
 
 
@@ -168,33 +168,40 @@ class Index:
         return build_outs_graph(self.graph, self.outs_trie)
 
     @cached_property
-    def tree(self) -> "Tree":
-        from dvc.config import NoRemoteError
-        from dvc_data import Tree
+    def data(self) -> "Dict[str, DataIndex]":
+        from collections import defaultdict
 
-        tree = Tree()
+        from dvc.config import NoRemoteError
+        from dvc_data.index import DataIndex, DataIndexEntry
+
+        by_workspace: dict = defaultdict(DataIndex)
+
+        by_workspace["repo"] = DataIndex()
+        by_workspace["local"] = DataIndex()
 
         for out in self.outs:
             if not out.use_cache:
                 continue
 
-            if out.is_in_repo:
-                fs_key = "repo"
-                key = self.repo.fs.path.relparts(
-                    out.fs_path, self.repo.root_dir
-                )
-            else:
-                fs_key = out.fs.protocol
-                key = out.fs.path.parts(out.fs_path)
+            workspace, key = out.index_key
 
-            out.meta.odb = out.odb
             try:
-                out.meta.remote = self.repo.cloud.get_remote_odb(out.remote)
+                remote = self.repo.cloud.get_remote_odb(out.remote)
             except NoRemoteError:
-                out.meta.remote = None
-            tree.add((fs_key,) + key, out.meta, out.hash_info)
+                remote = None
 
-        return tree
+            data_index = by_workspace[workspace]
+
+            data_index[key] = DataIndexEntry(
+                meta=out.meta,
+                obj=out.obj,
+                hash_info=out.hash_info,
+                odb=out.odb,
+                cache=out.odb,
+                remote=remote,
+            )
+
+        return dict(by_workspace)
 
     def used_objs(
         self,
@@ -232,6 +239,28 @@ class Index:
                 used[odb].update(objs)
         return used
 
+    def partial_imports(
+        self,
+        targets: "TargetType" = None,
+        recursive: bool = False,
+    ) -> List["Stage"]:
+        from itertools import chain
+
+        from dvc.utils.collections import ensure_list
+
+        collect_targets: Sequence[Optional[str]] = (None,)
+        if targets:
+            collect_targets = ensure_list(targets)
+
+        pairs = chain.from_iterable(
+            self.stage_collector.collect_granular(
+                target, recursive=recursive, with_deps=True
+            )
+            for target in collect_targets
+        )
+
+        return [stage for stage, _ in pairs if stage.is_partial_import]
+
     # Following methods help us treat the collection as a set-like structure
     # and provides faux-immutability.
     # These methods do not preserve stages order.

dvc/repo/ls.py

@@ -1,5 +1,4 @@
 import os
-from itertools import chain
 from typing import TYPE_CHECKING, Optional
 
 from dvc.exceptions import PathMissingError
@@ -66,15 +65,16 @@ def _ls(
 
     infos = {}
     for root, dirs, files in fs.walk(
-        fs_path, dvcfiles=True, dvc_only=dvc_only
+        fs_path, dvcfiles=True, dvc_only=dvc_only, detail=True
     ):
-        entries = chain(files, dirs) if not recursive else files
+        if not recursive:
+            files.update(dirs)
 
-        for entry in entries:
-            entry_fs_path = fs.path.join(root, entry)
+        for name, entry in files.items():
+            entry_fs_path = fs.path.join(root, name)
             relparts = fs.path.relparts(entry_fs_path, fs_path)
             name = os.path.join(*relparts)
-            infos[name] = fs.info(entry_fs_path)
+            infos[name] = entry
 
         if not recursive:
             break
@@ -85,11 +85,10 @@ def _ls(
     ret = {}
     for name, info in infos.items():
         dvc_info = info.get("dvc_info", {})
-        if dvc_info.get("outs") or not dvc_only:
-            ret[name] = {
-                "isout": dvc_info.get("isout", False),
-                "isdir": info["type"] == "directory",
-                "isexec": info.get("isexec", False),
-            }
+        ret[name] = {
+            "isout": dvc_info.get("isout", False),
+            "isdir": info["type"] == "directory",
+            "isexec": info.get("isexec", False),
+        }
 
     return ret

dvc/repo/metrics/show.py

@@ -12,7 +12,7 @@ from dvc.repo.live import summary_fs_path
 from dvc.scm import NoSCMError
 from dvc.utils import error_handler, errored_revisions, onerror_collect
 from dvc.utils.collections import ensure_list
-from dvc.utils.serialize import LOADERS
+from dvc.utils.serialize import load_path
 
 logger = logging.getLogger(__name__)
 
@@ -71,9 +71,7 @@ def _extract_metrics(metrics, path, rev):
 
 @error_handler
 def _read_metric(path, fs, rev, **kwargs):
-    suffix = fs.path.suffix(path).lower()
-    loader = LOADERS[suffix]
-    val = loader(path, fs=fs)
+    val = load_path(path, fs)
     val = _extract_metrics(val, path, rev)
     return val or {}
 
@@ -87,12 +85,14 @@ def _read_metrics(repo, metrics, rev, onerror=None):
 
     res = {}
     for metric in metrics:
+        rel_metric_path = os.path.join(relpath, *fs.path.parts(metric))
         if not fs.isfile(metric):
-            continue
+            if fs.isfile(rel_metric_path):
+                metric = rel_metric_path
+            else:
+                continue
 
-        res[os.path.join(relpath, *fs.path.parts(metric))] = _read_metric(
-            metric, fs, rev, onerror=onerror
-        )
+        res[rel_metric_path] = _read_metric(metric, fs, rev, onerror=onerror)
 
     return res
 

dvc/repo/params/show.py

@@ -22,7 +22,7 @@ from dvc.stage import PipelineStage
 from dvc.ui import ui
 from dvc.utils import error_handler, errored_revisions, onerror_collect
 from dvc.utils.collections import ensure_list
-from dvc.utils.serialize import LOADERS
+from dvc.utils.serialize import load_path
 
 if TYPE_CHECKING:
     from dvc.output import Output
@@ -36,7 +36,7 @@ def _is_params(dep: "Output"):
 
 
 def _collect_configs(
-    repo: "Repo", rev, targets=None, duplicates=False
+    repo: "Repo", rev, targets=None, deps=False, stages=None
 ) -> Tuple[List["Output"], List[str]]:
 
     params, fs_paths = collect(
@@ -45,10 +45,10 @@ def _collect_configs(
         deps=True,
         output_filter=_is_params,
         rev=rev,
-        duplicates=duplicates,
+        duplicates=deps or stages is not None,
     )
     all_fs_paths = fs_paths + [p.fs_path for p in params]
-    if not targets:
+    if not any([deps, targets, stages]):
         default_params = repo.fs.path.join(
             repo.root_dir, ParamsDependency.DEFAULT_PARAMS_FILE
         )
@@ -56,14 +56,15 @@ def _collect_configs(
             default_params
         ):
             fs_paths.append(default_params)
+    if targets and (deps or stages) and not params:
+        # A target has been provided but it is not used in the stages
+        fs_paths = []
     return params, fs_paths
 
 
 @error_handler
 def _read_fs_path(fs, fs_path, **kwargs):
-    suffix = fs.path.suffix(fs_path).lower()
-    loader = LOADERS[suffix]
-    return loader(fs_path, fs=fs)
+    return load_path(fs_path, fs)
 
 
 def _read_params(
@@ -173,7 +174,7 @@ def _gather_params(
     repo, rev, targets=None, deps=False, onerror=None, stages=None
 ):
     param_outs, params_fs_paths = _collect_configs(
-        repo, rev, targets=targets, duplicates=deps or stages
+        repo, rev, targets=targets, deps=deps, stages=stages
     )
     params = _read_params(
         repo,

dvc/repo/plots/__init__.py

@@ -386,30 +386,56 @@ def _collect_output_plots(
     return result
 
 
-def _adjust_definitions_to_cwd(fs, config_relpath, plots_definitions):
-    result = defaultdict(dict)
+def _id_is_path(plot_props=None):
+    if not plot_props:
+        return True
 
-    config_dirname = fs.path.dirname(config_relpath)
+    y_def = plot_props.get("y")
+    return not isinstance(y_def, dict)
 
-    for plot_id, plot_def in plots_definitions.items():
 
-        y_def = plot_def.get("y", None) if plot_def else None
-        if y_def is None or not isinstance(y_def, dict):
-            # plot_id is filename
-            new_plot_id = _normpath(fs.path.join(config_dirname, plot_id))
-            result[new_plot_id] = plot_def or {}
+def _adjust_sources(fs, plot_props, config_dir):
+    new_plot_props = deepcopy(plot_props)
+    old_y = new_plot_props.pop("y", {})
+    new_y = {}
+    for filepath, val in old_y.items():
+        new_y[_normpath(fs.path.join(config_dir, filepath))] = val
+    new_plot_props["y"] = new_y
+    return new_plot_props
+
+
+def _resolve_definitions(
+    fs, targets, props, config_path, definitions, onerror=None
+):
+    config_dir = fs.path.dirname(config_path)
+    result: Dict[str, Dict] = {}
+    for plot_id, plot_props in definitions.items():
+        if plot_props is None:
+            plot_props = {}
+        if _id_is_path(plot_props):
+            data_path = _normpath(fs.path.join(config_dir, plot_id))
+            if _matches(targets, config_path, plot_id):
+                unpacked = unpack_if_dir(
+                    fs,
+                    data_path,
+                    props={**plot_props, **props},
+                    onerror=onerror,
+                )
+                dpath.util.merge(
+                    result,
+                    unpacked,
+                )
         else:
-            new_plot_def = deepcopy(plot_def)
-            old_y = new_plot_def.pop("y")
-            new_y = {}
-            for filepath, val in old_y.items():
-                new_y[_normpath(fs.path.join(config_dirname, filepath))] = val
-            new_plot_def["y"] = new_y
-            result[plot_id] = new_plot_def
-    return dict(result)
+            if _matches(targets, config_path, plot_id):
+                adjusted_props = _adjust_sources(fs, plot_props, config_dir)
+                dpath.util.merge(
+                    result, {"data": {plot_id: {**adjusted_props, **props}}}
+                )
+
+    return result
 
 
-def _collect_pipeline_files(repo, targets: List[str], props):
+def _collect_pipeline_files(repo, targets: List[str], props, onerror=None):
     from dvc.dvcfile import PipelineFile
 
     result: Dict[str, Dict] = {}
@@ -417,21 +443,19 @@ def _collect_pipeline_files(repo, targets: List[str], props):
     for dvcfile in dvcfiles:
         if isinstance(dvcfile, PipelineFile):
             dvcfile_path = _relpath(repo.dvcfs, dvcfile.path)
-            dvcfile_defs = _adjust_definitions_to_cwd(
-                repo.fs, dvcfile_path, dvcfile.load().get("plots", {})
+            dvcfile_defs = dvcfile.load().get("plots", {})
+            resolved = _resolve_definitions(
+                repo.dvcfs,
+                targets,
+                props,
+                dvcfile_path,
+                dvcfile_defs,
+                onerror=onerror,
+            )
+            dpath.util.merge(
+                result,
+                {dvcfile_path: resolved},
             )
-            for plot_id, plot_props in dvcfile_defs.items():
-                if plot_props is None:
-                    plot_props = {}
-                if _matches(targets, dvcfile_path, plot_id):
-                    dpath.util.merge(
-                        result,
-                        {
-                            dvcfile_path: {
-                                "data": {plot_id: {**plot_props, **props}}
-                            }
-                        },
-                    )
     return result
 
 
@@ -453,7 +477,10 @@ def _collect_definitions(
     fs = DvcFileSystem(repo=repo)
 
     if not config_files:
-        dpath.util.merge(result, _collect_pipeline_files(repo, targets, props))
+        dpath.util.merge(
+            result,
+            _collect_pipeline_files(repo, targets, props, onerror=onerror),
+        )
 
     if targets or (not targets and not config_files):
         dpath.util.merge(
@@ -463,12 +490,20 @@ def _collect_definitions(
 
     if config_files:
         for path in config_files:
-            definitions = parse(fs, path)
-            definitions = _adjust_definitions_to_cwd(
-                repo.fs, path, definitions
-            )
+            definitions = parse(fs, path).get("data", {})
             if definitions:
-                dpath.util.merge(result, {path: definitions})
+                resolved = _resolve_definitions(
+                    repo.dvcfs,
+                    targets,
+                    props,
+                    path,
+                    definitions,
+                    onerror=onerror,
+                )
+                dpath.util.merge(
+                    result,
+                    {path: resolved},
+                )
 
     for target in targets:
         if not result or fs.exists(target):

dvc/repo/plots/diff.py

@@ -12,6 +12,8 @@ def _revisions(repo, revs, experiment):
 
 
 def diff(repo, *args, revs=None, experiment=False, **kwargs):
+    if repo.scm.no_commits:
+        return {}
     return repo.plots.show(
         *args, revs=_revisions(repo, revs, experiment), **kwargs
     )

dvc/repo/push.py

@@ -9,6 +9,52 @@ if TYPE_CHECKING:
     from dvc_objects.db.base import ObjectDB
 
 
+def _push_worktree(repo, remote):
+    from dvc_data.hashfile.tree import tree_from_index
+    from dvc_data.index import build, checkout, collect
+
+    index = repo.index.data["repo"]
+    checkout(index, remote.path, remote.fs, force=True)
+    build(index, remote.path, remote.fs)
+    if any(out.isdir() for out in repo.index.outs):
+        collect(index, remote.path, remote.fs)
+
+    for stage in repo.index.stages:
+        for out in stage.outs:
+            if not out.use_cache:
+                continue
+
+            if not out.is_in_repo:
+                continue
+
+            workspace, key = out.index_key
+            index = repo.index.data[workspace]
+            entry = index[key]
+            if out.isdir():
+                old_tree = out.get_obj()
+                entry.hash_info = old_tree.hash_info
+                entry.meta = out.meta
+                for subkey, entry in index.iteritems(key):
+                    if entry.meta.isdir:
+                        continue
+                    fs_path = repo.fs.path.join(repo.root_dir, *subkey)
+                    _, hash_info = old_tree.get(
+                        repo.fs.path.relparts(fs_path, out.fs_path)
+                    )
+                    entry.hash_info = hash_info
+                tree_meta, new_tree = tree_from_index(index, key)
+                new_tree.digest()
+                out.obj = new_tree
+                out.hash_info = new_tree.hash_info
+                out.meta = tree_meta
+            else:
+                out.hash_info = entry.hash_info
+                out.meta = entry.meta
+        stage.dvcfile.dump(stage, with_files=True)
+
+    return len(index)
+
+
 @locked
 def push(
     self,
@@ -26,6 +72,10 @@ def push(
     odb: Optional["ObjectDB"] = None,
     include_imports=False,
 ):
+    _remote = self.cloud.get_remote(name=remote)
+    if _remote.worktree:
+        return _push_worktree(self, _remote)
+
     used_run_cache = (
         self.stage_cache.push(remote, odb=odb) if run_cache else []
     )

dvc/repo/remove.py

@@ -1,6 +1,13 @@
 import logging
 import typing
 
+from dvc.dvcfile import DVC_FILE_SUFFIX
+from dvc.stage.exceptions import (
+    StageFileDoesNotExistError,
+    StageFileIsNotDvcFileError,
+    StageNotFound,
+)
+
 from . import locked
 
 if typing.TYPE_CHECKING:
@@ -11,7 +18,16 @@ logger = logging.getLogger(__name__)
 
 @locked
 def remove(self: "Repo", target: str, outs: bool = False):
-    stages = self.stage.from_target(target)
+    try:
+        stages = self.stage.from_target(target, accept_group=False)
+    except (StageNotFound, StageFileDoesNotExistError) as e:
+        # If the user specified a tracked file as a target instead of a stage,
+        # e.g. `data.csv` instead of `data.csv.dvc`,
+        # give a more helpful error message.
+        if self.fs.exists(target + DVC_FILE_SUFFIX):
+            raise StageFileIsNotDvcFileError(target) from e
+        else:
+            raise
 
     for stage in stages:
         stage.remove(remove_outs=outs, force=outs)

dvc/repo/reproduce.py

@@ -64,7 +64,9 @@ def _get_stage_files(stage: "Stage") -> typing.Iterator[str]:
         if (
             not dep.use_scm_ignore
             and dep.is_in_repo
-            and not stage.repo.dvcfs.isdvc(dep.fs_path)
+            and not stage.repo.dvcfs.isdvc(
+                stage.repo.dvcfs.from_os_path(str(dep))
+            )
         ):
             yield dep.fs_path
     for out in stage.outs:
@@ -100,7 +102,6 @@ def reproduce(
     from .graph import get_pipeline, get_pipelines
 
     glob = kwargs.pop("glob", False)
-    accept_group = not glob
 
     if isinstance(targets, str):
         targets = [targets]
@@ -135,7 +136,6 @@ def reproduce(
                 self.stage.collect(
                     target,
                     recursive=recursive,
-                    accept_group=accept_group,
                     glob=glob,
                 )
             )

dvc/repo/scm_context.py

@@ -46,7 +46,7 @@ class SCMContext:
     @staticmethod
     def _make_git_add_cmd(paths: Union[str, Iterable[str]]) -> str:
         files = " ".join(map(shlex.quote, ensure_list(paths)))
-        return f"\tgit add {files}".expandtabs(4)
+        return f"\tgit add {files}"
 
     def add(self, paths: Union[str, Iterable[str]]) -> None:
         from scmrepo.exceptions import UnsupportedIndexFormat

dvc/repo/stage.py

@@ -82,7 +82,6 @@ def _collect_specific_target(
     target: str,
     with_deps: bool,
     recursive: bool,
-    accept_group: bool,
 ) -> Tuple[StageIter, "OptStr", "OptStr"]:
     from dvc.dvcfile import is_valid_filename
 
@@ -98,13 +97,11 @@ def _collect_specific_target(
         msg = "Checking if stage '%s' is in '%s'"
         logger.debug(msg, target, PIPELINE_FILE)
         if not (recursive and loader.fs.isdir(target)):
-            stages = _maybe_collect_from_dvc_yaml(
-                loader, target, with_deps, accept_group=accept_group
-            )
+            stages = _maybe_collect_from_dvc_yaml(loader, target, with_deps)
             if stages:
                 return stages, file, name
     elif not with_deps and is_valid_filename(file):
-        stages = loader.load_all(file, name, accept_group=accept_group)
+        stages = loader.load_all(file, name)
         return stages, file, name
     return [], file, name
 
@@ -209,7 +206,7 @@ class StageLoad:
         return stage
 
     def from_target(
-        self, target: str, accept_group: bool = False, glob: bool = False
+        self, target: str, accept_group: bool = True, glob: bool = False
     ) -> StageList:
         """
         Returns a list of stage from the provided target.
@@ -250,15 +247,12 @@ class StageLoad:
         self,
         stages: "StageLoader",
         name: str = None,
-        accept_group: bool = False,
+        accept_group: bool = True,
         glob: bool = False,
     ) -> Iterable[str]:
 
-        assert not (accept_group and glob)
-
         if not name:
             return stages.keys()
-
         if accept_group and stages.is_foreach_generated(name):
             return self._get_group_keys(stages, name)
         if glob:
@@ -269,7 +263,7 @@ class StageLoad:
         self,
         path: str = None,
         name: str = None,
-        accept_group: bool = False,
+        accept_group: bool = True,
         glob: bool = False,
     ) -> StageList:
         """Load a list of stages from a file.
@@ -338,7 +332,6 @@ class StageLoad:
         with_deps: bool = False,
         recursive: bool = False,
         graph: "DiGraph" = None,
-        accept_group: bool = False,
         glob: bool = False,
     ) -> StageIter:
         """Collect list of stages from the provided target.
@@ -347,15 +340,14 @@ class StageLoad:
             target: if not provided, all of the stages in the graph are
                 returned.
                 Target can be:
-                - a stage name in the `dvc.yaml` file.
+                - a foreach group name or a stage name in the `dvc.yaml` file.
+                - a generated stage name from a foreach group.
                 - a path to `dvc.yaml` or `.dvc` file.
                 - in case of a stage to a dvc.yaml file in a different
                   directory than current working directory, it can be a path
                   to dvc.yaml file, followed by a colon `:`, followed by stage
                   name (eg: `../dvc.yaml:build`).
                 - in case of `recursive`, it can be a path to a directory.
-                - in case of `accept_group`, it can be a group name of
-                    `foreach` generated stage.
                 - in case of `glob`, it can be a wildcard pattern to match
                   stages. Example: `build*` for stages in `dvc.yaml` file, or
                   `../dvc.yaml:build*` for stages in dvc.yaml in a different
@@ -367,8 +359,6 @@ class StageLoad:
             recursive: if true and if `target` is a directory, all of the
                 stages inside that directory is returned.
             graph: graph to use. Defaults to `repo.graph`.
-            accept_group: if true, all of the `foreach` generated stages of
-                the specified target is returned.
             glob: Use `target` as a pattern to match stages in a file.
         """
         if not target:
@@ -380,7 +370,7 @@ class StageLoad:
             path = self.fs.path.abspath(target)
             return collect_inside_path(path, graph or self.graph)
 
-        stages = self.from_target(target, accept_group=accept_group, glob=glob)
+        stages = self.from_target(target, glob=glob)
         if not with_deps:
             return stages
 
@@ -392,14 +382,14 @@ class StageLoad:
         with_deps: bool = False,
         recursive: bool = False,
         graph: "DiGraph" = None,
-        accept_group: bool = False,
     ) -> List[StageInfo]:
         """Collects a list of (stage, filter_info) from the given target.
 
         Priority is in the order of following in case of ambiguity:
         - .dvc file or .yaml file
         - dir if recursive and directory exists
-        - stage_name
+        - foreach_group_name or stage_name
+        - generated stage name from a foreach group
         - output file
 
         Args:
@@ -418,7 +408,7 @@ class StageLoad:
         target = as_posix(target)
 
         stages, file, _ = _collect_specific_target(
-            self, target, with_deps, recursive, accept_group
+            self, target, with_deps, recursive
         )
         if not stages:
             if not (recursive and self.fs.isdir(target)):
@@ -440,7 +430,6 @@ class StageLoad:
                     with_deps,
                     recursive,
                     graph,
-                    accept_group=accept_group,
                 )
             except StageFileDoesNotExistError as exc:
                 # collect() might try to use `target` as a stage name

dvc/repo/update.py

@@ -10,6 +10,7 @@ def update(
     rev=None,
     recursive=False,
     to_remote=False,
+    no_download=False,
     remote=None,
     jobs=None,
 ):
@@ -21,6 +22,11 @@ def update(
     if isinstance(targets, str):
         targets = [targets]
 
+    if to_remote and no_download:
+        raise InvalidArgumentError(
+            "--to-remote can't be used with --no-download"
+        )
+
     if not to_remote and remote:
         raise InvalidArgumentError(
             "--remote can't be used without --to-remote"
@@ -31,7 +37,13 @@ def update(
         stages.update(self.stage.collect(target, recursive=recursive))
 
     for stage in stages:
-        stage.update(rev, to_remote=to_remote, remote=remote, jobs=jobs)
+        stage.update(
+            rev,
+            to_remote=to_remote,
+            remote=remote,
+            no_download=no_download,
+            jobs=jobs,
+        )
         dvcfile = Dvcfile(self, stage.path)
         dvcfile.dump(stage)
 

dvc/rwlock.py

@@ -7,6 +7,7 @@ from voluptuous import Invalid, Optional, Required, Schema
 
 from .exceptions import DvcException
 from .fs import localfs
+from .lock import make_lock
 from .utils import relpath
 
 INFO_SCHEMA = {Required("pid"): int, Required("cmd"): str}
@@ -33,22 +34,29 @@ class RWLockFileFormatError(DvcException):
 
 
 @contextmanager
-def _edit_rwlock(lock_dir):
-    path = os.path.join(lock_dir, "rwlock")
-    try:
-        with open(path, encoding="utf-8") as fobj:
-            lock = SCHEMA(json.load(fobj))
-    except FileNotFoundError:
-        lock = SCHEMA({})
-    except json.JSONDecodeError as exc:
-        raise RWLockFileCorruptedError(path) from exc
-    except Invalid as exc:
-        raise RWLockFileFormatError(path) from exc
-    lock["read"] = defaultdict(list, lock["read"])
-    lock["write"] = defaultdict(dict, lock["write"])
-    yield lock
-    with open(path, "w+", encoding="utf-8") as fobj:
-        json.dump(lock, fobj)
+def _edit_rwlock(lock_dir, fs, hardlink):
+    path = fs.path.join(lock_dir, "rwlock")
+
+    rwlock_guard = make_lock(
+        fs.path.join(lock_dir, "rwlock.lock"),
+        tmp_dir=lock_dir,
+        hardlink_lock=hardlink,
+    )
+    with rwlock_guard:
+        try:
+            with fs.open(path, encoding="utf-8") as fobj:
+                lock = SCHEMA(json.load(fobj))
+        except FileNotFoundError:
+            lock = SCHEMA({})
+        except json.JSONDecodeError as exc:
+            raise RWLockFileCorruptedError(path) from exc
+        except Invalid as exc:
+            raise RWLockFileFormatError(path) from exc
+        lock["read"] = defaultdict(list, lock["read"])
+        lock["write"] = defaultdict(dict, lock["write"])
+        yield lock
+        with fs.open(path, "w", encoding="utf-8") as fobj:
+            json.dump(lock, fobj)
 
 
 def _infos_to_str(infos):
@@ -133,14 +141,16 @@ def _release_read(lock, info, changes):
 
 
 @contextmanager
-def rwlock(tmp_dir, cmd, read, write):
+def rwlock(tmp_dir, fs, cmd, read, write, hardlink):
     """Create non-thread-safe RWLock for file paths.
 
     Args:
         tmp_dir (str): existing directory where to create the rwlock file.
+        fs (FileSystem): fs instance that tmp_dir belongs to.
         cmd (str): command that will be working on these file path.
         read ([str]): file paths that are going to be read.
         write ([str]): file paths that are going to be written.
+        hardlink (bool): use hardlink lock to guard rwlock file when on edit.
 
     Raises:
         LockError: raised if file paths we want to read is being written to by
@@ -152,7 +162,7 @@ def rwlock(tmp_dir, cmd, read, write):
     """
     info = {"pid": os.getpid(), "cmd": cmd}
 
-    with _edit_rwlock(tmp_dir) as lock:
+    with _edit_rwlock(tmp_dir, fs, hardlink) as lock:
 
         _check_blockers(lock, info, mode="write", waiters=read + write)
         _check_blockers(lock, info, mode="read", waiters=write)
@@ -163,6 +173,6 @@ def rwlock(tmp_dir, cmd, read, write):
     try:
         yield
     finally:
-        with _edit_rwlock(tmp_dir) as lock:
+        with _edit_rwlock(tmp_dir, fs, hardlink) as lock:
             _release_write(lock, info, wchanges)
             _release_read(lock, info, rchanges)

dvc/schema.py

@@ -3,11 +3,11 @@ from collections.abc import Mapping
 from voluptuous import Any, Optional, Required, Schema
 
 from dvc import dependency, output
-from dvc.output import CHECKSUMS_SCHEMA, Output
+from dvc.annotations import ANNOTATION_SCHEMA
+from dvc.output import CHECKSUMS_SCHEMA, DIR_FILES_SCHEMA, META_SCHEMA, Output
 from dvc.parsing import DO_KWD, FOREACH_KWD, VARS_KWD
 from dvc.parsing.versions import SCHEMA_KWD, lockfile_version_schema
 from dvc.stage.params import StageParams
-from dvc_data.hashfile.meta import Meta
 
 STAGES = "stages"
 SINGLE_STAGE_SCHEMA = {
@@ -25,10 +25,9 @@ SINGLE_STAGE_SCHEMA = {
 
 DATA_SCHEMA = {
     **CHECKSUMS_SCHEMA,
+    **META_SCHEMA,
     Required("path"): str,
-    Meta.PARAM_SIZE: int,
-    Meta.PARAM_NFILES: int,
-    Meta.PARAM_ISEXEC: bool,
+    Output.PARAM_FILES: [DIR_FILES_SCHEMA],
 }
 LOCK_FILE_STAGE_SCHEMA = {
     Required(StageParams.PARAM_CMD): Any(str, list),
@@ -47,16 +46,15 @@ LOCKFILE_V2_SCHEMA = {
 
 OUT_PSTAGE_DETAILED_SCHEMA = {
     str: {
+        **ANNOTATION_SCHEMA,  # type: ignore
         Output.PARAM_CACHE: bool,
         Output.PARAM_PERSIST: bool,
         Output.PARAM_CHECKPOINT: bool,
-        Output.PARAM_DESC: str,
         Output.PARAM_REMOTE: str,
     }
 }
 
 PLOTS = "plots"
-PLOTS_SCHEMA = dict
 PLOT_PROPS = {
     Output.PARAM_PLOT_TEMPLATE: str,
     Output.PARAM_PLOT_X: str,
@@ -112,6 +110,15 @@ def either_or(primary, fallback, fallback_includes=None):
     return validator
 
 
+PLOT_DEFINITION = {
+    Output.PARAM_PLOT_X: str,
+    Output.PARAM_PLOT_Y: Any(str, [str], {str: Any(str, [str])}),
+    Output.PARAM_PLOT_X_LABEL: str,
+    Output.PARAM_PLOT_Y_LABEL: str,
+    Output.PARAM_PLOT_TITLE: str,
+    Output.PARAM_PLOT_TEMPLATE: str,
+}
+PLOTS_SCHEMA = {str: Any(PLOT_DEFINITION, None)}
 FOREACH_IN = {
     Required(FOREACH_KWD): Any(dict, list, str),
     Required(DO_KWD): STAGE_DEFINITION,

dvc/scm.py

@@ -160,7 +160,7 @@ def resolve_rev(scm: "Git", rev: str) -> str:
     except InternalRevError as exc:
         # `scm` will only resolve git branch and tag names,
         # if rev is not a sha it may be an abbreviated experiment name
-        if not rev.startswith("refs/"):
+        if not (rev == "HEAD" or rev.startswith("refs/")):
             from dvc.repo.experiments.utils import (
                 AmbiguousExpRefInfo,
                 resolve_name,

dvc/stage/__init__.py

@@ -78,6 +78,7 @@ def create_stage(cls, repo, path, external=False, **kwargs):
 
     wdir = os.path.abspath(kwargs.get("wdir", None) or os.curdir)
     path = os.path.abspath(path)
+
     check_dvcfile_path(repo, path)
     check_stage_path(repo, wdir, is_wdir=kwargs.get("wdir"))
     check_stage_path(repo, os.path.dirname(path))
@@ -87,7 +88,7 @@ def create_stage(cls, repo, path, external=False, **kwargs):
     if not external:
         check_no_externals(stage)
     fill_stage_dependencies(
-        stage, **project(kwargs, ["deps", "erepo", "params"])
+        stage, **project(kwargs, ["deps", "erepo", "params", "fs_config"])
     )
     check_circular_dependency(stage)
     check_duplicated_arguments(stage)
@@ -109,16 +110,13 @@ def restore_fields(stage):
     # will be used to restore comments later
     # noqa, pylint: disable=protected-access
     stage._stage_text = old._stage_text
-
     stage.meta = old.meta
     stage.desc = old.desc
 
-    old_fields = {out.def_path: (out.desc, out.remote) for out in old.outs}
-
+    old_fields = {out.def_path: (out.annot, out.remote) for out in old.outs}
     for out in stage.outs:
-        out_fields = old_fields.get(out.def_path, None)
-        if out_fields:
-            out.desc, out.remote = out_fields
+        if out_fields := old_fields.get(out.def_path, None):
+            out.annot, out.remote = out_fields
 
 
 class Stage(params.StageParams):
@@ -242,6 +240,14 @@ class Stage(params.StageParams):
         """Whether the DVC file was created with `dvc import`."""
         return not self.cmd and len(self.deps) == 1 and len(self.outs) == 1
 
+    @property
+    def is_partial_import(self) -> bool:
+        """
+        Whether the DVC file was created using `dvc import --no-download`
+        or `dvc import-url --no-download`.
+        """
+        return self.is_import and (not self.outs[0].hash_info)
+
     @property
     def is_repo_import(self):
         if not self.is_import:
@@ -433,18 +439,30 @@ class Stage(params.StageParams):
 
         return self
 
-    def update(self, rev=None, to_remote=False, remote=None, jobs=None):
+    def update(
+        self,
+        rev=None,
+        to_remote=False,
+        remote=None,
+        no_download=None,
+        jobs=None,
+    ):
         if not (self.is_repo_import or self.is_import):
             raise StageUpdateError(self.relpath)
         update_import(
-            self, rev=rev, to_remote=to_remote, remote=remote, jobs=jobs
+            self,
+            rev=rev,
+            to_remote=to_remote,
+            remote=remote,
+            no_download=no_download,
+            jobs=jobs,
         )
 
     def reload(self):
         return self.dvcfile.stage
 
-    def dumpd(self):
-        return get_dump(self)
+    def dumpd(self, **kwargs):
+        return get_dump(self, **kwargs)
 
     def compute_md5(self):
         # `dvc add`ed files don't need stage md5
@@ -457,6 +475,7 @@ class Stage(params.StageParams):
 
     def save(self, allow_missing=False):
         self.save_deps(allow_missing=allow_missing)
+
         self.save_outs(allow_missing=allow_missing)
         self.md5 = self.compute_md5()
 
@@ -525,14 +544,16 @@ class Stage(params.StageParams):
         no_commit=False,
         force=False,
         allow_missing=False,
+        no_download=False,
         **kwargs,
     ):
         if (self.cmd or self.is_import) and not self.frozen and not dry:
             self.remove_outs(ignore_remove=False, force=False)
 
-        if not self.frozen and self.is_import:
-            jobs = kwargs.get("jobs", None)
-            self._sync_import(dry, force, jobs)
+        if (not self.frozen and self.is_import) or self.is_partial_import:
+            self._sync_import(
+                dry, force, kwargs.get("jobs", None), no_download
+            )
         elif not self.frozen and self.cmd:
             self._run_stage(dry, force, **kwargs)
         else:
@@ -544,7 +565,7 @@ class Stage(params.StageParams):
                 self._check_missing_outputs()
 
         if not dry:
-            if kwargs.get("checkpoint_func", None):
+            if kwargs.get("checkpoint_func", None) or no_download:
                 allow_missing = True
             self.save(allow_missing=allow_missing)
             if not no_commit:
@@ -555,8 +576,8 @@ class Stage(params.StageParams):
         return run_stage(self, dry, force, **kwargs)
 
     @rwlocked(read=["deps"], write=["outs"])
-    def _sync_import(self, dry, force, jobs):
-        sync_import(self, dry, force, jobs)
+    def _sync_import(self, dry, force, jobs, no_download):
+        sync_import(self, dry, force, jobs, no_download)
 
     @rwlocked(read=["outs"])
     def _check_missing_outputs(self):
@@ -571,6 +592,8 @@ class Stage(params.StageParams):
     @rwlocked(write=["outs"])
     def checkout(self, allow_missing=False, **kwargs):
         stats = defaultdict(list)
+        if self.is_partial_import:
+            return {}
         for out in self.filter_outs(kwargs.get("filter_info")):
             key, outs = self._checkout(
                 out,
@@ -658,6 +681,9 @@ class Stage(params.StageParams):
         self, *args, **kwargs
     ) -> Dict[Optional["ObjectDB"], Set["HashInfo"]]:
         """Return set of object IDs used by this stage."""
+        if self.is_partial_import:
+            return {}
+
         used_objs = defaultdict(set)
         for out in self.filter_outs(kwargs.get("filter_info")):
             for odb, objs in out.get_used_objs(*args, **kwargs).items():

dvc/stage/cache.py

@@ -9,7 +9,7 @@ from funcy import cached_property, first
 from dvc import fs
 from dvc.exceptions import DvcException
 from dvc.utils import dict_sha256, relpath
-from dvc_data.transfer import _log_exceptions
+from dvc_data.hashfile.transfer import _log_exceptions
 
 if TYPE_CHECKING:
     from dvc_objects.db import ObjectDB
@@ -65,7 +65,7 @@ class StageCache:
 
     @cached_property
     def cache_dir(self):
-        return os.path.join(self.repo.odb.local.cache_dir, "runs")
+        return os.path.join(self.repo.odb.local.path, "runs")
 
     def _get_cache_dir(self, key):
         return os.path.join(self.cache_dir, key[:2], key)

dvc/stage/decorators.py

@@ -32,7 +32,14 @@ def rwlocked(call, read=None, write=None):
 
     cmd = " ".join(sys.argv)
 
-    with rwlock(stage.repo.tmp_dir, cmd, _chain(read), _chain(write)):
+    with rwlock(
+        stage.repo.tmp_dir,
+        stage.repo.fs,
+        cmd,
+        _chain(read),
+        _chain(write),
+        stage.repo.config["core"].get("hardlink_lock", False),
+    ):
         return call()
 
 

dvc/stage/exceptions.py

@@ -31,7 +31,7 @@ class StageFileIsNotDvcFileError(DvcException):
 
         sname = fname + DVC_FILE_SUFFIX
         if is_dvc_file(sname):
-            msg += f" Do you mean '{sname}'?"
+            msg += f". Do you mean '{sname}'?"
 
         super().__init__(msg)
 
@@ -80,6 +80,11 @@ class MissingDataSource(DvcException):
         super().__init__(msg)
 
 
+class DataSourceChanged(DvcException):
+    def __init__(self, path: str):
+        super().__init__(f"data source changed: {path}")
+
+
 class StageNotFound(DvcException, KeyError):
     def __init__(self, file, name):
         self.file = file.relpath

dvc/stage/imports.py

@@ -17,20 +17,36 @@ def _update_import_on_remote(stage, remote, jobs):
     stage.outs[0].transfer(url, odb=odb, jobs=jobs, update=True)
 
 
-def update_import(stage, rev=None, to_remote=False, remote=None, jobs=None):
+def update_import(
+    stage, rev=None, to_remote=False, remote=None, no_download=None, jobs=None
+):
     stage.deps[0].update(rev=rev)
+    outs = stage.outs
+    deps = stage.deps
+
     frozen = stage.frozen
     stage.frozen = False
+
+    if stage.outs:
+        stage.outs[0].clear()
     try:
         if to_remote:
             _update_import_on_remote(stage, remote, jobs)
         else:
-            stage.reproduce(jobs=jobs)
+            stage.reproduce(no_download=no_download, jobs=jobs)
     finally:
+        if deps == stage.deps:
+            stage.outs = outs
         stage.frozen = frozen
 
 
-def sync_import(stage, dry=False, force=False, jobs=None):
+def sync_import(
+    stage,
+    dry=False,
+    force=False,
+    jobs=None,
+    no_download=False,
+):
     """Synchronize import's outs to the workspace."""
     logger.info("Importing '%s' -> '%s'", stage.deps[0], stage.outs[0])
     if dry:
@@ -40,4 +56,8 @@ def sync_import(stage, dry=False, force=False, jobs=None):
         stage.outs[0].checkout()
     else:
         stage.save_deps()
-        stage.deps[0].download(stage.outs[0], jobs=jobs)
+        if not no_download:
+            stage.deps[0].download(
+                stage.outs[0],
+                jobs=jobs,
+            )

dvc/stage/loader.py

@@ -69,7 +69,8 @@ class StageLoader(Mapping):
             info = info.copy()
             info.pop("path", None)
             item.meta = Meta.from_dict(info)
-            item.hash_info = HashInfo.from_dict(info)
+            hash_value = getattr(item.meta, item.hash_name, None)
+            item.hash_info = HashInfo(item.hash_name, hash_value)
 
     @classmethod
     def load_stage(cls, dvcfile, name, stage_data, lock_data=None):

dvc/stage/serialize.py

@@ -6,7 +6,7 @@ from typing import TYPE_CHECKING, List, no_type_check
 from funcy import post_processing
 
 from dvc.dependency import ParamsDependency
-from dvc.output import Output
+from dvc.output import Annotation, Output
 from dvc.utils.collections import apply_diff
 from dvc.utils.serialize import parse_yaml_for_update
 
@@ -27,7 +27,7 @@ PARAM_METRIC = Output.PARAM_METRIC
 PARAM_PLOT = Output.PARAM_PLOT
 PARAM_PERSIST = Output.PARAM_PERSIST
 PARAM_CHECKPOINT = Output.PARAM_CHECKPOINT
-PARAM_DESC = Output.PARAM_DESC
+PARAM_DESC = Annotation.PARAM_DESC
 PARAM_REMOTE = Output.PARAM_REMOTE
 
 DEFAULT_PARAMS_FILE = ParamsDependency.DEFAULT_PARAMS_FILE
@@ -38,8 +38,9 @@ sort_by_path = partial(sorted, key=attrgetter("def_path"))
 
 @post_processing(OrderedDict)
 def _get_flags(out):
-    if out.desc:
-        yield PARAM_DESC, out.desc
+    annot = out.annot.to_dict()
+    yield from annot.items()
+
     if not out.use_cache:
         yield PARAM_CACHE, False
     if out.checkpoint:
@@ -155,10 +156,12 @@ def to_single_stage_lockfile(stage: "Stage") -> dict:
     assert stage.cmd
 
     def _dumpd(item):
+        meta_d = item.meta.to_dict()
+        meta_d.pop("isdir", None)
         ret = [
             (item.PARAM_PATH, item.def_path),
             *item.hash_info.to_dict().items(),
-            *item.meta.to_dict().items(),
+            *meta_d.items(),
         ]
 
         return OrderedDict(ret)
@@ -185,8 +188,8 @@ def to_lockfile(stage: "PipelineStage") -> dict:
     return {stage.name: to_single_stage_lockfile(stage)}
 
 
-def to_single_stage_file(stage: "Stage"):
-    state = stage.dumpd()
+def to_single_stage_file(stage: "Stage", **kwargs):
+    state = stage.dumpd(**kwargs)
 
     # When we load a stage we parse yaml with a fast parser, which strips
     # off all the comments and formatting. To retain those on update we do

dvc/stage/utils.py

@@ -4,6 +4,7 @@ from typing import TYPE_CHECKING, Union
 
 from funcy import concat, first, lsplit, rpartial, without
 
+from dvc.annotations import ANNOTATION_FIELDS
 from dvc.exceptions import InvalidArgumentError
 from dvc_data.hashfile.meta import Meta
 
@@ -107,12 +108,16 @@ def _load_live_output(
     return outs
 
 
-def fill_stage_dependencies(stage, deps=None, erepo=None, params=None):
+def fill_stage_dependencies(
+    stage, deps=None, erepo=None, params=None, fs_config=None
+):
     from dvc.dependency import loads_from, loads_params
 
     assert not stage.deps
     stage.deps = []
-    stage.deps += loads_from(stage, deps or [], erepo=erepo)
+    stage.deps += loads_from(
+        stage, deps or [], erepo=erepo, fs_config=fs_config
+    )
     stage.deps += loads_params(stage, params or [])
 
 
@@ -194,9 +199,9 @@ def compute_md5(stage):
     return dict_md5(
         d,
         exclude=[
+            *ANNOTATION_FIELDS,
             stage.PARAM_LOCKED,  # backward compatibility
             stage.PARAM_FROZEN,
-            Output.PARAM_DESC,
             Output.PARAM_METRIC,
             Output.PARAM_PERSIST,
             Output.PARAM_CHECKPOINT,
@@ -221,7 +226,7 @@ def resolve_paths(fs, path, wdir=None):
     return path, wdir
 
 
-def get_dump(stage):
+def get_dump(stage, **kwargs):
     return {
         key: value
         for key, value in {
@@ -230,8 +235,8 @@ def get_dump(stage):
             stage.PARAM_CMD: stage.cmd,
             stage.PARAM_WDIR: resolve_wdir(stage.wdir, stage.path),
             stage.PARAM_FROZEN: stage.frozen,
-            stage.PARAM_DEPS: [d.dumpd() for d in stage.deps],
-            stage.PARAM_OUTS: [o.dumpd() for o in stage.outs],
+            stage.PARAM_DEPS: [d.dumpd(**kwargs) for d in stage.deps],
+            stage.PARAM_OUTS: [o.dumpd(**kwargs) for o in stage.outs],
             stage.PARAM_ALWAYS_CHANGED: stage.always_changed,
             stage.PARAM_META: stage.meta,
         }.items()

dvc/testing/test_api.py

@@ -14,7 +14,7 @@ class TestAPI:
         dvc.push()
 
         # Remove cache to force download
-        remove(dvc.odb.local.cache_dir)
+        remove(dvc.odb.local.path)
 
         with api.open("foo") as fd:
             assert fd.read() == "foo-text"

dvc/testing/test_remote.py

@@ -44,8 +44,8 @@ class TestRemote:
 
         # Move cache and check status
         # See issue https://github.com/iterative/dvc/issues/4383 for details
-        backup_dir = dvc.odb.local.cache_dir + ".backup"
-        shutil.move(dvc.odb.local.cache_dir, backup_dir)
+        backup_dir = dvc.odb.local.path + ".backup"
+        shutil.move(dvc.odb.local.path, backup_dir)
         status = dvc.cloud.status(foo_hashes)
         _check_status(status, missing={foo_hash})
 
@@ -53,8 +53,8 @@ class TestRemote:
         _check_status(status_dir, missing=dir_hashes)
 
         # Restore original cache:
-        remove(dvc.odb.local.cache_dir)
-        shutil.move(backup_dir, dvc.odb.local.cache_dir)
+        remove(dvc.odb.local.path)
+        shutil.move(backup_dir, dvc.odb.local.path)
 
         # Push and check status
         dvc.cloud.push(foo_hashes)
@@ -71,7 +71,7 @@ class TestRemote:
         _check_status(status_dir, ok=dir_hashes)
 
         # Remove and check status
-        remove(dvc.odb.local.cache_dir)
+        remove(dvc.odb.local.path)
 
         status = dvc.cloud.status(foo_hashes)
         _check_status(status, deleted={foo_hash})

dvc/utils/_benedict.py

@@ -1,26 +0,0 @@
-"""
-Rollbacks monkeypatching of `json.encoder` by benedict.
-
-It monkeypatches json to use Python-based encoder instead of C-based
-during import.
-
-We rollback that monkeypatch by keeping reference to that C-based
-encoder and reinstate them after importing benedict.
-See: https://github.com/iterative/dvc/issues/6423
-     https://github.com/fabiocaccamo/python-benedict/issues/62
-and the source of truth:
-https://github.com/fabiocaccamo/python-benedict/blob/c98c471065/benedict/dicts/__init__.py#L282-L285
-"""
-from json import encoder
-
-try:
-    c_make_encoder = encoder.c_make_encoder  # type: ignore[attr-defined]
-except AttributeError:
-    c_make_encoder = None
-
-
-from benedict import benedict  # noqa: E402
-
-encoder.c_make_encoder = c_make_encoder  # type: ignore[attr-defined]
-# Please import benedict from here lazily
-__all__ = ["benedict"]

dvc/utils/cli_parse.py

@@ -1,5 +1,5 @@
 from collections import defaultdict
-from typing import Any, Dict, Iterable, List
+from typing import Dict, Iterable, List
 
 
 def parse_params(path_params: Iterable[str]) -> List[Dict[str, List[str]]]:
@@ -17,35 +17,22 @@ def parse_params(path_params: Iterable[str]) -> List[Dict[str, List[str]]]:
     return [{path: params} for path, params in ret.items()]
 
 
-def loads_param_overrides(
+def to_path_overrides(
     path_params: Iterable[str],
-) -> Dict[str, Dict[str, Any]]:
-    """Loads the content of params from the cli as Python object."""
-    from ruamel.yaml import YAMLError
-
+) -> Dict[str, List[str]]:
+    """Group overrides by path"""
     from dvc.dependency.param import ParamsDependency
-    from dvc.exceptions import InvalidArgumentError
-
-    from .serialize import loads_yaml
-
-    ret: Dict[str, Dict[str, Any]] = defaultdict(dict)
 
+    path_overrides = defaultdict(list)
     for path_param in path_params:
-        param_name, _, param_value = path_param.partition("=")
-        if not param_value:
-            raise InvalidArgumentError(
-                f"Must provide a value for parameter '{param_name}'"
-            )
-        path, _, param_name = param_name.partition(":")
-        if not param_name:
-            param_name = path
+
+        path_and_name = path_param.partition("=")[0]
+        if ":" not in path_and_name:
+            override = path_param
             path = ParamsDependency.DEFAULT_PARAMS_FILE
+        else:
+            path, _, override = path_param.partition(":")
 
-        try:
-            ret[path][param_name] = loads_yaml(param_value)
-        except (ValueError, YAMLError):
-            raise InvalidArgumentError(
-                f"Invalid parameter value for '{param_name}': '{param_value}"
-            )
+        path_overrides[path].append(override)
 
-    return ret
+    return dict(path_overrides)

dvc/utils/collections.py

@@ -3,16 +3,6 @@ from collections.abc import Mapping
 from functools import wraps
 from typing import Callable, Dict, Iterable, List, TypeVar, Union
 
-from dvc.exceptions import DvcException
-
-
-class NewParamsFound(DvcException):
-    """Thrown if new params were found during merge_params"""
-
-    def __init__(self, new_params: List, *args):
-        self.new_params = new_params
-        super().__init__("New params found during merge", *args)
-
 
 def apply_diff(src, dest):
     """Recursively apply changes from src to dest.
@@ -61,6 +51,53 @@ def apply_diff(src, dest):
         )
 
 
+def to_omegaconf(item):
+    """
+    Some parsers return custom classes (i.e. parse_yaml_for_update)
+    that can mess up with omegaconf logic.
+    Cast the custom classes to Python primitives.
+    """
+    if isinstance(item, dict):
+        item = {k: to_omegaconf(v) for k, v in item.items()}
+    elif isinstance(item, list):
+        item = [to_omegaconf(x) for x in item]
+    return item
+
+
+def remove_missing_keys(src, to_update):
+    keys = list(src.keys())
+    for key in keys:
+        if key not in to_update:
+            del src[key]
+        elif isinstance(src[key], dict):
+            remove_missing_keys(src[key], to_update[key])
+
+    return src
+
+
+def _merge_item(d, key, value):
+    if key in d:
+        item = d.get(key, None)
+        if isinstance(item, dict) and isinstance(value, dict):
+            merge_dicts(item, value)
+        else:
+            d[key] = value
+    else:
+        d[key] = value
+
+
+def merge_dicts(src: Dict, to_update: Dict) -> Dict:
+    """Recursively merges dictionaries.
+
+    Args:
+        src (dict): source dictionary of parameters
+        to_update (dict): dictionary of parameters to merge into src
+    """
+    for key, value in to_update.items():
+        _merge_item(src, key, value)
+    return src
+
+
 def ensure_list(item: Union[Iterable[str], str, None]) -> List[str]:
     if item is None:
         return []
@@ -79,31 +116,6 @@ def chunk_dict(d: Dict[_KT, _VT], size: int = 1) -> List[Dict[_KT, _VT]]:
     return [{key: d[key] for key in chunk} for chunk in chunks(size, d)]
 
 
-def merge_params(src: Dict, to_update: Dict, allow_new: bool = True) -> Dict:
-    """
-    Recursively merges params with benedict's syntax support in-place.
-
-    Args:
-        src (dict): source dictionary of parameters
-        to_update (dict): dictionary of parameters to merge into src
-        allow_new (bool): if False, raises an error if new keys would be
-            added to src
-    """
-    from ._benedict import benedict
-
-    data = benedict(src)
-
-    if not allow_new:
-        new_params = list(
-            set(to_update.keys()) - set(data.keypaths(indexes=True))
-        )
-        if new_params:
-            raise NewParamsFound(new_params)
-
-    data.merge(to_update, overwrite=True)
-    return src
-
-
 class _NamespacedDict(dict):
     def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)

dvc/utils/hydra.py

@@ -0,0 +1,109 @@
+from collections import defaultdict
+from pathlib import Path
+from typing import TYPE_CHECKING, List
+
+from hydra import compose, initialize_config_dir
+from hydra._internal.config_loader_impl import ConfigLoaderImpl
+from hydra._internal.core_plugins.basic_sweeper import BasicSweeper
+from hydra.core.override_parser.overrides_parser import OverridesParser
+from hydra.core.override_parser.types import ValueType
+from hydra.errors import ConfigCompositionException, OverrideParseException
+from omegaconf import OmegaConf
+
+from dvc.exceptions import InvalidArgumentError
+
+from .collections import merge_dicts, remove_missing_keys, to_omegaconf
+from .serialize import DUMPERS, MODIFIERS
+
+if TYPE_CHECKING:
+    from dvc.types import StrPath
+
+
+def compose_and_dump(
+    output_file: "StrPath",
+    config_dir: str,
+    config_name: str,
+    overrides: List[str],
+) -> None:
+    """Compose Hydra config and dumpt it to `output_file`.
+
+    Args:
+        output_file: File where the composed config will be dumped.
+        config_dir: Folder containing the Hydra config files.
+            Must be absolute file system path.
+        config_name: Name of the config file containing defaults,
+            without the .yaml extension.
+        overrides: List of `Hydra Override`_ patterns.
+
+    .. _Hydra Override:
+        https://hydra.cc/docs/advanced/override_grammar/basic/
+    """
+    with initialize_config_dir(config_dir, version_base=None):
+        cfg = compose(config_name=config_name, overrides=overrides)
+
+    dumper = DUMPERS[Path(output_file).suffix.lower()]
+    dumper(output_file, OmegaConf.to_object(cfg))
+
+
+def apply_overrides(path: "StrPath", overrides: List[str]) -> None:
+    """Update `path` params with the provided `Hydra Override`_ patterns.
+
+    Args:
+        overrides: List of `Hydra Override`_ patterns.
+
+    .. _Hydra Override:
+        https://hydra.cc/docs/next/advanced/override_grammar/basic/
+    """
+    suffix = Path(path).suffix.lower()
+
+    hydra_errors = (ConfigCompositionException, OverrideParseException)
+
+    modify_data = MODIFIERS[suffix]
+    with modify_data(path) as original_data:
+        try:
+            parsed = to_hydra_overrides(overrides)
+
+            new_data = OmegaConf.create(
+                to_omegaconf(original_data),
+                flags={"allow_objects": True},
+            )
+            OmegaConf.set_struct(new_data, True)
+            # pylint: disable=protected-access
+            ConfigLoaderImpl._apply_overrides_to_config(parsed, new_data)
+            new_data = OmegaConf.to_object(new_data)
+        except hydra_errors as e:
+            raise InvalidArgumentError("Invalid `--set-param` value") from e
+
+        merge_dicts(original_data, new_data)
+        remove_missing_keys(original_data, new_data)
+
+
+def to_hydra_overrides(path_overrides):
+    parser = OverridesParser.create()
+    return parser.parse_overrides(overrides=path_overrides)
+
+
+def get_hydra_sweeps(path_overrides):
+    merged_overrides = []
+    for path, overrides in path_overrides.items():
+        merged_overrides.extend(
+            [f"{path}___{override}" for override in overrides]
+        )
+
+    hydra_overrides = to_hydra_overrides(merged_overrides)
+    for hydra_override in hydra_overrides:
+        if hydra_override.value_type == ValueType.GLOB_CHOICE_SWEEP:
+            raise InvalidArgumentError(
+                f"Glob override '{hydra_override.input_line}' "
+                "is not supported."
+            )
+
+    splits = BasicSweeper.split_arguments(hydra_overrides, None)[0]
+    sweeps = []
+    for split in splits:
+        sweep_overrides = defaultdict(list)
+        for merged_override in split:
+            path, override = merged_override.split("___")
+            sweep_overrides[path].append(override)
+        sweeps.append(dict(sweep_overrides))
+    return sweeps

dvc/utils/serialize/__init__.py

@@ -14,6 +14,13 @@ LOADERS.update(
     {".toml": load_toml, ".json": load_json, ".py": load_py}  # noqa: F405
 )
 
+
+def load_path(fs_path, fs):
+    suffix = fs.path.suffix(fs_path).lower()
+    loader = LOADERS[suffix]
+    return loader(fs_path, fs=fs)
+
+
 DUMPERS: DefaultDict[str, DumperFn] = defaultdict(  # noqa: F405
     lambda: dump_yaml  # noqa: F405
 )

dvc/utils/serialize/_toml.py

@@ -14,30 +14,31 @@ def load_toml(path, fs=None):
     return _load_data(path, parser=parse_toml, fs=fs)
 
 
-def parse_toml(text, path, decoder=None):
-    from toml import TomlDecodeError, loads
+def _parse_toml(text, path):
+    from tomlkit import loads
+    from tomlkit.exceptions import ParseError as TomlkitParseError
 
-    with reraise(TomlDecodeError, TOMLFileCorruptedError(path)):
-        return loads(text, decoder=decoder)
+    with reraise(TomlkitParseError, TOMLFileCorruptedError(path)):
+        return loads(text)
+
+
+def parse_toml(text, path, preserve_comments=False):
+    rval = _parse_toml(text, path)
+
+    if preserve_comments:
+        return rval
+
+    return rval.unwrap()
 
 
 def parse_toml_for_update(text, path):
-    """Parses text into Python structure.
-
-    NOTE: Python toml package does not currently use ordered dicts, so
-    keys may be re-ordered between load/dump, but this function will at
-    least preserve comments.
-    """
-    from toml import TomlPreserveCommentDecoder
-
-    decoder = TomlPreserveCommentDecoder()
-    return parse_toml(text, path, decoder=decoder)
+    return parse_toml(text, path, preserve_comments=True)
 
 
-def _dump(data, stream):
-    import toml
+def _dump(data, stream, sort_keys=False):
+    import tomlkit
 
-    return toml.dump(data, stream, encoder=toml.TomlPreserveCommentEncoder())
+    return tomlkit.dump(data, stream, sort_keys=sort_keys)
 
 
 def dump_toml(path, data, fs=None, **kwargs):

pyproject.toml

@@ -30,11 +30,11 @@ line_length = 79
 
 [tool.pytest.ini_options]
 log_level = "debug"
-addopts = "-ra"
+addopts = "-ra -p no:hydra_pytest"
 markers = [
     "needs_internet: Might need network access for the tests",
-"vscode: Tests verifying contract between DVC and VSCode plugin",
-"studio: Tests verifying contract between DVC and Studio"
+    "vscode: Tests verifying contract between DVC and VSCode plugin",
+    "studio: Tests verifying contract between DVC and Studio",
 ]
 xfail_strict = true
 

scripts/build-requirements.txt

@@ -1,3 +1,3 @@
 # NOTE: using strict version due to
 # https://github.com/iterative/dvc/issues/7949
-PyInstaller==5.2
+PyInstaller==5.0

scripts/build.py

@@ -1,5 +1,5 @@
 import argparse
-import importlib
+import importlib.util
 import pathlib
 import textwrap
 from subprocess import STDOUT, check_call

scripts/pyinstaller/build.py

@@ -1,6 +1,6 @@
 import os
 import pathlib
-from subprocess import STDOUT, check_call
+from subprocess import STDOUT, check_call, check_output
 
 path = pathlib.Path(__file__).parent.absolute()
 hooks = path / "hooks"
@@ -21,10 +21,27 @@ check_call(
     stderr=STDOUT,
 )
 
-check_call(
+out = check_output(
     [
         path / "dist" / "dvc" / "dvc",
         "doctor",
     ],
     stderr=STDOUT,
-)
+).decode()
+
+remotes = [
+    "s3",
+    "oss",
+    "gdrive",
+    "gs",
+    "hdfs",
+    "http",
+    "webhdfs",
+    "azure",
+    "ssh",
+    "webdav",
+]
+
+print(out)
+for remote in remotes:
+    assert f"\t{remote}" in out, f"Missing support for {remote}"

scripts/pyinstaller/hooks/hook-dvc.py

@@ -16,5 +16,15 @@ datas += copy_metadata("webdav4")
 datas += copy_metadata("aiohttp")
 datas += copy_metadata("aiohttp_retry")
 
-# https://github.com/pypa/setuptools/issues/1963
-hiddenimports = ["pkg_resources.py2_warn"]
+hiddenimports = [
+    "dvc_azure",
+    "dvc_gdrive",
+    "dvc_gs",
+    "dvc_hdfs",
+    "dvc_oss",
+    "dvc_s3",
+    "dvc_webdav",
+    "dvc_webhdfs",
+    # https://github.com/pypa/setuptools/issues/1963
+    "pkg_resources.py2_warn",
+]

scripts/pyinstaller/hooks/hook-fsspec.py

@@ -0,0 +1 @@
+hiddenimports = ["fsspec.implementations.memory"]

scripts/pyinstaller/hooks/hook-googleapiclient.model.py

@@ -1,8 +0,0 @@
-"""Temporary fix for https://github.com/iterative/dvc/issues/5618."""
-from PyInstaller.utils.hooks import (  # pylint:disable=import-error
-    collect_data_files,
-    copy_metadata,
-)
-
-datas = collect_data_files("googleapiclient.discovery")
-datas += copy_metadata("google_api_python_client")

setup.cfg

@@ -42,7 +42,7 @@ install_requires =
     distro>=1.3.0
     appdirs>=1.4.3
     ruamel.yaml>=0.17.11
-    toml>=0.10.1
+    tomlkit>=0.11.1
     funcy>=1.14
     pathspec>=0.9.0,<0.10.0
     shortuuid>=0.5.0
@@ -60,16 +60,15 @@ install_requires =
     dpath>=2.0.2,<3
     shtab>=1.3.4,<2
     rich>=10.13.0
-    python-benedict>=0.24.2
     pyparsing>=2.4.7
     typing-extensions>=3.7.4
-    fsspec[http]>=2021.10.1
-    aiohttp-retry>=2.4.5
-    scmrepo==0.0.25
-    dvc-render==0.0.9
-    dvc-task==0.1.0
+    scmrepo==0.1.1
+    dvc-render==0.0.10
+    dvc-task==0.1.2
     dvclive>=0.10.0
-    dvc-data==0.1.6
+    dvc-data==0.8.0
+    dvc-http==2.19.1
+    hydra-core>=1.1.0
 
 [options.extras_require]
 all =
@@ -81,46 +80,34 @@ all =
     %(s3)s
     %(ssh)s
     %(webdav)s
+    %(webhdfs)s
 dev =
     %(all)s
     %(tests)s
     dvc-data[cli]
 # Extra dependencies for remote integrations
-azure =
-    adlfs>=2021.10.0
-    azure-identity>=1.4.0
-    knack
-gdrive = pydrive2[fsspec]>=1.10.1
-gs = gcsfs>=2021.11.1
+azure = dvc-azure==2.20.2
+gdrive = dvc-gdrive==2.19.0
+gs = dvc-gs==2.19.1
 hdfs =
-    # due to https://github.com/python-poetry/poetry/issues/4683, we have to
-    # explicitly specify pyarrow here
-    pyarrow>=1
-    fsspec[arrow]
-oss = ossfs>=2021.8.0
-s3 =
-    s3fs[boto3]>=2022.02.0
-    aiobotocore[boto3]>2
-ssh =
-    # due to https://github.com/python-poetry/poetry/issues/4683, we have to
-    # explicitly specify bcrypt here
-    bcrypt
-    sshfs[bcrypt]>=2022.6.0
+    dvc-hdfs==2.19.0; python_version < '3.11'
+oss = dvc-oss==2.19.0
+s3 = dvc-s3==2.20.0
+ssh = dvc-ssh==2.19.0
 # gssapi should not be included in all_remotes, because it doesn't have wheels
 # for Linux, so it will fail to compile if user doesn't have all the
 # requirements, including kerberos itself.
-ssh_gssapi = sshfs[gssapi]>=2022.6.0
-webdav = webdav4>=0.9.3
-# not to break `dvc[webhdfs]`
-webhdfs =
+ssh_gssapi = dvc-ssh[gssapi]==2.19.0
+webdav = dvc-webdav==2.19.0
+webhdfs = dvc-webhdfs==2.19.0
 # requests-kerberos requires krb5 & gssapi, which does not provide wheels Linux
-webhdfs_kerberos = requests-kerberos==0.14.0
+webhdfs_kerberos = dvc-webhdfs[kerberos]==2.19.0
 terraform = tpi[ssh]>=2.1.0
 tests =
     %(terraform)s
-    dvc_ssh==0.0.1a0
+    dvc-ssh==2.19.0
     # Test requirements
-    pytest==7.1.2
+    pytest==7.1.3
     pytest-cov==3.0.0
     pytest-xdist==2.5.0
     pytest-mock==3.8.2
@@ -129,11 +116,10 @@ tests =
     # https://github.com/docker/docker-py/issues/2902
     pytest-docker==0.11.0; python_version < '3.10' or sys_platform != 'win32'
     flaky==3.7.0
-    mock==4.0.3
     pytest-timeout==2.1.0
-    filelock==3.7.1
+    filelock==3.8.0
     # pylint requirements
-    pylint==2.14.5
+    pylint==2.15.2
     # we use this to suppress pytest-related false positives in our tests.
     pylint-pytest==1.1.2
     # we use this to suppress some messages in tests, eg: foo/bar naming,
@@ -159,6 +145,8 @@ exclude =
 [options.entry_points]
 console_scripts =
     dvc = dvc.cli:main
+fsspec.specs =
+    dvc = dvc.api:DvcFileSystem
 
 [flake8]
 ignore=

tests/conftest.py

@@ -250,3 +250,15 @@ def run_copy_metrics(tmp_dir, run_copy):
         return stage
 
     return run
+
+
+@pytest.fixture(autouse=True)
+def mock_hydra_conf(mocker):
+    if sys.version_info < (3, 11):
+        return
+
+    # `hydra.conf` fails to import in 3.11, it raises ValueError due to changes
+    # in dataclasses. See https://github.com/python/cpython/pull/29867.
+    # NOTE: using sentinel here so that any imports from `hydra.conf`
+    # return a mock.
+    sys.modules["hydra.conf"] = mocker.sentinel

tests/func/api/test_data.py

@@ -48,7 +48,7 @@ def test_open_external(tmp_dir, erepo_dir, cloud):
     erepo_dir.dvc.push(all_branches=True)
 
     # Remove cache to force download
-    remove(erepo_dir.dvc.odb.local.cache_dir)
+    remove(erepo_dir.dvc.odb.local.path)
 
     # Using file url to force clone to tmp repo
     repo_url = f"file://{erepo_dir.as_posix()}"
@@ -63,7 +63,7 @@ def test_open_granular(tmp_dir, dvc, remote):
     dvc.push()
 
     # Remove cache to force download
-    remove(dvc.odb.local.cache_dir)
+    remove(dvc.odb.local.path)
 
     with api.open("dir/foo") as fd:
         assert fd.read() == "foo-text"
@@ -73,7 +73,7 @@ def test_missing(tmp_dir, dvc, remote):
     tmp_dir.dvc_gen("foo", "foo")
 
     # Remove cache to make foo missing
-    remove(dvc.odb.local.cache_dir)
+    remove(dvc.odb.local.path)
 
     api.read("foo")
 
@@ -135,7 +135,7 @@ def test_api_missing_local_cache_exists_on_remote(
     dvc.push()
 
     # Remove cache to make foo missing
-    remove(dvc.odb.local.cache_dir)
+    remove(dvc.odb.local.path)
     remove(first(files))
 
     repo_url = f"file://{tmp_dir.as_posix()}" if as_external else None
@@ -220,7 +220,7 @@ def test_open_from_remote(tmp_dir, erepo_dir, cloud, local_cloud):
     erepo_dir.add_remote(config=local_cloud.config, default=True)
     erepo_dir.dvc_gen({"dir": {"foo": "foo content"}}, commit="create file")
     erepo_dir.dvc.push(remote="other")
-    remove(erepo_dir.dvc.odb.local.cache_dir)
+    remove(erepo_dir.dvc.odb.local.path)
 
     with api.open(
         os.path.join("dir", "foo"),

tests/func/api/test_params.py

@@ -1,3 +1,4 @@
+import os
 from textwrap import dedent
 
 import pytest
@@ -12,6 +13,11 @@ def params_repo(tmp_dir, scm, dvc):
     tmp_dir.gen("params.json", '{"bar": 2, "foobar": 3}')
     tmp_dir.gen("other_params.json", '{"foo": {"bar": 4}}')
 
+    dvc.run(
+        name="stage-0",
+        cmd="echo stage-0",
+    )
+
     dvc.run(
         name="stage-1",
         cmd="echo stage-1",
@@ -62,6 +68,9 @@ def test_params_show_targets(params_repo):
         "bar": 2,
         "foobar": 3,
     }
+    assert api.params_show("params.yaml", stages="stage-1") == {
+        "foo": 5,
+    }
 
 
 def test_params_show_deps(params_repo):
@@ -83,6 +92,30 @@ def test_params_show_stages(params_repo):
 
     assert api.params_show("params.json", stages="stage-3") == {"foobar": 3}
 
+    with pytest.raises(DvcException, match="No params found"):
+        api.params_show(stages="stage-0")
+
+
+def test_params_show_stage_addressing(tmp_dir, dvc):
+    for subdir in {"subdir1", "subdir2"}:
+        subdir = tmp_dir / subdir
+        subdir.mkdir()
+        with subdir.chdir():
+            subdir.gen("params.yaml", "foo: 1")
+
+            dvc.run(name="stage-0", cmd="echo stage-0", params=["foo"])
+
+    for s in {"subdir1", "subdir2"}:
+        dvcyaml = os.path.join(s, "dvc.yaml")
+        assert api.params_show(stages=f"{dvcyaml}:stage-0") == {"foo": 1}
+
+    with subdir.chdir():
+        nested = subdir / "nested"
+        nested.mkdir()
+        with nested.chdir():
+            dvcyaml = os.path.join("..", "dvc.yaml")
+            assert api.params_show(stages=f"{dvcyaml}:stage-0") == {"foo": 1}
+
 
 def test_params_show_revs(params_repo):
     assert api.params_show(rev="HEAD~1") == {
@@ -145,3 +178,30 @@ def test_params_show_no_params_found(tmp_dir, dvc):
     dvc.stage.add(name="echo", cmd="echo foo")
     with pytest.raises(DvcException, match="No params found"):
         api.params_show()
+
+
+def test_params_show_stage_without_params(tmp_dir, dvc):
+    tmp_dir.gen("params.yaml", "foo: 1")
+
+    dvc.run(
+        name="stage-0",
+        cmd="echo stage-0",
+    )
+
+    with pytest.raises(DvcException, match="No params found"):
+        api.params_show(stages="stage-0")
+
+    with pytest.raises(DvcException, match="No params found"):
+        api.params_show(deps=True)
+
+
+def test_params_show_untracked_target(params_repo, tmp_dir):
+    tmp_dir.gen("params_foo.yaml", "foo: 1")
+
+    assert api.params_show("params_foo.yaml") == {"foo": 1}
+
+    with pytest.raises(DvcException, match="No params found"):
+        api.params_show("params_foo.yaml", stages="stage-0")
+
+    with pytest.raises(DvcException, match="No params found"):
+        api.params_show("params_foo.yaml", deps=True)

tests/func/data/db/test_index.py

@@ -3,7 +3,7 @@ import pytest
 from dvc.exceptions import DownloadError, UploadError
 from dvc.fs import LocalFileSystem
 from dvc.utils.fs import remove
-from dvc_data.db import get_index
+from dvc_data.hashfile.db import get_index
 
 
 @pytest.fixture

tests/func/experiments/conftest.py

@@ -3,7 +3,9 @@ from textwrap import dedent
 import pytest
 
 from tests.func.test_repro_multistage import COPY_SCRIPT
-from tests.unit.repo.experiments.conftest import test_queue  # noqa
+from tests.unit.repo.experiments.conftest import (  # noqa pylint disable=unused-argument
+    test_queue,
+)
 
 DEFAULT_ITERATIONS = 2
 CHECKPOINT_SCRIPT_FORMAT = dedent(
@@ -133,3 +135,17 @@ def http_auth_patch(mocker):
 @pytest.fixture(params=[True, False])
 def workspace(request, test_queue) -> bool:  # noqa
     return request.param
+
+
+@pytest.fixture
+def params_repo(tmp_dir, scm, dvc):
+    (tmp_dir / "params.yaml").dump(
+        {"foo": [{"bar": 1}, {"baz": 2}], "goo": {"bag": 3.0}, "lorem": False}
+    )
+    dvc.run(
+        cmd="echo foo",
+        params=["params.yaml:"],
+        name="foo",
+    )
+    scm.add(["dvc.yaml", "dvc.lock", "copy.py", "params.yaml"])
+    scm.commit("init")