pyinstaller: drop google-api-client hooks

Bumps [iterative-telemetry](https://github.com/iterative/telemetry-python) from 0.0.5 to 0.0.6.
- [Release notes](https://github.com/iterative/telemetry-python/releases)
- [Commits](https://github.com/iterative/telemetry-python/compare/0.0.5...0.0.6)

---
updated-dependencies:
- dependency-name: iterative-telemetry
  dependency-type: direct:production
  update-type: version-update:semver-patch
...

Signed-off-by: dependabot[bot] <[email protected]>

.codecov.yml

@@ -1,10 +0,0 @@
-comment: false
-coverage:
-  status:
-    project:
-      default:
-        target: 90
-        threshold: 10%
-    patch:
-      default:
-        threshold: 25%

.coveragerc

@@ -1,16 +0,0 @@
-[run]
-branch = True
-source = dvc
-omit =
-    *__main__.py
-
-[report]
-exclude_lines =
-    if __name__ == .__main__.:
-    if typing.TYPE_CHECKING:
-    if TYPE_CHECKING:
-    pass
-    raise NotImplementedError
-    # pragma: no cover
-    #  pragma: no cover
-    \.\.\.$

.dvcignore

@@ -1,4 +1,3 @@
 /tests
 /dvc
 /.github
-/bin

.flake8

@@ -0,0 +1,12 @@
+[flake8]
+ignore=
+    E203, # Whitespace before ':'
+    E266, # Too many leading '#' for block comment
+    W503, # Line break occurred before a binary operator
+    P1,  # unindexed parameters in the str.format, see:
+    # https://pypi.org/project/flake8-string-format/
+max_line_length = 79
+max-complexity = 15
+select = B,C,E,F,W,T4,B902,T,P
+show_source = true
+count = true

.github/ISSUE_TEMPLATE/bug_report.md

@@ -8,7 +8,7 @@ about: Create a bug report to help us improve DVC
 <!--
 ## Issue name
 
-Issue names must follow the pattern `command: description` where the command is the dvc command that you are trying to run. The description should describe the consequence of the bug. 
+Issue names must follow the pattern `command: description` where the command is the dvc command that you are trying to run. The description should describe the consequence of the bug.
 
 Example: `repro: doesn't detect input changes`
 -->

.github/ISSUE_TEMPLATE/feature_request.md

@@ -2,4 +2,3 @@
 name: "\U0001F680 Feature Request"
 about: Suggest an idea for this project
 ---
-

.github/codecov.yml

@@ -0,0 +1,12 @@
+codecov:
+  notify:
+    wait_for_ci: true
+coverage:
+  status:
+    project:
+      default:
+        target: auto
+        threshold: 2%
+    patch: off
+github_checks:
+  annotations: false

.github/release-drafter.yml

@@ -1,49 +0,0 @@
-# Config for https://github.com/apps/release-drafter
-name-template: "$RESOLVED_VERSION 🦉 "
-tag-template: "$RESOLVED_VERSION"
-categories:
-  - title: "🚀 New Features and Enhancements "
-    labels:
-      - "feature"
-      - "enhancement"
-      - "ui"
-  - title: "💣 Breaking Changes "
-    labels:
-      - "breaking-change"
-  - title: "🏇 Optimizations "
-    labels:
-      - "optimize"
-      - "performance"
-  - title: "🐛 Bug Fixes "
-    labels:
-      - "bugfix"
-      - "bug"
-  - title: "🔨 Maintenance "
-    labels:
-      - "maintenance"
-      - "refactoring"
-      - "chore"
-      - "build"
-      - "ci"
-change-template: "- $TITLE (#$NUMBER) @$AUTHOR"
-version-resolver:
-  major:
-    labels:
-      - "major"
-  minor:
-    labels:
-      - "minor"
-  patch:
-    labels:
-      - "patch"
-  default: patch
-exclude-labels:
-  - "skip-changelog"
-template: |
-  > Refer to https://dvc.org/doc/install for installation instructions.
-
-  ## Changes
-
-  $CHANGES
-
-  Thanks again to $CONTRIBUTORS for the contributions! 🎉

.github/release.yml

@@ -0,0 +1,16 @@
+changelog:
+  exclude:
+    labels: ["skip-changelog"]
+  categories:
+    - title: 🛠 Breaking Changes
+      labels: ["breaking-change"]
+    - title: 🚀 New Features and Enhancements
+      labels: ["feature", "enhancement", "ui"]
+    - title: ⚡ Optimizations
+      labels: ["optimize", "performance"]
+    - title: 🐛 Bug Fixes
+      labels: ["bugfix", "bug"]
+    - title: 🔨 Maintenance
+      labels: ["maintenance", "refactoring", "chore", "build", "ci"]
+    - title: Other Changes
+      labels: ["*"]

.github/workflows/benchmarks.yaml

@@ -12,7 +12,7 @@ jobs:
     steps:
       - uses: actions/setup-python@v4
         with:
-            python-version: "3.10"
+            python-version: "3.11"
       - uses: iterative/dvc-bench@main
         with:
             pytest_options: "-k 'test_init or test_help'"

.github/workflows/codeql.yml

@@ -0,0 +1,39 @@
+name: "CodeQL"
+
+on:
+  push:
+    branches: ["main"]
+  pull_request:
+    branches: ["main"]
+  schedule:
+    - cron: '32 19 * * 2'
+  workflow_dispatch:
+
+permissions:
+  contents: read
+
+jobs:
+  analyze:
+    name: Analyze
+    runs-on: ubuntu-latest
+    permissions:
+      actions: read
+      contents: read
+      security-events: write
+
+    strategy:
+      fail-fast: false
+      matrix:
+        language: ['python']
+
+    steps:
+    - name: Checkout repository
+      uses: actions/checkout@v3
+
+    - name: Initialize CodeQL
+      uses: github/codeql-action/init@v2
+      with:
+        languages: ${{ matrix.language }}
+
+    - name: Perform CodeQL Analysis
+      uses: github/codeql-action/analyze@v2

.github/workflows/packages.yaml

@@ -7,8 +7,13 @@ on:
     types: [released, prereleased]
   workflow_dispatch:
 
+permissions:  # added using https://github.com/step-security/secure-workflows
+  contents: read
+
 jobs:
   binary:
+    permissions:
+      contents: write  # for actions/upload-release-asset to upload release asset
     strategy:
       matrix:
         include:
@@ -24,13 +29,13 @@ jobs:
       with:
           fetch-depth: 0
 
-    - name: Set up Python 3.9
+    - name: Set up Python 3.10
       uses: actions/setup-python@v4
       with:
-        python-version: 3.9
+        python-version: "3.10"
         cache: pip
         cache-dependency-path: |
-          setup.cfg
+          pyproject.toml
           scripts/build-requirements.txt
 
     - name: Set up Ruby 2.6
@@ -45,7 +50,7 @@ jobs:
 
     - name: Install deps
       run: |
-        pip install -U wheel pip setuptools
+        pip install --upgrade pip wheel setuptools
         pip install .[all]
         pip install -r scripts/build-requirements.txt
 
@@ -77,21 +82,31 @@ jobs:
       uses: actions/setup-python@v4
       with:
         python-version: 3.8
-        cache: pip
-        cache-dependency-path: setup.cfg
 
     - name: Install
+      run: pip install --upgrade pip wheel
+
+    - name: Force version for Test PyPI uploads
+      if: ${{ !startsWith(github.ref, 'refs/tags') }}
       run: |
-        pip install -U wheel pip build setuptools
-        pip install ".[all,tests]"
+        pip install setuptools_scm
+        echo version=$(python -m setuptools_scm | awk -F+ '{print $1}' | tail -1) >> $GITHUB_ENV
 
     - name: Build packages
-      run: |
-        pip install -U pip
-        ./scripts/build_package.sh
+      run: ./scripts/build_package.sh
+      env:
+        SETUPTOOLS_SCM_PRETEND_VERSION: ${{ env.version }}
 
     - name: Publish packages to PyPI
       if: github.event_name == 'release'
       uses: pypa/gh-action-pypi-publish@release/v1
       with:
         password: ${{ secrets.PYPI_TOKEN }}
+
+    - name: Publish to Test PyPI
+      if: ${{ github.event_name == 'release' || (github.event_name == 'push' && github.ref == 'refs/heads/main') }}
+      uses: pypa/gh-action-pypi-publish@release/v1
+      with:
+        password: ${{ secrets.TEST_PYPI_TOKEN }}
+        repository_url: https://test.pypi.org/legacy/
+        skip_existing: true

.github/workflows/tests.yaml

@@ -17,6 +17,9 @@ concurrency:
   group: ${{ github.workflow }}-${{ github.head_ref || github.run_id }}
   cancel-in-progress: true
 
+permissions:  # added using https://github.com/step-security/secure-workflows
+  contents: read
+
 jobs:
   lint:
     timeout-minutes: 10
@@ -29,13 +32,12 @@ jobs:
       uses: actions/setup-python@v4
       with:
         python-version: 3.8
+        cache: pip
+        cache-dependency-path: pyproject.toml
     - name: Install requirements
       run: |
-        pip install --upgrade pip setuptools wheel
-        pip install collective.checkdocs==0.2
+        pip install --upgrade pip wheel
         pip install ".[dev]"
-    - name: Check README
-      run: python setup.py checkdocs
     - uses: pre-commit/[email protected]
   tests:
     timeout-minutes: 45
@@ -43,13 +45,16 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        os: [ubuntu-20.04, windows-latest, macos-latest]
-        pyv: ["3.8", "3.9", "3.10"]
-        pytest-filter: 
+        os: [ubuntu-20.04, windows-latest]
+        pyv: ["3.8", "3.9", "3.10", "3.11"]
+        pytest-filter:
         - "import or plot or live or experiment"
         - "not (import or plot or live or experiment)"
         include:
-        - {os: ubuntu-latest, pyv: "3.11-dev"}
+        - {os: macos-latest, pyv: "3.8"}
+        - {os: macos-latest, pyv: "3.9"}
+        - {os: macos-latest, pyv: "3.10"}
+        - {os: macos-latest, pyv: "3.11"}
 
     steps:
     - uses: actions/checkout@v3
@@ -60,27 +65,30 @@ jobs:
       with:
         python-version: ${{ matrix.pyv }}
         cache: pip
-        cache-dependency-path: setup.cfg
+        cache-dependency-path: pyproject.toml
     - name: install
-      if: steps.cache.pip-cache-dir.cache-hit != 'true'
       run: |
-        pip install --upgrade pip setuptools wheel
+        pip install --upgrade pip wheel
         pip install -e ".[dev]"
-      env:
-        AIOHTTP_NO_EXTENSIONS: ${{ matrix.pyv == '3.11-dev' && '1' }}
     - name: run tests
-      timeout-minutes: 40
-      run: pytest -nauto -ra --durations 100 --cov=dvc --cov-report=xml --cov-report=term -k "${{ matrix.pytest-filter }}"
+      timeout-minutes: 20
+      run: pytest -nauto --durations 100 --cov --cov-report=xml --cov-report=term -k "${{ matrix.pytest-filter }}"
     - name: upload coverage report
       uses: codecov/codecov-action@v3
       with:
         file: ./coverage.xml
         fail_ci_if_error: false
+  check:
+    if: always()
+    needs: [lint, tests]
+    runs-on: ubuntu-latest
+    steps:
+      - uses: re-actors/alls-green@release/v1
+        with:
+          jobs: ${{ toJSON(needs) }}
   notify:
     if: github.ref == 'refs/heads/main' && failure()
-    needs:
-      - lint
-      - tests
+    needs: [lint, tests]
     runs-on: ubuntu-latest
     steps:
     - name: Slack Notification

.pre-commit-config.yaml

@@ -1,39 +1,62 @@
+default_language_version:
+  python: python3
+
 ci:
   skip: [mypy, pylint, dvc-pre-commit]
 
 repos:
-  - hooks:
-      - id: black
-        language_version: python3
-    repo: https://github.com/ambv/black
-    rev: 22.6.0
   - repo: https://github.com/pre-commit/pre-commit-hooks
     rev: v4.3.0
     hooks:
+      - id: check-added-large-files
+      - id: check-case-conflict
+      - id: check-executables-have-shebangs
+      - id: check-json
+      - id: check-merge-conflict
+        exclude: "tests/func/utils/test_strict_yaml.py"
+        args: ['--assume-in-merge']
       - id: check-toml
       - id: check-yaml
-  - hooks:
-      - id: codespell
-        args: 
-          - --ignore-words-list
-          - ba,datas,fo,uptodate,cachable
-    repo: https://github.com/codespell-project/codespell
-    rev: v2.1.0
-  - hooks:
-      - id: isort
-        language_version: python3
-    repo: https://github.com/timothycrosley/isort
+      - id: debug-statements
+        exclude: "dvc/_debug.py"
+      - id: end-of-file-fixer
+      - id: mixed-line-ending
+      - id: sort-simple-yaml
+      - id: trailing-whitespace
+  - repo: https://github.com/lovesegfault/beautysh
+    rev: v6.2.1
+    hooks:
+      - id: beautysh
+        args: ["-i", "2"]
+  - repo: https://github.com/asottile/pyupgrade
+    rev: v3.2.0
+    hooks:
+      - id: pyupgrade
+        args:
+          - --py38-plus
+  - repo: https://github.com/psf/black
+    rev: 22.10.0
+    hooks:
+      - id: black
+  - repo: https://github.com/PyCQA/isort
     rev: 5.10.1
-  - hooks:
+    hooks:
+      - id: isort
+  - repo: https://github.com/codespell-project/codespell
+    rev: v2.2.2
+    hooks:
+      - id: codespell
+        additional_dependencies: ["tomli"]
+  - repo: https://github.com/PyCQA/flake8
+    rev: 5.0.4
+    hooks:
       - id: flake8
-        language_version: python3
         additional_dependencies:
+          - flake8-broken-line
           - flake8-bugbear
           - flake8-comprehensions
           - flake8-debugger
           - flake8-string-format
-    repo: https://gitlab.com/pycqa/flake8
-    rev: 3.9.2
   - repo: local
     hooks:
     - id: mypy
@@ -47,14 +70,6 @@ repos:
       entry: pylint
       language: system
       types: [python]
-  - hooks:
-      - args:
-          - -i
-          - "2"
-        id: beautysh
-        language_version: python3
-    repo: https://github.com/lovesegfault/beautysh
-    rev: v6.2.1
   - hooks:
       - args:
           - git-hook

CODE_OF_CONDUCT.md

@@ -74,4 +74,3 @@ available at https://www.contributor-covenant.org/version/1/4/code-of-conduct.ht
 
 For answers to common questions about this code of conduct, see
 https://www.contributor-covenant.org/faq
-

MANIFEST.in

@@ -1,3 +0,0 @@
-include LICENSE
-recursive-include requirements *.txt
-recursive-include dvc/repo/plots/templates *.json

README.rst

@@ -13,7 +13,7 @@
 
 |CI| |Python Version| |Coverage| |VS Code| |DOI|
 
-|PyPI| |Packages| |Brew| |Conda| |Choco| |Snap|
+|PyPI| |PyPI Downloads| |Packages| |Brew| |Conda| |Choco| |Snap|
 
 |
 
@@ -82,7 +82,7 @@ To share and back up the *data cache*, DVC supports multiple remote storage plat
 
 |Flowchart|
 
-`DVC pipelines <https://dvc.org/doc/start/data-management/pipelines>`_ (computational graphs) connect code and data together.
+`DVC pipelines <https://dvc.org/doc/start/data-management/data-pipelines>`_ (computational graphs) connect code and data together.
 They specify all steps required to produce a model: input dependencies including code, data, commands to run; and output information to be saved.
 
 Last but not least, `DVC Experiment Versioning <https://dvc.org/doc/start/experiments>`_ lets you prepare and run a large number of experiments.
@@ -276,6 +276,10 @@ Barrak, A., Eghan, E.E. and Adams, B. `On the Co-evolution of ML Pipelines and S
    :target: https://pypi.org/project/dvc
    :alt: PyPI
 
+.. |PyPI Downloads| image:: https://img.shields.io/pypi/dm/dvc.svg?color=blue&label=Downloads&logo=pypi&logoColor=gold
+   :target: https://pypi.org/project/dvc
+   :alt: PyPI Downloads
+
 .. |Packages| image:: https://img.shields.io/github/v/release/iterative/dvc?label=deb|pkg|rpm|exe&logo=GitHub
    :target: https://github.com/iterative/dvc/releases/latest
    :alt: deb|pkg|rpm|exe
@@ -292,6 +296,6 @@ Barrak, A., Eghan, E.E. and Adams, B. `On the Co-evolution of ML Pipelines and S
    :target: https://github.com/iterative/dvc/graphs/contributors
    :alt: Contributors
 
-.. |VS Code| image:: https://vsmarketplacebadge.apphb.com/version/Iterative.dvc.svg
+.. |VS Code| image:: https://img.shields.io/visual-studio-marketplace/v/Iterative.dvc?color=blue&label=VSCode&logo=visualstudiocode&logoColor=blue
    :target: https://marketplace.visualstudio.com/items?itemName=Iterative.dvc
    :alt: VS Code Extension

bin/dvc

@@ -1,3 +0,0 @@
-#!/bin/bash
-
-PYTHONPATH=$DVC_HOME python -m dvc $@

bin/dvc.bat

@@ -1,3 +0,0 @@
-@echo OFF
-set PYTHONPATH=%DVC_HOME%
-python -m dvc %*

dvc/__init__.py

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

dvc/_debug.py

@@ -1,16 +1,14 @@
 from contextlib import ExitStack, contextmanager
 from datetime import datetime
-from typing import TYPE_CHECKING, Callable, Union
+from typing import TYPE_CHECKING, Callable, Optional, Union
 
 if TYPE_CHECKING:
     from argparse import Namespace
+    from types import FrameType
 
 
 @contextmanager
-def viztracer_profile(
-    path: Union[Callable[[], str], str],
-    max_stack_depth: int = -1,
-):
+def viztracer_profile(path: Union[Callable[[], str], str], depth: int = -1):
     try:
         import viztracer  # pylint: disable=import-error
     except ImportError:
@@ -18,7 +16,7 @@ def viztracer_profile(
         yield
         return
 
-    tracer = viztracer.VizTracer(max_stack_depth=max_stack_depth)
+    tracer = viztracer.VizTracer(max_stack_depth=depth)
 
     tracer.start()
     yield
@@ -29,7 +27,9 @@ def viztracer_profile(
 
 @contextmanager
 def yappi_profile(
-    path: Union[Callable[[], str], str] = None, wall_clock: bool = True
+    path: Union[Callable[[], str], str] = None,
+    wall_clock: Optional[bool] = True,
+    separate_threads: Optional[bool] = False,
 ):
     try:
         import yappi  # pylint: disable=import-error
@@ -44,14 +44,26 @@ def yappi_profile(
     yield
     yappi.stop()
 
-    # pylint:disable=no-member
-    if path:
-        stats = yappi.get_func_stats()
-        fpath = path() if callable(path) else path
-        stats.save(fpath, "callgrind")
+    threads = yappi.get_thread_stats()
+    stats = {}
+    if separate_threads:
+        for thread in threads:
+            ctx_id = thread.id
+            stats[ctx_id] = yappi.get_func_stats(ctx_id=ctx_id)
     else:
-        yappi.get_func_stats().print_all()
-        yappi.get_thread_stats().print_all()
+        stats[None] = yappi.get_func_stats()
+
+    fpath = path() if callable(path) else path
+    for ctx_id, st in stats.items():
+        if fpath:
+            out = f"{fpath}-{ctx_id}" if ctx_id is not None else fpath
+            st.save(out, type="callgrind")
+        else:
+            if ctx_id is not None:
+                print(f"\nThread {ctx_id}")
+            st.print_all()  # pylint:disable=no-member
+            if ctx_id is None:
+                threads.print_all()  # pylint:disable=no-member
 
     yappi.clear_stats()
 
@@ -109,6 +121,38 @@ def debug():
         raise  # prevent from jumping ahead
 
 
+def _sigshow(_, frame: Optional["FrameType"]) -> None:
+    from shutil import get_terminal_size
+    from traceback import format_stack
+
+    from dvc.ui import ui
+
+    lines = "\u2015" * get_terminal_size().columns
+    ui.error_write(lines, "\n", *format_stack(frame), lines, sep="")
+
+
+@contextmanager
+def show_stack():
+    r"""Show stack trace on SIGQUIT (Ctrl-\) or SIGINFO (Ctrl-T on macOS)."""
+    import signal
+
+    signal.signal(signal.SIGQUIT, _sigshow)
+    try:
+        signal.signal(signal.SIGINFO, _sigshow)  # only available on macOS
+    except AttributeError:
+        pass
+    yield
+
+
+def _get_path_func(tool: str, ext: str):
+    fmt = f"{tool}.dvc-{{now:%Y%m%d}}_{{now:%H%M%S}}.{ext}"
+
+    def func(now: Optional["datetime"] = None) -> str:
+        return fmt.format(now=now or datetime.now())
+
+    return func
+
+
 @contextmanager
 def debugtools(args: "Namespace" = None, **kwargs):
     kw = vars(args) if args else {}
@@ -121,19 +165,21 @@ def debugtools(args: "Namespace" = None, **kwargs):
             stack.enter_context(profile(kw.get("cprofile_dump")))
         if kw.get("instrument") or kw.get("instrument_open"):
             stack.enter_context(instrument(kw.get("instrument_open", False)))
+        if kw.get("show_stack", False):
+            stack.enter_context(show_stack())
         if kw.get("yappi"):
-            output = "callgrind.dvc-{0:%Y%m%d}_{0:%H%M%S}.out"
+            path_func = _get_path_func("callgrind", "out")
             stack.enter_context(
-                yappi_profile(path=lambda: output.format(datetime.now()))
-            )
-        if kw.get("viztracer") or kw.get("viztracer_depth"):
-            output = "viztracer.dvc-{0:%Y%m%d}_{0:%H%M%S}.json"
-            stack.enter_context(
-                viztracer_profile(
-                    path=lambda: output.format(datetime.now()),
-                    max_stack_depth=kw.get("viztracer_depth") or -1,
+                yappi_profile(
+                    path=path_func,
+                    separate_threads=kw.get("yappi_separate_threads"),
                 )
             )
+        if kw.get("viztracer") or kw.get("viztracer_depth"):
+            path_func = _get_path_func("viztracer", "json")
+            depth = kw.get("viztracer_depth") or -1
+            prof = viztracer_profile(path=path_func, depth=depth)
+            stack.enter_context(prof)
         yield
 
 
@@ -146,6 +192,12 @@ def add_debugging_flags(parser):
     parser.add_argument(
         "--yappi", action="store_true", default=False, help=SUPPRESS
     )
+    parser.add_argument(
+        "--yappi-separate-threads",
+        action="store_true",
+        default=False,
+        help=SUPPRESS,
+    )
     parser.add_argument(
         "--viztracer", action="store_true", default=False, help=SUPPRESS
     )
@@ -160,3 +212,10 @@ def add_debugging_flags(parser):
     parser.add_argument(
         "--instrument-open", action="store_true", default=False, help=SUPPRESS
     )
+    parser.add_argument(
+        "--show-stack",
+        "--ss",
+        action="store_true",
+        default=False,
+        help=SUPPRESS,
+    )

dvc/cli/parser.py

@@ -29,6 +29,7 @@ from dvc.commands import (
     init,
     install,
     ls,
+    ls_url,
     machine,
     metrics,
     move,
@@ -75,6 +76,7 @@ COMMANDS = [
     install,
     root,
     ls,
+    ls_url,
     freeze,
     dag,
     daemon,

dvc/commands/checkout.py

@@ -110,7 +110,7 @@ def add_parser(subparsers, parent_parser):
         nargs="*",
         help=(
             "Limit command scope to these tracked files/directories, "
-            ".dvc files, or stage names."
+            ".dvc files and stage names."
         ),
     ).complete = completion.DVC_FILE
     checkout_parser.set_defaults(func=CmdCheckout)

dvc/commands/commit.py

@@ -70,7 +70,9 @@ def add_parser(subparsers, parent_parser):
     commit_parser.add_argument(
         "targets",
         nargs="*",
-        help="stages or .dvc files to commit. Optional. "
-        "(Finds all DVC files in the workspace by default.)",
+        help=(
+            "Limit command scope to these tracked files/directories, "
+            ".dvc files and stage names."
+        ),
     ).complete = completion.DVCFILES_AND_STAGE
     commit_parser.set_defaults(func=CmdCommit)

dvc/commands/dag.py

@@ -204,7 +204,7 @@ def add_parser(subparsers, parent_parser):
     dag_parser.add_argument(
         "target",
         nargs="?",
-        help="Stage or output to show pipeline for (optional). "
+        help="Stage name or output to show pipeline for. "
         "Finds all stages in the workspace by default.",
     )
     dag_parser.set_defaults(func=CmdDAG)

dvc/commands/data_sync.py

@@ -120,7 +120,7 @@ def shared_parent_parser():
         nargs="*",
         help=(
             "Limit command scope to these tracked files/directories, "
-            ".dvc files, or stage names."
+            ".dvc files and stage names."
         ),
     ).complete = completion.DVC_FILE
 
@@ -195,7 +195,7 @@ def add_parser(subparsers, _parent_parser):
         "--glob",
         action="store_true",
         default=False,
-        help="Pull cache for targets matching shell-style wildcards.",
+        help=argparse.SUPPRESS,
     )
     pull_parser.set_defaults(func=CmdDataPull)
 

dvc/commands/experiments/ls.py

@@ -16,13 +16,17 @@ class CmdExperimentsList(CmdBase):
             num=self.args.num,
             git_remote=self.args.git_remote,
         )
+        tags = self.repo.scm.describe(exps)
+        remained = {baseline for baseline, tag in tags.items() if tag is None}
+        base = "refs/heads/"
+        ref_heads = self.repo.scm.describe(remained, base=base)
+
         for baseline in exps:
-            tag = self.repo.scm.describe(baseline)
-            if not tag:
-                branch = self.repo.scm.describe(baseline, base="refs/heads")
-                if branch:
-                    tag = branch.split("/")[-1]
-            name = tag if tag else baseline[:7]
+            name = (
+                tags[baseline]
+                or ref_heads[baseline][len(base) :]
+                or baseline[:7]
+            )
             if not name_only:
                 print(f"{name}:")
             for exp_name in exps[baseline]:

dvc/commands/experiments/show.py

@@ -95,11 +95,8 @@ def _collect_rows(
 
         exp = results.get("data", {})
 
-        if exp.get("running"):
-            state = "Running"
-        elif exp.get("queued"):
-            state = "Queued"
-        else:
+        state = exp.get("status")
+        if state == "Success":
             state = fill_value
 
         is_baseline = rev == "baseline"
@@ -476,6 +473,8 @@ class CmdExperimentsShow(CmdBase):
                 all_branches=self.args.all_branches,
                 all_tags=self.args.all_tags,
                 all_commits=self.args.all_commits,
+                hide_queued=self.args.hide_queued,
+                hide_failed=self.args.hide_failed,
                 revs=self.args.rev,
                 num=self.args.num,
                 sha_only=self.args.sha,
@@ -594,6 +593,18 @@ def add_parser(experiments_subparsers, parent_parser):
         default=False,
         help="Always show git commit SHAs instead of branch/tag names.",
     )
+    experiments_show_parser.add_argument(
+        "--hide-failed",
+        action="store_true",
+        default=False,
+        help="Hide failed experiments in the table.",
+    )
+    experiments_show_parser.add_argument(
+        "--hide-queued",
+        action="store_true",
+        default=False,
+        help="Hide queued experiments in the table.",
+    )
     experiments_show_parser.add_argument(
         "--json",
         "--show-json",

dvc/commands/git_hook.py

@@ -74,7 +74,7 @@ class CmdMergeDriver(CmdHookBase):
             our = Dvcfile(dvc, self.args.our, verify=False)
             their = Dvcfile(dvc, self.args.their, verify=False)
 
-            our.merge(ancestor, their)
+            our.merge(ancestor, their, allowed=["add", "remove", "change"])
 
             return 0
         finally:

dvc/commands/imp_url.py

@@ -25,6 +25,7 @@ class CmdImportUrl(CmdBase):
                 labels=self.args.labels,
                 meta=self.args.meta,
                 jobs=self.args.jobs,
+                version_aware=self.args.version_aware,
             )
         except DvcException:
             logger.exception(
@@ -108,5 +109,14 @@ def add_parser(subparsers, parent_parser):
         ),
         metavar="<number>",
     )
+    import_parser.add_argument(
+        "--version-aware",
+        action="store_true",
+        default=False,
+        help=(
+            "Import using cloud versioning. Implied if the URL contains a "
+            "version ID."
+        ),
+    )
     _add_annotating_args(import_parser)
     import_parser.set_defaults(func=CmdImportUrl)

dvc/commands/ls_url.py

@@ -0,0 +1,43 @@
+import argparse
+import logging
+
+from dvc.cli.command import CmdBaseNoRepo
+from dvc.cli.utils import append_doc_link
+from dvc.ui import ui
+
+from .ls import _prettify
+
+logger = logging.getLogger(__name__)
+
+
+class CmdListUrl(CmdBaseNoRepo):
+    def run(self):
+        from dvc.repo import Repo
+
+        entries = Repo.ls_url(self.args.url, recursive=self.args.recursive)
+        if entries:
+            entries = _prettify(entries, with_color=True)
+            ui.write("\n".join(entries))
+        return 0
+
+
+def add_parser(subparsers, parent_parser):
+    LS_HELP = "List directory contents from URL."
+    lsurl_parser = subparsers.add_parser(
+        "list-url",
+        aliases=["ls-url"],
+        parents=[parent_parser],
+        description=append_doc_link(LS_HELP, "list-url"),
+        help=LS_HELP,
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+    )
+    lsurl_parser.add_argument(
+        "url", help="See `dvc import-url -h` for full list of supported URLs."
+    )
+    lsurl_parser.add_argument(
+        "-R",
+        "--recursive",
+        action="store_true",
+        help="Recursively list files.",
+    )
+    lsurl_parser.set_defaults(func=CmdListUrl)

dvc/commands/plots.py

@@ -25,7 +25,7 @@ def _show_json(renderers, split=False):
 
 
 def _adjust_vega_renderers(renderers):
-    from dvc.render import VERSION_FIELD
+    from dvc.render import REVISION_FIELD, VERSION_FIELD
     from dvc_render import VegaRenderer
 
     for r in renderers:
@@ -42,6 +42,7 @@ def _adjust_vega_renderers(renderers):
                         dp["rev"] = "::".join(vi.values())
             else:
                 for dp in r.datapoints:
+                    dp[REVISION_FIELD] = dp[VERSION_FIELD]["revision"]
                     dp.pop(VERSION_FIELD, {})
 
 
@@ -66,18 +67,6 @@ def _data_versions_count(renderer):
     return len(set(x))
 
 
-def _filter_unhandled_renderers(renderers):
-    # filtering out renderers currently unhandled by vscode extension
-    from dvc_render import VegaRenderer
-
-    def _is_json_viable(r):
-        return not (
-            isinstance(r, VegaRenderer) and _data_versions_count(r) > 1
-        )
-
-    return list(filter(_is_json_viable, renderers))
-
-
 class CmdPlots(CmdBase):
     def _func(self, *args, **kwargs):
         raise NotImplementedError
@@ -156,12 +145,10 @@ class CmdPlots(CmdBase):
                 templates_dir=self.repo.plots.templates_dir,
             )
             if self.args.json:
-                renderers = _filter_unhandled_renderers(renderers)
                 _show_json(renderers, self.args.split)
                 return 0
 
             _adjust_vega_renderers(renderers)
-
             if self.args.show_vega:
                 renderer = first(filter(lambda r: r.TYPE == "vega", renderers))
                 if renderer:

dvc/commands/repro.py

@@ -55,7 +55,16 @@ def add_arguments(repro_parser):
     repro_parser.add_argument(
         "targets",
         nargs="*",
-        help="Stages to reproduce. 'dvc.yaml' by default.",
+        help=(
+            """\
+Stages to reproduce. 'dvc.yaml' by default.
+The targets can be path to a dvc.yaml file or `.dvc` file,
+or a stage name from dvc.yaml file from
+current working directory. To run a stage from dvc.yaml
+from other directories, the target must be a path followed by colon `:`
+and then the stage name name.
+"""
+        ),
     ).complete = completion.DVCFILES_AND_STAGE
     repro_parser.add_argument(
         "-f",

dvc/commands/stage.py

@@ -238,26 +238,6 @@ def _add_common_args(parser):
         help="Declare output plot file (do not put into DVC cache).",
         metavar="<path>",
     )
-    parser.add_argument(
-        "--live", help="Declare output as dvclive.", metavar="<path>"
-    )
-    parser.add_argument(
-        "--live-no-cache",
-        help="Declare output as dvclive (do not put into DVC cache).",
-        metavar="<path>",
-    )
-    parser.add_argument(
-        "--live-no-summary",
-        action="store_true",
-        default=False,
-        help=argparse.SUPPRESS,
-    )
-    parser.add_argument(
-        "--live-no-html",
-        action="store_true",
-        default=False,
-        help="Signal dvclive logger to not produce training report.",
-    )
     parser.add_argument(
         "-w",
         "--wdir",

dvc/commands/update.py

@@ -60,7 +60,7 @@ def add_parser(subparsers, parent_parser):
         "--no-download",
         action="store_true",
         default=False,
-        help="Update .dvc file hash value(s)"
+        help="Update .dvc file git revision/hash value(s)"
         " but do not download the file(s).",
     )
     update_parser.add_argument(

dvc/config.py

@@ -176,7 +176,10 @@ class Config(dict):
 
         if fs.exists(filename):
             with fs.open(filename) as fobj:
-                conf_obj = ConfigObj(fobj)
+                try:
+                    conf_obj = ConfigObj(fobj)
+                except UnicodeDecodeError as exc:
+                    raise ConfigError(str(exc)) from exc
         else:
             conf_obj = ConfigObj()
         return _parse_named(_lower_keys(conf_obj.dict()))

dvc/config_schema.py

@@ -180,6 +180,8 @@ SCHEMA = {
                     "user": str,
                     "password": str,
                     "ask_password": Bool,
+                    "passphrase": str,
+                    "ask_passphrase": Bool,
                     "keyfile": str,
                     "timeout": Coerce(int),
                     "gss_auth": Bool,

dvc/data_cloud.py

@@ -11,6 +11,7 @@ if TYPE_CHECKING:
     from dvc_data.hashfile.db import HashFileDB
     from dvc_data.hashfile.hash_info import HashInfo
     from dvc_data.hashfile.status import CompareStatusResult
+    from dvc_data.hashfile.transfer import TransferResult
 
 logger = logging.getLogger(__name__)
 
@@ -106,14 +107,10 @@ class DataCloud:
         dest_odb: "HashFileDB",
         objs: Iterable["HashInfo"],
         **kwargs,
-    ):
-        from dvc.exceptions import FileTransferError
-        from dvc_data.hashfile.transfer import TransferError, transfer
+    ) -> "TransferResult":
+        from dvc_data.hashfile.transfer import transfer
 
-        try:
-            return transfer(src_odb, dest_odb, objs, **kwargs)
-        except TransferError as exc:
-            raise FileTransferError(exc.fails) from exc
+        return transfer(src_odb, dest_odb, objs, **kwargs)
 
     def push(
         self,
@@ -121,7 +118,7 @@ class DataCloud:
         jobs: Optional[int] = None,
         remote: Optional[str] = None,
         odb: Optional["HashFileDB"] = None,
-    ):
+    ) -> "TransferResult":
         """Push data items in a cloud-agnostic way.
 
         Args:
@@ -148,7 +145,7 @@ class DataCloud:
         jobs: Optional[int] = None,
         remote: Optional[str] = None,
         odb: Optional["HashFileDB"] = None,
-    ):
+    ) -> "TransferResult":
         """Pull data items in a cloud-agnostic way.
 
         Args:

dvc/dependency/__init__.py

@@ -1,7 +1,7 @@
 from collections import defaultdict
 from typing import Any, Mapping
 
-from dvc.output import ARTIFACT_SCHEMA, Output
+from dvc.output import ARTIFACT_SCHEMA, DIR_FILES_SCHEMA, Output
 
 from .base import Dependency
 from .param import ParamsDependency
@@ -15,10 +15,11 @@ SCHEMA: Mapping[str, Any] = {
     **ARTIFACT_SCHEMA,
     **RepoDependency.REPO_SCHEMA,
     **ParamsDependency.PARAM_SCHEMA,
+    Output.PARAM_FILES: [DIR_FILES_SCHEMA],
 }
 
 
-def _get(stage, p, info, fs_config=None):
+def _get(stage, p, info, **kwargs):
     if info and info.get(RepoDependency.PARAM_REPO):
         repo = info.pop(RepoDependency.PARAM_REPO)
         return RepoDependency(repo, stage, p, info)
@@ -27,14 +28,15 @@ def _get(stage, p, info, fs_config=None):
         params = info.pop(ParamsDependency.PARAM_PARAMS)
         return ParamsDependency(stage, p, params)
 
-    return Dependency(stage, p, info, fs_config=fs_config)
+    return Dependency(stage, p, info, **kwargs)
 
 
 def loadd_from(stage, d_list):
     ret = []
     for d in d_list:
         p = d.pop(Output.PARAM_PATH, None)
-        ret.append(_get(stage, p, d))
+        files = d.pop(Output.PARAM_FILES, None)
+        ret.append(_get(stage, p, d, files=files))
     return ret
 
 

dvc/dependency/base.py

@@ -1,6 +1,7 @@
-from typing import Type
+from typing import Dict, Type
 
 from dvc.exceptions import DvcException
+from dvc.fs import download as fs_download
 from dvc.output import Output
 
 
@@ -30,5 +31,39 @@ class Dependency(Output):
     )  # type: Type[DvcException]
     IsStageFileError = DependencyIsStageFileError  # type: Type[DvcException]
 
+    def workspace_status(self) -> Dict[str, str]:
+        if self.fs.version_aware:
+            old_fs_path = self.fs_path
+            try:
+                self.fs_path = self.fs.path.version_path(self.fs_path, None)
+                if self.changed_meta():
+                    return {str(self): "update available"}
+            finally:
+                self.fs_path = old_fs_path
+        return super().workspace_status()
+
     def update(self, rev=None):
-        pass
+        if self.fs.version_aware:
+            self.fs_path = self.fs.path.version_path(self.fs_path, rev)
+            self.meta = self.get_meta()
+            self.def_path = self.fs.path.version_path(
+                self.def_path, self.meta.version_id
+            )
+            self.fs_path = self.fs.path.version_path(
+                self.fs_path, self.meta.version_id
+            )
+
+    def download(self, to, jobs=None):
+        fs_download(self.fs, self.fs_path, to, jobs=jobs)
+
+    def save(self):
+        super().save()
+        if self.fs.version_aware:
+            self.fs_path = self.fs.path.version_path(
+                self.fs_path, self.meta.version_id
+            )
+
+    def dumpd(self, **kwargs):
+        if self.fs.version_aware:
+            kwargs["with_files"] = True
+        return super().dumpd(**kwargs)

dvc/dependency/repo.py

@@ -6,6 +6,7 @@ from typing import TYPE_CHECKING, Dict, Optional, Set, Tuple
 from voluptuous import Required
 
 from dvc.prompt import confirm
+from dvc_data.hashfile.meta import Meta
 
 from .base import Dependency
 
@@ -32,6 +33,7 @@ class RepoDependency(Dependency):
     def __init__(self, def_repo, stage, *args, **kwargs):
         self.def_repo = def_repo
         self._objs: Dict[str, "HashFile"] = {}
+        self._meta: Dict[str, Meta] = {}
         super().__init__(stage, *args, **kwargs)
 
     def _parse_path(self, fs, fs_path):
@@ -94,12 +96,12 @@ class RepoDependency(Dependency):
     def get_used_objs(
         self, **kwargs
     ) -> Dict[Optional["ObjectDB"], Set["HashInfo"]]:
-        used, _ = self._get_used_and_obj(**kwargs)
+        used, _, _ = self._get_used_and_obj(**kwargs)
         return used
 
     def _get_used_and_obj(
         self, obj_only=False, **kwargs
-    ) -> Tuple[Dict[Optional["ObjectDB"], Set["HashInfo"]], "HashFile"]:
+    ) -> Tuple[Dict[Optional["ObjectDB"], Set["HashInfo"]], Meta, "HashFile"]:
         from dvc.config import NoRemoteError
         from dvc.exceptions import NoOutputOrStageError, PathMissingError
         from dvc.utils import as_posix
@@ -131,7 +133,7 @@ class RepoDependency(Dependency):
                     pass
 
             try:
-                object_store, _, obj = build(
+                object_store, meta, obj = build(
                     local_odb,
                     as_posix(self.def_path),
                     repo.dvcfs,
@@ -145,10 +147,12 @@ class RepoDependency(Dependency):
             object_store.read_only = True
 
             self._objs[rev] = obj
+            self._meta[rev] = meta
+
             used_obj_ids[object_store].add(obj.hash_info)
             if isinstance(obj, Tree):
                 used_obj_ids[object_store].update(oid for _, _, oid in obj)
-            return used_obj_ids, obj
+            return used_obj_ids, meta, obj
 
     def _check_circular_import(self, odb, obj_ids):
         from dvc.exceptions import CircularImportError
@@ -190,11 +194,21 @@ class RepoDependency(Dependency):
         rev = self._get_rev(locked=locked)
         if rev in self._objs:
             return self._objs[rev]
-        _, obj = self._get_used_and_obj(
+        _, _, obj = self._get_used_and_obj(
             obj_only=True, filter_info=filter_info, **kwargs
         )
         return obj
 
+    def get_meta(self, filter_info=None, **kwargs):
+        locked = kwargs.get("locked", True)
+        rev = self._get_rev(locked=locked)
+        if rev in self._meta:
+            return self._meta[rev]
+        _, meta, _ = self._get_used_and_obj(
+            obj_only=True, filter_info=filter_info, **kwargs
+        )
+        return meta
+
     def _make_repo(self, locked=True, **kwargs):
         from dvc.external_repo import external_repo
 

dvc/dvcfile.py

@@ -172,7 +172,7 @@ class FileMixin:
     def dump(self, stage, **kwargs):
         raise NotImplementedError
 
-    def merge(self, ancestor, other):
+    def merge(self, ancestor, other, allowed=None):
         raise NotImplementedError
 
 
@@ -204,12 +204,12 @@ class SingleStageFile(FileMixin):
     def remove_stage(self, stage):  # pylint: disable=unused-argument
         self.remove()
 
-    def merge(self, ancestor, other):
+    def merge(self, ancestor, other, allowed=None):
         assert isinstance(ancestor, SingleStageFile)
         assert isinstance(other, SingleStageFile)
 
         stage = self.stage
-        stage.merge(ancestor.stage, other.stage)
+        stage.merge(ancestor.stage, other.stage, allowed=allowed)
         self.dump(stage)
 
 
@@ -237,10 +237,10 @@ class PipelineFile(FileMixin):
             self._dump_pipeline_file(stage)
 
         if update_lock:
-            self._dump_lockfile(stage)
+            self._dump_lockfile(stage, **kwargs)
 
-    def _dump_lockfile(self, stage):
-        self._lockfile.dump(stage)
+    def _dump_lockfile(self, stage, **kwargs):
+        self._lockfile.dump(stage, **kwargs)
 
     @staticmethod
     def _check_if_parametrized(stage, action: str = "dump") -> None:
@@ -310,7 +310,7 @@ class PipelineFile(FileMixin):
         else:
             super().remove()
 
-    def merge(self, ancestor, other):
+    def merge(self, ancestor, other, allowed=None):
         raise NotImplementedError
 
 
@@ -366,7 +366,7 @@ class Lockfile(FileMixin):
         return {SCHEMA_KWD: version}
 
     def dump(self, stage, **kwargs):
-        stage_data = serialize.to_lockfile(stage)
+        stage_data = serialize.to_lockfile(stage, **kwargs)
 
         with modify_yaml(self.path, fs=self.repo.fs) as data:
             version = LOCKFILE_VERSION.from_dict(data)
@@ -411,7 +411,7 @@ class Lockfile(FileMixin):
         else:
             self.remove()
 
-    def merge(self, ancestor, other):
+    def merge(self, ancestor, other, allowed=None):
         raise NotImplementedError
 
 

dvc/env.py

@@ -2,9 +2,6 @@ DVC_CHECKPOINT = "DVC_CHECKPOINT"
 DVC_DAEMON = "DVC_DAEMON"
 DVC_PAGER = "DVC_PAGER"
 DVC_ROOT = "DVC_ROOT"
-DVCLIVE_PATH = "DVCLIVE_PATH"
-DVCLIVE_SUMMARY = "DVCLIVE_SUMMARY"
-DVCLIVE_HTML = "DVCLIVE_HTML"
 DVCLIVE_RESUME = "DVCLIVE_RESUME"
 DVC_IGNORE_ISATTY = "DVC_IGNORE_ISATTY"
 DVC_EXP_GIT_REMOTE = "DVC_EXP_GIT_REMOTE"

dvc/exceptions.py

@@ -132,10 +132,17 @@ class NotDvcRepoError(DvcException):
 class CyclicGraphError(DvcException):
     def __init__(self, stages):
         assert isinstance(stages, list)
-        msg = "Pipeline has a cycle involving: {}.".format(
-            ", ".join(s.addressing for s in stages)
+        stage_part = "stage" if len(stages) == 1 else "stages"
+        msg = (
+            "Same item(s) are defined as both a dependency and an output "
+            "in {stage_part}: {stage}."
+        )
+        super().__init__(
+            msg.format(
+                stage_part=stage_part,
+                stage=", ".join(s.addressing for s in stages),
+            )
         )
-        super().__init__(msg)
 
 
 class ConfirmRemoveError(DvcException):
@@ -278,6 +285,11 @@ class PathMissingError(DvcException):
         self.dvc_only = dvc_only
 
 
+class URLMissingError(DvcException):
+    def __init__(self, url):
+        super().__init__(f"The path '{url}' does not exist")
+
+
 class RemoteCacheRequiredError(DvcException):
     def __init__(self, scheme, fs_path):
 

dvc/fs/__init__.py

@@ -2,6 +2,9 @@ from urllib.parse import urlparse
 
 from dvc_http import HTTPFileSystem, HTTPSFileSystem  # noqa: F401
 
+from dvc.config import ConfigError as RepoConfigError
+from dvc.config_schema import SCHEMA, Invalid
+
 # pylint: disable=unused-import
 from dvc_objects.fs import utils  # noqa: F401
 from dvc_objects.fs import (  # noqa: F401
@@ -23,6 +26,7 @@ from dvc_objects.fs.errors import (  # noqa: F401
 )
 from dvc_objects.fs.path import Path  # noqa: F401
 
+from .callbacks import Callback
 from .data import DataFileSystem  # noqa: F401
 from .dvc import DVCFileSystem  # noqa: F401
 from .git import GitFileSystem  # noqa: F401
@@ -44,7 +48,23 @@ known_implementations.update(
 # pylint: enable=unused-import
 
 
-def get_fs_config(repo, config, **kwargs):
+def download(fs, fs_path, to, jobs=None):
+    with Callback.as_tqdm_callback(
+        desc=f"Downloading {fs.path.name(fs_path)}",
+        unit="files",
+    ) as cb:
+        fs.get(fs_path, to.fs_path, batch_size=jobs, callback=cb)
+
+
+def parse_external_url(url, config=None):
+    remote_config = dict(config) if config else {}
+    remote_config["url"] = url
+    fs_cls, fs_config, fs_path = get_cloud_fs(None, **remote_config)
+    fs = fs_cls(**fs_config)
+    return fs, fs_path
+
+
+def get_fs_config(config, **kwargs):
     name = kwargs.get("name")
     if name:
         try:
@@ -55,10 +75,10 @@ def get_fs_config(repo, config, **kwargs):
             raise RemoteNotFoundError(f"remote '{name}' doesn't exist")
     else:
         remote_conf = kwargs
-    return _resolve_remote_refs(repo, config, remote_conf)
+    return _resolve_remote_refs(config, remote_conf)
 
 
-def _resolve_remote_refs(repo, config, remote_conf):
+def _resolve_remote_refs(config, remote_conf):
     # Support for cross referenced remotes.
     # This will merge the settings, shadowing base ref with remote_conf.
     # For example, having:
@@ -84,21 +104,22 @@ def _resolve_remote_refs(repo, config, remote_conf):
     if parsed.scheme != "remote":
         return remote_conf
 
-    base = get_fs_config(repo, config, name=parsed.netloc)
-    cls, _, _ = get_cloud_fs(repo, **base)
+    base = get_fs_config(config, name=parsed.netloc)
+    cls, _, _ = _get_cloud_fs(config, **base)
     relpath = parsed.path.lstrip("/").replace("/", cls.sep)
     url = cls.sep.join((base["url"], relpath))
     return {**base, **remote_conf, "url": url}
 
 
 def get_cloud_fs(repo, **kwargs):
-    from dvc.config import ConfigError as RepoConfigError
-    from dvc.config_schema import SCHEMA, Invalid
-
     repo_config = repo.config if repo else {}
+    return _get_cloud_fs(repo_config, **kwargs)
+
+
+def _get_cloud_fs(repo_config, **kwargs):
     core_config = repo_config.get("core", {})
 
-    remote_conf = get_fs_config(repo, repo_config, **kwargs)
+    remote_conf = get_fs_config(repo_config, **kwargs)
     try:
         remote_conf = SCHEMA["remote"][str](remote_conf)
     except Invalid as exc:

dvc/fs/callbacks.py

@@ -1,6 +1,6 @@
 # pylint: disable=unused-import
 from contextlib import ExitStack
-from typing import TYPE_CHECKING, Optional
+from typing import TYPE_CHECKING, Any, BinaryIO, Dict, Optional, Union
 
 from funcy import cached_property
 
@@ -24,6 +24,7 @@ class RichCallback(Callback):
         bytes: bool = False,  # pylint: disable=redefined-builtin
         unit: str = None,
         disable: bool = False,
+        transient: bool = True,
     ) -> None:
         self._progress = progress
         self.disable = disable
@@ -35,6 +36,7 @@ class RichCallback(Callback):
             "visible": False,
             "progress_type": None if bytes else "summary",
         }
+        self._transient = transient
         self._stack = ExitStack()
         super().__init__(size=size, value=value)
 
@@ -47,7 +49,7 @@ class RichCallback(Callback):
             return self._progress
 
         progress = RichTransferProgress(
-            transient=True,
+            transient=self._transient,
             disable=self.disable,
             console=ui.error_console,
         )
@@ -61,7 +63,8 @@ class RichCallback(Callback):
         return self
 
     def close(self):
-        self.progress.clear_task(self.task)
+        if self._transient:
+            self.progress.clear_task(self.task)
         self._stack.close()
 
     def call(self, hook_name=None, **kwargs):
@@ -72,8 +75,17 @@ class RichCallback(Callback):
             visible=not self.disable,
         )
 
-    def branch(self, path_1, path_2, kwargs, child: Optional[Callback] = None):
+    def branch(
+        self,
+        path_1: Union[str, BinaryIO],
+        path_2: str,
+        kwargs: Dict[str, Any],
+        child: "Callback" = None,
+    ):
         child = child or RichCallback(
-            progress=self.progress, desc=path_1, bytes=True
+            progress=self.progress,
+            desc=path_1 if isinstance(path_1, str) else path_2,
+            bytes=True,
+            transient=self._transient,
         )
         return super().branch(path_1, path_2, kwargs, child=child)

dvc/fs/dvc.py

@@ -10,9 +10,7 @@ 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
 
-from dvc.utils.fs import makedirs
 from dvc_objects.fs.base import FileSystem
-from dvc_objects.fs.callbacks import DEFAULT_CALLBACK
 from dvc_objects.fs.path import Path
 
 from .data import DataFileSystem
@@ -66,15 +64,7 @@ def _get_dvc_path(dvc_fs, subkey):
 
 
 class _DVCFileSystem(AbstractFileSystem):  # pylint:disable=abstract-method
-    """DVC + git-tracked files fs.
-
-    Args:
-        repo: DVC or git repo.
-        subrepos: traverse to subrepos (by default, it ignores subrepos)
-        repo_factory: A function to initialize subrepo with, default is Repo.
-        kwargs: Additional keyword arguments passed to the `DataFileSystem()`.
-    """
-
+    cachable = False
     root_marker = "/"
 
     def __init__(
@@ -86,6 +76,41 @@ class _DVCFileSystem(AbstractFileSystem):  # pylint:disable=abstract-method
         repo_factory: Optional[RepoFactory] = None,
         **repo_kwargs: Any,
     ) -> None:
+        """DVC + git-tracked files fs.
+
+        Args:
+            path (str, optional): URL or path to a DVC/Git repository.
+                Defaults to a DVC repository in the current working directory.
+                Both HTTP and SSH protocols are supported for remote Git repos
+                (e.g. [user@]server:project.git).
+            rev (str, optional): Any Git revision such as a branch or tag name,
+                a commit hash or a dvc experiment name.
+                Defaults to the default branch in case of remote repositories.
+                In case of a local repository, if rev is unspecified, it will
+                default to the working directory.
+                If the repo is not a Git repo, this option is ignored.
+            repo (:obj:`Repo`, optional): `Repo` instance.
+            subrepos (bool): traverse to subrepos.
+                By default, it ignores subrepos.
+            repo_factory (callable): A function to initialize subrepo with.
+                The default is `Repo`.
+
+        Examples:
+            - Opening a filesystem from repo in current working directory
+
+            >>> fs = DVCFileSystem()
+
+            - Opening a filesystem from local repository
+
+            >>> fs = DVCFileSystem("path/to/local/repository")
+
+            - Opening a remote repository
+
+            >>> fs = DVCFileSystem(
+            ...    "https://github.com/iterative/example-get-started",
+            ...    rev="main",
+            ... )
+        """
         from pygtrie import Trie
 
         super().__init__()
@@ -238,7 +263,8 @@ class _DVCFileSystem(AbstractFileSystem):  # pylint:disable=abstract-method
         dvc_path = _get_dvc_path(dvc_fs, subkey)
         return dvc_fs.open(dvc_path, mode=mode)
 
-    def isdvc(self, path, **kwargs):
+    def isdvc(self, path, **kwargs) -> bool:
+        """Is this entry dvc-tracked?"""
         key = self._get_key_from_relative(path)
         _, dvc_fs, subkey = self._get_subrepo_info(key)
         dvc_path = _get_dvc_path(dvc_fs, subkey)
@@ -295,27 +321,6 @@ class _DVCFileSystem(AbstractFileSystem):  # pylint:disable=abstract-method
 
         return infos
 
-    def get_file(  # pylint: disable=arguments-differ
-        self, rpath, lpath, callback=DEFAULT_CALLBACK, **kwargs
-    ):
-        key = self._get_key_from_relative(rpath)
-        fs_path = self._from_key(key)
-        fs = self.repo.fs
-
-        if self.isdir(rpath):
-            makedirs(lpath, exist_ok=True)
-            return None
-
-        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):
         key = self._get_key_from_relative(path)
         ignore_subrepos = kwargs.get("ignore_subrepos", True)

dvc/ignore.py

@@ -300,12 +300,25 @@ class DvcIgnoreFilter:
         return [fs_dict[name] for name in chain(dirs, nondirs)]
 
     def walk(self, fs: FileSystem, path: AnyFSPath, **kwargs):
+        detail = kwargs.get("detail", False)
         ignore_subrepos = kwargs.pop("ignore_subrepos", True)
         if fs.protocol == Schemes.LOCAL:
             for root, dirs, files in fs.walk(path, **kwargs):
-                dirs[:], files[:] = self(
-                    root, dirs, files, ignore_subrepos=ignore_subrepos
-                )
+                if detail:
+                    all_dnames = set(dirs.keys())
+                    all_fnames = set(files.keys())
+                    dnames, fnames = self(
+                        root,
+                        all_dnames,
+                        all_fnames,
+                        ignore_subrepos=ignore_subrepos,
+                    )
+                    list(map(dirs.pop, all_dnames - set(dnames)))
+                    list(map(files.pop, all_fnames - set(fnames)))
+                else:
+                    dirs[:], files[:] = self(
+                        root, dirs, files, ignore_subrepos=ignore_subrepos
+                    )
                 yield root, dirs, files
         else:
             yield from fs.walk(path, **kwargs)

dvc/info.py

@@ -76,7 +76,7 @@ def _get_caches(cache):
 
 def _get_remotes(config):
     schemes = (
-        get_fs_cls(get_fs_config(None, config, name=remote)).protocol
+        get_fs_cls(get_fs_config(config, name=remote)).protocol
         for remote in config["remote"]
     )
 

dvc/logger.py

@@ -213,8 +213,6 @@ def set_loggers_level(level: int = logging.INFO) -> None:
 
 
 def setup(level: int = logging.INFO) -> None:
-    colorama.init()
-
     if level >= logging.DEBUG:
         # Unclosed session errors for asyncio/aiohttp are only available
         # on the tracing mode for extensive debug purposes. They are really
@@ -297,3 +295,8 @@ def setup(level: int = logging.INFO) -> None:
             "disable_existing_loggers": False,
         }
     )
+
+    # NOTE: colorama init needs to go after logging config to avoid potential
+    # conflicts with libs that modify logging (like tensorflow/abseil)
+    # https://github.com/iterative/dvc/issues/8387
+    colorama.init()

dvc/machine/backend/base.py

@@ -26,7 +26,7 @@ class BaseMachineBackend(ABC):
     ) -> Iterator[dict]:
         """Iterate over status of all instances of the specified machine."""
 
-    def close(self):
+    def close(self):  # noqa: B027
         pass
 
     @abstractmethod

dvc/output.py

@@ -26,10 +26,12 @@ 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.hashfile.transfer import transfer as otransfer
+from dvc_data.index import DataIndexEntry
 from dvc_objects.errors import ObjectFormatError
 
 from .annotations import ANNOTATION_FIELDS, ANNOTATION_SCHEMA, Annotation
 from .fs import LocalFileSystem, RemoteMissingDepsError, Schemes, get_cloud_fs
+from .fs.callbacks import DEFAULT_CALLBACK
 from .utils import relpath
 from .utils.fs import path_isin
 
@@ -38,6 +40,8 @@ if TYPE_CHECKING:
     from dvc_data.index import DataIndexKey
     from dvc_objects.db import ObjectDB
 
+    from .fs.callbacks import Callback
+
 logger = logging.getLogger(__name__)
 
 
@@ -83,7 +87,6 @@ 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)
-        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)
@@ -97,7 +100,6 @@ def loadd_from(stage, d_list):
                 plot=plot,
                 persist=persist,
                 checkpoint=checkpoint,
-                live=live,
                 remote=remote,
                 **annot,
                 files=files,
@@ -114,7 +116,6 @@ def loads_from(
     plot=False,
     persist=False,
     checkpoint=False,
-    live=False,
     remote=None,
 ):
     return [
@@ -127,7 +128,6 @@ def loads_from(
             plot=plot,
             persist=persist,
             checkpoint=checkpoint,
-            live=live,
             remote=remote,
         )
         for s in s_list
@@ -162,29 +162,21 @@ def load_from_pipeline(stage, data, typ="outs"):
         stage.PARAM_OUTS,
         stage.PARAM_METRICS,
         stage.PARAM_PLOTS,
-        stage.PARAM_LIVE,
     ):
         raise ValueError(f"'{typ}' key is not allowed for pipeline files.")
 
     metric = typ == stage.PARAM_METRICS
     plot = typ == stage.PARAM_PLOTS
-    live = typ == stage.PARAM_LIVE
-    if live:
-        # `live` is single object
-        data = [data]
 
     d = _merge_data(data)
 
     for path, flags in d.items():
-        plt_d, live_d = {}, {}
+        plt_d = {}
         if plot:
             from dvc.schema import PLOT_PROPS
 
             plt_d, flags = _split_dict(flags, keys=PLOT_PROPS.keys())
-        if live:
-            from dvc.schema import LIVE_PROPS
 
-            live_d, flags = _split_dict(flags, keys=LIVE_PROPS.keys())
         extra = project(
             flags,
             [
@@ -202,7 +194,6 @@ def load_from_pipeline(stage, data, typ="outs"):
             info={},
             plot=plt_d or plot,
             metric=metric,
-            live=live_d or live,
             **extra,
         )
 
@@ -259,9 +250,6 @@ class Output:
     PARAM_PLOT_TITLE = "title"
     PARAM_PLOT_HEADER = "header"
     PARAM_PERSIST = "persist"
-    PARAM_LIVE = "live"
-    PARAM_LIVE_SUMMARY = "summary"
-    PARAM_LIVE_HTML = "html"
     PARAM_REMOTE = "remote"
 
     METRIC_SCHEMA = Any(
@@ -288,7 +276,6 @@ class Output:
         plot=False,
         persist=False,
         checkpoint=False,
-        live=False,
         desc=None,
         type=None,  # pylint: disable=redefined-builtin
         labels=None,
@@ -351,7 +338,6 @@ class Output:
         self.plot = False if self.IS_DEPENDENCY else plot
         self.persist = persist
         self.checkpoint = checkpoint
-        self.live = live
 
         self.fs_path = self._parse_path(self.fs, fs_path)
         self.obj: Optional["HashFile"] = None
@@ -373,8 +359,12 @@ class Output:
             name=self.hash_name,
             value=getattr(self.meta, self.hash_name, None),
         )
-        if self.hash_info and self.hash_info.isdir:
+        if self.meta.nfiles or self.hash_info and self.hash_info.isdir:
             self.meta.isdir = True
+            if not self.hash_info and self.hash_name != "md5":
+                md5 = getattr(self.meta, "md5", None)
+                if md5:
+                    self.hash_info = HashInfo("md5", md5)
 
     def _parse_path(self, fs, fs_path):
         parsed = urlparse(self.def_path)
@@ -511,6 +501,36 @@ class Output:
             key = self.fs.path.parts(no_drive)[1:]
         return workspace, key
 
+    def get_entry(self) -> "DataIndexEntry":
+        from dvc.config import NoRemoteError
+
+        try:
+            remote = self.repo.cloud.get_remote_odb(self.remote)
+        except NoRemoteError:
+            remote = None
+
+        if self.files and not self.obj:
+            self.obj = self.get_obj()
+
+        entry = DataIndexEntry(
+            meta=self.meta,
+            obj=self.obj,
+            hash_info=self.hash_info,
+            odb=self.odb,
+            cache=self.odb,
+            remote=remote,
+        )
+        if self.stage.is_import and not self.stage.is_repo_import:
+            dep = self.stage.deps[0]
+            entry.fs = dep.fs
+            entry.path = dep.fs_path
+            entry.meta = dep.meta
+            if not entry.obj:
+                if not dep.obj and dep.files:
+                    dep.obj = dep.get_obj()
+                entry.obj = dep.obj
+        return entry
+
     def changed_checksum(self):
         return self.hash_info != self.get_hash()
 
@@ -530,7 +550,7 @@ class Output:
 
     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 self.meta.version_id != self.get_meta().version_id
         return False
 
     def workspace_status(self):
@@ -610,8 +630,16 @@ class Output:
         if self.metric:
             self.verify_metric()
 
-        if not self.use_cache:
-            _, self.meta, obj = build(
+        if self.use_cache:
+            _, self.meta, self.obj = build(
+                self.odb,
+                self.fs_path,
+                self.fs,
+                self.hash_name,
+                ignore=self.dvcignore,
+            )
+        else:
+            _, self.meta, self.obj = build(
                 self.repo.odb.local,
                 self.fs_path,
                 self.fs,
@@ -619,23 +647,11 @@ class Output:
                 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
                 )
-            return
 
-        assert not self.IS_DEPENDENCY
-
-        _, self.meta, self.obj = build(
-            self.odb,
-            self.fs_path,
-            self.fs,
-            self.hash_name,
-            ignore=self.dvcignore,
-        )
         self.hash_info = self.obj.hash_info
         self.files = None
 
@@ -733,41 +749,35 @@ class Output:
 
         ret[self.PARAM_PATH] = path
 
-        if self.IS_DEPENDENCY:
-            return ret
+        if not self.IS_DEPENDENCY:
+            ret.update(self.annot.to_dict())
+            if not self.use_cache:
+                ret[self.PARAM_CACHE] = self.use_cache
 
-        ret.update(self.annot.to_dict())
-        if not self.use_cache:
-            ret[self.PARAM_CACHE] = self.use_cache
+            if isinstance(self.metric, dict):
+                if (
+                    self.PARAM_METRIC_XPATH in self.metric
+                    and not self.metric[self.PARAM_METRIC_XPATH]
+                ):
+                    del self.metric[self.PARAM_METRIC_XPATH]
 
-        if isinstance(self.metric, dict):
-            if (
-                self.PARAM_METRIC_XPATH in self.metric
-                and not self.metric[self.PARAM_METRIC_XPATH]
-            ):
-                del self.metric[self.PARAM_METRIC_XPATH]
+            if self.metric:
+                ret[self.PARAM_METRIC] = self.metric
 
-        if self.metric:
-            ret[self.PARAM_METRIC] = self.metric
+            if self.plot:
+                ret[self.PARAM_PLOT] = self.plot
 
-        if self.plot:
-            ret[self.PARAM_PLOT] = self.plot
+            if self.persist:
+                ret[self.PARAM_PERSIST] = self.persist
 
-        if self.persist:
-            ret[self.PARAM_PERSIST] = self.persist
+            if self.checkpoint:
+                ret[self.PARAM_CHECKPOINT] = self.checkpoint
 
-        if self.checkpoint:
-            ret[self.PARAM_CHECKPOINT] = self.checkpoint
-
-        if self.live:
-            ret[self.PARAM_LIVE] = self.live
-
-        if self.remote:
-            ret[self.PARAM_REMOTE] = self.remote
+            if self.remote:
+                ret[self.PARAM_REMOTE] = self.remote
 
         if (
-            self.use_cache
-            and self.is_in_repo
+            (not self.IS_DEPENDENCY or self.stage.is_import)
             and self.hash_info.isdir
             and (kwargs.get("with_files") or self.files is not None)
         ):
@@ -800,15 +810,6 @@ class Output:
                 f"binary file '{self.fs_path}' cannot be used as metrics."
             )
 
-    def download(self, to, jobs=None):
-        from dvc.fs.callbacks import Callback
-
-        with Callback.as_tqdm_callback(
-            desc=f"Downloading {self.fs.path.name(self.fs_path)}",
-            unit="files",
-        ) as cb:
-            self.fs.get(self.fs_path, to.fs_path, batch_size=jobs, callback=cb)
-
     def get_obj(
         self, filter_info: Optional[str] = None, **kwargs
     ) -> Optional["HashFile"]:
@@ -828,6 +829,7 @@ class Output:
         else:
             return None
 
+        assert obj
         fs_path = self.fs.path
         if filter_info and filter_info != self.fs_path:
             prefix = fs_path.relparts(filter_info, self.fs_path)
@@ -838,7 +840,7 @@ class Output:
     def checkout(
         self,
         force=False,
-        progress_callback=None,
+        progress_callback: "Callback" = DEFAULT_CALLBACK,
         relink=False,
         filter_info=None,
         allow_missing=False,
@@ -846,9 +848,9 @@ class Output:
         **kwargs,
     ):
         if not self.use_cache:
-            if progress_callback:
-                progress_callback(
-                    self.fs_path, self.get_files_number(filter_info)
+            if progress_callback != DEFAULT_CALLBACK:
+                progress_callback.relative_update(
+                    self.get_files_number(filter_info)
                 )
             return None
 
@@ -1127,7 +1129,7 @@ class Output:
                 "unable to auto-merge outputs that are not directories"
             )
 
-    def merge(self, ancestor, other):
+    def merge(self, ancestor, other, allowed=None):
         from dvc_data.hashfile.tree import MergeError as TreeMergeError
         from dvc_data.hashfile.tree import du, merge
 
@@ -1144,7 +1146,11 @@ class Output:
 
         try:
             merged = merge(
-                self.odb, ancestor_info, self.hash_info, other.hash_info
+                self.odb,
+                ancestor_info,
+                self.hash_info,
+                other.hash_info,
+                allowed=allowed,
             )
         except TreeMergeError as exc:
             raise MergeError(str(exc)) from exc
@@ -1168,11 +1174,11 @@ class Output:
 
     @property
     def is_metric(self) -> bool:
-        return bool(self.metric) or bool(self.live)
+        return bool(self.metric)
 
     @property
     def is_plot(self) -> bool:
-        return bool(self.plot) or bool(self.live)
+        return bool(self.plot)
 
 
 META_SCHEMA = {

dvc/parsing/__init__.py

@@ -36,7 +36,7 @@ from .interpolate import (
 )
 
 if TYPE_CHECKING:
-    from typing_extensions import NoReturn
+    from typing import NoReturn
 
     from dvc.repo import Repo
 

dvc/parsing/interpolate.py

@@ -9,10 +9,9 @@ from dvc.exceptions import DvcException
 from dvc.utils.flatten import flatten
 
 if typing.TYPE_CHECKING:
-    from typing import List, Match
+    from typing import List, Match, NoReturn
 
     from pyparsing import ParseException
-    from typing_extensions import NoReturn
 
     from .context import Context
 

dvc/render/convert.py

@@ -2,7 +2,13 @@ import json
 from collections import defaultdict
 from typing import Dict, List, Union
 
-from dvc.render import REVISION_FIELD, REVISIONS_KEY, SRC_FIELD, TYPE_KEY
+from dvc.render import (
+    REVISION_FIELD,
+    REVISIONS_KEY,
+    SRC_FIELD,
+    TYPE_KEY,
+    VERSION_FIELD,
+)
 from dvc.render.converter.image import ImageConverter
 from dvc.render.converter.vega import VegaConverter
 
@@ -23,7 +29,7 @@ def _get_converter(
 def _group_by_rev(datapoints):
     grouped = defaultdict(list)
     for datapoint in datapoints:
-        rev = datapoint.pop(REVISION_FIELD)
+        rev = datapoint.get(VERSION_FIELD, {}).get("revision")
         grouped[rev].append(datapoint)
     return dict(grouped)
 

dvc/render/converter/vega.py

@@ -127,13 +127,20 @@ class VegaConverter(Converter):
                 ),
             )
         )
+        self.steps.append(
+            (
+                "infer_y",
+                partial(
+                    self._infer_y,
+                ),
+            )
+        )
 
         self.steps.append(
             (
                 "generate_y",
                 partial(
                     self._generate_y_values,
-                    y_values=self.plot_properties.get("y", None),
                 ),
             )
         )
@@ -156,7 +163,7 @@ class VegaConverter(Converter):
             } - {None}
             self.inferred_properties["fields"] = fields
 
-    def _infer_y(self, datapoints: List[Dict]):
+    def _infer_y(self, datapoints: List[Dict], **kwargs):
         if "y" not in self.plot_properties:
             data_fields = list(first(datapoints))
             skip = (
@@ -178,6 +185,7 @@ class VegaConverter(Converter):
                     )
             else:
                 self.inferred_properties["y"] = inferred_y
+        return datapoints
 
     def convert(
         self,
@@ -197,7 +205,6 @@ class VegaConverter(Converter):
         processed = deepcopy(data)
 
         for step_name, step in self.steps:
-
             if step_name not in skip:
                 processed = step(  # type: ignore
                     processed,
@@ -205,25 +212,28 @@ class VegaConverter(Converter):
                     filename=filename,
                 )
 
-        self._infer_y(processed)  # type: ignore
         return processed, {**self.plot_properties, **self.inferred_properties}
 
     def _generate_y_values(  # noqa: C901
         self,
         datapoints: List[Dict],
-        y_values: Optional[Union[str, List, Dict]],
         revision: str,
         filename: str,
         **kwargs,
     ) -> List[Dict]:
 
+        y_values = self.plot_properties.get(
+            "y", None
+        ) or self.inferred_properties.get("y", None)
+
+        assert y_values is not None
+
         result = []
         properties_update = {}
 
         def _add_version_info(datapoint, version_info):
             tmp = datapoint.copy()
             tmp[VERSION_FIELD] = version_info
-            tmp[REVISION_FIELD] = version_info["revision"]
             return tmp
 
         def _version_info(revision, filename=None, field=None):
@@ -250,12 +260,6 @@ class VegaConverter(Converter):
 
             return tmp
 
-        if not y_values:
-            for dp in datapoints:
-                result.append(
-                    _add_version_info(dp, _version_info(revision, filename))
-                )
-
         if isinstance(y_values, str):
             for datapoint in datapoints:
                 result.append(
@@ -290,13 +294,15 @@ class VegaConverter(Converter):
             ):
                 # if we use the same field from all files,
                 # we dont have to generate it
+                y_field = all_fields.pop()
                 for datapoint in datapoints:
                     result.append(
                         _add_version_info(
-                            datapoint, _version_info(revision, filename)
+                            datapoint,
+                            _version_info(revision, filename, y_field),
                         )
                     )
-                properties_update.update({"y": all_fields.pop()})
+                properties_update.update({"y": y_field})
             else:
                 for def_filename, val in y_values.items():
                     if isinstance(val, str):

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, List, Optional
+from typing import TYPE_CHECKING, Callable, Optional
 
 from funcy import cached_property
 
@@ -18,7 +18,6 @@ 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__)
 
@@ -68,6 +67,7 @@ class Repo:
     from dvc.repo.imp_url import imp_url  # type: ignore[misc]
     from dvc.repo.install import install  # type: ignore[misc]
     from dvc.repo.ls import ls as _ls  # type: ignore[misc]
+    from dvc.repo.ls_url import ls_url as _ls_url  # type: ignore[misc]
     from dvc.repo.move import move  # type: ignore[misc]
     from dvc.repo.pull import pull  # type: ignore[misc]
     from dvc.repo.push import push  # type: ignore[misc]
@@ -80,6 +80,7 @@ class Repo:
     from .data import status as data_status  # type: ignore[misc]
 
     ls = staticmethod(_ls)
+    ls_url = staticmethod(_ls_url)
     get = staticmethod(_get)
     get_url = staticmethod(_get_url)
 
@@ -268,7 +269,7 @@ class Repo:
         except SCMError:
             if self._uninitialized:
                 # might not be a git/dvc repo at all
-                # used in `params/metrics/plots/live` targets
+                # used in `params/metrics/plots` targets
                 return SCM(self.root_dir, no_scm=True)
             raise
 
@@ -445,44 +446,6 @@ 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

dvc/repo/brancher.py

@@ -77,6 +77,7 @@ def brancher(  # noqa: E302
         from dvc.fs import GitFileSystem
 
         for sha, names in found_revs.items():
+            self.__dict__.pop("index", None)
             self.fs = GitFileSystem(scm=scm, rev=sha)
             self.root_dir = self.fs.path.join("/", *repo_root_parts)
 

dvc/repo/checkout.py

@@ -7,7 +7,6 @@ from dvc.exceptions import (
     CheckoutErrorSuggestGit,
     NoOutputOrStageError,
 )
-from dvc.progress import Tqdm
 from dvc.utils import relpath
 
 from . import locked
@@ -80,6 +79,7 @@ def checkout(
     allow_missing=False,
     **kwargs,
 ):
+    from dvc.fs.callbacks import Callback
 
     stats = {"added": [], "deleted": [], "modified": [], "failed": []}
     if not targets:
@@ -91,13 +91,16 @@ def checkout(
 
     pairs = _collect_pairs(self, targets, with_deps, recursive)
     total = get_all_files_numbers(pairs)
-    with Tqdm(
-        total=total, unit="file", desc="Checkout", disable=total == 0
-    ) as pbar:
+    with Callback.as_tqdm_callback(
+        unit="file",
+        desc="Checkout",
+        disable=total == 0,
+    ) as cb:
+        cb.set_size(total)
         for stage, filter_info in pairs:
             result = stage.checkout(
                 force=force,
-                progress_callback=pbar.update_msg,
+                progress_callback=cb,
                 relink=relink,
                 filter_info=filter_info,
                 allow_missing=allow_missing,

dvc/repo/commit.py

@@ -56,10 +56,13 @@ def commit(
     ]
     for stage_info in stages_info:
         stage = stage_info.stage
-        changes = stage.changed_entries()
-        if any(changes):
-            prompt_to_commit(stage, changes, force=force)
+        if force:
             stage.save(allow_missing=allow_missing)
+        else:
+            changes = stage.changed_entries()
+            if any(changes):
+                prompt_to_commit(stage, changes, force=force)
+                stage.save(allow_missing=allow_missing)
         stage.commit(
             filter_info=stage_info.filter_info, allow_missing=allow_missing
         )

dvc/repo/data.py

@@ -12,6 +12,7 @@ from typing import (
     Optional,
     Tuple,
     TypedDict,
+    Union,
     cast,
 )
 
@@ -19,10 +20,9 @@ from dvc.fs.git import GitFileSystem
 from dvc.ui import ui
 
 if TYPE_CHECKING:
-    from scmrepo.base import Base
-
     from dvc.output import Output
     from dvc.repo import Repo
+    from dvc.scm import Git, NoSCM
     from dvc_data.hashfile.db import HashFileDB
     from dvc_data.hashfile.hash_info import HashInfo
     from dvc_data.hashfile.obj import HashFile
@@ -140,7 +140,9 @@ class GitInfo(TypedDict, total=False):
     is_dirty: bool
 
 
-def _git_info(scm: "Base", untracked_files: str = "all") -> GitInfo:
+def _git_info(
+    scm: Union["Git", "NoSCM"], untracked_files: str = "all"
+) -> GitInfo:
     from scmrepo.exceptions import SCMError
 
     from dvc.scm import NoSCM

dvc/repo/experiments/__init__.py

@@ -2,9 +2,9 @@ import logging
 import os
 import re
 import time
-from typing import Any, Dict, Iterable, Optional
+from typing import Dict, Iterable, Optional
 
-from funcy import cached_property, first
+from funcy import cached_property, chain, first
 
 from dvc.exceptions import DvcException
 from dvc.ui import ui
@@ -16,7 +16,7 @@ from .exceptions import (
     InvalidExpRefError,
     MultipleBranchError,
 )
-from .executor.base import BaseExecutor, ExecutorInfo
+from .executor.base import BaseExecutor
 from .queue.base import BaseStashQueue, QueueEntry
 from .queue.celery import LocalCeleryQueue
 from .queue.tempdir import TempDirQueue
@@ -25,7 +25,6 @@ from .refs import (
     CELERY_FAILED_STASH,
     CELERY_STASH,
     EXEC_APPLY,
-    EXEC_BRANCH,
     EXEC_CHECKPOINT,
     EXEC_NAMESPACE,
     EXPS_NAMESPACE,
@@ -172,7 +171,18 @@ class Experiments:
     ) -> Dict[str, str]:
         results: Dict[str, str] = {}
         if entries is None:
-            entries = list(self.celery_queue.iter_queued())
+            entries = list(
+                chain(
+                    self.celery_queue.iter_active(),
+                    self.celery_queue.iter_queued(),
+                )
+            )
+
+        logger.debug(
+            "reproduce all these entries '%s'",
+            entries,
+        )
+
         if not entries:
             return results
 
@@ -190,7 +200,10 @@ class Experiments:
                     time.sleep(1)
                 self.celery_queue.follow(entry)
                 # wait for task collection to complete
-                result = self.celery_queue.get_result(entry)
+                try:
+                    result = self.celery_queue.get_result(entry)
+                except FileNotFoundError:
+                    result = None
                 if result is None or result.exp_hash is None:
                     name = entry.name or entry.stash_rev[:7]
                     failed.append(name)
@@ -211,8 +224,9 @@ class Experiments:
 
     def _log_reproduced(self, revs: Iterable[str], tmp_dir: bool = False):
         names = []
+        rev_names = self.get_exact_name(revs)
         for rev in revs:
-            name = self.get_exact_name(rev)
+            name = rev_names[rev]
             names.append(name if name else rev[:7])
         ui.write("\nRan experiment(s): {}".format(", ".join(names)))
         if tmp_dir:
@@ -411,86 +425,41 @@ class Experiments:
             raise MultipleBranchError(rev, ref_infos)
         return str(ref_infos[0])
 
-    def get_exact_name(self, rev: str):
+    def get_exact_name(self, revs: Iterable[str]) -> Dict[str, Optional[str]]:
         """Returns preferred name for the specified revision.
 
         Prefers tags, branches (heads), experiments in that orer.
         """
+        result: Dict[str, Optional[str]] = {}
         exclude = f"{EXEC_NAMESPACE}/*"
-        ref = self.scm.describe(rev, base=EXPS_NAMESPACE, exclude=exclude)
-        if ref:
-            try:
-                name = ExpRefInfo.from_ref(ref).name
-                if name:
-                    return name
-            except InvalidExpRefError:
-                pass
-        if rev in self.stash_revs:
-            return self.stash_revs[rev].name
-        return None
-
-    def get_running_exps(self, fetch_refs: bool = True) -> Dict[str, Any]:
-        """Return info for running experiments."""
-        result = {}
-        infofile = self.workspace_queue.get_infofile_path("workspace")
-        result.update(
-            self._fetch_running_exp("workspace", infofile, fetch_refs)
+        ref_dict = self.scm.describe(
+            revs, base=EXPS_NAMESPACE, exclude=exclude
         )
-        for queue in (self.tempdir_queue, self.celery_queue):
-            for entry in queue.iter_active():
-                infofile = queue.get_infofile_path(entry.stash_rev)
-                result.update(
-                    self._fetch_running_exp(
-                        entry.stash_rev, infofile, fetch_refs
-                    )
-                )
+        for rev in revs:
+            name: Optional[str] = None
+            ref = ref_dict[rev]
+            if ref:
+                try:
+                    name = ExpRefInfo.from_ref(ref).name
+                except InvalidExpRefError:
+                    pass
+            if not name:
+                if rev in self.stash_revs:
+                    name = self.stash_revs[rev].name
+                elif rev in self.celery_queue.failed_stash.stash_revs:
+                    name = self.celery_queue.failed_stash.stash_revs[rev].name
+            result[rev] = name
         return result
 
-    def _fetch_running_exp(
-        self, rev: str, infofile: str, fetch_refs: bool
-    ) -> Dict[str, Any]:
-        from dvc.scm import InvalidRemoteSCMRepo
-        from dvc.utils.serialize import load_json
-
-        from .executor.local import TempDirExecutor
-
-        result: Dict[str, Any] = {}
-        try:
-            info = ExecutorInfo.from_dict(load_json(infofile))
-        except OSError:
-            return result
-        if info.result is None:
-            if rev == "workspace":
-                # If we are appending to a checkpoint branch in a workspace
-                # run, show the latest checkpoint as running.
-                last_rev = self.scm.get_ref(EXEC_BRANCH)
-                if last_rev:
-                    result[last_rev] = info.asdict()
-                else:
-                    result[rev] = info.asdict()
-            else:
-                result[rev] = info.asdict()
-                if info.git_url and fetch_refs:
-
-                    def on_diverged(_ref: str, _checkpoint: bool):
-                        return False
-
-                    executor = TempDirExecutor.from_info(info)
-                    try:
-                        for ref in executor.fetch_exps(
-                            self.scm,
-                            on_diverged=on_diverged,
-                        ):
-                            logger.debug(
-                                "Updated running experiment '%s'.", ref
-                            )
-                            last_rev = self.scm.get_ref(ref)
-                            result[rev]["last"] = last_rev
-                            if last_rev:
-                                result[last_rev] = info.asdict()
-                    except InvalidRemoteSCMRepo:
-                        # ignore stale info files
-                        del result[rev]
+    def get_running_exps(self, fetch_refs: bool = True) -> Dict[str, Dict]:
+        """Return info for running experiments."""
+        result = {}
+        for queue in (
+            self.workspace_queue,
+            self.tempdir_queue,
+            self.celery_queue,
+        ):
+            result.update(queue.get_running_exps(fetch_refs))
         return result
 
     def apply(self, *args, **kwargs):

dvc/repo/experiments/diff.py

@@ -7,7 +7,7 @@ logger = logging.getLogger(__name__)
 
 
 def diff(repo, *args, a_rev=None, b_rev=None, param_deps=False, **kwargs):
-    from dvc.repo.experiments.show import _collect_experiment_commit
+    from dvc.repo.experiments.show import collect_experiment_commit
     from dvc.scm import resolve_rev
 
     if repo.scm.no_commits:
@@ -15,15 +15,15 @@ def diff(repo, *args, a_rev=None, b_rev=None, param_deps=False, **kwargs):
 
     if a_rev:
         rev = resolve_rev(repo.scm, a_rev)
-        old = _collect_experiment_commit(repo, rev, param_deps=param_deps)
+        old = collect_experiment_commit(repo, rev, param_deps=param_deps)
     else:
-        old = _collect_experiment_commit(repo, "HEAD", param_deps=param_deps)
+        old = collect_experiment_commit(repo, "HEAD", param_deps=param_deps)
 
     if b_rev:
         rev = resolve_rev(repo.scm, b_rev)
-        new = _collect_experiment_commit(repo, rev, param_deps=param_deps)
+        new = collect_experiment_commit(repo, rev, param_deps=param_deps)
     else:
-        new = _collect_experiment_commit(
+        new = collect_experiment_commit(
             repo, "workspace", param_deps=param_deps
         )
 

dvc/repo/experiments/executor/base.py

@@ -4,6 +4,7 @@ import pickle
 from abc import ABC, abstractmethod
 from contextlib import contextmanager
 from dataclasses import asdict, dataclass
+from enum import IntEnum
 from functools import partial
 from typing import (
     TYPE_CHECKING,
@@ -19,6 +20,8 @@ from typing import (
     Union,
 )
 
+from scmrepo.exceptions import SCMError
+
 from dvc.env import DVC_EXP_AUTO_PUSH, DVC_EXP_GIT_REMOTE
 from dvc.exceptions import DvcException
 from dvc.stage.serialize import to_lockfile
@@ -35,6 +38,8 @@ from ..refs import (
     EXEC_BASELINE,
     EXEC_BRANCH,
     EXEC_CHECKPOINT,
+    EXEC_HEAD,
+    EXEC_MERGE,
     EXEC_NAMESPACE,
     EXPS_NAMESPACE,
     EXPS_STASH,
@@ -47,10 +52,9 @@ if TYPE_CHECKING:
     from scmrepo.git import Git
 
     from dvc.repo import Repo
+    from dvc.repo.experiments.stash import ExpStashEntry
     from dvc.stage import PipelineStage
 
-    from ..base import ExpStashEntry
-
 logger = logging.getLogger(__name__)
 
 
@@ -64,6 +68,16 @@ class ExecutorResult(NamedTuple):
     force: bool
 
 
+class TaskStatus(IntEnum):
+    PENDING = 0
+    PREPARING = 1
+    RUNNING = 2
+    SUCCESS = 3
+    FAILED = 4
+    CANCELED = 5
+    FINISHED = 6
+
+
 @dataclass
 class ExecutorInfo:
     git_url: str
@@ -73,13 +87,16 @@ class ExecutorInfo:
     dvc_dir: str
     name: Optional[str] = None
     wdir: Optional[str] = None
-    collected: bool = False
     result_hash: Optional[str] = None
     result_ref: Optional[str] = None
     result_force: bool = False
+    status: TaskStatus = TaskStatus.PENDING
 
     @classmethod
     def from_dict(cls, d):
+        if "collected" in d:
+            if d.pop("collected"):
+                d["status"] = TaskStatus.FINISHED
         return cls(**d)
 
     def asdict(self):
@@ -136,6 +153,7 @@ class BaseExecutor(ABC):
         root_dir: str,
         dvc_dir: str,
         baseline_rev: str,
+        status: TaskStatus,
         wdir: Optional[str] = None,
         name: Optional[str] = None,
         location: Optional[str] = None,
@@ -149,9 +167,17 @@ class BaseExecutor(ABC):
         self.baseline_rev = baseline_rev
         self.location: str = location or self.DEFAULT_LOCATION
         self.result = result
+        self.status = status
 
     @abstractmethod
-    def init_git(self, scm: "Git", branch: Optional[str] = None):
+    def init_git(
+        self,
+        scm: "Git",
+        stash_rev: str,
+        entry: "ExpStashEntry",
+        infofile: Optional[str],
+        branch: Optional[str] = None,
+    ):
         """Init git repo and populate it using exp refs from the specified
         SCM instance.
         """
@@ -191,6 +217,7 @@ class BaseExecutor(ABC):
             dvc_dir=self.dvc_dir,
             name=self.name,
             wdir=self.wdir,
+            status=self.status,
             **result_dict,
         )
 
@@ -212,6 +239,7 @@ class BaseExecutor(ABC):
             root_dir=info.root_dir,
             dvc_dir=info.dvc_dir,
             baseline_rev=info.baseline_rev,
+            status=info.status,
             name=info.name,
             wdir=info.wdir,
             result=result,
@@ -222,7 +250,6 @@ class BaseExecutor(ABC):
     def from_stash_entry(
         cls: Type[_T],
         repo: "Repo",
-        stash_rev: str,
         entry: "ExpStashEntry",
         **kwargs,
     ) -> _T:
@@ -232,7 +259,6 @@ class BaseExecutor(ABC):
     def _from_stash_entry(
         cls: Type[_T],
         repo: "Repo",
-        stash_rev: str,
         entry: "ExpStashEntry",
         root_dir: str,
         **kwargs,
@@ -241,12 +267,11 @@ class BaseExecutor(ABC):
             root_dir=root_dir,
             dvc_dir=relpath(repo.dvc_dir, repo.scm.root_dir),
             baseline_rev=entry.baseline_rev,
+            status=TaskStatus.PREPARING,
             name=entry.name,
             wdir=relpath(os.getcwd(), repo.scm.root_dir),
             **kwargs,
         )
-        executor.init_git(repo.scm, branch=entry.branch)
-        executor.init_cache(repo, stash_rev)
         return executor
 
     @staticmethod
@@ -259,8 +284,12 @@ class BaseExecutor(ABC):
                 exp_data.update(to_lockfile(stage))
         return dict_sha256(exp_data)
 
-    def cleanup(self):
-        pass
+    def cleanup(self, infofile: str):
+        if infofile is not None:
+            info = ExecutorInfo.load_json(infofile)
+            if info.status < TaskStatus.FAILED:
+                info.status = TaskStatus.FINISHED
+            info.dump_json(infofile)
 
     # TODO: come up with better way to stash repro arguments
     @staticmethod
@@ -324,30 +353,35 @@ class BaseExecutor(ABC):
                 logger.debug("Replacing existing experiment '%s'", orig_ref)
                 return True
 
+            if on_diverged:
+                return on_diverged(orig_ref, has_checkpoint)
+
             self._raise_ref_conflict(
                 dest_scm, orig_ref, new_rev, has_checkpoint
             )
-            if on_diverged:
-                on_diverged(orig_ref, has_checkpoint)
             logger.debug("Reproduced existing experiment '%s'", orig_ref)
             return False
 
         # fetch experiments
-        dest_scm.fetch_refspecs(
-            self.git_url,
-            [f"{ref}:{ref}" for ref in refs],
-            on_diverged=on_diverged_ref,
-            force=force,
-            **kwargs,
-        )
-        # update last run checkpoint (if it exists)
-        if has_checkpoint:
+        try:
             dest_scm.fetch_refspecs(
                 self.git_url,
-                [f"{EXEC_CHECKPOINT}:{EXEC_CHECKPOINT}"],
-                force=True,
+                [f"{ref}:{ref}" for ref in refs],
+                on_diverged=on_diverged_ref,
+                force=force,
                 **kwargs,
             )
+            # update last run checkpoint (if it exists)
+            if has_checkpoint:
+                dest_scm.fetch_refspecs(
+                    self.git_url,
+                    [f"{EXEC_CHECKPOINT}:{EXEC_CHECKPOINT}"],
+                    force=True,
+                    **kwargs,
+                )
+        except SCMError:
+            pass
+
         return refs
 
     @classmethod
@@ -411,11 +445,9 @@ class BaseExecutor(ABC):
         exp_ref: Optional["ExpRefInfo"] = None
         repro_force: bool = False
 
-        if infofile is not None:
-            info.dump_json(infofile)
-
         with cls._repro_dvc(
             info,
+            infofile,
             log_errors=log_errors,
             **kwargs,
         ) as dvc:
@@ -491,9 +523,6 @@ class BaseExecutor(ABC):
             info.result_ref = ref
             info.result_force = repro_force
 
-        if infofile is not None:
-            info.dump_json(infofile)
-
         # ideally we would return stages here like a normal repro() call, but
         # stages is not currently picklable and cannot be returned across
         # multiprocessing calls
@@ -550,6 +579,7 @@ class BaseExecutor(ABC):
     def _repro_dvc(
         cls,
         info: "ExecutorInfo",
+        infofile: str = None,
         log_errors: bool = True,
         **kwargs,
     ):
@@ -557,6 +587,9 @@ class BaseExecutor(ABC):
         from dvc.stage.monitor import CheckpointKilledError
 
         dvc = Repo(os.path.join(info.root_dir, info.dvc_dir))
+        info.status = TaskStatus.RUNNING
+        if infofile is not None:
+            info.dump_json(infofile)
         if cls.QUIET:
             dvc.scm_context.quiet = cls.QUIET
         old_cwd = os.getcwd()
@@ -568,17 +601,23 @@ class BaseExecutor(ABC):
         try:
             logger.debug("Running repro in '%s'", os.getcwd())
             yield dvc
+            info.status = TaskStatus.SUCCESS
         except CheckpointKilledError:
+            info.status = TaskStatus.FAILED
             raise
         except DvcException:
             if log_errors:
                 logger.exception("")
+            info.status = TaskStatus.FAILED
             raise
         except Exception:
             if log_errors:
                 logger.exception("unexpected error")
+            info.status = TaskStatus.FAILED
             raise
         finally:
+            if infofile is not None:
+                info.dump_json(infofile)
             dvc.close()
             os.chdir(old_cwd)
 
@@ -714,3 +753,23 @@ class BaseExecutor(ABC):
         disable_other_loggers()
         if level is not None:
             dvc_logger.setLevel(level)
+
+    @contextmanager
+    def set_exec_refs(
+        self, scm: "Git", stash_rev: str, entry: "ExpStashEntry"
+    ):
+        try:
+            # Executor will be initialized with an empty git repo that
+            # we populate by pushing:
+            #   EXEC_HEAD - the base commit for this experiment
+            #   EXEC_MERGE - the unmerged changes (from our stash)
+            #       to be reproduced
+            #   EXEC_BASELINE - the baseline commit for this experiment
+            scm.set_ref(EXEC_HEAD, entry.head_rev)
+            scm.set_ref(EXEC_MERGE, stash_rev)
+            scm.set_ref(EXEC_BASELINE, entry.baseline_rev)
+            yield
+        finally:
+            for ref in (EXEC_HEAD, EXEC_MERGE, EXEC_BASELINE):
+                if scm.get_ref(ref):
+                    scm.remove_ref(ref)

dvc/repo/experiments/executor/local.py

@@ -19,7 +19,7 @@ from ..refs import (
     EXEC_MERGE,
     EXEC_NAMESPACE,
 )
-from .base import EXEC_TMP_DIR, BaseExecutor
+from .base import EXEC_TMP_DIR, BaseExecutor, TaskStatus
 
 if TYPE_CHECKING:
     from scmrepo.git import Git
@@ -46,10 +46,10 @@ class BaseLocalExecutor(BaseExecutor):
     def scm(self):
         return SCM(self.root_dir)
 
-    def cleanup(self):
-        super().cleanup()
+    def cleanup(self, infofile: str):
         self.scm.close()
         del self.scm
+        super().cleanup(infofile)
 
     def collect_cache(
         self, repo: "Repo", exp_ref: "ExpRefInfo", run_cache: bool = True
@@ -67,15 +67,28 @@ class TempDirExecutor(BaseLocalExecutor):
     QUIET = True
     DEFAULT_LOCATION = "tempdir"
 
-    def init_git(self, scm: "Git", branch: Optional[str] = None):
+    def init_git(
+        self,
+        scm: "Git",
+        stash_rev: str,
+        entry: "ExpStashEntry",
+        infofile: Optional[str],
+        branch: Optional[str] = None,
+    ):
         from dulwich.repo import Repo as DulwichRepo
 
         from ..utils import push_refspec
 
         DulwichRepo.init(os.fspath(self.root_dir))
 
-        refspec = f"{EXEC_NAMESPACE}/"
-        push_refspec(scm, self.git_url, refspec, refspec)
+        self.status = TaskStatus.PREPARING
+        if infofile:
+            self.info.dump_json(infofile)
+
+        with self.set_exec_refs(scm, stash_rev, entry):
+            refspec = f"{EXEC_NAMESPACE}/"
+            push_refspec(scm, self.git_url, refspec, refspec)
+
         if branch:
             push_refspec(scm, self.git_url, branch, branch)
             self.scm.set_ref(EXEC_BRANCH, branch, symbolic=True)
@@ -84,17 +97,12 @@ class TempDirExecutor(BaseLocalExecutor):
 
         if self.scm.get_ref(EXEC_CHECKPOINT):
             self.scm.remove_ref(EXEC_CHECKPOINT)
-
         # checkout EXEC_HEAD and apply EXEC_MERGE on top of it without
         # committing
         head = EXEC_BRANCH if branch else EXEC_HEAD
         self.scm.checkout(head, detach=True)
         merge_rev = self.scm.get_ref(EXEC_MERGE)
 
-        for ref in (EXEC_HEAD, EXEC_MERGE, EXEC_BASELINE):
-            if scm.get_ref(ref):
-                scm.remove_ref(ref)
-
         try:
             self.scm.merge(merge_rev, squash=True, commit=False)
         except _SCMError as exc:
@@ -114,8 +122,8 @@ class TempDirExecutor(BaseLocalExecutor):
         """Initialize DVC cache."""
         self._config(repo.odb.repo.path)
 
-    def cleanup(self):
-        super().cleanup()
+    def cleanup(self, infofile: str):
+        super().cleanup(infofile)
         logger.debug("Removing tmpdir '%s'", self.root_dir)
         remove(self.root_dir)
 
@@ -123,7 +131,6 @@ class TempDirExecutor(BaseLocalExecutor):
     def from_stash_entry(
         cls,
         repo: "Repo",
-        stash_rev: str,
         entry: "ExpStashEntry",
         wdir: Optional[str] = None,
         **kwargs,
@@ -132,9 +139,7 @@ class TempDirExecutor(BaseLocalExecutor):
         makedirs(parent_dir, exist_ok=True)
         tmp_dir = mkdtemp(dir=parent_dir)
         try:
-            executor = cls._from_stash_entry(
-                repo, stash_rev, entry, tmp_dir, **kwargs
-            )
+            executor = cls._from_stash_entry(repo, entry, tmp_dir, **kwargs)
             logger.debug("Init temp dir executor in '%s'", tmp_dir)
             return executor
         except Exception:
@@ -152,18 +157,31 @@ class WorkspaceExecutor(BaseLocalExecutor):
     def from_stash_entry(
         cls,
         repo: "Repo",
-        stash_rev: str,
         entry: "ExpStashEntry",
         **kwargs,
     ):
         root_dir = repo.scm.root_dir
-        executor = cls._from_stash_entry(
-            repo, stash_rev, entry, root_dir, **kwargs
+        executor: "WorkspaceExecutor" = cls._from_stash_entry(
+            repo, entry, root_dir, **kwargs
         )
         logger.debug("Init workspace executor in '%s'", root_dir)
         return executor
 
-    def init_git(self, scm: "Git", branch: Optional[str] = None):
+    def init_git(
+        self,
+        scm: "Git",
+        stash_rev: str,
+        entry: "ExpStashEntry",
+        infofile: Optional[str],
+        branch: Optional[str] = None,
+    ):
+        self.status = TaskStatus.PREPARING
+        if infofile:
+            self.info.dump_json(infofile)
+
+        scm.set_ref(EXEC_HEAD, entry.head_rev)
+        scm.set_ref(EXEC_MERGE, stash_rev)
+        scm.set_ref(EXEC_BASELINE, entry.baseline_rev)
         self._detach_stack.enter_context(
             self.scm.detach_head(
                 self.scm.get_ref(EXEC_HEAD),
@@ -184,7 +202,9 @@ class WorkspaceExecutor(BaseLocalExecutor):
     def init_cache(self, repo: "Repo", rev: str, run_cache: bool = True):
         pass
 
-    def cleanup(self):
+    def cleanup(self, infofile: str):
+        super().cleanup(infofile)
+        remove(os.path.dirname(infofile))
         with self._detach_stack:
             self.scm.remove_ref(EXEC_BASELINE)
             self.scm.remove_ref(EXEC_MERGE)
@@ -193,4 +213,3 @@ class WorkspaceExecutor(BaseLocalExecutor):
             checkpoint = self.scm.get_ref(EXEC_CHECKPOINT)
             if checkpoint and checkpoint != self._orig_checkpoint:
                 self.scm.set_ref(EXEC_APPLY, checkpoint)
-        super().cleanup()

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

@@ -1,269 +0,0 @@
-import logging
-import os
-from abc import ABC
-from collections import defaultdict, deque
-from collections.abc import Mapping
-from typing import TYPE_CHECKING, Deque, Dict, Generator, Optional, Tuple, Type
-
-from dvc.proc.manager import ProcessManager
-
-from ...exceptions import CheckpointExistsError, ExperimentExistsError
-from ...refs import EXEC_BASELINE, EXEC_HEAD, EXEC_MERGE, ExpRefInfo
-from ...stash import ExpStashEntry
-from ..base import EXEC_PID_DIR, BaseExecutor
-from ..local import TempDirExecutor, WorkspaceExecutor
-
-if TYPE_CHECKING:
-    from scmrepo.git import Git
-
-    from dvc.repo import Repo
-
-logger = logging.getLogger(__name__)
-
-
-class BaseExecutorManager(ABC, Mapping):  # noqa: B024
-    """Manages executors for a collection of experiments to be run."""
-
-    EXECUTOR_CLS: Type = BaseExecutor
-
-    def __init__(
-        self,
-        scm: "Git",
-        wdir: str,
-        **kwargs,
-    ):
-        from dvc.utils.fs import makedirs
-
-        self.scm = scm
-        makedirs(wdir, exist_ok=True)
-        self.wdir = wdir
-        self.proc = ProcessManager(self.pid_dir)
-        self._attached: Dict[str, "BaseExecutor"] = {}
-        self._detached: Dict[str, "BaseExecutor"] = dict(self._load_infos())
-        self._queue: Deque[Tuple[str, "BaseExecutor"]] = deque()
-
-    def __getitem__(self, key: str) -> "BaseExecutor":
-        try:
-            return self._attached[key]
-        except KeyError:
-            pass
-        return self._detached[key]
-
-    def __iter__(self):
-        yield from self._attached
-        yield from self._detached
-
-    def __len__(self):
-        return len(self._attached) + len(self._detached)
-
-    @property
-    def pid_dir(self) -> str:
-        return os.path.join(self.wdir, EXEC_PID_DIR)
-
-    def enqueue(self, rev: str, executor: "BaseExecutor"):
-        assert rev not in self
-        self._queue.append((rev, executor))
-
-    def _load_infos(self) -> Generator[Tuple[str, "BaseExecutor"], None, None]:
-        import json
-        from urllib.parse import urlparse
-
-        from ..base import ExecutorInfo
-        from ..ssh import SSHExecutor
-
-        def make_executor(info: "ExecutorInfo"):
-            if info.git_url:
-                scheme = urlparse(info.git_url).scheme
-                if scheme == "file":
-                    cls: Type = TempDirExecutor
-                elif scheme == "ssh":
-                    cls = SSHExecutor
-                else:
-                    raise NotImplementedError
-            else:
-                cls = WorkspaceExecutor
-            return cls.from_info(info)
-
-        for name in self.proc:
-            infofile = self.get_infofile_path(name)
-            try:
-                with open(infofile, encoding="utf-8") as fobj:
-                    info = ExecutorInfo.from_dict(json.load(fobj))
-                yield name, make_executor(info)
-            except OSError:
-                continue
-
-    def get_infofile_path(self, name: str) -> str:
-        return os.path.join(
-            self.pid_dir,
-            name,
-            f"{name}{BaseExecutor.INFOFILE_EXT}",
-        )
-
-    @classmethod
-    def from_stash_entries(
-        cls,
-        scm: "Git",
-        wdir: str,
-        repo: "Repo",
-        to_run: Dict[str, ExpStashEntry],
-        **kwargs,
-    ):
-        manager = cls(scm, wdir)
-        manager._enqueue_stash_entries(scm, repo, to_run, **kwargs)
-        return manager
-
-    def _enqueue_stash_entries(
-        self,
-        scm: "Git",
-        repo: "Repo",
-        to_run: Dict[str, ExpStashEntry],
-        **kwargs,
-    ):
-        try:
-            for stash_rev, entry in to_run.items():
-                scm.set_ref(EXEC_HEAD, entry.head_rev)
-                scm.set_ref(EXEC_MERGE, stash_rev)
-                scm.set_ref(EXEC_BASELINE, entry.baseline_rev)
-
-                # Executor will be initialized with an empty git repo that
-                # we populate by pushing:
-                #   EXEC_HEAD - the base commit for this experiment
-                #   EXEC_MERGE - the unmerged changes (from our stash)
-                #       to be reproduced
-                #   EXEC_BASELINE - the baseline commit for this experiment
-                executor = self.EXECUTOR_CLS.from_stash_entry(
-                    repo,
-                    stash_rev,
-                    entry,
-                    **kwargs,
-                )
-                self.enqueue(stash_rev, executor)
-        finally:
-            for ref in (EXEC_HEAD, EXEC_MERGE, EXEC_BASELINE):
-                scm.remove_ref(ref)
-
-    def exec_queue(
-        self, repo: "Repo", jobs: Optional[int] = 1, detach: bool = False
-    ):
-        """Run dvc repro for queued executors in parallel."""
-        if detach:
-            raise NotImplementedError
-            # TODO use ProcessManager.spawn() to support detached runs
-        return self._exec_attached(repo, jobs=jobs)
-
-    def _exec_attached(self, repo: "Repo", jobs: Optional[int] = 1):
-        import signal
-        from concurrent.futures import (
-            CancelledError,
-            ProcessPoolExecutor,
-            wait,
-        )
-        from multiprocessing import Manager
-
-        from dvc.stage.monitor import CheckpointKilledError
-
-        result: Dict[str, Dict[str, str]] = defaultdict(dict)
-
-        manager = Manager()
-        pid_q = manager.Queue()
-
-        with ProcessPoolExecutor(max_workers=jobs) as workers:
-            futures = {}
-            while self._queue:
-                rev, executor = self._queue.popleft()
-                infofile = self.get_infofile_path(rev)
-                future = workers.submit(
-                    executor.reproduce,
-                    info=executor.info,
-                    rev=rev,
-                    queue=pid_q,
-                    infofile=infofile,
-                    log_level=logger.getEffectiveLevel(),
-                )
-                futures[future] = (rev, executor)
-                self._attached[rev] = executor
-
-            try:
-                wait(futures)
-            except KeyboardInterrupt:
-                # forward SIGINT to any running executor processes and
-                # cancel any remaining futures
-                workers.shutdown(wait=False)
-                pids = {}
-                for future, (rev, _) in futures.items():
-                    if future.running():
-                        # if future has already been started by the scheduler
-                        # we still have to wait until it tells us its PID
-                        while rev not in pids:
-                            rev, pid = pid_q.get()
-                            pids[rev] = pid
-                        os.kill(pids[rev], signal.SIGINT)
-                    elif not future.done():
-                        future.cancel()
-
-            for future, (rev, executor) in futures.items():
-                rev, executor = futures[future]
-
-                try:
-                    exc = future.exception()
-                    if exc is None:
-                        exec_result = future.result()
-                        result[rev].update(
-                            self._collect_executor(repo, executor, exec_result)
-                        )
-                    elif not isinstance(exc, CheckpointKilledError):
-                        logger.error(
-                            "Failed to reproduce experiment '%s'", rev[:7]
-                        )
-                except CancelledError:
-                    logger.error(
-                        "Cancelled before attempting to reproduce experiment "
-                        "'%s'",
-                        rev[:7],
-                    )
-                finally:
-                    self.cleanup_executor(rev, executor)
-
-        return result
-
-    def _collect_executor(self, repo, executor, exec_result) -> Dict[str, str]:
-        # NOTE: GitPython Repo instances cannot be re-used
-        # after process has received SIGINT or SIGTERM, so we
-        # need this hack to re-instantiate git instances after
-        # checkpoint runs. See:
-        # https://github.com/gitpython-developers/GitPython/issues/427
-        # del self.repo.scm
-
-        results = {}
-
-        def on_diverged(ref: str, checkpoint: bool):
-            ref_info = ExpRefInfo.from_ref(ref)
-            if checkpoint:
-                raise CheckpointExistsError(ref_info.name)
-            raise ExperimentExistsError(ref_info.name)
-
-        for ref in executor.fetch_exps(
-            self.scm,
-            force=exec_result.force,
-            on_diverged=on_diverged,
-        ):
-            exp_rev = self.scm.get_ref(ref)
-            if exp_rev:
-                logger.debug("Collected experiment '%s'.", exp_rev[:7])
-                results[exp_rev] = exec_result.exp_hash
-
-        if exec_result.ref_info is not None:
-            executor.collect_cache(repo, exec_result.ref_info)
-
-        return results
-
-    def cleanup_executor(self, rev: str, executor: "BaseExecutor"):
-        from dvc.utils.fs import remove
-
-        executor.cleanup()
-        try:
-            self.proc.remove(rev)
-        except KeyError:
-            pass
-        remove(os.path.join(self.pid_dir, rev))

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

@@ -1,107 +0,0 @@
-import logging
-from collections import defaultdict
-from typing import TYPE_CHECKING, Dict, Optional
-
-from ...refs import EXEC_BASELINE, EXEC_BRANCH, EXEC_HEAD, EXEC_MERGE
-from ...stash import ExpStashEntry
-from ..local import TempDirExecutor, WorkspaceExecutor
-from .base import BaseExecutorManager
-
-if TYPE_CHECKING:
-    from scmrepo.git import Git
-
-    from dvc.repo import Repo
-
-logger = logging.getLogger(__name__)
-
-
-class TempDirExecutorManager(BaseExecutorManager):
-    EXECUTOR_CLS = TempDirExecutor
-
-
-class WorkspaceExecutorManager(BaseExecutorManager):
-    EXECUTOR_CLS = WorkspaceExecutor
-
-    @classmethod
-    def from_stash_entries(
-        cls,
-        scm: "Git",
-        wdir: str,
-        repo: "Repo",
-        to_run: Dict[str, ExpStashEntry],
-        **kwargs,
-    ):
-        manager = cls(scm, wdir)
-        try:
-            assert len(to_run) == 1
-            for stash_rev, entry in to_run.items():
-                scm.set_ref(EXEC_HEAD, entry.head_rev)
-                scm.set_ref(EXEC_MERGE, stash_rev)
-                scm.set_ref(EXEC_BASELINE, entry.baseline_rev)
-
-                executor = cls.EXECUTOR_CLS.from_stash_entry(
-                    repo,
-                    stash_rev,
-                    entry,
-                    **kwargs,
-                )
-                manager.enqueue(stash_rev, executor)
-        finally:
-            for ref in (EXEC_MERGE,):
-                scm.remove_ref(ref)
-        return manager
-
-    def _collect_executor(self, repo, executor, exec_result) -> Dict[str, str]:
-        results = {}
-        exp_rev = self.scm.get_ref(EXEC_BRANCH)
-        if exp_rev:
-            logger.debug("Collected experiment '%s'.", exp_rev[:7])
-            results[exp_rev] = exec_result.exp_hash
-        return results
-
-    def exec_queue(
-        self, repo: "Repo", jobs: Optional[int] = 1, detach: bool = False
-    ):
-        """Run a single WorkspaceExecutor.
-
-        Workspace execution is done within the main DVC process
-        (rather than in multiprocessing context)
-        """
-        from dvc.exceptions import DvcException
-        from dvc.stage.monitor import CheckpointKilledError
-
-        assert len(self._queue) == 1
-        assert not detach
-        result: Dict[str, Dict[str, str]] = defaultdict(dict)
-        rev, executor = self._queue.popleft()
-
-        exec_name = "workspace"
-        infofile = self.get_infofile_path(exec_name)
-        try:
-            exec_result = executor.reproduce(
-                info=executor.info,
-                rev=rev,
-                infofile=infofile,
-                log_level=logger.getEffectiveLevel(),
-                log_errors=not isinstance(executor, WorkspaceExecutor),
-            )
-            if not exec_result.exp_hash:
-                raise DvcException(
-                    f"Failed to reproduce experiment '{rev[:7]}'"
-                )
-            if exec_result.ref_info:
-                result[rev].update(
-                    self._collect_executor(repo, executor, exec_result)
-                )
-        except CheckpointKilledError:
-            # Checkpoint errors have already been logged
-            return {}
-        except DvcException:
-            raise
-        except Exception as exc:
-            raise DvcException(
-                f"Failed to reproduce experiment '{rev[:7]}'"
-            ) from exc
-        finally:
-            self.cleanup_executor(exec_name, executor)
-        return result

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

@@ -1,109 +0,0 @@
-import logging
-import posixpath
-from collections import defaultdict
-from typing import TYPE_CHECKING, Callable, Dict, Generator, Optional, Tuple
-
-from ...stash import ExpStashEntry
-from ..base import BaseExecutor
-from ..ssh import SSHExecutor, _sshfs
-from .base import BaseExecutorManager
-
-if TYPE_CHECKING:
-    from scmrepo.git import Git
-
-    from dvc.repo import Repo
-
-logger = logging.getLogger(__name__)
-
-
-class SSHExecutorManager(BaseExecutorManager):
-    EXECUTOR_CLS = SSHExecutor
-
-    def __init__(
-        self,
-        scm: "Git",
-        wdir: str,
-        host: Optional[str] = None,
-        port: Optional[int] = None,
-        username: Optional[str] = None,
-        fs_factory: Optional[Callable] = None,
-        **kwargs,
-    ):
-        assert host
-        super().__init__(scm, wdir, **kwargs)
-        self.host = host
-        self.port = port
-        self.username = username
-        self._fs_factory = fs_factory
-
-    def _load_infos(self) -> Generator[Tuple[str, "BaseExecutor"], None, None]:
-        # TODO: load existing infos using sshfs
-        yield from []
-
-    @classmethod
-    def from_stash_entries(
-        cls,
-        scm: "Git",
-        wdir: str,
-        repo: "Repo",
-        to_run: Dict[str, ExpStashEntry],
-        **kwargs,
-    ):
-        machine_name: Optional[str] = kwargs.get("machine_name", None)
-        manager = cls(
-            scm, wdir, **repo.machine.get_executor_kwargs(machine_name)
-        )
-        manager._enqueue_stash_entries(scm, repo, to_run, **kwargs)
-        return manager
-
-    def sshfs(self):
-        return _sshfs(self._fs_factory, host=self.host, port=self.port)
-
-    def get_infofile_path(self, name: str) -> str:
-        return f"{name}{BaseExecutor.INFOFILE_EXT}"
-
-    def _exec_attached(self, repo: "Repo", jobs: Optional[int] = 1):
-        from dvc.exceptions import DvcException
-        from dvc.stage.monitor import CheckpointKilledError
-
-        assert len(self._queue) == 1
-        result: Dict[str, Dict[str, str]] = defaultdict(dict)
-        rev, executor = self._queue.popleft()
-        info = executor.info
-        infofile = posixpath.join(
-            info.root_dir,
-            info.dvc_dir,
-            "tmp",
-            self.get_infofile_path(rev),
-        )
-        try:
-            exec_result = executor.reproduce(
-                info=executor.info,
-                rev=rev,
-                infofile=infofile,
-                log_level=logger.getEffectiveLevel(),
-                fs_factory=self._fs_factory,
-            )
-            if not exec_result.exp_hash:
-                raise DvcException(
-                    f"Failed to reproduce experiment '{rev[:7]}'"
-                )
-            if exec_result.ref_info:
-                result[rev].update(
-                    self._collect_executor(repo, executor, exec_result)
-                )
-        except CheckpointKilledError:
-            # Checkpoint errors have already been logged
-            return {}
-        except DvcException:
-            raise
-        except Exception as exc:
-            raise DvcException(
-                f"Failed to reproduce experiment '{rev[:7]}'"
-            ) from exc
-        finally:
-            self.cleanup_executor(rev, executor)
-        return result
-
-    def cleanup_executor(self, rev: str, executor: "BaseExecutor"):
-        executor.cleanup()

dvc/repo/experiments/executor/ssh.py

@@ -15,7 +15,7 @@ from ..refs import (
     EXEC_MERGE,
     EXEC_NAMESPACE,
 )
-from .base import BaseExecutor, ExecutorInfo, ExecutorResult
+from .base import BaseExecutor, ExecutorInfo, ExecutorResult, TaskStatus
 
 if TYPE_CHECKING:
     from queue import Queue
@@ -23,8 +23,8 @@ if TYPE_CHECKING:
     from scmrepo.git import Git
 
     from dvc.repo import Repo
-
-    from ..base import ExpRefInfo, ExpStashEntry
+    from dvc.repo.experiments.refs import ExpRefInfo
+    from dvc.repo.experiments.stash import ExpStashEntry
 
 logger = logging.getLogger(__name__)
 
@@ -75,14 +75,12 @@ class SSHExecutor(BaseExecutor):
     def from_stash_entry(
         cls,
         repo: "Repo",
-        stash_rev: str,
         entry: "ExpStashEntry",
         **kwargs,
     ):
         machine_name: Optional[str] = kwargs.pop("machine_name", None)
         executor = cls._from_stash_entry(
             repo,
-            stash_rev,
             entry,
             cls.gen_dirname(entry.name),
             location=machine_name,
@@ -119,9 +117,20 @@ class SSHExecutor(BaseExecutor):
         }
         return kwargs
 
-    def init_git(self, scm: "Git", branch: Optional[str] = None):
+    def init_git(
+        self,
+        scm: "Git",
+        stash_rev: str,
+        entry: "ExpStashEntry",
+        infofile: Optional[str],
+        branch: Optional[str] = None,
+    ):
         from ..utils import push_refspec
 
+        self.status = TaskStatus.PREPARING
+        if infofile:
+            self.info.dump_json(infofile)
+
         with self.sshfs() as fs:
             fs.makedirs(self.root_dir)
             self._ssh_cmd(fs, "git init .")
@@ -137,8 +146,11 @@ class SSHExecutor(BaseExecutor):
             # TODO: support multiple client key retries in git backends
             # (see https://github.com/iterative/dvc/issues/6508)
             kwargs = self._git_client_args(fs)
-            refspec = f"{EXEC_NAMESPACE}/"
-            push_refspec(scm, self.git_url, refspec, refspec, **kwargs)
+
+            with self.set_exec_refs(scm, stash_rev, entry):
+                refspec = f"{EXEC_NAMESPACE}/"
+                push_refspec(scm, self.git_url, refspec, refspec, **kwargs)
+
             if branch:
                 push_refspec(scm, self.git_url, branch, branch, **kwargs)
                 self._ssh_cmd(fs, f"git symbolic-ref {EXEC_BRANCH} {branch}")

dvc/repo/experiments/init.py

@@ -248,11 +248,6 @@ def init(
         except MissingParamsFile:
             pass
 
-    models = context.get("models")
-    live_path = context.pop("live", None)
-    live_metrics = f"{live_path}.json" if live_path else None
-    live_plots = os.path.join(live_path, "scalars") if live_path else None
-
     if type == "checkpoint":
         outs_key = "checkpoints"
         metrics_key = "metrics_persist_no_cache"
@@ -262,6 +257,13 @@ def init(
         metrics_key = "metrics_no_cache"
         plots_key = "plots_no_cache"
 
+    models = [context.get("models")]
+    metrics = [context.get("metrics")]
+    plots = [context.get("plots")]
+    if live_path := context.pop("live", None):
+        metrics.append(os.path.join(live_path, "metrics.json"))
+        plots.append(os.path.join(live_path, "plots"))
+
     stage = repo.stage.create(
         name=name,
         cmd=context["cmd"],
@@ -269,9 +271,9 @@ def init(
         params=[{params: None}] if params else None,
         force=force,
         **{
-            outs_key: compact([models]),
-            metrics_key: compact([context.get("metrics"), live_metrics]),
-            plots_key: compact([context.get("plots"), live_plots]),
+            outs_key: compact(models),
+            metrics_key: compact(metrics),
+            plots_key: compact(plots),
         },
     )
 

dvc/repo/experiments/queue/base.py

@@ -1,6 +1,5 @@
 import logging
 import os
-import sys
 from abc import ABC, abstractmethod
 from dataclasses import asdict, dataclass
 from typing import (
@@ -18,11 +17,12 @@ from typing import (
     Union,
 )
 
-from funcy import cached_property
+from funcy import cached_property, retry
 
 from dvc.dependency import ParamsDependency
 from dvc.env import DVCLIVE_RESUME
 from dvc.exceptions import DvcException
+from dvc.lock import LockError
 from dvc.ui import ui
 
 from ..exceptions import CheckpointExistsError, ExperimentExistsError
@@ -33,7 +33,7 @@ from ..executor.base import (
     ExecutorResult,
 )
 from ..executor.local import WorkspaceExecutor
-from ..refs import EXEC_BASELINE, EXEC_HEAD, EXEC_MERGE, ExpRefInfo
+from ..refs import ExpRefInfo
 from ..stash import ExpStash, ExpStashEntry
 from ..utils import exp_refs_by_rev, scm_locked
 
@@ -268,6 +268,7 @@ class BaseStashQueue(ABC):
                 finish any active experiments before shutting down.
         """
 
+    @abstractmethod
     def logs(
         self,
         rev: str,
@@ -524,16 +525,9 @@ class BaseStashQueue(ABC):
         .. _Hydra Override:
             https://hydra.cc/docs/advanced/override_grammar/basic/
         """
-        logger.debug("Using experiment params '%s'", params)
+        from dvc.utils.hydra import apply_overrides, compose_and_dump
 
-        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
+        logger.debug("Using experiment params '%s'", params)
 
         hydra_config = self.repo.config.get("hydra", {})
         hydra_enabled = hydra_config.get("enabled", False)
@@ -560,8 +554,9 @@ class BaseStashQueue(ABC):
         self.scm.add(list(params.keys()))
 
     @staticmethod
+    @retry(180, errors=LockError, timeout=1)
     @scm_locked
-    def setup_executor(
+    def init_executor(
         exp: "Experiments",
         queue_entry: QueueEntry,
         executor_cls: Type[BaseExecutor] = WorkspaceExecutor,
@@ -576,21 +571,23 @@ class BaseStashQueue(ABC):
         )
         if stash_entry.stash_index is not None:
             stash.drop(stash_entry.stash_index)
-
-        scm.set_ref(EXEC_HEAD, stash_entry.head_rev)
-        scm.set_ref(EXEC_MERGE, stash_rev)
-        scm.set_ref(EXEC_BASELINE, stash_entry.baseline_rev)
-
-        # Executor will be initialized with an empty git repo that
-        # we populate by pushing:
-        #   EXEC_HEAD - the base commit for this experiment
-        #   EXEC_MERGE - the unmerged changes (from our stash)
-        #       to be reproduced
-        #   EXEC_BASELINE - the baseline commit for this experiment
-        return executor_cls.from_stash_entry(
-            exp.repo, stash_rev, stash_entry, **kwargs
+        executor = executor_cls.from_stash_entry(
+            exp.repo, stash_entry, **kwargs
         )
 
+        infofile = exp.celery_queue.get_infofile_path(stash_rev)
+        executor.init_git(
+            exp.repo.scm,
+            stash_rev,
+            stash_entry,
+            infofile,
+            branch=stash_entry.branch,
+        )
+
+        executor.init_cache(exp.repo, stash_rev)
+
+        return executor
+
     def get_infofile_path(self, name: str) -> str:
         return os.path.join(
             self.pid_dir,
@@ -599,8 +596,9 @@ class BaseStashQueue(ABC):
         )
 
     @staticmethod
+    @retry(180, errors=LockError, timeout=1)
     @scm_locked
-    def collect_executor(
+    def collect_git(
         exp: "Experiments",
         executor: BaseExecutor,
         exec_result: ExecutorResult,
@@ -624,6 +622,17 @@ class BaseStashQueue(ABC):
                 logger.debug("Collected experiment '%s'.", exp_rev[:7])
                 results[exp_rev] = exec_result.exp_hash
 
+        return results
+
+    @classmethod
+    def collect_executor(
+        cls,
+        exp: "Experiments",
+        executor: BaseExecutor,
+        exec_result: ExecutorResult,
+    ) -> Dict[str, str]:
+        results = cls.collect_git(exp, executor, exec_result)
+
         if exec_result.ref_info is not None:
             executor.collect_cache(exp.repo, exec_result.ref_info)
 
@@ -690,3 +699,11 @@ class BaseStashQueue(ABC):
                 entry.stash_rev,
                 message=f"commit: {msg}",
             )
+
+    @abstractmethod
+    def get_running_exps(self, fetch_refs: bool = True) -> Dict[str, Dict]:
+        """Get the execution info of the currently running experiments
+
+        Args:
+            fetch_ref (bool): fetch completed checkpoints or not.
+        """

dvc/repo/experiments/queue/celery.py

@@ -26,6 +26,7 @@ from ..exceptions import UnresolvedQueueExpNamesError
 from ..executor.base import EXEC_TMP_DIR, ExecutorInfo, ExecutorResult
 from .base import BaseStashQueue, QueueDoneResult, QueueEntry, QueueGetResult
 from .tasks import run_exp
+from .utils import fetch_running_exp_from_temp_dir
 
 if TYPE_CHECKING:
     from dvc_task.app import FSApp
@@ -181,6 +182,7 @@ class LocalCeleryQueue(BaseStashQueue):
                 continue
             args, kwargs, _embed = msg.decode()
             entry_dict = kwargs.get("entry_dict", args[0])
+            logger.debug("Found queued task %s", entry_dict["stash_rev"])
             yield _MessageEntry(msg, QueueEntry.from_dict(entry_dict))
 
     def _iter_processed(self) -> Generator[_MessageEntry, None, None]:
@@ -197,6 +199,7 @@ class LocalCeleryQueue(BaseStashQueue):
             task_id = msg.headers["id"]
             result: AsyncResult = AsyncResult(task_id)
             if not result.ready():
+                logger.debug("Found active task %s", entry.stash_rev)
                 yield _TaskEntry(result, entry)
 
     def _iter_done_tasks(self) -> Generator[_TaskEntry, None, None]:
@@ -205,6 +208,7 @@ class LocalCeleryQueue(BaseStashQueue):
             task_id = msg.headers["id"]
             result: AsyncResult = AsyncResult(task_id)
             if result.ready():
+                logger.debug("Found done task %s", entry.stash_rev)
                 yield _TaskEntry(result, entry)
 
     def iter_active(self) -> Generator[QueueEntry, None, None]:
@@ -237,48 +241,50 @@ class LocalCeleryQueue(BaseStashQueue):
     def reproduce(self) -> Mapping[str, Mapping[str, str]]:
         raise NotImplementedError
 
-    def get_result(
+    def _load_info(self, rev: str) -> ExecutorInfo:
+        infofile = self.get_infofile_path(rev)
+        return ExecutorInfo.load_json(infofile)
+
+    def _get_done_result(
         self, entry: QueueEntry, timeout: Optional[float] = None
-    ) -> Optional[ExecutorResult]:
+    ) -> Optional["ExecutorResult"]:
         from celery.exceptions import TimeoutError as _CeleryTimeout
 
-        def _load_info(rev: str) -> ExecutorInfo:
-            infofile = self.get_infofile_path(rev)
-            return ExecutorInfo.load_json(infofile)
-
-        def _load_collected(rev: str) -> Optional[ExecutorResult]:
-            executor_info = _load_info(rev)
-            if executor_info.collected:
+        for msg, processed_entry in self._iter_processed():
+            if entry.stash_rev == processed_entry.stash_rev:
+                task_id = msg.headers["id"]
+                result: AsyncResult = AsyncResult(task_id)
+                if not result.ready():
+                    logger.debug(
+                        "Waiting for exp task '%s' to complete", result.id
+                    )
+                    try:
+                        result.get(timeout=timeout)
+                    except _CeleryTimeout as exc:
+                        raise DvcException(
+                            "Timed out waiting for exp to finish."
+                        ) from exc
+                executor_info = self._load_info(entry.stash_rev)
                 return executor_info.result
-            raise FileNotFoundError
+        raise FileNotFoundError
+
+    def get_result(
+        self, entry: QueueEntry, timeout: Optional[float] = None
+    ) -> Optional["ExecutorResult"]:
 
         try:
-            return _load_collected(entry.stash_rev)
+            return self._get_done_result(entry, timeout)
         except FileNotFoundError:
-            # Infofile will not be created until execution begins
             pass
 
         for queue_entry in self.iter_queued():
             if entry.stash_rev == queue_entry.stash_rev:
                 raise DvcException("Experiment has not been started.")
-        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", result.id
-                )
-                try:
-                    result.get(timeout=timeout)
-                except _CeleryTimeout as exc:
-                    raise DvcException(
-                        "Timed out waiting for exp to finish."
-                    ) from exc
-                executor_info = _load_info(entry.stash_rev)
-                return executor_info.result
 
         # 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.
-        return _load_collected(entry.stash_rev)
+        return self._get_done_result(entry, timeout)
 
     def kill(self, revs: Collection[str]) -> None:
         to_kill: Set[QueueEntry] = set()
@@ -368,3 +374,18 @@ class LocalCeleryQueue(BaseStashQueue):
         from .remove import celery_remove
 
         return celery_remove(self, *args, **kwargs)
+
+    def get_running_exps(self, fetch_refs: bool = True) -> Dict[str, Dict]:
+        """Get the execution info of the currently running experiments
+
+        Args:
+            fetch_ref (bool): fetch completed checkpoints or not.
+        """
+        result: Dict[str, Dict] = {}
+        for entry in self.iter_active():
+            result.update(
+                fetch_running_exp_from_temp_dir(
+                    self, entry.stash_rev, fetch_refs
+                )
+            )
+        return result

dvc/repo/experiments/queue/tasks.py

@@ -3,8 +3,6 @@ from typing import Any, Dict
 from celery import shared_task
 from celery.utils.log import get_task_logger
 
-from dvc.utils.fs import remove
-
 from ..executor.base import ExecutorInfo
 from ..executor.local import TempDirExecutor
 from .base import BaseStashQueue, QueueEntry
@@ -13,7 +11,7 @@ logger = get_task_logger(__name__)
 
 
 @shared_task
-def setup_exp(entry_dict: Dict[str, Any]) -> str:
+def setup_exp(entry_dict: Dict[str, Any]) -> TempDirExecutor:
     """Setup an experiment.
 
     Arguments:
@@ -28,7 +26,7 @@ def setup_exp(entry_dict: Dict[str, Any]) -> str:
     repo = Repo(entry.dvc_root)
     # TODO: split executor.init_cache into separate subtask - we can release
     # exp.scm_lock before DVC push
-    executor = BaseStashQueue.setup_executor(
+    executor = BaseStashQueue.init_executor(
         repo.experiments,
         entry,
         TempDirExecutor,
@@ -36,7 +34,7 @@ def setup_exp(entry_dict: Dict[str, Any]) -> str:
     )
     infofile = repo.experiments.celery_queue.get_infofile_path(entry.stash_rev)
     executor.info.dump_json(infofile)
-    return executor.root_dir
+    return executor
 
 
 @shared_task
@@ -79,25 +77,14 @@ def collect_exp(
 
 
 @shared_task
-def cleanup_exp(  # pylint: disable=unused-argument
-    tmp_dir: str, entry_dict: Dict[str, Any]
-) -> None:
+def cleanup_exp(executor: TempDirExecutor, infofile: str) -> None:
     """Cleanup after an experiment.
 
     Arguments:
         tmp_dir: Temp directory to be removed.
         entry_dict: Serialized QueueEntry for this experiment.
     """
-    remove(tmp_dir)
-
-
-def _set_collected(infofile: str):
-    try:
-        executor_info = ExecutorInfo.load_json(infofile)
-        executor_info.collected = True
-        executor_info.dump_json(infofile)
-    except FileNotFoundError:
-        pass
+    executor.cleanup(infofile)
 
 
 @shared_task
@@ -115,11 +102,10 @@ def run_exp(entry_dict: Dict[str, Any]) -> None:
     repo = Repo(entry.dvc_root)
     queue = repo.experiments.celery_queue
     infofile = queue.get_infofile_path(entry.stash_rev)
-    root_dir = setup_exp.s(entry_dict)()
+    executor = setup_exp.s(entry_dict)()
     try:
         cmd = ["dvc", "exp", "exec-run", "--infofile", infofile]
         proc_dict = queue.proc.run_signature(cmd, name=entry.stash_rev)()
         collect_exp.s(proc_dict, entry_dict)()
     finally:
-        cleanup_exp.s(root_dir, entry_dict)()
-        _set_collected(infofile)
+        cleanup_exp.s(executor, infofile)()

dvc/repo/experiments/queue/tempdir.py

@@ -11,9 +11,11 @@ from ..executor.base import (
     BaseExecutor,
     ExecutorInfo,
     ExecutorResult,
+    TaskStatus,
 )
 from ..executor.local import TempDirExecutor
 from .base import BaseStashQueue, QueueEntry, QueueGetResult
+from .utils import fetch_running_exp_from_temp_dir
 from .workspace import WorkspaceQueue
 
 if TYPE_CHECKING:
@@ -60,7 +62,7 @@ class TempDirQueue(WorkspaceQueue):
             stash_entry.name,
             stash_entry.head_rev,
         )
-        executor = self.setup_executor(
+        executor = self.init_executor(
             self.repo.experiments,
             entry,
             TempDirExecutor,
@@ -75,8 +77,9 @@ class TempDirQueue(WorkspaceQueue):
         for stash_rev in self.proc:
             infofile = self.get_infofile_path(stash_rev)
             executor_info = ExecutorInfo.load_json(infofile)
-            if not executor_info.collected and os.path.exists(
-                executor_info.root_dir
+            if (
+                not executor_info.status <= TaskStatus.SUCCESS
+                and os.path.exists(executor_info.root_dir)
             ):
                 yield QueueEntry(
                     self.repo.root_dir,
@@ -96,3 +99,13 @@ class TempDirQueue(WorkspaceQueue):
         exec_result: ExecutorResult,
     ) -> Dict[str, str]:
         return BaseStashQueue.collect_executor(exp, executor, exec_result)
+
+    def get_running_exps(self, fetch_refs: bool = True) -> Dict[str, Dict]:
+        result: Dict[str, Dict] = {}
+        for entry in self.iter_active():
+            result.update(
+                fetch_running_exp_from_temp_dir(
+                    self, entry.stash_rev, fetch_refs
+                )
+            )
+        return result

dvc/repo/experiments/queue/utils.py

@@ -0,0 +1,60 @@
+import logging
+from typing import TYPE_CHECKING, Dict
+
+from scmrepo.exceptions import SCMError
+
+from ..executor.base import ExecutorInfo, TaskStatus
+
+logger = logging.getLogger(__name__)
+
+
+if TYPE_CHECKING:
+    from .base import BaseStashQueue
+
+
+def fetch_running_exp_from_temp_dir(
+    queue: "BaseStashQueue", rev: str, fetch_refs: bool
+) -> Dict[str, Dict]:
+    """Fetch status of running exps out of current working directory
+
+    Args:
+        queue (BaseStashQueue):
+        rev (str): stash revision of the experiment
+        fetch_refs (bool): fetch running checkpoint results to local or not.
+
+    Returns:
+        Dict[str, Dict]: _description_
+    """
+    from dvc.scm import InvalidRemoteSCMRepo
+    from dvc.utils.serialize import load_json
+
+    from ..executor.local import TempDirExecutor
+
+    result: Dict[str, Dict] = {}
+    infofile = queue.get_infofile_path(rev)
+    try:
+        info = ExecutorInfo.from_dict(load_json(infofile))
+    except OSError:
+        return result
+    if info.status < TaskStatus.FAILED:
+        result[rev] = info.asdict()
+        if info.git_url and fetch_refs and info.status > TaskStatus.PREPARING:
+
+            def on_diverged(_ref: str, _checkpoint: bool):
+                return False
+
+            executor = TempDirExecutor.from_info(info)
+            try:
+                for ref in executor.fetch_exps(
+                    queue.scm,
+                    on_diverged=on_diverged,
+                ):
+                    logger.debug("Updated running experiment '%s'.", ref)
+                    last_rev = queue.scm.get_ref(ref)
+                    result[rev]["last"] = last_rev
+                    if last_rev:
+                        result[last_rev] = info.asdict()
+            except (InvalidRemoteSCMRepo, SCMError):
+                # ignore stale info files
+                del result[rev]
+    return result

dvc/repo/experiments/queue/workspace.py

@@ -1,15 +1,25 @@
+import json
 import logging
-import os
 from collections import defaultdict
-from typing import TYPE_CHECKING, Collection, Dict, Generator, Optional
+from typing import TYPE_CHECKING, Collection, Dict, Generator, List, Optional
 
+import psutil
 from funcy import first
+from voluptuous import Invalid
 
 from dvc.exceptions import DvcException
+from dvc.lock import make_lock
+from dvc.rwlock import RWLOCK_FILE, RWLOCK_LOCK, SCHEMA
+from dvc.utils import relpath
 from dvc.utils.fs import remove
 
 from ..exceptions import ExpQueueEmptyError
-from ..executor.base import BaseExecutor, ExecutorResult
+from ..executor.base import (
+    BaseExecutor,
+    ExecutorInfo,
+    ExecutorResult,
+    TaskStatus,
+)
 from ..executor.local import WorkspaceExecutor
 from ..refs import EXEC_BRANCH
 from .base import BaseStashQueue, QueueDoneResult, QueueEntry, QueueGetResult
@@ -41,7 +51,7 @@ class WorkspaceQueue(BaseStashQueue):
             stash_entry.name,
             stash_entry.head_rev,
         )
-        executor = self.setup_executor(self.repo.experiments, entry)
+        executor = self.init_executor(self.repo.experiments, entry)
         return QueueGetResult(entry, executor)
 
     def iter_queued(self) -> Generator[QueueEntry, None, None]:
@@ -118,9 +128,7 @@ class WorkspaceQueue(BaseStashQueue):
                 f"Failed to reproduce experiment '{rev[:7]}'"
             ) from exc
         finally:
-            if self._EXEC_NAME == exec_name:
-                remove(os.path.join(self.pid_dir, exec_name))
-            executor.cleanup()
+            executor.cleanup(infofile)
         return results
 
     @staticmethod
@@ -135,6 +143,7 @@ class WorkspaceQueue(BaseStashQueue):
             assert exec_result.exp_hash
             logger.debug("Collected experiment '%s'.", exp_rev[:7])
             results[exp_rev] = exec_result.exp_hash
+
         return results
 
     def get_result(self, entry: QueueEntry) -> Optional[ExecutorResult]:
@@ -153,3 +162,89 @@ class WorkspaceQueue(BaseStashQueue):
         follow: bool = False,
     ):
         raise NotImplementedError
+
+    def check_rwlock(
+        self,
+        hardlink: bool = False,
+        autocorrect: bool = False,
+    ) -> bool:
+        """Check and autocorrect the RWLock status for file paths.
+
+        Args:
+            hardlink (bool): use hardlink lock to guard rwlock file when on
+                            edit.
+            autocorrect (bool): autocorrect corrupted rwlock file.
+
+        Return:
+            (bool): if the pid alive.
+        """
+        path = self.repo.fs.path.join(self.repo.tmp_dir, RWLOCK_FILE)
+
+        rwlock_guard = make_lock(
+            self.repo.fs.path.join(self.repo.tmp_dir, RWLOCK_LOCK),
+            tmp_dir=self.repo.tmp_dir,
+            hardlink_lock=hardlink,
+        )
+        with rwlock_guard:
+            try:
+                with self.repo.fs.open(path, encoding="utf-8") as fobj:
+                    lock: Dict[str, List[Dict]] = SCHEMA(json.load(fobj))
+                file_path = first(lock["read"])
+                if not file_path:
+                    return False
+                lock_info = first(lock["read"][file_path])
+                pid = int(lock_info["pid"])
+                if psutil.pid_exists(pid):
+                    return True
+                cmd = lock_info["cmd"]
+                logger.warning(
+                    "Process '%s' with (Pid %s), in RWLock-file '%s'"
+                    " had been killed.",
+                    cmd,
+                    pid,
+                    relpath(path),
+                )
+            except FileNotFoundError:
+                return False
+            except json.JSONDecodeError:
+                logger.warning(
+                    "Unable to read RWLock-file '%s'. JSON structure is"
+                    " corrupted",
+                    relpath(path),
+                )
+            except Invalid:
+                logger.warning("RWLock-file '%s' format error.", relpath(path))
+            if autocorrect:
+                logger.warning(
+                    "Delete corrupted RWLock-file '%s'", relpath(path)
+                )
+                remove(path)
+            return False
+
+    def get_running_exps(self, fetch_refs: bool = True) -> Dict[str, Dict]:
+        from dvc.utils.serialize import load_json
+
+        assert self._EXEC_NAME
+        result: Dict[str, Dict] = {}
+
+        if not self.check_rwlock(autocorrect=True):
+            return result
+
+        infofile = self.get_infofile_path(self._EXEC_NAME)
+
+        try:
+            info = ExecutorInfo.from_dict(load_json(infofile))
+        except OSError:
+            return result
+
+        if info.status < TaskStatus.FAILED:
+            # If we are appending to a checkpoint branch in a workspace
+            # run, show the latest checkpoint as running.
+            if info.status == TaskStatus.SUCCESS:
+                return result
+            last_rev = self.scm.get_ref(EXEC_BRANCH)
+            if last_rev:
+                result[last_rev] = info.asdict()
+            else:
+                result[self._EXEC_NAME] = info.asdict()
+        return result

dvc/repo/experiments/run.py

@@ -28,14 +28,24 @@ 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)
+        return repo.experiments.reproduce_celery(jobs=jobs)
 
+    hydra_sweep = None
     if params:
+        from dvc.utils.hydra import to_hydra_overrides
+
         path_overrides = to_path_overrides(params)
+        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`"
+            )
     else:
         path_overrides = {}
 
@@ -45,23 +55,16 @@ def run(
         # 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:
+        if kwargs.get("name"):
+            raise InvalidArgumentError(
+                "Sweep overrides can't be used alongside `--name`"
+            )
         from dvc.utils.hydra import get_hydra_sweeps
 
         sweeps = get_hydra_sweeps(path_overrides)

dvc/repo/experiments/show.py

@@ -1,52 +1,86 @@
 import logging
 from collections import OrderedDict, defaultdict
 from datetime import datetime
+from enum import Enum
 from itertools import chain
-from typing import TYPE_CHECKING, Any, Callable, Dict, List, Optional, Union
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    Callable,
+    Dict,
+    List,
+    Optional,
+    Tuple,
+    Union,
+)
+
+from scmrepo.exceptions import SCMError as InnerScmError
 
 from dvc.repo.metrics.show import _gather_metrics
 from dvc.repo.params.show import _gather_params
-from dvc.scm import iter_revs
+from dvc.scm import SCMError, iter_revs, resolve_rev
 from dvc.utils import error_handler, onerror_collect, relpath
 
 from .refs import ExpRefInfo
 
 if TYPE_CHECKING:
+    from scmrepo.git.objects import GitCommit
+
     from dvc.repo import Repo
 
 logger = logging.getLogger(__name__)
 
 
+class ExpStatus(Enum):
+    Success = 0
+    Queued = 1
+    Running = 2
+    Failed = 3
+
+
+def _is_scm_error(collected_exp: Dict[str, Any]) -> bool:
+    if "error" in collected_exp and (
+        isinstance(collected_exp["error"], SCMError)
+        or isinstance(collected_exp["error"], InnerScmError)
+    ):
+        return True
+    return False
+
+
+def _show_onerror_collect(result: Dict, exception: Exception, *args, **kwargs):
+    onerror_collect(result, exception, *args, **kwargs)
+    result["data"] = {}
+
+
 @error_handler
-def _collect_experiment_commit(
-    repo,
-    exp_rev,
-    stash=False,
-    sha_only=True,
+def collect_experiment_commit(
+    repo: "Repo",
+    exp_rev: str,
+    status: ExpStatus = ExpStatus.Success,
     param_deps=False,
-    running=None,
+    running: Optional[Dict[str, Any]] = None,
     onerror: Optional[Callable] = None,
-    is_baseline: bool = False,
-):
+) -> Dict[str, Any]:
     from dvc.dependency import ParamsDependency, RepoDependency
 
-    res: Dict[str, Optional[Any]] = defaultdict(dict)
+    result: Dict[str, Any] = defaultdict(dict)
+    running = running or {}
     for rev in repo.brancher(revs=[exp_rev]):
         if rev == "workspace":
             if exp_rev != "workspace":
                 continue
-            res["timestamp"] = None
+            result["timestamp"] = None
         else:
             commit = repo.scm.resolve_commit(rev)
-            res["timestamp"] = datetime.fromtimestamp(commit.commit_time)
+            result["timestamp"] = datetime.fromtimestamp(commit.commit_time)
 
         params = _gather_params(
             repo, rev=rev, targets=None, deps=param_deps, onerror=onerror
         )
         if params:
-            res["params"] = params
+            result["params"] = params
 
-        res["deps"] = {
+        result["deps"] = {
             relpath(dep.fs_path, repo.root_dir): {
                 "hash": dep.hash_info.value,
                 "size": dep.meta.size,
@@ -55,7 +89,7 @@ def _collect_experiment_commit(
             for dep in repo.index.deps
             if not isinstance(dep, (ParamsDependency, RepoDependency))
         }
-        res["outs"] = {
+        result["outs"] = {
             relpath(out.fs_path, repo.root_dir): {
                 "hash": out.hash_info.value,
                 "size": out.meta.size,
@@ -67,66 +101,239 @@ def _collect_experiment_commit(
             if not (out.is_metric or out.is_plot)
         }
 
-        res["queued"] = stash
-        if running is not None and exp_rev in running:
-            res["running"] = True
-            res["executor"] = running[exp_rev].get("location")
+        result["status"] = status.name
+        if status == ExpStatus.Running:
+            result["executor"] = running.get(exp_rev, {}).get("location", None)
         else:
-            res["running"] = False
-            res["executor"] = None
-        if not stash:
+            result["executor"] = None
+
+        if status == ExpStatus.Failed:
+            result["error"] = {
+                "msg": "Experiment run failed.",
+                "type": "",
+            }
+
+        if status not in {ExpStatus.Queued, ExpStatus.Failed}:
             vals = _gather_metrics(
                 repo, targets=None, rev=rev, recursive=False, onerror=onerror
             )
-            res["metrics"] = vals
+            result["metrics"] = vals
 
-        if not sha_only and rev != "workspace":
-            name: Optional[str] = None
-            if is_baseline:
-                for refspec in ["refs/tags", "refs/heads"]:
-                    name = repo.scm.describe(rev, base=refspec)
-                    if name:
-                        break
-            if not name:
-                name = repo.experiments.get_exact_name(rev)
-            if name:
-                name = name.rsplit("/")[-1]
-                res["name"] = name
-
-    return res
+    return result
 
 
-def _collect_experiment_branch(
-    res, repo, branch, baseline, onerror: Optional[Callable] = None, **kwargs
-):
-    from dvc.scm import resolve_rev
+def _collect_complete_experiment(
+    repo: "Repo",
+    baseline: str,
+    exp_rev: str,
+    running: Dict[str, Any],
+    revs: List[str],
+    **kwargs,
+) -> Dict[str, Dict[str, Any]]:
+    results: "OrderedDict[str, Dict[str, Any]]" = OrderedDict()
 
-    exp_rev = resolve_rev(repo.scm, branch)
-    prev = None
-    revs = list(repo.scm.branch_revs(exp_rev, baseline))
+    checkpoint: bool = True if len(revs) > 1 else False
+    prev = ""
     for rev in revs:
-        collected_exp = _collect_experiment_commit(
-            repo, rev, onerror=onerror, **kwargs
+        status = ExpStatus.Running if rev in running else ExpStatus.Success
+        collected_exp = collect_experiment_commit(
+            repo,
+            rev,
+            status=status,
+            running=running,
+            **kwargs,
         )
-        if len(revs) > 1:
+        if _is_scm_error(collected_exp):
+            return {}
+        if checkpoint:
             exp = {"checkpoint_tip": exp_rev}
             if prev:
-                res[prev]["data"][  # type: ignore[unreachable]
+                results[prev]["data"][  # type: ignore[unreachable]
                     "checkpoint_parent"
                 ] = rev
-            if rev in res:
-                res[rev]["data"].update(exp)
-                res.move_to_end(rev)
+            if rev in results:
+                results[rev]["data"].update(exp)
+                results.move_to_end(rev)
             else:
                 exp.update(collected_exp["data"])
         else:
             exp = collected_exp["data"]
-        if rev not in res:
-            res[rev] = {"data": exp}
+        if rev not in results:
+            results[rev] = {"data": exp}
         prev = rev
-    if len(revs) > 1:
-        res[prev]["data"]["checkpoint_parent"] = baseline
-    return res
+    if checkpoint and prev:
+        results[prev]["data"]["checkpoint_parent"] = baseline
+    return results
+
+
+def _collect_branch(
+    repo: "Repo",
+    baseline: str,
+    running: Dict[str, Any],
+    **kwargs,
+) -> Dict[str, Dict[str, Any]]:
+    results: Dict[str, Dict[str, Any]] = OrderedDict()
+    status = ExpStatus.Running if baseline in running else ExpStatus.Success
+    results["baseline"] = collect_experiment_commit(
+        repo,
+        baseline,
+        status=status,
+        running=running,
+        **kwargs,
+    )
+    if baseline == "workspace" or _is_scm_error(results["baseline"]):
+        return results
+
+    ref_info = ExpRefInfo(baseline_sha=baseline)
+    commits: List[Tuple[str, "GitCommit", str, List[str]]] = []
+
+    for ref in repo.scm.iter_refs(base=str(ref_info)):
+        try:
+            commit = repo.scm.resolve_commit(ref)
+            exp_rev = resolve_rev(repo.scm, ref)
+            revs = list(repo.scm.branch_revs(exp_rev, baseline))
+        except (SCMError, InnerScmError):
+            continue
+        commits.append((ref, commit, exp_rev, revs))
+
+    for exp_ref, _, exp_rev, revs in sorted(
+        commits, key=lambda x: x[1].commit_time, reverse=True
+    ):
+        ref_info = ExpRefInfo.from_ref(exp_ref)
+        assert ref_info.baseline_sha == baseline
+        collected_exp = _collect_complete_experiment(
+            repo,
+            baseline=baseline,
+            exp_rev=exp_rev,
+            running=running,
+            revs=revs,
+            **kwargs,
+        )
+        if _is_scm_error(collected_exp):
+            continue
+        results.update(collected_exp)
+    return results
+
+
+def get_names(repo: "Repo", result: Dict[str, Dict[str, Any]]):
+
+    rev_set = set()
+    baseline_set = set()
+    for baseline in result:
+        for rev in result[baseline]:
+            if rev == "baseline":
+                rev = baseline
+                baseline_set.add(rev)
+            if rev != "workspace":
+                rev_set.add(rev)
+
+    names: Dict[str, Optional[str]] = {}
+    for base in ("refs/tags/", "refs/heads/"):
+        if rev_set:
+            names.update(
+                (rev, ref[len(base) :])
+                for rev, ref in repo.scm.describe(
+                    baseline_set, base=base
+                ).items()
+                if ref is not None
+            )
+            rev_set.difference_update(names.keys())
+
+    exact_name = repo.experiments.get_exact_name(rev_set)
+
+    for baseline, baseline_results in result.items():
+        for rev, rev_result in baseline_results.items():
+            name: Optional[str] = None
+            if rev == "baseline":
+                rev = baseline
+                if rev == "workspace":
+                    continue
+            name = names.get(rev, None) or exact_name[rev]
+            if name:
+                rev_result["data"]["name"] = name
+
+
+def _collect_active_experiment(
+    repo: "Repo",
+    found_revs: Dict[str, List[str]],
+    running: Dict[str, Any],
+    **kwargs,
+) -> Dict[str, Dict[str, Any]]:
+    result: Dict[str, Dict] = defaultdict(OrderedDict)
+    for entry in chain(
+        repo.experiments.tempdir_queue.iter_active(),
+        repo.experiments.celery_queue.iter_active(),
+    ):
+        stash_rev = entry.stash_rev
+        if entry.baseline_rev in found_revs and (
+            stash_rev not in running or not running[stash_rev].get("last")
+        ):
+            collected_exp = collect_experiment_commit(
+                repo,
+                stash_rev,
+                status=ExpStatus.Running,
+                running=running,
+                **kwargs,
+            )
+            if _is_scm_error(collected_exp):
+                continue
+            result[entry.baseline_rev][stash_rev] = collected_exp
+    return result
+
+
+def _collect_queued_experiment(
+    repo: "Repo",
+    found_revs: Dict[str, List[str]],
+    running: Dict[str, Any],
+    **kwargs,
+) -> Dict[str, Dict[str, Any]]:
+    result: Dict[str, Dict] = defaultdict(OrderedDict)
+    for entry in repo.experiments.celery_queue.iter_queued():
+        stash_rev = entry.stash_rev
+        if entry.baseline_rev in found_revs:
+            collected_exp = collect_experiment_commit(
+                repo,
+                stash_rev,
+                status=ExpStatus.Queued,
+                running=running,
+                **kwargs,
+            )
+            if _is_scm_error(collected_exp):
+                continue
+            result[entry.baseline_rev][stash_rev] = collected_exp
+    return result
+
+
+def _collect_failed_experiment(
+    repo: "Repo",
+    found_revs: Dict[str, List[str]],
+    running: Dict[str, Any],
+    **kwargs,
+) -> Dict[str, Dict[str, Any]]:
+    result: Dict[str, Dict] = defaultdict(OrderedDict)
+    for queue_done_result in repo.experiments.celery_queue.iter_failed():
+        entry = queue_done_result.entry
+        stash_rev = entry.stash_rev
+        if entry.baseline_rev in found_revs:
+            collected_exp = collect_experiment_commit(
+                repo,
+                stash_rev,
+                status=ExpStatus.Failed,
+                running=running,
+                **kwargs,
+            )
+            if _is_scm_error(collected_exp):
+                continue
+            result[entry.baseline_rev][stash_rev] = collected_exp
+    return result
+
+
+def update_new(
+    to_dict: Dict[str, Dict[str, Any]], from_dict: Dict[str, Dict[str, Any]]
+):
+    for baseline, experiments in from_dict.items():
+        for rev, experiment in experiments.items():
+            to_dict[baseline][rev] = to_dict[baseline].get(rev, experiment)
 
 
 def show(
@@ -135,6 +342,8 @@ def show(
     all_tags=False,
     revs: Union[List[str], str, None] = None,
     all_commits=False,
+    hide_queued=False,
+    hide_failed=False,
     sha_only=False,
     num=1,
     param_deps=False,
@@ -146,7 +355,7 @@ def show(
         return {}
 
     if onerror is None:
-        onerror = onerror_collect
+        onerror = _show_onerror_collect
 
     res: Dict[str, Dict] = defaultdict(OrderedDict)
 
@@ -160,62 +369,58 @@ def show(
         iter_revs(repo.scm, revs, num, all_branches, all_tags, all_commits)
     )
 
-    running = repo.experiments.get_running_exps(fetch_refs=fetch_running)
+    running: Dict[str, Dict] = repo.experiments.get_running_exps(
+        fetch_refs=fetch_running
+    )
 
-    for rev in found_revs:
-        res[rev]["baseline"] = _collect_experiment_commit(
+    queued_experiment = (
+        _collect_queued_experiment(
             repo,
-            rev,
-            sha_only=sha_only,
+            found_revs,
+            running,
+            param_deps=param_deps,
+            onerror=onerror,
+        )
+        if not hide_queued
+        else {}
+    )
+
+    active_experiment = _collect_active_experiment(
+        repo,
+        found_revs,
+        running,
+        param_deps=param_deps,
+        onerror=onerror,
+    )
+
+    failed_experiments = (
+        _collect_failed_experiment(
+            repo,
+            found_revs,
+            running,
+            param_deps=param_deps,
+            onerror=onerror,
+        )
+        if not hide_failed
+        else {}
+    )
+
+    for baseline in found_revs:
+        res[baseline] = _collect_branch(
+            repo,
+            baseline,
+            running=running,
             param_deps=param_deps,
-            running=running,
             onerror=onerror,
-            is_baseline=True,
         )
 
-        if rev == "workspace":
-            continue
+    update_new(res, failed_experiments)
 
-        ref_info = ExpRefInfo(baseline_sha=rev)
-        commits = [
-            (ref, repo.scm.resolve_commit(ref))
-            for ref in repo.scm.iter_refs(base=str(ref_info))
-        ]
-        for exp_ref, _ in sorted(
-            commits, key=lambda x: x[1].commit_time, reverse=True
-        ):
-            ref_info = ExpRefInfo.from_ref(exp_ref)
-            assert ref_info.baseline_sha == rev
-            _collect_experiment_branch(
-                res[rev],
-                repo,
-                exp_ref,
-                rev,
-                sha_only=sha_only,
-                param_deps=param_deps,
-                running=running,
-                onerror=onerror,
-            )
+    update_new(res, active_experiment)
+
+    update_new(res, queued_experiment)
+
+    if not sha_only:
+        get_names(repo, res)
 
-        # collect standalone & celery experiments
-        for entry in chain(
-            repo.experiments.tempdir_queue.iter_active(),
-            repo.experiments.celery_queue.iter_active(),
-            repo.experiments.celery_queue.iter_queued(),
-        ):
-            stash_rev = entry.stash_rev
-            if entry.baseline_rev in found_revs:
-                if stash_rev not in running or not running[stash_rev].get(
-                    "last"
-                ):
-                    experiment = _collect_experiment_commit(
-                        repo,
-                        stash_rev,
-                        sha_only=sha_only,
-                        stash=stash_rev not in running,
-                        param_deps=param_deps,
-                        running=running,
-                        onerror=onerror,
-                    )
-                    res[entry.baseline_rev][stash_rev] = experiment
     return res

dvc/repo/fetch.py

@@ -3,12 +3,15 @@ from contextlib import suppress
 from typing import TYPE_CHECKING, Optional
 
 from dvc.config import NoRemoteError
-from dvc.exceptions import DownloadError, FileTransferError
+from dvc.exceptions import DownloadError
 from dvc.fs import Schemes
 
 from . import locked
 
 if TYPE_CHECKING:
+    from dvc.repo import Repo
+    from dvc.types import TargetType
+    from dvc_data.hashfile.transfer import TransferResult
     from dvc_objects.db.base import ObjectDB
 
 logger = logging.getLogger(__name__)
@@ -25,22 +28,6 @@ def _fetch_worktree(repo, remote):
             *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)
 
 
@@ -58,7 +45,7 @@ def fetch(
     run_cache=False,
     revs=None,
     odb: Optional["ObjectDB"] = None,
-):
+) -> int:
     """Download data items from a cloud and imported repositories
 
     Returns:
@@ -71,6 +58,9 @@ def fetch(
         config.NoRemoteError: thrown when downloading only local files and no
             remote is configured
     """
+    from dvc.repo.imports import save_imports
+    from dvc_data.hashfile.transfer import TransferResult
+
     if isinstance(targets, str):
         targets = [targets]
 
@@ -79,110 +69,102 @@ def fetch(
         if _remote.worktree:
             return _fetch_worktree(self, _remote)
 
-    used = self.used_objs(
-        targets,
-        all_branches=all_branches,
-        all_tags=all_tags,
-        all_commits=all_commits,
-        with_deps=with_deps,
-        force=True,
-        remote=remote,
-        jobs=jobs,
-        recursive=recursive,
-        revs=revs,
-    )
-
-    downloaded = 0
-    failed = 0
+    failed_count = 0
 
     try:
         if run_cache:
             self.stage_cache.pull(remote)
     except DownloadError as exc:
-        failed += exc.amount
+        failed_count += exc.amount
 
+    no_remote_msg: Optional[str] = None
+    result = TransferResult(set(), set())
+    try:
+        d, f = _fetch(
+            self,
+            targets,
+            all_branches=all_branches,
+            all_tags=all_tags,
+            all_commits=all_commits,
+            with_deps=with_deps,
+            force=True,
+            remote=remote,
+            jobs=jobs,
+            recursive=recursive,
+            revs=revs,
+            odb=odb,
+        )
+        result.transferred.update(d)
+        result.failed.update(f)
+    except NoRemoteError as exc:
+        no_remote_msg = str(exc)
+
+    for rev in self.brancher(
+        revs=revs,
+        all_branches=all_branches,
+        all_tags=all_tags,
+        all_commits=all_commits,
+    ):
+        imported = save_imports(
+            self,
+            targets,
+            unpartial=not rev or rev == "workspace",
+            recursive=recursive,
+        )
+        result.transferred.update(imported)
+        result.failed.difference_update(imported)
+
+    failed_count += len(result.failed)
+
+    if failed_count:
+        if no_remote_msg:
+            logger.error(no_remote_msg)
+        raise DownloadError(failed_count)
+
+    return len(result.transferred)
+
+
+def _fetch(
+    repo: "Repo",
+    targets: "TargetType",
+    remote: Optional[str] = None,
+    jobs: Optional[int] = None,
+    odb: Optional["ObjectDB"] = None,
+    **kwargs,
+) -> "TransferResult":
+    from dvc_data.hashfile.transfer import TransferResult
+
+    result = TransferResult(set(), set())
+    used = repo.used_objs(
+        targets,
+        remote=remote,
+        jobs=jobs,
+        **kwargs,
+    )
     if odb:
         all_ids = set()
         for _odb, obj_ids in used.items():
             all_ids.update(obj_ids)
-        d, f = _fetch(
-            self,
+        d, f = repo.cloud.pull(
             all_ids,
             jobs=jobs,
             remote=remote,
             odb=odb,
         )
-        downloaded += d
-        failed += f
+        result.transferred.update(d)
+        result.failed.update(f)
     else:
         for src_odb, obj_ids in sorted(
             used.items(),
             key=lambda item: item[0] is not None
             and item[0].fs.protocol == Schemes.MEMORY,
         ):
-            d, f = _fetch(
-                self,
+            d, f = repo.cloud.pull(
                 obj_ids,
                 jobs=jobs,
                 remote=remote,
                 odb=src_odb,
             )
-            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)
-
-    return downloaded
-
-
-def _fetch(repo, obj_ids, **kwargs):
-    downloaded = 0
-    failed = 0
-    try:
-        downloaded += repo.cloud.pull(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
+            result.transferred.update(d)
+            result.failed.update(f)
+    return result

dvc/repo/get_url.py

@@ -1,19 +1,17 @@
 import os
 
+from dvc import output
+from dvc.exceptions import URLMissingError
+from dvc.fs import download, parse_external_url
+from dvc.utils import resolve_output
 
-def get_url(url, out=None, jobs=None):
-    from dvc import dependency, output
-    from dvc.utils import resolve_output
 
+def get_url(url, out=None, *, config=None, jobs=None):
     out = resolve_output(url, out)
-
-    if os.path.exists(url):
-        url = os.path.abspath(url)
-
     out = os.path.abspath(out)
-
-    (dep,) = dependency.loads_from(None, [url])
     (out,) = output.loads_from(None, [out], use_cache=False)
-    if not dep.exists:
-        raise dep.DoesNotExistError(dep)
-    dep.download(out, jobs=jobs)
+
+    src_fs, src_path = parse_external_url(url, config)
+    if not src_fs.exists(src_path):
+        raise URLMissingError(url)
+    download(src_fs, src_path, out, jobs=jobs)

dvc/repo/imp_url.py

@@ -1,4 +1,5 @@
 import os
+from typing import TYPE_CHECKING
 
 from dvc.repo.scm_context import scm_context
 from dvc.utils import relpath, resolve_output, resolve_paths
@@ -7,6 +8,9 @@ from dvc.utils.fs import path_isin
 from ..exceptions import InvalidArgumentError, OutputDuplicationError
 from . import locked
 
+if TYPE_CHECKING:
+    from dvc.dvcfile import DVCFile
+
 
 @locked
 @scm_context
@@ -27,6 +31,7 @@ def imp_url(
     meta=None,
     jobs=None,
     fs_config=None,
+    version_aware: bool = False,
 ):
     from dvc.dvcfile import Dvcfile
     from dvc.stage import Stage, create_stage, restore_fields
@@ -54,6 +59,11 @@ def imp_url(
     ):
         url = relpath(url, wdir)
 
+    if version_aware:
+        if fs_config is None:
+            fs_config = {}
+        fs_config["version_aware"] = True
+
     stage = create_stage(
         Stage,
         self,
@@ -68,7 +78,7 @@ def imp_url(
 
     out_obj = stage.outs[0]
     out_obj.annot.update(desc=desc, type=type, labels=labels, meta=meta)
-    dvcfile = Dvcfile(self, stage.path)
+    dvcfile: "DVCFile" = Dvcfile(self, stage.path)  # type: ignore
     dvcfile.remove()
 
     try:

dvc/repo/imports.py

@@ -0,0 +1,132 @@
+import logging
+from tempfile import TemporaryDirectory
+from typing import TYPE_CHECKING, List, Set, Tuple, Union
+
+if TYPE_CHECKING:
+    from dvc.dependency.base import Dependency
+    from dvc.repo import Repo
+    from dvc.repo.index import Index, IndexView
+    from dvc.stage import Stage
+    from dvc.types import TargetType
+    from dvc_data.hashfile import HashInfo
+
+logger = logging.getLogger(__name__)
+
+
+def unfetched_view(
+    index: "Index", targets: "TargetType", unpartial: bool = False, **kwargs
+) -> Tuple["IndexView", List["Dependency"]]:
+    """Return index view of imports which have not been fetched.
+
+    Returns:
+        Tuple in the form (view, changed_deps) where changed_imports is a list
+        of import dependencies that cannot be fetched due to changed data
+        source.
+    """
+    changed_deps: List["Dependency"] = []
+
+    def need_fetch(stage: "Stage") -> bool:
+        if (
+            not stage.is_import
+            or stage.is_repo_import
+            or (stage.is_partial_import and not unpartial)
+        ):
+            return False
+
+        out = stage.outs[0]
+        if not out.changed_cache():
+            return False
+
+        dep = stage.deps[0]
+        if dep.changed_checksum():
+            changed_deps.append(dep)
+            return False
+
+        return True
+
+    unfetched = index.targets_view(targets, stage_filter=need_fetch, **kwargs)
+    return unfetched, changed_deps
+
+
+def partial_view(
+    index: "Index", targets: "TargetType", **kwargs
+) -> "IndexView":
+    return index.targets_view(
+        targets,
+        stage_filter=lambda s: s.is_partial_import,
+        **kwargs,
+    )
+
+
+def unpartial_imports(index: Union["Index", "IndexView"]) -> int:
+    """Update any outs in the index which are no longer partial imports.
+
+    Returns:
+        Total number of files which were unpartialed.
+    """
+    updated = 0
+    for out in index.outs:
+        # we need to use view[key] here and since the out fields have not been
+        # updated yet (out.get_entry() would return the partial-import state)
+        workspace, key = out.index_key
+        entry = index.data[workspace][key]
+        if out.stage.is_partial_import:
+            if out.stage.is_repo_import:
+                dep = out.stage.deps[0]
+                out.hash_info = dep.get_obj().hash_info
+                out.meta = dep.get_meta()
+            else:
+                out.hash_info = entry.hash_info
+                out.meta = entry.meta
+            out.stage.dump()
+            updated += out.meta.nfiles if out.meta.nfiles is not None else 1
+    return updated
+
+
+def save_imports(
+    repo: "Repo", targets: "TargetType", unpartial: bool = False, **kwargs
+) -> Set["HashInfo"]:
+    """Save (download) imports from their original source location.
+
+    Imports which are already cached will not be downloaded.
+
+    Returns:
+        Objects which were downloaded from source location.
+    """
+    from dvc.stage.exceptions import DataSourceChanged
+    from dvc.utils.fs import makedirs
+    from dvc_data.index import checkout, md5, save
+    from dvc_objects.fs.callbacks import Callback
+
+    downloaded: Set["HashInfo"] = set()
+
+    unfetched, changed = unfetched_view(
+        repo.index, targets, unpartial=unpartial, **kwargs
+    )
+    for dep in changed:
+        logger.warning(str(DataSourceChanged(f"{dep.stage} ({dep})")))
+
+    data_view = unfetched.data["repo"]
+    if len(data_view):
+        cache = repo.odb.local
+        if not cache.fs.exists(cache.path):
+            makedirs(cache.path)
+        with TemporaryDirectory(dir=cache.path) as tmpdir:
+            with Callback.as_tqdm_callback(
+                desc="Downloading imports from source",
+                unit="files",
+            ) as cb:
+                checkout(data_view, tmpdir, cache.fs, callback=cb)
+            md5(data_view)
+            save(data_view, odb=cache, hardlink=True)
+
+        downloaded.update(
+            entry.hash_info
+            for _, entry in data_view.iteritems()
+            if not entry.meta.isdir and entry.hash_info is not None
+        )
+
+    if unpartial:
+        unpartial_imports(partial_view(repo.index, targets, **kwargs))
+
+    return downloaded

dvc/repo/index.py

@@ -1,14 +1,16 @@
 from contextlib import suppress
 from typing import (
     TYPE_CHECKING,
+    Any,
     Callable,
     Dict,
     Iterable,
     Iterator,
     List,
+    NamedTuple,
     Optional,
-    Sequence,
     Set,
+    Tuple,
 )
 
 from funcy import cached_property, nullcontext
@@ -22,11 +24,11 @@ if TYPE_CHECKING:
     from dvc.dependency import Dependency, ParamsDependency
     from dvc.fs import FileSystem
     from dvc.output import Output
-    from dvc.repo.stage import StageLoad
+    from dvc.repo.stage import StageInfo, StageLoad
     from dvc.stage import Stage
     from dvc.types import StrPath, TargetType
     from dvc_data.hashfile.hash_info import HashInfo
-    from dvc_data.index import DataIndex
+    from dvc_data.index import DataIndex, DataIndexKey, DataIndexView
     from dvc_objects.db import ObjectDB
 
 
@@ -64,6 +66,7 @@ class Index:
         self.stage_collector: "StageLoad" = repo.stage
         if stages is not None:
             self.stages: List["Stage"] = stages
+        self._collected_targets: Dict[int, List["StageInfo"]] = {}
 
     @cached_property
     def stages(self) -> List["Stage"]:  # pylint: disable=method-hidden
@@ -113,6 +116,72 @@ class Index:
 
         return self.filter(is_stage_inside_path)
 
+    @staticmethod
+    def _hash_targets(
+        targets: Iterable[Optional[str]],
+        **kwargs: Any,
+    ) -> int:
+        return hash(
+            (
+                frozenset(targets),
+                kwargs.get("with_deps", False),
+                kwargs.get("recursive", False),
+            )
+        )
+
+    def _collect_targets(
+        self, targets: Optional["TargetType"], **kwargs: Any
+    ) -> List["StageInfo"]:
+        from itertools import chain
+
+        from dvc.repo.stage import StageInfo
+        from dvc.utils.collections import ensure_list
+
+        targets = ensure_list(targets)
+        if not targets:
+            return [StageInfo(stage) for stage in self.stages]
+        targets_hash = self._hash_targets(targets, **kwargs)
+        if targets_hash not in self._collected_targets:
+            self._collected_targets[targets_hash] = list(
+                chain.from_iterable(
+                    self.stage_collector.collect_granular(target, **kwargs)
+                    for target in targets
+                )
+            )
+        return self._collected_targets[targets_hash]
+
+    def targets_view(
+        self,
+        targets: "TargetType",
+        stage_filter: Optional[Callable[["Stage"], bool]] = None,
+        outs_filter: Optional[Callable[["Output"], bool]] = None,
+        **kwargs: Any,
+    ) -> "IndexView":
+        """Return read-only view of index for the specified targets.
+
+        Args:
+            targets: Targets to collect
+            stage_filter: Optional stage filter to be applied after collecting
+                targets.
+            outs_filter: Optional output filter to be applied after collecting
+                targets.
+
+        Additional kwargs will be passed into the stage collector.
+
+        Note:
+            If both stage_filter and outs_filter are provided, stage_filter
+            will be applied first, and the resulting view will only contain
+            outputs from stages that matched stage_filter. Outputs from stages
+            that did not match will be excluded from the view (whether or not
+            the output would have matched outs_filter).
+        """
+        stage_infos = [
+            stage_info
+            for stage_info in self._collect_targets(targets, **kwargs)
+            if not stage_filter or stage_filter(stage_info.stage)
+        ]
+        return IndexView(self, stage_infos, outs_filter=outs_filter)
+
     @property
     def outs(self) -> Iterator["Output"]:
         for stage in self:
@@ -171,8 +240,7 @@ class Index:
     def data(self) -> "Dict[str, DataIndex]":
         from collections import defaultdict
 
-        from dvc.config import NoRemoteError
-        from dvc_data.index import DataIndex, DataIndexEntry
+        from dvc_data.index import DataIndex
 
         by_workspace: dict = defaultdict(DataIndex)
 
@@ -184,22 +252,11 @@ class Index:
                 continue
 
             workspace, key = out.index_key
-
-            try:
-                remote = self.repo.cloud.get_remote_odb(out.remote)
-            except NoRemoteError:
-                remote = None
-
             data_index = by_workspace[workspace]
 
-            data_index[key] = DataIndexEntry(
-                meta=out.meta,
-                obj=out.get_obj() if out.files else out.obj,
-                hash_info=out.hash_info,
-                odb=out.odb,
-                cache=out.odb,
-                remote=remote,
-            )
+            entry = out.get_entry()
+            entry.key = key
+            data_index.add(entry)
 
         return dict(by_workspace)
 
@@ -213,22 +270,11 @@ class Index:
         jobs: int = None,
     ) -> "ObjectContainer":
         from collections import defaultdict
-        from itertools import chain
-
-        from dvc.utils.collections import ensure_list
 
         used: "ObjectContainer" = defaultdict(set)
-        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=with_deps
-            )
-            for target in collect_targets
+        pairs = self._collect_targets(
+            targets, recursive=recursive, with_deps=with_deps
         )
-
         for stage, filter_info in pairs:
             for odb, objs in stage.get_used_objs(
                 remote=remote,
@@ -239,28 +285,6 @@ 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.
@@ -326,6 +350,105 @@ class Index:
         return dict_md5(self.dumpd())
 
 
+class _DataPrefixes(NamedTuple):
+    explicit: Set["DataIndexKey"]
+    recursive: Set["DataIndexKey"]
+
+
+class IndexView:
+    """Read-only view of Index.data using filtered stages."""
+
+    def __init__(  # pylint: disable=redefined-outer-name
+        self,
+        index: Index,
+        stage_infos: Iterable["StageInfo"],
+        outs_filter: Optional[Callable[["Output"], bool]],
+    ):
+        self._index = index
+        self._stage_infos = stage_infos
+        # NOTE: stage_infos might have the same stage multiple times but with
+        # different filter_info
+        self._stages = list({stage for stage, _ in stage_infos})
+        self._outs_filter = outs_filter
+
+    def __len__(self) -> int:
+        return len(self._stages)
+
+    def __contains__(self, stage: "Stage") -> bool:
+        # as we are keeping stages inside a list, it might be slower.
+        return stage in self._stages
+
+    def __iter__(self) -> Iterator["Stage"]:
+        yield from self._stages
+
+    def __getitem__(self, item: str) -> "Stage":
+        """Get a stage by its addressing attribute."""
+        for stage in self:
+            if stage.addressing == item:
+                return stage
+        raise KeyError(f"{item} - available stages are {self.stages}")
+
+    @property
+    def stages(self):
+        return self._stages
+
+    @property
+    def deps(self) -> Iterator["Dependency"]:
+        for stage in self:
+            yield from stage.deps
+
+    @property
+    def _filtered_outs(self) -> Iterator[Tuple["Output", Optional[str]]]:
+        for stage, filter_info in self._stage_infos:
+            for out in stage.filter_outs(filter_info):
+                if not self._outs_filter or self._outs_filter(out):
+                    yield out, filter_info
+
+    @property
+    def outs(self) -> Iterator["Output"]:
+        yield from {out for (out, _) in self._filtered_outs}
+
+    @cached_property
+    def _data_prefixes(self) -> Dict[str, "_DataPrefixes"]:
+        from collections import defaultdict
+
+        prefixes: Dict[str, "_DataPrefixes"] = defaultdict(
+            lambda: _DataPrefixes(set(), set())
+        )
+        for out, filter_info in self._filtered_outs:
+            workspace, key = out.index_key
+            if filter_info and out.fs.path.isin(filter_info, out.fs_path):
+                key = key + out.fs.path.relparts(filter_info, out.fs_path)
+            if out.meta.isdir:
+                prefixes[workspace].recursive.add(key)
+            prefixes[workspace].explicit.update(
+                key[:i] for i in range(len(key), 0, -1)
+            )
+        return prefixes
+
+    @cached_property
+    def data(self) -> "Dict[str, DataIndexView]":
+        from functools import partial
+
+        from dvc_data.index import view
+
+        def key_filter(workspace: str, key: "DataIndexKey"):
+            try:
+                prefixes = self._data_prefixes[workspace]
+                return key in prefixes.explicit or any(
+                    key[: len(prefix)] == prefix
+                    for prefix in prefixes.recursive
+                )
+            except KeyError:
+                return False
+
+        data = {}
+        for workspace, data_index in self._index.data.items():
+            data_index.load()
+            data[workspace] = view(data_index, partial(key_filter, workspace))
+        return data
+
+
 if __name__ == "__main__":
     import logging
 

dvc/repo/live.py

@@ -1,19 +0,0 @@
-import logging
-from typing import TYPE_CHECKING, Optional
-
-logger = logging.getLogger(__name__)
-
-if TYPE_CHECKING:
-    from dvc.output import Output
-
-
-def summary_fs_path(out: "Output") -> Optional[str]:
-    from dvc.output import Output
-
-    assert out.live
-    has_summary = True
-    if isinstance(out.live, dict):
-        has_summary = out.live.get(Output.PARAM_LIVE_SUMMARY, True)
-    if has_summary:
-        return out.fs.path.with_suffix(out.fs_path, ".json")
-    return None

dvc/repo/ls_url.py

@@ -0,0 +1,29 @@
+from dvc.exceptions import URLMissingError
+from dvc.fs import parse_external_url
+
+
+def ls_url(url, *, config=None, recursive=False):
+    fs, fs_path = parse_external_url(url, config=config)
+    try:
+        info = fs.info(fs_path)
+    except FileNotFoundError as exc:
+        raise URLMissingError(url) from exc
+    if info["type"] != "directory":
+        return [{"path": info["name"], "isdir": False}]
+
+    ret = []
+    for _, dirs, files in fs.walk(fs_path, detail=True):
+        if not recursive:
+            files.update(dirs)
+
+        for info in files.values():
+            ls_info = {
+                "path": fs.path.relpath(info["name"], fs_path),
+                "isdir": info["type"] == "directory",
+            }
+            ret.append(ls_info)
+
+        if not recursive:
+            break
+
+    return ret

dvc/repo/metrics/show.py

@@ -8,7 +8,6 @@ from dvc.fs.dvc import DVCFileSystem
 from dvc.output import Output
 from dvc.repo import locked
 from dvc.repo.collect import StrPaths, collect
-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
@@ -18,7 +17,7 @@ logger = logging.getLogger(__name__)
 
 
 def _is_metric(out: Output) -> bool:
-    return bool(out.metric) or bool(out.live)
+    return bool(out.metric)
 
 
 def _to_fs_paths(metrics: List[Output]) -> StrPaths:
@@ -26,10 +25,6 @@ def _to_fs_paths(metrics: List[Output]) -> StrPaths:
     for out in metrics:
         if out.metric:
             result.append(out.repo.dvcfs.from_os_path(out.fs_path))
-        elif out.live:
-            fs_path = summary_fs_path(out)
-            if fs_path:
-                result.append(out.repo.dvcfs.from_os_path(fs_path))
     return result
 
 

dvc/repo/plots/__init__.py

@@ -14,6 +14,7 @@ from typing import (
     List,
     Optional,
     Set,
+    Union,
 )
 
 import dpath.options
@@ -100,7 +101,7 @@ class Plots:
                             "filename":
                             {
                                 "data_source": callable loading the data,
-                                "props": propreties for the file if it is
+                                "props": properties for the file if it is
                                          plots type output
                             }
                         }
@@ -265,7 +266,7 @@ class Plots:
 
 
 def _is_plot(out: "Output") -> bool:
-    return bool(out.plot) or bool(out.live)
+    return bool(out.plot)
 
 
 def _resolve_data_sources(plots_data: Dict):
@@ -444,12 +445,22 @@ def _collect_pipeline_files(repo, targets: List[str], props, onerror=None):
         if isinstance(dvcfile, PipelineFile):
             dvcfile_path = _relpath(repo.dvcfs, dvcfile.path)
             dvcfile_defs = dvcfile.load().get("plots", {})
+            dvcfile_defs_dict: Dict[str, Union[Dict, None]] = {}
+            if isinstance(dvcfile_defs, list):
+                for elem in dvcfile_defs:
+                    if isinstance(elem, str):
+                        dvcfile_defs_dict[elem] = None
+                    else:
+                        k, v = list(elem.items())[0]
+                        dvcfile_defs_dict[k] = v
+            else:
+                dvcfile_defs_dict = dvcfile_defs
             resolved = _resolve_definitions(
                 repo.dvcfs,
                 targets,
                 props,
                 dvcfile_path,
-                dvcfile_defs,
+                dvcfile_defs_dict,
                 onerror=onerror,
             )
             dpath.util.merge(
@@ -542,7 +553,7 @@ def parse(fs, path, props=None, **kwargs):
         return _load_sv(path=path, fs=fs, delimiter="\t", header=header)
     if extension in LOADERS or extension in (".yml", ".yaml"):
         return LOADERS[extension](path=path, fs=fs)
-    if extension in (".jpeg", ".jpg", ".gif", ".png"):
+    if extension in (".jpeg", ".jpg", ".gif", ".png", ".svg"):
         with fs.open(path, "rb") as fd:
             return fd.read()
     raise PlotMetricTypeError(path)
@@ -551,7 +562,7 @@ def parse(fs, path, props=None, **kwargs):
 def _plot_props(out: "Output") -> Dict:
     from dvc.schema import PLOT_PROPS
 
-    if not (out.plot or out.live):
+    if not (out.plot):
         raise NotAPlotError(out)
     if isinstance(out.plot, list):
         raise DvcException("Multiple plots per data file not supported.")

dvc/repo/push.py

@@ -1,6 +1,6 @@
 from typing import TYPE_CHECKING, Optional
 
-from dvc.exceptions import FileTransferError, UploadError
+from dvc.exceptions import UploadError
 
 from ..utils import glob_targets
 from . import locked
@@ -10,14 +10,11 @@ if TYPE_CHECKING:
 
 
 def _push_worktree(repo, remote):
-    from dvc_data.hashfile.tree import tree_from_index
-    from dvc_data.index import build, checkout, collect
+    from dvc_data.index import checkout
+    from dvc_data.index.save import build_tree
 
     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)
+    checkout(index, remote.path, remote.fs)
 
     for stage in repo.index.stages:
         for out in stage.outs:
@@ -42,8 +39,7 @@ def _push_worktree(repo, remote):
                         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()
+                tree_meta, new_tree = build_tree(index, key)
                 out.obj = new_tree
                 out.hash_info = new_tree.hash_info
                 out.meta = tree_meta
@@ -106,18 +102,18 @@ def push(
             if not include_imports and dest_odb and dest_odb.read_only:
                 continue
             all_ids.update(obj_ids)
-        try:
-            pushed += self.cloud.push(all_ids, jobs, remote=remote, odb=odb)
-        except FileTransferError as exc:
-            raise UploadError(exc.amount)
+        result = self.cloud.push(all_ids, jobs, remote=remote, odb=odb)
+        if result.failed:
+            raise UploadError(len(result.failed))
+        pushed += len(result.transferred)
     else:
         for dest_odb, obj_ids in used.items():
             if dest_odb and dest_odb.read_only:
                 continue
-            try:
-                pushed += self.cloud.push(
-                    obj_ids, jobs, remote=remote, odb=odb or dest_odb
-                )
-            except FileTransferError as exc:
-                raise UploadError(exc.amount)
+            result = self.cloud.push(
+                obj_ids, jobs, remote=remote, odb=odb or dest_odb
+            )
+            if result.failed:
+                raise UploadError(len(result.failed))
+            pushed += len(result.transferred)
     return pushed

dvc/repo/reproduce.py

@@ -72,12 +72,6 @@ def _get_stage_files(stage: "Stage") -> typing.Iterator[str]:
     for out in stage.outs:
         if not out.use_scm_ignore and out.is_in_repo:
             yield out.fs_path
-        if out.live:
-            from dvc.repo.live import summary_fs_path
-
-            summary = summary_fs_path(out)
-            if summary:
-                yield summary
 
 
 def _track_stage(stage: "Stage") -> None:

dvc/repo/stage.py

@@ -225,10 +225,9 @@ class StageLoad:
         path, name = parse_target(target)
         return self.load_one(path=path, name=name)
 
-    @staticmethod
-    def _get_filepath(path: str = None, name: str = None) -> str:
+    def _get_filepath(self, path: str = None, name: str = None) -> str:
         if path:
-            return path
+            return self.repo.fs.path.realpath(path)
 
         path = PIPELINE_FILE
         logger.debug("Assuming '%s' to be a stage inside '%s'", name, path)

dvc/repo/status.py

@@ -14,7 +14,9 @@ def _joint_status(pairs):
     status_info = {}
 
     for stage, filter_info in pairs:
-        if stage.frozen and not stage.is_repo_import:
+        if stage.frozen and not (
+            stage.is_repo_import or stage.is_versioned_import
+        ):
             logger.warning(
                 "%s is frozen. Its dependencies are"
                 " not going to be shown in the status output.",

dvc/rwlock.py

@@ -1,4 +1,5 @@
 import json
+import logging
 import os
 from collections import defaultdict
 from contextlib import contextmanager
@@ -10,6 +11,9 @@ from .fs import localfs
 from .lock import make_lock
 from .utils import relpath
 
+logger = logging.getLogger(__name__)
+
+
 INFO_SCHEMA = {Required("pid"): int, Required("cmd"): str}
 
 SCHEMA = Schema(
@@ -19,6 +23,9 @@ SCHEMA = Schema(
     }
 )
 
+RWLOCK_FILE = "rwlock"
+RWLOCK_LOCK = "rwlock.lock"
+
 
 class RWLockFileCorruptedError(DvcException):
     def __init__(self, path):
@@ -35,10 +42,10 @@ class RWLockFileFormatError(DvcException):
 
 @contextmanager
 def _edit_rwlock(lock_dir, fs, hardlink):
-    path = fs.path.join(lock_dir, "rwlock")
+    path = fs.path.join(lock_dir, RWLOCK_FILE)
 
     rwlock_guard = make_lock(
-        fs.path.join(lock_dir, "rwlock.lock"),
+        fs.path.join(lock_dir, RWLOCK_LOCK),
         tmp_dir=lock_dir,
         hardlink_lock=hardlink,
     )

dvc/schema.py

@@ -67,13 +67,6 @@ PLOT_PROPS = {
 PLOT_PROPS_SCHEMA = {**OUT_PSTAGE_DETAILED_SCHEMA[str], **PLOT_PROPS}
 PLOT_PSTAGE_SCHEMA = {str: Any(PLOT_PROPS_SCHEMA, [PLOT_PROPS_SCHEMA])}
 
-LIVE_PROPS = {
-    Output.PARAM_LIVE_SUMMARY: bool,
-    Output.PARAM_LIVE_HTML: bool,
-}
-LIVE_PROPS_SCHEMA = {**PLOT_PROPS_SCHEMA, **LIVE_PROPS}
-LIVE_PSTAGE_SCHEMA = {str: LIVE_PROPS_SCHEMA}
-
 PARAM_PSTAGE_NON_DEFAULT_SCHEMA = {str: [str]}
 
 VARS_SCHEMA = [str, dict]
@@ -93,7 +86,6 @@ STAGE_DEFINITION = {
         Any(str, OUT_PSTAGE_DETAILED_SCHEMA)
     ],
     Optional(StageParams.PARAM_PLOTS): [Any(str, PLOT_PSTAGE_SCHEMA)],
-    Optional(StageParams.PARAM_LIVE): Any(str, LIVE_PSTAGE_SCHEMA),
 }
 
 
@@ -118,7 +110,7 @@ PLOT_DEFINITION = {
     Output.PARAM_PLOT_TITLE: str,
     Output.PARAM_PLOT_TEMPLATE: str,
 }
-PLOTS_SCHEMA = {str: Any(PLOT_DEFINITION, None)}
+SINGLE_PLOT_SCHEMA = {str: Any(PLOT_DEFINITION, None)}
 FOREACH_IN = {
     Required(FOREACH_KWD): Any(dict, list, str),
     Required(DO_KWD): STAGE_DEFINITION,
@@ -127,9 +119,9 @@ SINGLE_PIPELINE_STAGE_SCHEMA = {
     str: either_or(STAGE_DEFINITION, FOREACH_IN, [FOREACH_KWD, DO_KWD])
 }
 MULTI_STAGE_SCHEMA = {
+    PLOTS: Any(SINGLE_PLOT_SCHEMA, [Any(str, SINGLE_PLOT_SCHEMA)]),
     STAGES: SINGLE_PIPELINE_STAGE_SCHEMA,
     VARS_KWD: VARS_SCHEMA,
-    PLOTS: PLOTS_SCHEMA,
 }
 
 COMPILED_SINGLE_STAGE_SCHEMA = Schema(SINGLE_STAGE_SCHEMA)

dvc/stage/__init__.py

@@ -257,6 +257,10 @@ class Stage(params.StageParams):
 
         return isinstance(self.deps[0], RepoDependency)
 
+    @property
+    def is_versioned_import(self):
+        return self.is_import and self.deps[0].fs.version_aware
+
     @property
     def is_checkpoint(self):
         """
@@ -276,22 +280,7 @@ class Stage(params.StageParams):
 
     def _read_env(self, out, checkpoint_func=None) -> Env:
         env: Env = {}
-        if out.live:
-            from dvc.env import DVCLIVE_HTML, DVCLIVE_PATH, DVCLIVE_SUMMARY
-            from dvc.output import Output
-            from dvc.schema import LIVE_PROPS
-
-            env[DVCLIVE_PATH] = relpath(out.fs_path, self.wdir)
-            if isinstance(out.live, dict):
-                config = project(out.live, LIVE_PROPS)
-
-                env[DVCLIVE_SUMMARY] = str(
-                    int(config.get(Output.PARAM_LIVE_SUMMARY, True))
-                )
-                env[DVCLIVE_HTML] = str(
-                    int(config.get(Output.PARAM_LIVE_HTML, True))
-                )
-        elif out.checkpoint and checkpoint_func:
+        if out.checkpoint and checkpoint_func:
             from dvc.env import DVC_CHECKPOINT
 
             env.update({DVC_CHECKPOINT: "1"})
@@ -375,7 +364,7 @@ class Stage(params.StageParams):
     def remove_outs(self, ignore_remove=False, force=False):
         """Used mainly for `dvc remove --outs` and :func:`Stage.reproduce`."""
         for out in self.outs:
-            if (out.persist or out.checkpoint or out.live) and not force:
+            if (out.persist or out.checkpoint) and not force:
                 out.unprotect()
                 continue
 
@@ -568,6 +557,8 @@ class Stage(params.StageParams):
             if kwargs.get("checkpoint_func", None) or no_download:
                 allow_missing = True
             self.save(allow_missing=allow_missing)
+            if no_download:
+                self.ignore_outs()
             if not no_commit:
                 self.commit(allow_missing=allow_missing)
 
@@ -618,7 +609,9 @@ class Stage(params.StageParams):
     @rwlocked(read=["deps", "outs"])
     def status(self, check_updates=False, filter_info=None):
         ret = []
-        show_import = self.is_repo_import and check_updates
+        show_import = (
+            self.is_repo_import or self.is_versioned_import
+        ) and check_updates
 
         if not self.frozen or show_import:
             self._status_deps(ret)
@@ -681,7 +674,7 @@ 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:
+        if self.is_partial_import and not self.is_repo_import:
             return {}
 
         used_objs = defaultdict(set)
@@ -706,7 +699,7 @@ class Stage(params.StageParams):
                 "unable to auto-merge DVC files with deleted outputs"
             )
 
-    def merge(self, ancestor, other):
+    def merge(self, ancestor, other, allowed=None):
         assert other
 
         if not other.outs:
@@ -726,7 +719,7 @@ class Stage(params.StageParams):
         self._check_can_merge(self, ancestor_out)
         self._check_can_merge(other, ancestor_out)
 
-        self.outs[0].merge(ancestor_out, other.outs[0])
+        self.outs[0].merge(ancestor_out, other.outs[0], allowed=allowed)
 
     def dump(self, **kwargs):
         self.dvcfile.dump(self, **kwargs)
@@ -768,5 +761,5 @@ class PipelineStage(Stage):
     def _changed_stage_entry(self):
         return f"'cmd' of {self} has changed."
 
-    def merge(self, ancestor, other):
+    def merge(self, ancestor, other, allowed=None):
         raise NotImplementedError

dvc/stage/cache.py

@@ -9,7 +9,6 @@ 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.hashfile.transfer import _log_exceptions
 
 if TYPE_CHECKING:
     from dvc_objects.db import ObjectDB
@@ -222,7 +221,7 @@ class StageCache:
 
         from_fs = from_odb.fs
         to_fs = to_odb.fs
-        func = _log_exceptions(fs.generic.copy)
+        func = fs.generic.log_exceptions(fs.generic.copy)
         runs = from_fs.path.join(from_odb.path, "runs")
 
         http_odb = next(

dvc/stage/imports.py

@@ -56,7 +56,10 @@ def sync_import(
         stage.outs[0].checkout()
     else:
         stage.save_deps()
-        if not no_download:
+        if no_download:
+            if stage.is_repo_import:
+                stage.deps[0].update()
+        else:
             stage.deps[0].download(
                 stage.outs[0],
                 jobs=jobs,

dvc/stage/loader.py

@@ -73,6 +73,7 @@ class StageLoader(Mapping):
             item.hash_info = HashInfo(item.hash_name, hash_value)
             if item.hash_info and item.hash_info.isdir:
                 item.meta.isdir = True
+            item.files = get_in(checksums, [key, path, item.PARAM_FILES])
 
     @classmethod
     def load_stage(cls, dvcfile, name, stage_data, lock_data=None):
@@ -96,7 +97,6 @@ class StageLoader(Mapping):
                 stage.PARAM_OUTS,
                 stage.PARAM_METRICS,
                 stage.PARAM_PLOTS,
-                stage.PARAM_LIVE,
             ],
         )
         stage.outs = lcat(

dvc/stage/monitor.py

@@ -20,10 +20,6 @@ class CheckpointKilledError(StageCmdFailedError):
     pass
 
 
-class LiveKilledError(StageCmdFailedError):
-    pass
-
-
 @dataclass
 class MonitorTask:
     stage: "Stage"

dvc/stage/params.py

@@ -12,4 +12,3 @@ class StageParams:
     PARAM_METRICS = "metrics"
     PARAM_PLOTS = "plots"
     PARAM_DESC = "desc"
-    PARAM_LIVE = "live"