dvc: bump to 2.8.0

Co-authored-by: Zhenyu Gao <[email protected]>

.codecov.yml

@@ -3,7 +3,7 @@ coverage:
   status:
     project:
       default:
-        target: 85
+        target: 90
         threshold: 10%
     patch:
       default:

.github/CODEOWNERS

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

.github/workflows/benchmarks.yaml

@@ -0,0 +1,23 @@
+name: benchmarks
+on: [pull_request, workflow_dispatch]
+
+jobs:
+  bench:
+    name: run benchmarks
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ubuntu-18.04]
+    steps:
+      - name: Cancel Previous Runs
+        uses: styfle/[email protected]
+        with:
+          access_token: ${{ github.token }}
+      - uses: actions/setup-python@v2
+        with:
+            python-version: 3.7
+      - uses: iterative/dvc-bench@master
+        with:
+            pytest_options: "-k 'test_init or test_help'"
+

.github/workflows/packages.yaml

@@ -5,9 +5,10 @@ on:
     - master
   release:
     types: [released, prereleased]
+  workflow_dispatch:
 jobs:
   deb:
-    runs-on: ubuntu-16.04
+    runs-on: ubuntu-18.04
     steps:
     - uses: actions/[email protected]
     - name: Set up Python 3.8
@@ -36,7 +37,7 @@ jobs:
         asset_name: dvc_${{ github.event.release.tag_name }}_amd64.deb
         asset_content_type: binary/octet-stream
   rpm:
-    runs-on: ubuntu-16.04
+    runs-on: ubuntu-18.04
     steps:
     - uses: actions/[email protected]
     - name: Set up Python 3.8
@@ -125,7 +126,7 @@ jobs:
         asset_name: dvc-${{ github.event.release.tag_name }}.exe
         asset_content_type: binary/octet-stream
   pip:
-    runs-on: ubuntu-16.04
+    runs-on: ubuntu-18.04
     steps:
     - uses: actions/[email protected]
     - name: Set up Python 3.7

.github/workflows/tests.yaml

@@ -1,12 +1,8 @@
 name: Tests
 
 on:
-  pull_request:
-    branches:
-      - master
-  push:
-    branches:
-      - master
+  pull_request: {}
+  push: {}
   schedule:
     - cron: '5 1 * * *'  # every day at 01:05
 
@@ -17,8 +13,13 @@ env:
 
 jobs:
   lint:
+    timeout-minutes: 10
     runs-on: ubuntu-latest
     steps:
+    - name: Cancel Previous Runs
+      uses: styfle/[email protected]
+      with:
+        access_token: ${{ github.token }}
     - uses: actions/[email protected]
     - name: Set up Python 3.8
       uses: actions/[email protected]
@@ -27,7 +28,7 @@ jobs:
     - name: Install requirements
       run: |
         pip install wheel
-        pip install ".[all,tests]" Pygments collective.checkdocs pre-commit
+        pip install ".[all,tests,terraform]" Pygments collective.checkdocs pre-commit
     - name: install temporary dependencies
       run: |
         pip install git+https://github.com/isidentical/gdrivefs@service-account
@@ -36,20 +37,17 @@ jobs:
       run: python setup.py checkdocs
     - uses: pre-commit/[email protected]
   tests:
+    timeout-minutes: 45
     runs-on: ${{ matrix.os }}
     strategy:
       fail-fast: false
       matrix:
-        os: [ubuntu-18.04, windows-2019, macos-10.15]
-        pyv: ["3.6", "3.7", "3.8", "3.9"]
-# macos 11.0 workers take too long to start up
-#        include:
-#          - os: "macos-11.0"
-#            pyv: "3.9"
+        os: [ubuntu-20.04, windows-latest, macos-latest]
+        pyv: ["3.6", "3.7", "3.8", "3.9", "3.10"]
         exclude:
-          - os: macos-10.15
-            pyv: "3.9"
-
+          # no wheels for pygit2 yet
+          - os: windows-latest
+            pyv: "3.10"
     steps:
     - uses: actions/[email protected]
     - name: Set up Python
@@ -65,14 +63,14 @@ jobs:
       uses: actions/[email protected]
       with:
         path: ${{ steps.pip-cache-dir.outputs.dir }}
-        key: ${{ runner.os }}-pip-${{ hashFiles('setup.py') }}
+        key: ${{ runner.os }}-pip-${{ hashFiles('setup.cfg') }}
         restore-keys: |
           ${{ runner.os }}-pip-
     - name: install
       if: steps.cache.pip-cache-dir.cache-hit != 'true'
       run: |
-        pip install wheel
-        pip install -e ".[all,tests]"
+        pip install --upgrade pip setuptools wheel
+        pip install -e ".[all,tests,terraform]"
     - name: install temporary dependencies
       run: |
         pip install git+https://github.com/isidentical/gdrivefs@service-account
@@ -96,16 +94,20 @@ jobs:
       run: |
         echo "extra_test_args=--disable-gdrive" >> $GITHUB_ENV
     - name: run tests
+      timeout-minutes: 40
       env:
         GDRIVE_CREDENTIALS_DATA: ${{ secrets.GDRIVE_CREDENTIALS_DATA }}
         AWS_ACCESS_KEY_ID: ${{ secrets.AWS_ACCESS_KEY_ID }}
         AWS_SECRET_ACCESS_KEY: ${{ secrets.AWS_SECRET_ACCESS_KEY }}
+        OSS_ACCESS_KEY_ID: ${{ secrets.OSS_ACCESS_KEY_ID}}
+        OSS_ACCESS_KEY_SECRET: ${{ secrets.OSS_ACCESS_KEY_SECRET}}
+        OSS_ENDPOINT: ${{ secrets.OSS_ENDPOINT}}
       run: >-
         python -m tests -n=4
         --cov-report=xml --cov-report=term
         --all ${{ env.extra_test_args }}
     - name: upload coverage report
-      uses: codecov/codecov-action@v1.5.0
+      uses: codecov/codecov-action@v2.1.0
       with:
         file: ./coverage.xml
         fail_ci_if_error: false
@@ -117,7 +119,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
     - name: Slack Notification
-      uses: rtCamp/action-slack-notify@v2.1.3
+      uses: rtCamp/action-slack-notify@v2.2.0
       env:
         SLACK_WEBHOOK: ${{ secrets.SLACK_WEBHOOK }}
         SLACK_COLOR: ${{ job.status }}

.pre-commit-config.yaml

@@ -1,14 +1,24 @@
+ci:
+  skip: [pylint, dvc-pre-commit]
+
 repos:
   - hooks:
       - id: black
         language_version: python3
     repo: https://github.com/ambv/black
-    rev: 21.5b1
+    rev: 21.9b0
+  - hooks:
+      - id: codespell
+        args: 
+          - --ignore-words-list
+          - ba,datas,fo,uptodate
+    repo: https://github.com/codespell-project/codespell
+    rev: v2.1.0
   - hooks:
       - id: isort
         language_version: python3
     repo: https://github.com/timothycrosley/isort
-    rev: 5.8.0
+    rev: 5.9.3
   - hooks:
       - id: flake8
         language_version: python3
@@ -23,8 +33,13 @@ repos:
       -  id: mypy
          language_version: python3
          files: ^dvc/
+         additional_dependencies:
+           - types-requests
+           - types-paramiko
+           - types-tabulate
+           - types-toml
     repo: https://github.com/pre-commit/mirrors-mypy
-    rev: 'v0.812'
+    rev: 'v0.910'
   - repo: local
     hooks:
     - id: pylint

LICENSE

@@ -186,7 +186,7 @@
       same "printed page" as the copyright notice for easier
       identification within third-party archives.
 
-   Copyright {yyyy} {name of copyright owner}
+   Copyright 2017-2021 Iterative, Inc.
 
    Licensed under the Apache License, Version 2.0 (the "License");
    you may not use this file except in compliance with the License.

MANIFEST.in

@@ -1,3 +1,2 @@
 include fastentrypoints.py
 include LICENSE
-include test_requirements.txt

README.rst

@@ -8,7 +8,7 @@
 • `Tutorial <https://dvc.org/doc/get-started>`_
 • `Mailing List <https://sweedom.us10.list-manage.com/subscribe/post?u=a08bf93caae4063c4e6a351f6&id=24c0ecc49a>`_
 
-|Release| |CI| |Maintainability| |Coverage| |Donate| |DOI|
+|CI| |Maintainability| |Coverage| |Donate| |DOI|
 
 |PyPI| |Packages| |Brew| |Conda| |Choco| |Snap|
 
@@ -20,8 +20,9 @@ learning projects. Key features:
 #. Simple **command line** Git-like experience. Does not require installing and maintaining
    any databases. Does not depend on any proprietary online services.
 
-#. Management and versioning of **datasets** and **machine learning models**. Data is saved in
-   S3, Google cloud, Azure, Alibaba cloud, SSH server, HDFS, or even local HDD RAID.
+#. Management and versioning of **datasets** and **machine learning
+   models**. Data can be saved in S3, Google cloud, Azure, Alibaba 
+   cloud, SSH server, HDFS, or even local HDD RAID.
 
 #. Makes projects **reproducible** and **shareable**; helping to answer questions about how
    a model was built.
@@ -29,9 +30,9 @@ learning projects. Key features:
 #. Helps manage experiments with Git tags/branches and **metrics** tracking.
 
 **DVC** aims to replace spreadsheet and document sharing tools (such as Excel or Google Docs)
-which are being used frequently as both knowledge repositories and team ledgers.
-DVC also replaces both ad-hoc scripts to track, move, and deploy different model versions;
-as well as ad-hoc data file suffixes and prefixes.
+frequently used as both knowledge repositories and team ledgers.
+DVC also replaces both ad-hoc scripts to track, move, and deploy different model versions
+and ad-hoc data file suffixes and prefixes.
 
 .. contents:: **Contents**
   :backlinks: none
@@ -65,25 +66,25 @@ Quick start
 
 Please read `Get Started <https://dvc.org/doc/get-started>`_ guide for a full version. Common workflow commands include:
 
-+-----------------------------------+-------------------------------------------------------------------+
-| Step                              | Command                                                           |
-+===================================+===================================================================+
-| Track data                        | | ``$ git add train.py``                                          |
-|                                   | | ``$ dvc add images.zip``                                        |
-+-----------------------------------+-------------------------------------------------------------------+
-| Connect code and data by commands | | ``$ dvc run -d images.zip -o images/ unzip -q images.zip``      |
-|                                   | | ``$ dvc run -d images/ -d train.py -o model.p python train.py`` |
-+-----------------------------------+-------------------------------------------------------------------+
-| Make changes and reproduce        | | ``$ vi train.py``                                               |
-|                                   | | ``$ dvc repro model.p.dvc``                                     |
-+-----------------------------------+-------------------------------------------------------------------+
-| Share code                        | | ``$ git add .``                                                 |
-|                                   | | ``$ git commit -m 'The baseline model'``                        |
-|                                   | | ``$ git push``                                                  |
-+-----------------------------------+-------------------------------------------------------------------+
-| Share data and ML models          | | ``$ dvc remote add myremote -d s3://mybucket/image_cnn``        |
-|                                   | | ``$ dvc push``                                                  |
-+-----------------------------------+-------------------------------------------------------------------+
++-----------------------------------+----------------------------------------------------------------------------+
+| Step                              | Command                                                                    |
++===================================+============================================================================+
+| Track data                        | | ``$ git add train.py``                                                   |
+|                                   | | ``$ dvc add images.zip``                                                 |
++-----------------------------------+----------------------------------------------------------------------------+
+| Connect code and data by commands | | ``$ dvc run -n prepare -d images.zip -o images/ unzip -q images.zip``    |
+|                                   | | ``$ dvc run -n train -d images/ -d train.py -o model.p python train.py`` |
++-----------------------------------+----------------------------------------------------------------------------+
+| Make changes and reproduce        | | ``$ vi train.py``                                                        |
+|                                   | | ``$ dvc repro model.p.dvc``                                              |
++-----------------------------------+----------------------------------------------------------------------------+
+| Share code                        | | ``$ git add .``                                                          |
+|                                   | | ``$ git commit -m 'The baseline model'``                                 |
+|                                   | | ``$ git push``                                                           |
++-----------------------------------+----------------------------------------------------------------------------+
+| Share data and ML models          | | ``$ dvc remote add myremote -d s3://mybucket/image_cnn``                 |
+|                                   | | ``$ dvc push``                                                           |
++-----------------------------------+----------------------------------------------------------------------------+
 
 Installation
 ============
@@ -182,27 +183,38 @@ Fedora / CentOS (rpm)
 Comparison to related technologies
 ==================================
 
-#. *Data Engineering* tools such as `AirFlow <https://airflow.apache.org/>`_, `Luigi <https://github.com/spotify/luigi>`_ and
-   others - in DVC data, model and ML pipelines represent a single ML project and focuses on data scientist' experience while
-   data engineering pipeline orchestrates multiple data projects and focuses on efficent execution. DVC project can be used
-   from data pipeline as a single execution step. `AirFlow DVC <https://github.com/covid-genomics/airflow-dvc>`_ is an example
-   of such integration.
+#. Data Engineering tools such as `AirFlow <https://airflow.apache.org/>`,
+   `Luigi <https://github.com/spotify/luigi>`, and others - in DVC data,
+   model and ML pipelines represent a single ML project focused on data
+   scientists' experience.  Data engineering tools orchestrate multiple data
+   projects and focus on efficient execution. A DVC project can be used from
+   existing data pipelines as a single execution step.
 
 #. `Git-annex <https://git-annex.branchable.com/>`_ - DVC uses the idea of storing the content of large files (which should
    not be in a Git repository) in a local key-value store, and uses file hardlinks/symlinks instead of
    copying/duplicating files.
 
-#. `Git-LFS <https://git-lfs.github.com/>`_ - DVC is compatible with any remote storage (S3, Google Cloud, Azure, SSH,
-   etc). DVC also uses reflinks or hardlinks to avoid copy operations on checkouts; thus handling large data files
-   much more efficiently.
+#. `Git-LFS <https://git-lfs.github.com/>`_ - DVC is compatible with many
+   remote storage services (S3, Google Cloud, Azure, SSH, etc). DVC also
+   uses reflinks or hardlinks to avoid copy operations on checkouts; thus
+   handling large data files much more efficiently.
 
-#. *Makefile* (and analogues including ad-hoc scripts) - DVC tracks dependencies (in a directed acyclic graph).
+#. Makefile (and analogues including ad-hoc scripts) - DVC tracks
+   dependencies (in a directed acyclic graph).
 
 #. `Workflow Management Systems <https://en.wikipedia.org/wiki/Workflow_management_system>`_ - DVC is a workflow
    management system designed specifically to manage machine learning experiments. DVC is built on top of Git.
 
-#. `DAGsHub <https://dagshub.com/>`_ - online service of Git+DVC repositories with pipeline and metrics visualization and
-   DVC-specific cloud storage.
+#. `DAGsHub <https://dagshub.com/>`_ - online service to host DVC
+   projects.  It provides a useful UI around DVC repositories and integrates
+   other tools.
+
+#. `DVC Studio <https://studio.iterative.ai/>`_ - official online
+   platform for DVC projects.  It can be used to manage data and models, run
+   and track experiments, and visualize and share results.  Also, it
+   integrates with `CML (CI/CD for ML) <https://cml.dev/>` for training
+   models in the cloud or Kubernetes.
+
 
 Contributing
 ============
@@ -210,7 +222,9 @@ Contributing
 |Maintainability| |Donate|
 
 Contributions are welcome! Please see our `Contributing Guide <https://dvc.org/doc/user-guide/contributing/core>`_ for more
-details.
+details. Thanks to all our contributors!
+
+|Contribs|
 
 Mailing List
 ============
@@ -240,10 +254,6 @@ Barrak, A., Eghan, E.E. and Adams, B. `On the Co-evolution of ML Pipelines and S
    :target: https://dvc.org
    :alt: DVC logo
 
-.. |Release| image:: https://img.shields.io/badge/release-ok-brightgreen
-   :target: https://travis-ci.com/iterative/dvc/branches
-   :alt: Release
-
 .. |CI| image:: https://github.com/iterative/dvc/workflows/Tests/badge.svg?branch=master
    :target: https://github.com/iterative/dvc/actions
    :alt: GHA Tests
@@ -291,3 +301,7 @@ Barrak, A., Eghan, E.E. and Adams, B. `On the Co-evolution of ML Pipelines and S
 .. |Flowchart| image:: https://dvc.org/img/flow.gif
    :target: https://dvc.org/img/flow.gif
    :alt: how_dvc_works
+
+.. |Contribs| image:: https://contrib.rocks/image?repo=iterative/dvc
+   :target: https://github.com/iterative/dvc/graphs/contributors
+   :alt: Contributors

dvc/_debug.py

@@ -1,10 +1,39 @@
 from contextlib import ExitStack, contextmanager
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, Callable, Union
 
 if TYPE_CHECKING:
     from argparse import Namespace
 
 
+@contextmanager
+def yappi_profile(
+    path: Union[Callable[[], str], str] = None, wall_clock: bool = True
+):
+    try:
+        import yappi  # pylint: disable=import-error
+    except ImportError:
+        print("Failed to run profiler, yappi is not installed")
+        yield
+        return
+
+    yappi.set_clock_type("wall" if wall_clock else "cpu")
+
+    yappi.start()
+    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")
+    else:
+        yappi.get_func_stats().print_all()
+        yappi.get_thread_stats().print_all()
+
+    yappi.clear_stats()
+
+
 @contextmanager
 def instrument(html_output=False):
     """Run a statistical profiler"""
@@ -70,6 +99,13 @@ 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("yappi"):
+            from datetime import datetime
+
+            output = "callgrind.dvc-{0:%Y%m%d}_{0:%H%M%S}.out"
+            stack.enter_context(
+                yappi_profile(path=lambda: output.format(datetime.now()))
+            )
         yield
 
 
@@ -79,6 +115,9 @@ def add_debugging_flags(parser):
     parser.add_argument(
         "--cprofile", action="store_true", default=False, help=SUPPRESS
     )
+    parser.add_argument(
+        "--yappi", action="store_true", default=False, help=SUPPRESS
+    )
     parser.add_argument("--cprofile-dump", help=SUPPRESS)
     parser.add_argument(
         "--pdb", action="store_true", default=False, help=SUPPRESS

dvc/analytics.py

@@ -2,6 +2,8 @@ import json
 import logging
 import os
 
+from .env import DVC_NO_ANALYTICS
+
 logger = logging.getLogger(__name__)
 
 
@@ -32,7 +34,7 @@ def collect_and_send_report(args=None, return_code=None):
 
     with tempfile.NamedTemporaryFile(delete=False, mode="w") as fobj:
         json.dump(report, fobj)
-        daemon(["analytics", fobj.name])
+    daemon(["analytics", fobj.name])
 
 
 def is_enabled():
@@ -42,9 +44,12 @@ def is_enabled():
     if env2bool("DVC_TEST"):
         return False
 
-    enabled = to_bool(
-        Config(validate=False).get("core", {}).get("analytics", "true")
-    )
+    enabled = not os.getenv(DVC_NO_ANALYTICS)
+    if enabled:
+        enabled = to_bool(
+            Config(validate=False).get("core", {}).get("analytics", "true")
+        )
+
     logger.debug("Analytics is {}abled.".format("en" if enabled else "dis"))
 
     return enabled

dvc/cli.py

@@ -30,6 +30,7 @@ from .command import (
     install,
     live,
     ls,
+    machine,
     metrics,
     move,
     params,
@@ -87,6 +88,7 @@ COMMANDS = [
     experiments,
     check_ignore,
     live,
+    machine,
 ]
 
 

dvc/command/base.py

@@ -33,17 +33,12 @@ class CmdBase(ABC):
 
     def __init__(self, args):
         from dvc.repo import Repo
-        from dvc.updater import Updater
 
         os.chdir(args.cd)
 
         self.repo = Repo(uninitialized=self.UNINITIALIZED)
         self.config = self.repo.config
         self.args = args
-        if self.repo.tmp_dir:
-            hardlink_lock = self.config["core"].get("hardlink_lock", False)
-            updater = Updater(self.repo.tmp_dir, hardlink_lock=hardlink_lock)
-            updater.check()
 
     def do_run(self):
         with self.repo:

dvc/command/config.py

@@ -3,6 +3,7 @@ import logging
 import os
 
 from dvc.command.base import CmdBaseNoRepo, append_doc_link
+from dvc.ui import ui
 
 logger = logging.getLogger(__name__)
 
@@ -65,22 +66,23 @@ class CmdConfig(CmdBaseNoRepo):
             )
             return 1
 
-        levels = [self.args.level] if self.args.level else self.config.LEVELS
+        levels = self._get_appropriate_levels(self.args.level)
+
         for level in levels:
             conf = self.config.read(level)
             prefix = self._config_file_prefix(
                 self.args.show_origin, self.config, level
             )
-            logger.info("\n".join(self._format_config(conf, prefix)))
+            configs = list(self._format_config(conf, prefix))
+            if configs:
+                ui.write("\n".join(configs))
 
         return 0
 
     def _get(self, remote, section, opt):
         from dvc.config import ConfigError
 
-        levels = (
-            [self.args.level] if self.args.level else self.config.LEVELS[::-1]
-        )
+        levels = self._get_appropriate_levels(self.args.level)[::-1]
 
         for level in levels:
             conf = self.config.read(level)
@@ -96,7 +98,7 @@ class CmdConfig(CmdBaseNoRepo):
                 prefix = self._config_file_prefix(
                     self.args.show_origin, self.config, level
                 )
-                logger.info("{}{}".format(prefix, conf[section][opt]))
+                ui.write(prefix, conf[section][opt], sep="")
                 break
 
         return 0
@@ -133,6 +135,20 @@ class CmdConfig(CmdBaseNoRepo):
                 f"option '{opt}' doesn't exist in {name} '{section}'"
             )
 
+    def _get_appropriate_levels(self, levels):
+        if levels:
+            self._validate_level_for_non_repo_operation(levels)
+            return [levels]
+        if self.config.dvc_dir is None:
+            return self.config.SYSTEM_LEVELS
+        return self.config.LEVELS
+
+    def _validate_level_for_non_repo_operation(self, level):
+        from dvc.config import ConfigError
+
+        if self.config.dvc_dir is None and level in self.config.REPO_LEVELS:
+            raise ConfigError("Not inside a DVC repo")
+
     @staticmethod
     def _format_config(config, prefix=""):
         from dvc.utils.flatten import flatten

dvc/command/dag.py

@@ -36,18 +36,20 @@ def _collect_targets(repo, target, outs):
         return [stage.addressing for stage, _ in pairs]
 
     targets = []
+
+    outs_trie = repo.index.outs_trie
     for stage, info in pairs:
         if not info:
             targets.extend([str(out) for out in stage.outs])
             continue
 
-        for out in repo.outs_trie.itervalues(prefix=info.parts):  # noqa: B301
+        for out in outs_trie.itervalues(prefix=info.parts):  # noqa: B301
             targets.extend(str(out))
 
     return targets
 
 
-def _transform(repo, outs):
+def _transform(index, outs):
     import networkx as nx
 
     from dvc.stage import Stage
@@ -55,7 +57,7 @@ def _transform(repo, outs):
     def _relabel(node) -> str:
         return node.addressing if isinstance(node, Stage) else str(node)
 
-    G = repo.outs_graph if outs else repo.graph
+    G = index.outs_graph if outs else index.graph
     return nx.relabel_nodes(G, _relabel, copy=True)
 
 
@@ -85,7 +87,7 @@ def _filter(G, targets, full):
 
 def _build(repo, target=None, full=False, outs=False):
     targets = _collect_targets(repo, target, outs)
-    G = _transform(repo, outs)
+    G = _transform(repo.index, outs)
     return _filter(G, targets, full)
 
 
@@ -101,9 +103,8 @@ class CmdDAG(CmdBase):
         if self.args.dot:
             ui.write(_show_dot(G))
         else:
-            from dvc.utils.pager import pager
-
-            pager(_show_ascii(G))
+            with ui.pager():
+                ui.write(_show_ascii(G))
 
         return 0
 

dvc/command/data_sync.py

@@ -9,10 +9,11 @@ logger = logging.getLogger(__name__)
 
 class CmdDataBase(CmdBase):
     def log_summary(self, stats):
+        from dvc.ui import ui
         from dvc.utils.humanize import get_summary
 
         default_msg = "Everything is up to date."
-        logger.info(get_summary(stats.items()) or default_msg)
+        ui.write(get_summary(stats.items()) or default_msg)
 
 
 class CmdDataPull(CmdDataBase):
@@ -392,6 +393,7 @@ def add_parser(subparsers, _parent_parser):
         help="Show status of all stages in the specified directory.",
     )
     status_parser.add_argument(
+        "--json",
         "--show-json",
         action="store_true",
         default=False,

dvc/command/destroy.py

@@ -1,7 +1,6 @@
 import argparse
 import logging
 
-from dvc import prompt
 from dvc.command.base import CmdBase, append_doc_link
 
 logger = logging.getLogger(__name__)
@@ -10,6 +9,7 @@ logger = logging.getLogger(__name__)
 class CmdDestroy(CmdBase):
     def run(self):
         from dvc.exceptions import DvcException
+        from dvc.ui import ui
 
         try:
             statement = (
@@ -19,7 +19,7 @@ class CmdDestroy(CmdBase):
                 "Are you sure you want to continue?"
             )
 
-            if not self.args.force and not prompt.confirm(statement):
+            if not self.args.force and not ui.confirm(statement):
                 raise DvcException(
                     "cannot destroy without a confirmation from the user."
                     " Use `-f` to force."

dvc/command/diff.py

@@ -1,12 +1,10 @@
 import argparse
-import json
 import logging
 import os
 
-import colorama
-
 from dvc.command import completion
 from dvc.command.base import CmdBase, append_doc_link
+from dvc.ui import ui
 
 logger = logging.getLogger(__name__)
 
@@ -17,14 +15,13 @@ def _digest(checksum):
     return "{}..{}".format(checksum["old"][0:8], checksum["new"][0:8])
 
 
-def _show_md(diff, show_hash=False, hide_missing=False):
-    from dvc.ui import ui
-
+def _show_markdown(diff, show_hash=False, hide_missing=False):
     headers = ["Status", "Hash", "Path"] if show_hash else ["Status", "Path"]
     rows = []
     statuses = ["added", "deleted", "renamed", "modified"]
     if not hide_missing:
         statuses.append("not in cache")
+
     for status in statuses:
         entries = diff.get(status, [])
         if not entries:
@@ -44,7 +41,7 @@ def _show_md(diff, show_hash=False, hide_missing=False):
 
 class CmdDiff(CmdBase):
     @staticmethod
-    def _format(diff, hide_missing=False):
+    def _show_diff(diff, hide_missing=False):
         """
         Given a diff structure, generate a string of paths separated
         by new lines and grouped together by their state.
@@ -71,15 +68,14 @@ class CmdDiff(CmdBase):
         """
 
         colors = {
-            "added": colorama.Fore.GREEN,
-            "modified": colorama.Fore.YELLOW,
-            "deleted": colorama.Fore.RED,
-            "renamed": colorama.Fore.GREEN,
-            "not in cache": colorama.Fore.YELLOW,
+            "added": "green",
+            "modified": "yellow",
+            "deleted": "red",
+            "renamed": "green",
+            "not in cache": "yellow",
         }
 
         summary = {}
-        groups = []
 
         states = ["added", "deleted", "renamed", "modified"]
         if not hide_missing:
@@ -91,7 +87,8 @@ class CmdDiff(CmdBase):
             if not entries:
                 continue
 
-            content = []
+            header = state.capitalize()
+            ui.write(f"[{colors[state]}]{header}[/]:", styled=True)
 
             for entry in entries:
                 path = entry["path"]
@@ -99,7 +96,7 @@ class CmdDiff(CmdBase):
                     path = f"{path['old']} -> {path['new']}"
                 checksum = entry.get("hash")
                 summary[state] += 1 if not path.endswith(os.sep) else 0
-                content.append(
+                ui.write(
                     "{space}{checksum}{separator}{path}".format(
                         space="    ",
                         checksum=_digest(checksum) if checksum else "",
@@ -108,27 +105,17 @@ class CmdDiff(CmdBase):
                     )
                 )
 
-            groups.append(
-                "{color}{header}{nc}:\n{content}".format(
-                    color=colors[state],
-                    header=state.capitalize(),
-                    nc=colorama.Fore.RESET,
-                    content="\n".join(content),
-                )
-            )
+            ui.write()
 
         if not sum(summary.values()):
             return None
 
-        fmt = (
-            "files summary: {added} added, {deleted} deleted,"
-            " {renamed} renamed, {modified} modified"
+        states_summary = ", ".join(
+            f"{summary[state]} {state}"
+            for state in states
+            if summary[state] > 0
         )
-        if not hide_missing:
-            fmt += ", {not in cache} not in cache"
-        groups.append(fmt.format_map(summary))
-
-        return "\n\n".join(groups)
+        ui.write("files summary:", states_summary)
 
     def run(self):
         from dvc.exceptions import DvcException
@@ -154,14 +141,12 @@ class CmdDiff(CmdBase):
                         del entry["hash"]
                 diff[key] = entries
 
-            if self.args.show_json:
-                logger.info(json.dumps(diff))
-            elif self.args.show_md:
-                logger.info(_show_md(diff, show_hash, hide_missing))
+            if self.args.json:
+                ui.write_json(diff)
+            elif self.args.markdown:
+                _show_markdown(diff, show_hash, hide_missing)
             elif diff:
-                output = self._format(diff, hide_missing)
-                if output:
-                    logger.info(output)
+                self._show_diff(diff, hide_missing)
 
         except DvcException:
             logger.exception("failed to get diff")
@@ -202,6 +187,7 @@ def add_parser(subparsers, parent_parser):
         nargs="?",
     )
     diff_parser.add_argument(
+        "--json",
         "--show-json",
         help="Format the output into a JSON",
         action="store_true",
@@ -214,9 +200,11 @@ def add_parser(subparsers, parent_parser):
         default=False,
     )
     diff_parser.add_argument(
+        "--md",
         "--show-md",
         help="Show tabulated output in the Markdown format (GFM).",
         action="store_true",
+        dest="markdown",
         default=False,
     )
     diff_parser.add_argument(

dvc/command/experiments.py

@@ -5,21 +5,21 @@ from datetime import date, datetime
 from fnmatch import fnmatch
 from typing import TYPE_CHECKING, Dict, Iterable, Optional
 
-from funcy import lmap
+from funcy import compact, lmap
 
-from dvc import prompt
 from dvc.command import completion
 from dvc.command.base import CmdBase, append_doc_link, fix_subparsers
 from dvc.command.metrics import DEFAULT_PRECISION
 from dvc.command.repro import CmdRepro
 from dvc.command.repro import add_arguments as add_repro_arguments
 from dvc.exceptions import DvcException, InvalidArgumentError
+from dvc.ui import ui
 from dvc.utils.flatten import flatten
+from dvc.utils.serialize import encode_exception
 
 if TYPE_CHECKING:
-    from rich.text import Text
-
     from dvc.compare import TabularData
+    from dvc.ui import RichText
 
 
 logger = logging.getLogger(__name__)
@@ -27,6 +27,7 @@ logger = logging.getLogger(__name__)
 
 SHOW_MAX_WIDTH = 1024
 FILL_VALUE = "-"
+FILL_VALUE_ERRORED = "!"
 
 
 def _filter_name(names, label, filter_strs):
@@ -89,6 +90,7 @@ def _filter_names(
 
 def _update_names(names, items):
     for name, item in items:
+        item = item.get("data", {})
         if isinstance(item, dict):
             item = flatten(item)
             names[name].update({key: None for key in item})
@@ -99,7 +101,8 @@ def _collect_names(all_experiments, **kwargs):
     param_names = defaultdict(dict)
 
     for _, experiments in all_experiments.items():
-        for exp in experiments.values():
+        for exp_data in experiments.values():
+            exp = exp_data.get("data", {})
             _update_names(metric_names, exp.get("metrics", {}).items())
             _update_names(param_names, exp.get("params", {}).items())
     metric_names = _filter_names(
@@ -136,6 +139,8 @@ def _collect_rows(
     precision=DEFAULT_PRECISION,
     sort_by=None,
     sort_order=None,
+    fill_value=FILL_VALUE,
+    iso=False,
 ):
     from dvc.scm.git import Git
 
@@ -149,8 +154,15 @@ def _collect_rows(
         )
 
     new_checkpoint = True
-    for i, (rev, exp) in enumerate(experiments.items()):
-        queued = str(exp.get("queued") or "")
+    for i, (rev, results) in enumerate(experiments.items()):
+        exp = results.get("data", {})
+        if exp.get("running"):
+            state = "Running"
+        elif exp.get("queued"):
+            state = "Queued"
+        else:
+            state = fill_value
+        executor = exp.get("executor", fill_value)
         is_baseline = rev == "baseline"
 
         if is_baseline:
@@ -162,7 +174,7 @@ def _collect_rows(
         tip = exp.get("checkpoint_tip")
 
         parent_rev = exp.get("checkpoint_parent", "")
-        parent_exp = experiments.get(parent_rev, {})
+        parent_exp = experiments.get(parent_rev, {}).get("data", {})
         parent_tip = parent_exp.get("checkpoint_tip")
 
         parent = ""
@@ -189,15 +201,27 @@ def _collect_rows(
         row = [
             exp_name,
             name_rev,
-            queued,
             typ,
-            _format_time(exp.get("timestamp")),
+            _format_time(exp.get("timestamp"), fill_value, iso),
             parent,
+            state,
+            executor,
         ]
+        fill_value = FILL_VALUE_ERRORED if results.get("error") else fill_value
         _extend_row(
-            row, metric_names, exp.get("metrics", {}).items(), precision
+            row,
+            metric_names,
+            exp.get("metrics", {}).items(),
+            precision,
+            fill_value=fill_value,
+        )
+        _extend_row(
+            row,
+            param_names,
+            exp.get("params", {}).items(),
+            precision,
+            fill_value=fill_value,
         )
-        _extend_row(row, param_names, exp.get("params", {}).items(), precision)
 
         yield row
 
@@ -234,11 +258,12 @@ def _sort_column(sort_by, metric_names, param_names):
 def _sort_exp(experiments, sort_path, sort_name, typ, reverse):
     def _sort(item):
         rev, exp = item
-        tip = exp.get("checkpoint_tip")
+        exp_data = exp.get("data", {})
+        tip = exp_data.get("checkpoint_tip")
         if tip and tip != rev:
             # Sort checkpoint experiments by tip commit
             return _sort((tip, experiments[tip]))
-        data = exp.get(typ, {}).get(sort_path, {})
+        data = exp_data.get(typ, {}).get(sort_path, {}).get("data", {})
         val = flatten(data).get(sort_name)
         return val is None, val
 
@@ -250,33 +275,39 @@ def _sort_exp(experiments, sort_path, sort_name, typ, reverse):
     return ret
 
 
-def _format_time(timestamp):
-    if timestamp is None:
-        return FILL_VALUE
-    if timestamp.date() == date.today():
+def _format_time(datetime_obj, fill_value=FILL_VALUE, iso=False):
+    if datetime_obj is None:
+        return fill_value
+
+    if iso:
+        return datetime_obj.isoformat()
+
+    if datetime_obj.date() == date.today():
         fmt = "%I:%M %p"
     else:
         fmt = "%b %d, %Y"
-    return timestamp.strftime(fmt)
+    return datetime_obj.strftime(fmt)
 
 
-def _extend_row(row, names, items, precision):
-    from rich.text import Text
-
+def _extend_row(row, names, items, precision, fill_value=FILL_VALUE):
     from dvc.compare import _format_field, with_value
 
     if not items:
-        row.extend(FILL_VALUE for keys in names.values() for _ in keys)
+        row.extend(fill_value for keys in names.values() for _ in keys)
         return
 
-    for fname, item in items:
+    for fname, data in items:
+        item = data.get("data", {})
         item = flatten(item) if isinstance(item, dict) else {fname: item}
         for name in names[fname]:
-            value = with_value(item.get(name), FILL_VALUE)
-            # wrap field data in rich.Text, otherwise rich may
+            value = with_value(
+                item.get(name),
+                FILL_VALUE_ERRORED if data.get("error", None) else fill_value,
+            )
+            # wrap field data in ui.rich_text, otherwise rich may
             # interpret unescaped braces from list/dict types as rich
             # markup tags
-            row.append(Text(str(_format_field(value, precision))))
+            row.append(ui.rich_text(str(_format_field(value, precision))))
 
 
 def _parse_filter_list(param_list):
@@ -292,6 +323,7 @@ def _parse_filter_list(param_list):
 
 def experiments_table(
     all_experiments,
+    headers,
     metric_headers,
     metric_names,
     param_headers,
@@ -299,14 +331,15 @@ def experiments_table(
     sort_by=None,
     sort_order=None,
     precision=DEFAULT_PRECISION,
+    fill_value=FILL_VALUE,
+    iso=False,
 ) -> "TabularData":
     from funcy import lconcat
 
     from dvc.compare import TabularData
 
-    headers = ["Experiment", "rev", "queued", "typ", "Created", "parent"]
     td = TabularData(
-        lconcat(headers, metric_headers, param_headers), fill_value=FILL_VALUE
+        lconcat(headers, metric_headers, param_headers), fill_value=fill_value
     )
     for base_rev, experiments in all_experiments.items():
         rows = _collect_rows(
@@ -317,32 +350,31 @@ def experiments_table(
             sort_by=sort_by,
             sort_order=sort_order,
             precision=precision,
+            fill_value=fill_value,
+            iso=iso,
         )
         td.extend(rows)
 
     return td
 
 
-def prepare_exp_id(kwargs) -> "Text":
-    from rich.text import Text
-
+def prepare_exp_id(kwargs) -> "RichText":
     exp_name = kwargs["Experiment"]
     rev = kwargs["rev"]
     typ = kwargs.get("typ", "baseline")
 
     if typ == "baseline" or not exp_name:
-        text = Text(exp_name or rev)
+        text = ui.rich_text(exp_name or rev)
     else:
-        text = Text.assemble(rev, " [", (exp_name, "bold"), "]")
+        text = ui.rich_text.assemble(rev, " [", (exp_name, "bold"), "]")
 
     parent = kwargs.get("parent")
     suff = f" ({parent})" if parent else ""
     text.append(suff)
 
     tree = experiment_types[typ]
-    queued = "*" if kwargs.get("queued") else ""
-    pref = (f"{tree} " if tree else "") + queued
-    return Text(pref) + text
+    pref = f"{tree} " if tree else ""
+    return ui.rich_text(pref) + text
 
 
 def baseline_styler(typ):
@@ -350,8 +382,10 @@ def baseline_styler(typ):
 
 
 def show_experiments(
-    all_experiments, pager=True, no_timestamp=False, **kwargs
+    all_experiments, pager=True, no_timestamp=False, csv=False, **kwargs
 ):
+    from funcy.seqs import flatten as flatten_list
+
     include_metrics = _parse_filter_list(kwargs.pop("include_metrics", []))
     exclude_metrics = _parse_filter_list(kwargs.pop("exclude_metrics", []))
     include_params = _parse_filter_list(kwargs.pop("include_params", []))
@@ -364,11 +398,26 @@ def show_experiments(
         include_params=include_params,
         exclude_params=exclude_params,
     )
-    metric_headers = _normalize_headers(metric_names)
-    param_headers = _normalize_headers(param_names)
+
+    headers = [
+        "Experiment",
+        "rev",
+        "typ",
+        "Created",
+        "parent",
+        "State",
+        "Executor",
+    ]
+
+    names = {**metric_names, **param_names}
+    counter = Counter(flatten_list([list(a.keys()) for a in names.values()]))
+    counter.update(headers)
+    metric_headers = _normalize_headers(metric_names, counter)
+    param_headers = _normalize_headers(param_names, counter)
 
     td = experiments_table(
         all_experiments,
+        headers,
         metric_headers,
         metric_names,
         param_headers,
@@ -376,27 +425,38 @@ def show_experiments(
         kwargs.get("sort_by"),
         kwargs.get("sort_order"),
         kwargs.get("precision"),
+        kwargs.get("fill_value"),
+        kwargs.get("iso"),
     )
 
     if no_timestamp:
         td.drop("Created")
 
+    for col in ("State", "Executor"):
+        if td.is_empty(col):
+            td.drop(col)
+
     row_styles = lmap(baseline_styler, td.column("typ"))
 
-    merge_headers = ["Experiment", "rev", "queued", "typ", "parent"]
-    td.column("Experiment")[:] = map(prepare_exp_id, td.as_dict(merge_headers))
-    td.drop(*merge_headers[1:])
+    if not csv:
+        merge_headers = ["Experiment", "rev", "typ", "parent"]
+        td.column("Experiment")[:] = map(
+            prepare_exp_id, td.as_dict(merge_headers)
+        )
+        td.drop(*merge_headers[1:])
 
     headers = {"metrics": metric_headers, "params": param_headers}
     styles = {
         "Experiment": {"no_wrap": True, "header_style": "black on grey93"},
         "Created": {"header_style": "black on grey93"},
+        "State": {"header_style": "black on grey93"},
+        "Executor": {"header_style": "black on grey93"},
     }
     header_bg_colors = {"metrics": "cornsilk1", "params": "light_cyan1"}
     styles.update(
         {
             header: {
-                "justify": "left" if typ == "metrics" else "params",
+                "justify": "right" if typ == "metrics" else "left",
                 "header_style": f"black on {header_bg_colors[typ]}",
                 "collapse": idx != 0,
                 "no_wrap": typ == "metrics",
@@ -412,13 +472,11 @@ def show_experiments(
         rich_table=True,
         header_styles=styles,
         row_styles=row_styles,
+        csv=csv,
     )
 
 
-def _normalize_headers(names):
-    count = Counter(
-        name for path in names for name in names[path] for path in names
-    )
+def _normalize_headers(names, count):
     return [
         name if count[name] == 1 else f"{path}:{name}"
         for path in names
@@ -429,7 +487,7 @@ def _normalize_headers(names):
 def _format_json(item):
     if isinstance(item, (date, datetime)):
         return item.isoformat()
-    raise TypeError
+    return encode_exception(item)
 
 
 class CmdExperimentsShow(CmdBase):
@@ -447,11 +505,17 @@ class CmdExperimentsShow(CmdBase):
             logger.exception("failed to show experiments")
             return 1
 
-        if self.args.show_json:
-            import json
-
-            logger.info(json.dumps(all_experiments, default=_format_json))
+        if self.args.json:
+            ui.write_json(all_experiments, default=_format_json)
         else:
+            precision = (
+                self.args.precision or None
+                if self.args.csv
+                else DEFAULT_PRECISION
+            )
+            fill_value = "" if self.args.csv else FILL_VALUE
+            iso = True if self.args.csv else False
+
             show_experiments(
                 all_experiments,
                 include_metrics=self.args.include_metrics,
@@ -461,8 +525,11 @@ class CmdExperimentsShow(CmdBase):
                 no_timestamp=self.args.no_timestamp,
                 sort_by=self.args.sort_by,
                 sort_order=self.args.sort_order,
-                precision=self.args.precision or DEFAULT_PRECISION,
+                precision=precision,
+                fill_value=fill_value,
+                iso=iso,
                 pager=not self.args.no_pager,
+                csv=self.args.csv,
             )
         return 0
 
@@ -491,10 +558,8 @@ class CmdExperimentsDiff(CmdBase):
             logger.exception("failed to show experiments diff")
             return 1
 
-        if self.args.show_json:
-            import json
-
-            logger.info(json.dumps(diff))
+        if self.args.json:
+            ui.write_json(diff)
         else:
             from dvc.compare import show_diff
 
@@ -502,8 +567,6 @@ class CmdExperimentsDiff(CmdBase):
             diffs = [("metrics", "Metric"), ("params", "Param")]
             for idx, (key, title) in enumerate(diffs):
                 if idx:
-                    from dvc.ui import ui
-
                     # we are printing tables even in `--quiet` mode
                     # so we should also be printing the "table" separator
                     ui.write(force=True)
@@ -511,7 +574,7 @@ class CmdExperimentsDiff(CmdBase):
                 show_diff(
                     diff[key],
                     title=title,
-                    markdown=self.args.show_md,
+                    markdown=self.args.markdown,
                     no_path=self.args.no_path,
                     old=self.args.old,
                     on_empty_diff="diff not supported",
@@ -537,7 +600,7 @@ class CmdExperimentsRun(CmdRepro):
                 )
 
         if self.args.reset:
-            logger.info("Any existing checkpoints will be reset and re-run.")
+            ui.write("Any existing checkpoints will be reset and re-run.")
 
         results = self.repo.experiments.run(
             name=self.args.name,
@@ -554,7 +617,7 @@ class CmdExperimentsRun(CmdRepro):
         if self.args.metrics and results:
             metrics = self.repo.metrics.show(revs=list(results))
             metrics.pop("workspace", None)
-            logger.info(show_metrics(metrics))
+            show_metrics(metrics)
 
         return 0
 
@@ -590,13 +653,13 @@ class CmdExperimentsGC(CmdRepro):
         msg += " of the current repo."
         if self.args.queued:
             msg += " Run queued experiments will be preserved."
-        if self.args.queued:
+        else:
             msg += " Run queued experiments will be removed."
 
         logger.warning(msg)
 
         msg = "Are you sure you want to proceed?"
-        if not self.args.force and not prompt.confirm(msg):
+        if not self.args.force and not ui.confirm(msg):
             return 1
 
         removed = self.repo.experiments.gc(
@@ -608,12 +671,13 @@ class CmdExperimentsGC(CmdRepro):
         )
 
         if removed:
-            logger.info(
-                f"Removed {removed} experiments. To remove unused cache files "
-                "use 'dvc gc'."
+            ui.write(
+                f"Removed {removed} experiments.",
+                "To remove unused cache files",
+                "use 'dvc gc'.",
             )
         else:
-            logger.info("No experiments to remove.")
+            ui.write("No experiments to remove.")
         return 0
 
 
@@ -662,15 +726,15 @@ class CmdExperimentsPush(CmdBase):
             run_cache=self.args.run_cache,
         )
 
-        logger.info(
-            "Pushed experiment '%s' to Git remote '%s'.",
-            self.args.experiment,
-            self.args.git_remote,
+        ui.write(
+            f"Pushed experiment '{self.args.experiment}'"
+            f"to Git remote '{self.args.git_remote}'."
         )
         if not self.args.push_cache:
-            logger.info(
-                "To push cached outputs for this experiment to DVC remote "
-                "storage, re-run this command without '--no-cache'."
+            ui.write(
+                "To push cached outputs",
+                "for this experiment to DVC remote storage,"
+                "re-run this command without '--no-cache'.",
             )
 
         return 0
@@ -689,15 +753,15 @@ class CmdExperimentsPull(CmdBase):
             run_cache=self.args.run_cache,
         )
 
-        logger.info(
-            "Pulled experiment '%s' from Git remote '%s'. ",
-            self.args.experiment,
-            self.args.git_remote,
+        ui.write(
+            f"Pulled experiment '{self.args.experiment}'",
+            f"from Git remote '{self.args.git_remote}'.",
         )
         if not self.args.pull_cache:
-            logger.info(
-                "To pull cached outputs for this experiment from DVC remote "
-                "storage, re-run this command without '--no-cache'."
+            ui.write(
+                "To pull cached outputs for this experiment"
+                "from DVC remote storage,"
+                "re-run this command without '--no-cache'."
             )
 
         return 0
@@ -707,12 +771,86 @@ class CmdExperimentsRemove(CmdBase):
     def run(self):
 
         self.repo.experiments.remove(
-            exp_names=self.args.experiment, queue=self.args.queue
+            exp_names=self.args.experiment,
+            queue=self.args.queue,
+            clear_all=self.args.all,
+            remote=self.args.git_remote,
         )
 
         return 0
 
 
+class CmdExperimentsInit(CmdBase):
+    CODE = "src"
+    DATA = "data"
+    MODELS = "models"
+    DEFAULT_METRICS = "metrics.json"
+    DEFAULT_PARAMS = "params.yaml"
+    PLOTS = "plots"
+    DVCLIVE = "dvclive"
+    DEFAULTS = {
+        "code": CODE,
+        "data": DATA,
+        "models": MODELS,
+        "metrics": DEFAULT_METRICS,
+        "params": DEFAULT_PARAMS,
+        "plots": PLOTS,
+        "live": DVCLIVE,
+    }
+
+    def run(self):
+        from dvc.command.stage import parse_cmd
+
+        cmd = parse_cmd(self.args.cmd)
+        if not self.args.interactive and not cmd:
+            raise InvalidArgumentError("command is not specified")
+
+        from dvc.repo.experiments.init import init
+
+        defaults = {}
+        if not self.args.explicit:
+            config = self.repo.config["exp"]
+            defaults.update({**self.DEFAULTS, **config})
+
+        cli_args = compact(
+            {
+                "cmd": cmd,
+                "code": self.args.code,
+                "data": self.args.data,
+                "models": self.args.models,
+                "metrics": self.args.metrics,
+                "params": self.args.params,
+                "plots": self.args.plots,
+                "live": self.args.live,
+            }
+        )
+
+        initialized_stage = init(
+            self.repo,
+            name=self.args.name,
+            type=self.args.type,
+            defaults=defaults,
+            overrides=cli_args,
+            interactive=self.args.interactive,
+            force=self.args.force,
+        )
+        if self.args.run:
+            return self.repo.experiments.run(
+                targets=[initialized_stage.addressing]
+            )
+        return 0
+
+
+class RawDefaultsHelpFormatter(
+    argparse.RawDescriptionHelpFormatter,
+    argparse.ArgumentDefaultsHelpFormatter,
+):
+    def _get_help_string(self, action: argparse.Action) -> Optional[str]:
+        if action.default:
+            return super()._get_help_string(action)
+        return action.help
+
+
 def add_parser(subparsers, parent_parser):
     EXPERIMENTS_HELP = "Commands to run and compare experiments."
 
@@ -835,11 +973,19 @@ def add_parser(subparsers, parent_parser):
         help="Always show git commit SHAs instead of branch/tag names.",
     )
     experiments_show_parser.add_argument(
+        "--json",
         "--show-json",
         action="store_true",
         default=False,
         help="Print output in JSON format instead of a human-readable table.",
     )
+    experiments_show_parser.add_argument(
+        "--csv",
+        "--show-csv",
+        action="store_true",
+        default=False,
+        help="Print output in csv format instead of a human-readable table.",
+    )
     experiments_show_parser.add_argument(
         "--precision",
         type=int,
@@ -903,15 +1049,18 @@ def add_parser(subparsers, parent_parser):
         help="Show only params that are stage dependencies.",
     )
     experiments_diff_parser.add_argument(
+        "--json",
         "--show-json",
         action="store_true",
         default=False,
         help="Show output in JSON format.",
     )
     experiments_diff_parser.add_argument(
+        "--md",
         "--show-md",
         action="store_true",
         default=False,
+        dest="markdown",
         help="Show tabulated output in the Markdown format (GFM).",
     )
     experiments_diff_parser.add_argument(
@@ -937,9 +1086,7 @@ def add_parser(subparsers, parent_parser):
     )
     experiments_diff_parser.set_defaults(func=CmdExperimentsDiff)
 
-    EXPERIMENTS_RUN_HELP = (
-        "Reproduce complete or partial experiment pipelines."
-    )
+    EXPERIMENTS_RUN_HELP = "Run or resume an experiment."
     experiments_run_parser = experiments_subparsers.add_parser(
         "run",
         parents=[parent_parser],
@@ -1071,9 +1218,9 @@ def add_parser(subparsers, parent_parser):
         nargs="?",
         default=None,
         help=(
-            "Optional Git remote name or Git URL. If provided, experiments "
-            "from the specified Git repository will be listed instead of "
-            "local experiments."
+            "Optional Git remote name or Git URL. "
+            "If provided, experiments from the specified Git repository "
+            " will be listed instead of local ones."
         ),
         metavar="[<git_remote>]",
     )
@@ -1191,7 +1338,7 @@ def add_parser(subparsers, parent_parser):
     )
     experiments_pull_parser.set_defaults(func=CmdExperimentsPull)
 
-    EXPERIMENTS_REMOVE_HELP = "Remove local experiments."
+    EXPERIMENTS_REMOVE_HELP = "Remove experiments."
     experiments_remove_parser = experiments_subparsers.add_parser(
         "remove",
         parents=[parent_parser],
@@ -1199,9 +1346,22 @@ def add_parser(subparsers, parent_parser):
         help=EXPERIMENTS_REMOVE_HELP,
         formatter_class=argparse.RawDescriptionHelpFormatter,
     )
-    experiments_remove_parser.add_argument(
+    remove_group = experiments_remove_parser.add_mutually_exclusive_group()
+    remove_group.add_argument(
         "--queue", action="store_true", help="Remove all queued experiments."
     )
+    remove_group.add_argument(
+        "-A",
+        "--all",
+        action="store_true",
+        help="Remove all committed experiments.",
+    )
+    remove_group.add_argument(
+        "-g",
+        "--git-remote",
+        metavar="<git_remote>",
+        help="Name or URL of the Git remote to remove the experiment from",
+    )
     experiments_remove_parser.add_argument(
         "experiment",
         nargs="*",
@@ -1210,6 +1370,92 @@ def add_parser(subparsers, parent_parser):
     )
     experiments_remove_parser.set_defaults(func=CmdExperimentsRemove)
 
+    EXPERIMENTS_INIT_HELP = "Initialize experiments."
+    experiments_init_parser = experiments_subparsers.add_parser(
+        "init",
+        parents=[parent_parser],
+        description=append_doc_link(EXPERIMENTS_INIT_HELP, "exp/init"),
+        formatter_class=RawDefaultsHelpFormatter,
+    )
+    experiments_init_parser.add_argument(
+        "cmd",
+        nargs=argparse.REMAINDER,
+        help="Command to execute.",
+        metavar="command",
+    )
+    experiments_init_parser.add_argument(
+        "--run",
+        action="store_true",
+        help="Run the experiment after initializing it",
+    )
+    experiments_init_parser.add_argument(
+        "--interactive",
+        "-i",
+        action="store_true",
+        help="Prompt for values that are not provided",
+    )
+    experiments_init_parser.add_argument(
+        "-f",
+        "--force",
+        action="store_true",
+        default=False,
+        help="Overwrite existing stage",
+    )
+
+    experiments_init_parser.add_argument(
+        "--explicit",
+        action="store_true",
+        default=False,
+        help="Only use the path values explicitly provided",
+    )
+    experiments_init_parser.add_argument(
+        "--name", "-n", help="Name of the stage to create"
+    )
+    experiments_init_parser.add_argument(
+        "--code",
+        default=CmdExperimentsInit.CODE,
+        help="Path to the source file or directory "
+        "which your experiments depend",
+    )
+    experiments_init_parser.add_argument(
+        "--data",
+        default=CmdExperimentsInit.DATA,
+        help="Path to the data file or directory "
+        "which your experiments depend",
+    )
+    experiments_init_parser.add_argument(
+        "--models",
+        default=CmdExperimentsInit.MODELS,
+        help="Path to the model file or directory for your experiments",
+    )
+    experiments_init_parser.add_argument(
+        "--params",
+        default=CmdExperimentsInit.DEFAULT_PARAMS,
+        help="Path to the parameters file for your experiments",
+    )
+    experiments_init_parser.add_argument(
+        "--metrics",
+        default=CmdExperimentsInit.DEFAULT_METRICS,
+        help="Path to the metrics file for your experiments",
+    )
+    experiments_init_parser.add_argument(
+        "--plots",
+        default=CmdExperimentsInit.PLOTS,
+        help="Path to the plots file or directory for your experiments",
+    )
+    experiments_init_parser.add_argument(
+        "--live",
+        help="Path to log dvclive outputs for your experiments "
+        f"(default: {CmdExperimentsInit.DVCLIVE})",
+    )
+    experiments_init_parser.add_argument(
+        "--type",
+        choices=["default", "live"],
+        default="default",
+        help="Select type of stage to create",
+    )
+    experiments_init_parser.set_defaults(func=CmdExperimentsInit)
+
 
 def _add_run_common(parser):
     """Add common args for 'exp run' and 'exp resume'."""

dvc/command/gc.py

@@ -2,8 +2,8 @@ import argparse
 import logging
 import os
 
-from dvc import prompt
 from dvc.command.base import CmdBase, append_doc_link
+from dvc.ui import ui
 
 logger = logging.getLogger(__name__)
 
@@ -44,7 +44,7 @@ class CmdGC(CmdBase):
         logger.warning(msg)
 
         msg = "Are you sure you want to proceed?"
-        if not self.args.force and not prompt.confirm(msg):
+        if not self.args.force and not ui.confirm(msg):
             return 1
 
         self.repo.gc(

dvc/command/get.py

@@ -12,12 +12,13 @@ logger = logging.getLogger(__name__)
 class CmdGet(CmdBaseNoRepo):
     def _show_url(self):
         from dvc.api import get_url
+        from dvc.ui import ui
 
         try:
             url = get_url(
                 self.args.path, repo=self.args.url, rev=self.args.rev
             )
-            logger.info(url)
+            ui.write(url, force=True)
         except DvcException:
             logger.exception("failed to show URL")
             return 1

dvc/command/init.py

@@ -12,8 +12,10 @@ logger = logging.getLogger(__name__)
 
 
 def _welcome_message():
+    from dvc.ui import ui
+
     if analytics.is_enabled():
-        logger.info(
+        ui.write(
             boxify(
                 "DVC has enabled anonymous aggregate usage analytics.\n"
                 "Read the analytics documentation (and how to opt-out) here:\n"
@@ -30,7 +32,7 @@ def _welcome_message():
         f"- Star us on GitHub: {fmt_link('https://github.com/iterative/dvc')}"
     ).format(yellow=colorama.Fore.YELLOW, nc=colorama.Fore.RESET)
 
-    logger.info(msg)
+    ui.write(msg)
 
 
 class CmdInit(CmdBaseNoRepo):

dvc/command/live.py

@@ -1,11 +1,9 @@
 import argparse
-import logging
-import os
+from pathlib import Path
 
 from dvc.command import completion
 from dvc.command.base import CmdBase, fix_subparsers
-
-logger = logging.getLogger(__name__)
+from dvc.ui import ui
 
 
 class CmdLive(CmdBase):
@@ -14,12 +12,14 @@ class CmdLive(CmdBase):
     def _run(self, target, revs=None):
         metrics, plots = self.repo.live.show(target=target, revs=revs)
 
-        html_path = self.args.target + ".html"
-        self.repo.plots.write_html(html_path, plots, metrics)
+        if plots:
+            html_path = Path.cwd() / (self.args.target + "_html")
+            from dvc.render.utils import render
 
-        logger.info(f"\nfile://{os.path.abspath(html_path)}")
-
-        return 0
+            index_path = render(self.repo, plots, metrics, html_path)
+            ui.write(index_path.as_uri())
+            return 0
+        return 1
 
 
 class CmdLiveShow(CmdLive):

dvc/command/ls/__init__.py

@@ -34,10 +34,8 @@ class CmdList(CmdBaseNoRepo):
                 recursive=self.args.recursive,
                 dvc_only=self.args.dvc_only,
             )
-            if self.args.show_json:
-                import json
-
-                ui.write(json.dumps(entries))
+            if self.args.json:
+                ui.write_json(entries)
             elif entries:
                 entries = _prettify(entries, with_color=True)
                 ui.write("\n".join(entries))
@@ -54,6 +52,7 @@ def add_parser(subparsers, parent_parser):
     )
     list_parser = subparsers.add_parser(
         "list",
+        aliases=["ls"],
         parents=[parent_parser],
         description=append_doc_link(LIST_HELP, "list"),
         help=LIST_HELP,
@@ -70,7 +69,10 @@ def add_parser(subparsers, parent_parser):
         "--dvc-only", action="store_true", help="Show only DVC outputs."
     )
     list_parser.add_argument(
-        "--show-json", action="store_true", help="Show output in JSON format."
+        "--json",
+        "--show-json",
+        action="store_true",
+        help="Show output in JSON format.",
     )
     list_parser.add_argument(
         "--rev",

dvc/command/machine.py

@@ -0,0 +1,333 @@
+import argparse
+
+from dvc.command.base import CmdBase, append_doc_link, fix_subparsers
+from dvc.command.config import CmdConfig
+from dvc.config import ConfigError
+from dvc.ui import ui
+from dvc.utils import format_link
+
+
+class MachineDisabledError(ConfigError):
+    def __init__(self):
+        super().__init__("Machine feature is disabled")
+
+
+class CmdMachineConfig(CmdConfig):
+    def __init__(self, args):
+
+        super().__init__(args)
+        if not self.config["feature"].get("machine", False):
+            raise MachineDisabledError
+
+        if getattr(self.args, "name", None):
+            self.args.name = self.args.name.lower()
+
+    def _check_exists(self, conf):
+        if self.args.name not in conf["machine"]:
+            raise ConfigError(f"machine '{self.args.name}' doesn't exist.")
+
+
+class CmdMachineAdd(CmdMachineConfig):
+    def run(self):
+        from dvc.machine import validate_name
+
+        validate_name(self.args.name)
+
+        if self.args.default:
+            ui.write(f"Setting '{self.args.name}' as a default machine.")
+
+        with self.config.edit(self.args.level) as conf:
+            if self.args.name in conf["machine"] and not self.args.force:
+                raise ConfigError(
+                    "machine '{}' already exists. Use `-f|--force` to "
+                    "overwrite it.".format(self.args.name)
+                )
+
+            conf["machine"][self.args.name] = {"cloud": self.args.cloud}
+            if self.args.default:
+                conf["core"]["machine"] = self.args.name
+
+        return 0
+
+
+class CmdMachineRemove(CmdMachineConfig):
+    def run(self):
+        with self.config.edit(self.args.level) as conf:
+            self._check_exists(conf)
+            del conf["machine"][self.args.name]
+
+        up_to_level = self.args.level or "repo"
+        # Remove core.machine refs to this machine in any shadowing configs
+        for level in reversed(self.config.LEVELS):
+            with self.config.edit(level) as conf:
+                if conf["core"].get("machine") == self.args.name:
+                    del conf["core"]["machine"]
+
+            if level == up_to_level:
+                break
+
+        return 0
+
+
+class CmdMachineList(CmdMachineConfig):
+    def run(self):
+        levels = [self.args.level] if self.args.level else self.config.LEVELS
+        for level in levels:
+            conf = self.config.read(level)["machine"]
+            if self.args.name:
+                conf = conf.get(self.args.name, {})
+            prefix = self._config_file_prefix(
+                self.args.show_origin, self.config, level
+            )
+            configs = list(self._format_config(conf, prefix))
+            if configs:
+                ui.write("\n".join(configs))
+        return 0
+
+
+class CmdMachineModify(CmdMachineConfig):
+    def run(self):
+        from dvc.config import merge
+
+        with self.config.edit(self.args.level) as conf:
+            merged = self.config.load_config_to_level(self.args.level)
+            merge(merged, conf)
+            self._check_exists(merged)
+
+            if self.args.name not in conf["machine"]:
+                conf["machine"][self.args.name] = {}
+            section = conf["machine"][self.args.name]
+            if self.args.unset:
+                section.pop(self.args.option, None)
+            else:
+                section[self.args.option] = self.args.value
+        return 0
+
+
+class CmdMachineDefault(CmdMachineConfig):
+    def run(self):
+        if self.args.name is None and not self.args.unset:
+            conf = self.config.read(self.args.level)
+            try:
+                print(conf["core"]["machine"])
+            except KeyError:
+                ui.write("No default machine set")
+                return 1
+        else:
+            with self.config.edit(self.args.level) as conf:
+                if self.args.unset:
+                    conf["core"].pop("machine", None)
+                else:
+                    merged_conf = self.config.load_config_to_level(
+                        self.args.level
+                    )
+                    if (
+                        self.args.name in conf["machine"]
+                        or self.args.name in merged_conf["machine"]
+                    ):
+                        conf["core"]["machine"] = self.args.name
+                    else:
+                        raise ConfigError(
+                            "default machine must be present in machine "
+                            "list."
+                        )
+        return 0
+
+
+class CmdMachineCreate(CmdBase):
+    def run(self):
+        if self.repo.machine is None:
+            raise MachineDisabledError
+
+        self.repo.machine.create(self.args.name)
+        return 0
+
+
+class CmdMachineDestroy(CmdBase):
+    def run(self):
+        if self.repo.machine is None:
+            raise MachineDisabledError
+
+        self.repo.machine.destroy(self.args.name)
+        return 0
+
+
+class CmdMachineSsh(CmdBase):
+    def run(self):
+        if self.repo.machine is None:
+            raise MachineDisabledError
+
+        self.repo.machine.run_shell(self.args.name)
+        return 0
+
+
+def add_parser(subparsers, parent_parser):
+    from dvc.command.config import parent_config_parser
+
+    machine_HELP = "Set up and manage cloud machines."
+    machine_parser = subparsers.add_parser(
+        "machine",
+        parents=[parent_parser],
+        description=append_doc_link(machine_HELP, "machine"),
+        # NOTE: suppress help during development to hide command
+        # help=machine_HELP,
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+    )
+
+    machine_subparsers = machine_parser.add_subparsers(
+        dest="cmd",
+        help="Use `dvc machine CMD --help` for " "command-specific help.",
+    )
+
+    fix_subparsers(machine_subparsers)
+
+    machine_ADD_HELP = "Add a new data machine."
+    machine_add_parser = machine_subparsers.add_parser(
+        "add",
+        parents=[parent_config_parser, parent_parser],
+        description=append_doc_link(machine_ADD_HELP, "machine/add"),
+        help=machine_ADD_HELP,
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+    )
+    machine_add_parser.add_argument("name", help="Name of the machine")
+    machine_add_parser.add_argument(
+        "cloud",
+        help="Machine cloud. See full list of supported clouds at {}".format(
+            format_link(
+                "https://github.com/iterative/"
+                "terraform-provider-iterative#machine"
+            )
+        ),
+    )
+    machine_add_parser.add_argument(
+        "-d",
+        "--default",
+        action="store_true",
+        default=False,
+        help="Set as default machine.",
+    )
+    machine_add_parser.add_argument(
+        "-f",
+        "--force",
+        action="store_true",
+        default=False,
+        help="Force overwriting existing configs",
+    )
+    machine_add_parser.set_defaults(func=CmdMachineAdd)
+
+    machine_DEFAULT_HELP = "Set/unset the default machine."
+    machine_default_parser = machine_subparsers.add_parser(
+        "default",
+        parents=[parent_config_parser, parent_parser],
+        description=append_doc_link(machine_DEFAULT_HELP, "machine/default"),
+        help=machine_DEFAULT_HELP,
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+    )
+    machine_default_parser.add_argument(
+        "name", nargs="?", help="Name of the machine"
+    )
+    machine_default_parser.add_argument(
+        "-u",
+        "--unset",
+        action="store_true",
+        default=False,
+        help="Unset default machine.",
+    )
+    machine_default_parser.set_defaults(func=CmdMachineDefault)
+
+    machine_LIST_HELP = "List the configuration of one/all machines."
+    machine_list_parser = machine_subparsers.add_parser(
+        "list",
+        parents=[parent_config_parser, parent_parser],
+        description=append_doc_link(machine_LIST_HELP, "machine/list"),
+        help=machine_LIST_HELP,
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+    )
+    machine_list_parser.add_argument(
+        "--show-origin",
+        default=False,
+        action="store_true",
+        help="Show the source file containing each config value.",
+    )
+    machine_list_parser.add_argument(
+        "name",
+        nargs="?",
+        type=str,
+        help="name of machine to specify",
+    )
+    machine_list_parser.set_defaults(func=CmdMachineList)
+    machine_MODIFY_HELP = "Modify the configuration of an machine."
+    machine_modify_parser = machine_subparsers.add_parser(
+        "modify",
+        parents=[parent_config_parser, parent_parser],
+        description=append_doc_link(machine_MODIFY_HELP, "machine/modify"),
+        help=machine_MODIFY_HELP,
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+    )
+    machine_modify_parser.add_argument("name", help="Name of the machine")
+    machine_modify_parser.add_argument(
+        "option", help="Name of the option to modify."
+    )
+    machine_modify_parser.add_argument(
+        "value", nargs="?", help="(optional) Value of the option."
+    )
+    machine_modify_parser.add_argument(
+        "-u",
+        "--unset",
+        default=False,
+        action="store_true",
+        help="Unset option.",
+    )
+    machine_modify_parser.set_defaults(func=CmdMachineModify)
+
+    machine_REMOVE_HELP = "Remove an machine."
+    machine_remove_parser = machine_subparsers.add_parser(
+        "remove",
+        parents=[parent_config_parser, parent_parser],
+        description=append_doc_link(machine_REMOVE_HELP, "machine/remove"),
+        help=machine_REMOVE_HELP,
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+    )
+    machine_remove_parser.add_argument(
+        "name", help="Name of the machine to remove."
+    )
+    machine_remove_parser.set_defaults(func=CmdMachineRemove)
+
+    machine_CREATE_HELP = "Create and start a machine instance."
+    machine_create_parser = machine_subparsers.add_parser(
+        "create",
+        parents=[parent_config_parser, parent_parser],
+        description=append_doc_link(machine_CREATE_HELP, "machine/create"),
+        help=machine_CREATE_HELP,
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+    )
+    machine_create_parser.add_argument(
+        "name", help="Name of the machine to create."
+    )
+    machine_create_parser.set_defaults(func=CmdMachineCreate)
+
+    machine_DESTROY_HELP = "Destroy an machine instance."
+    machine_destroy_parser = machine_subparsers.add_parser(
+        "destroy",
+        parents=[parent_config_parser, parent_parser],
+        description=append_doc_link(machine_DESTROY_HELP, "machine/destroy"),
+        help=machine_DESTROY_HELP,
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+    )
+    machine_destroy_parser.add_argument(
+        "name", help="Name of the machine instance to destroy."
+    )
+    machine_destroy_parser.set_defaults(func=CmdMachineDestroy)
+
+    machine_SSH_HELP = "Connect to a machine via SSH."
+    machine_ssh_parser = machine_subparsers.add_parser(
+        "ssh",
+        parents=[parent_config_parser, parent_parser],
+        description=append_doc_link(machine_SSH_HELP, "machine/ssh"),
+        help=machine_SSH_HELP,
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+    )
+    machine_ssh_parser.add_argument(
+        "name", help="Name of the machine instance to connect to."
+    )
+    machine_ssh_parser.set_defaults(func=CmdMachineSsh)

dvc/command/metrics.py

@@ -3,7 +3,9 @@ import logging
 
 from dvc.command import completion
 from dvc.command.base import CmdBase, append_doc_link, fix_subparsers
-from dvc.exceptions import BadMetricError, DvcException
+from dvc.exceptions import DvcException
+from dvc.ui import ui
+from dvc.utils.serialize import encode_exception
 
 logger = logging.getLogger(__name__)
 
@@ -29,23 +31,14 @@ class CmdMetricsShow(CmdMetricsBase):
             logger.exception("")
             return 1
 
-        if self.args.show_json:
-            import json
-
-            logger.info(json.dumps(metrics))
+        if self.args.json:
+            ui.write_json(metrics, default=encode_exception)
         else:
             from dvc.compare import show_metrics
 
-            # When `metrics` contains a `None` key, it means that some files
-            # specified as `targets` in `repo.metrics.show` didn't contain any
-            # metrics.
-            missing = metrics.pop(None, None)
-            if missing:
-                raise BadMetricError(missing)
-
             show_metrics(
                 metrics,
-                markdown=self.args.show_md,
+                markdown=self.args.markdown,
                 all_branches=self.args.all_branches,
                 all_tags=self.args.all_tags,
                 all_commits=self.args.all_commits,
@@ -70,17 +63,15 @@ class CmdMetricsDiff(CmdMetricsBase):
             logger.exception("failed to show metrics diff")
             return 1
 
-        if self.args.show_json:
-            import json
-
-            logger.info(json.dumps(diff))
+        if self.args.json:
+            ui.write_json(diff)
         else:
             from dvc.compare import show_diff
 
             show_diff(
                 diff,
                 title="Metric",
-                markdown=self.args.show_md,
+                markdown=self.args.markdown,
                 no_path=self.args.no_path,
                 precision=self.args.precision or DEFAULT_PRECISION,
                 round_digits=True,
@@ -145,15 +136,18 @@ def add_parser(subparsers, parent_parser):
         help="Show metrics for all commits.",
     )
     metrics_show_parser.add_argument(
+        "--json",
         "--show-json",
         action="store_true",
         default=False,
         help="Show output in JSON format.",
     )
     metrics_show_parser.add_argument(
+        "--md",
         "--show-md",
         action="store_true",
         default=False,
+        dest="markdown",
         help="Show tabulated output in the Markdown format (GFM).",
     )
     metrics_show_parser.add_argument(
@@ -225,15 +219,18 @@ def add_parser(subparsers, parent_parser):
         help="Show unchanged metrics as well.",
     )
     metrics_diff_parser.add_argument(
+        "--json",
         "--show-json",
         action="store_true",
         default=False,
         help="Show output in JSON format.",
     )
     metrics_diff_parser.add_argument(
+        "--md",
         "--show-md",
         action="store_true",
         default=False,
+        dest="markdown",
         help="Show tabulated output in the Markdown format (GFM).",
     )
     metrics_diff_parser.add_argument(

dvc/command/params.py

@@ -4,6 +4,7 @@ import logging
 from dvc.command import completion
 from dvc.command.base import CmdBase, append_doc_link, fix_subparsers
 from dvc.exceptions import DvcException
+from dvc.ui import ui
 
 logger = logging.getLogger(__name__)
 
@@ -24,17 +25,15 @@ class CmdParamsDiff(CmdBase):
             logger.exception("failed to show params diff")
             return 1
 
-        if self.args.show_json:
-            import json
-
-            logger.info(json.dumps(diff))
+        if self.args.json:
+            ui.write_json(diff)
         else:
             from dvc.compare import show_diff
 
             show_diff(
                 diff,
                 title="Param",
-                markdown=self.args.show_md,
+                markdown=self.args.markdown,
                 no_path=self.args.no_path,
                 show_changes=False,
             )
@@ -102,15 +101,18 @@ def add_parser(subparsers, parent_parser):
         help="Show only params that are stage dependencies.",
     )
     params_diff_parser.add_argument(
+        "--json",
         "--show-json",
         action="store_true",
         default=False,
         help="Show output in JSON format.",
     )
     params_diff_parser.add_argument(
+        "--md",
         "--show-md",
         action="store_true",
         default=False,
+        dest="markdown",
         help="Show tabulated output in the Markdown format (GFM).",
     )
     params_diff_parser.add_argument(

dvc/command/plots.py

@@ -4,6 +4,8 @@ import logging
 from dvc.command import completion
 from dvc.command.base import CmdBase, append_doc_link, fix_subparsers
 from dvc.exceptions import DvcException
+from dvc.render.utils import find_vega, render
+from dvc.ui import ui
 from dvc.utils import format_link
 
 logger = logging.getLogger(__name__)
@@ -34,36 +36,51 @@ class CmdPlots(CmdBase):
                 return 1
 
         try:
-            plots = self._func(targets=self.args.targets, props=self._props())
+            plots_data = self._func(
+                targets=self.args.targets, props=self._props()
+            )
+
+            if not plots_data:
+                ui.error_write(
+                    "No plots were loaded, "
+                    "visualization file will not be created."
+                )
 
             if self.args.show_vega:
                 target = self.args.targets[0]
-                logger.info(plots[target])
+                plot_json = find_vega(self.repo, plots_data, target)
+                if plot_json:
+                    ui.write(plot_json)
                 return 0
 
-            rel: str = self.args.out or "plots.html"
-            path = (Path.cwd() / rel).resolve()
-            self.repo.plots.write_html(
-                path, plots=plots, html_template_path=self.args.html_template
+            rel: str = self.args.out or "dvc_plots"
+            path: Path = (Path.cwd() / rel).resolve()
+            index_path = render(
+                self.repo,
+                plots_data,
+                path=path,
+                html_template_path=self.args.html_template,
             )
 
+            assert index_path.is_absolute()
+            url = index_path.as_uri()
+            ui.write(url)
+
+            if self.args.open:
+                import webbrowser
+
+                opened = webbrowser.open(index_path)
+                if not opened:
+                    ui.error_write(
+                        "Failed to open. Please try opening it manually."
+                    )
+                    return 1
+            return 0
+
         except DvcException:
             logger.exception("")
             return 1
 
-        assert path.is_absolute()  # as_uri throws ValueError if not absolute
-        url = path.as_uri()
-        logger.info(url)
-        if self.args.open:
-            import webbrowser
-
-            opened = webbrowser.open(rel)
-            if not opened:
-                logger.error("Failed to open. Please try opening it manually.")
-                return 1
-
-        return 0
-
 
 class CmdPlotsShow(CmdPlots):
     UNINITIALIZED = True

dvc/command/remote.py

@@ -1,12 +1,10 @@
 import argparse
-import logging
 
 from dvc.command.base import append_doc_link, fix_subparsers
 from dvc.command.config import CmdConfig
+from dvc.ui import ui
 from dvc.utils import format_link
 
-logger = logging.getLogger(__name__)
-
 
 class CmdRemote(CmdConfig):
     def __init__(self, args):
@@ -27,7 +25,7 @@ class CmdRemoteAdd(CmdRemote):
         from dvc.config import ConfigError
 
         if self.args.default:
-            logger.info(f"Setting '{self.args.name}' as a default remote.")
+            ui.write(f"Setting '{self.args.name}' as a default remote.")
 
         with self.config.edit(self.args.level) as conf:
             if self.args.name in conf["remote"] and not self.args.force:
@@ -88,9 +86,9 @@ class CmdRemoteDefault(CmdRemote):
         if self.args.name is None and not self.args.unset:
             conf = self.config.read(self.args.level)
             try:
-                print(conf["core"]["remote"])
+                ui.write(conf["core"]["remote"])
             except KeyError:
-                logger.info("No default remote set")
+                ui.write("No default remote set")
                 return 1
         else:
             with self.config.edit(self.args.level) as conf:
@@ -116,7 +114,7 @@ class CmdRemoteList(CmdRemote):
     def run(self):
         conf = self.config.read(self.args.level)
         for name, conf in conf["remote"].items():
-            logger.info("{}\t{}".format(name, conf["url"]))
+            ui.write(name, conf["url"], sep="\t")
         return 0
 
 

dvc/command/repro.py

@@ -1,20 +1,19 @@
 import argparse
-import logging
 
 from dvc.command import completion
 from dvc.command.base import CmdBase, append_doc_link
 from dvc.command.status import CmdDataStatus
 
-logger = logging.getLogger(__name__)
-
 
 class CmdRepro(CmdBase):
     def run(self):
+        from dvc.ui import ui
+
         stages = self.repo.reproduce(**self._repro_kwargs)
         if len(stages) == 0:
-            logger.info(CmdDataStatus.UP_TO_DATE_MSG)
+            ui.write(CmdDataStatus.UP_TO_DATE_MSG)
         else:
-            logger.info(
+            ui.write(
                 "Use `dvc push` to send your updates to " "remote storage."
             )
 

dvc/command/root.py

@@ -10,8 +10,9 @@ logger = logging.getLogger(__name__)
 class CmdRoot(CmdBaseNoRepo):
     def run(self):
         from dvc.repo import Repo
+        from dvc.ui import ui
 
-        logger.info(relpath(Repo.find_root()))
+        ui.write(relpath(Repo.find_root()))
         return 0
 
 

dvc/command/stage.py

@@ -66,7 +66,7 @@ def prepare_stages_data(
 class CmdStageList(CmdBase):
     def _get_stages(self) -> Iterable["Stage"]:
         if self.args.all:
-            stages: List["Stage"] = self.repo.stages  # type: ignore
+            stages: List["Stage"] = self.repo.index.stages  # type: ignore
             logger.trace(  # type: ignore[attr-defined]
                 "%d no. of stages found", len(stages)
             )

dvc/command/status.py

@@ -2,6 +2,7 @@ import logging
 
 from dvc.command.data_sync import CmdDataBase
 from dvc.exceptions import DvcException
+from dvc.ui import ui
 from dvc.utils import format_link
 
 logger = logging.getLogger(__name__)
@@ -26,7 +27,7 @@ class CmdDataStatus(CmdDataBase):
         ind = indent * self.STATUS_INDENT
 
         if isinstance(status, str):
-            logger.info(f"{ind}{status}")
+            ui.write(f"{ind}{status}")
             return
 
         if isinstance(status, list):
@@ -38,14 +39,13 @@ class CmdDataStatus(CmdDataBase):
 
         for key, value in status.items():
             if isinstance(value, str):
-                logger.info("{}{}{}".format(ind, self._normalize(value), key))
+                ui.write(f"{ind}{self._normalize(value)}{key}")
             elif value:
-                logger.info(f"{ind}{key}:")
+                ui.write(f"{ind}{key}:")
                 self._show(value, indent + 1)
 
     def run(self):
         from dvc.repo import lock_repo
-        from dvc.ui import ui
 
         indent = 1 if self.args.cloud else 0
 
@@ -69,10 +69,8 @@ class CmdDataStatus(CmdDataBase):
             if self.args.quiet:
                 return bool(st)
 
-            if self.args.show_json:
-                import json
-
-                logger.info(json.dumps(st))
+            if self.args.json:
+                ui.write_json(st)
                 return 0
 
             if st:
@@ -80,7 +78,7 @@ class CmdDataStatus(CmdDataBase):
                 return 0
 
             # additional hints for the user
-            if not self.repo.stages:
+            if not self.repo.index.stages:
                 ui.write(self.EMPTY_PROJECT_MSG)
             elif self.args.cloud or self.args.remote:
                 remote = self.args.remote or self.repo.config["core"].get(

dvc/command/version.py

@@ -2,6 +2,7 @@ import argparse
 import logging
 
 from dvc.command.base import CmdBaseNoRepo, append_doc_link
+from dvc.ui import ui
 
 logger = logging.getLogger(__name__)
 
@@ -9,9 +10,12 @@ logger = logging.getLogger(__name__)
 class CmdVersion(CmdBaseNoRepo):
     def run(self):
         from dvc.info import get_dvc_info
+        from dvc.updater import notify_updates
 
         dvc_info = get_dvc_info()
-        logger.info(dvc_info)
+        ui.write(dvc_info, force=True)
+
+        notify_updates()
         return 0
 
 

dvc/compare.py

@@ -134,6 +134,10 @@ class TabularData(MutableSequence[Sequence["CellT"]]):
         self.drop(*(set(self._keys) - set(col_names)))
         self._keys = list(col_names)
 
+    def is_empty(self, col_name: str) -> bool:
+        col = self.column(col_name)
+        return not any(item != self._fill_value for item in col)
+
     def to_csv(self) -> str:
         import csv
         from io import StringIO
@@ -164,7 +168,10 @@ class TabularData(MutableSequence[Sequence["CellT"]]):
     def render(self, **kwargs: Any):
         from dvc.ui import ui
 
-        ui.table(self, headers=self.keys(), **kwargs)
+        if kwargs.pop("csv", False):
+            ui.write(self.to_csv(), end="")
+        else:
+            ui.table(self, headers=self.keys(), **kwargs)
 
     def as_dict(
         self, cols: Iterable[str] = None
@@ -277,8 +284,9 @@ def metrics_table(
     td = TabularData(["Revision", "Path"], fill_value="-")
 
     for branch, val in metrics.items():
-        for fname, metric in val.items():
+        for fname, metric in val.get("data", {}).items():
             row_data: Dict[str, str] = {"Revision": branch, "Path": fname}
+            metric = metric.get("data", {})
             flattened = (
                 flatten(format_dict(metric))
                 if isinstance(metric, dict)

dvc/config.py

@@ -20,7 +20,27 @@ class ConfigError(DvcException):
         super().__init__(f"config file error: {msg}")
 
 
-class NoRemoteError(ConfigError):
+class RemoteConfigError(ConfigError):
+    pass
+
+
+class NoRemoteError(RemoteConfigError):
+    pass
+
+
+class RemoteNotFoundError(RemoteConfigError):
+    pass
+
+
+class MachineConfigError(ConfigError):
+    pass
+
+
+class NoMachineError(MachineConfigError):
+    pass
+
+
+class MachineNotFoundError(MachineConfigError):
     pass
 
 
@@ -56,8 +76,10 @@ class Config(dict):
     APPNAME = "dvc"
     APPAUTHOR = "iterative"
 
+    SYSTEM_LEVELS = ("system", "global")
+    REPO_LEVELS = ("repo", "local")
     # In the order they shadow each other
-    LEVELS = ("system", "global", "repo", "local")
+    LEVELS = SYSTEM_LEVELS + REPO_LEVELS
 
     CONFIG = "config"
     CONFIG_LOCAL = "config.local"
@@ -159,7 +181,7 @@ class Config(dict):
                 conf_obj = ConfigObj(fobj)
         else:
             conf_obj = ConfigObj()
-        return _parse_remotes(_lower_keys(conf_obj.dict()))
+        return _parse_named(_lower_keys(conf_obj.dict()))
 
     def _save_config(self, level, conf_dict):
         from configobj import ConfigObj
@@ -171,7 +193,7 @@ class Config(dict):
 
         fs.makedirs(os.path.dirname(filename))
 
-        config = ConfigObj(_pack_remotes(conf_dict))
+        config = ConfigObj(_pack_named(conf_dict))
         with fs.open(filename, "wb") as fobj:
             config.write(fobj)
         config.filename = filename
@@ -243,6 +265,7 @@ class Config(dict):
                     "key_path": func,
                 }
             },
+            "machine": {str: {"startup_script": func}},
         }
         return Schema(dirs_schema, extra=ALLOW_EXTRA)(conf)
 
@@ -265,7 +288,7 @@ class Config(dict):
     def edit(self, level=None, validate=True):
         # NOTE: we write to repo config by default, same as git config
         level = level or "repo"
-        if level in {"repo", "local"} and self.dvc_dir is None:
+        if self.dvc_dir is None and level in self.REPO_LEVELS:
             raise ConfigError("Not inside a DVC repo")
 
         conf = self.load_one(level)
@@ -292,27 +315,29 @@ class Config(dict):
             raise ConfigError(str(exc)) from None
 
 
-def _parse_remotes(conf):
-    result = {"remote": {}}
+def _parse_named(conf):
+    result = {"remote": {}, "machine": {}}
 
     for section, val in conf.items():
-        name = re_find(r'^\s*remote\s*"(.*)"\s*$', section)
-        if name:
-            result["remote"][name] = val
+        match = re_find(r'^\s*(remote|machine)\s*"(.*)"\s*$', section)
+        if match:
+            key, name = match
+            result[key][name] = val
         else:
             result[section] = val
 
     return result
 
 
-def _pack_remotes(conf):
+def _pack_named(conf):
     # Drop empty sections
     result = compact(conf)
 
     # Transform remote.name -> 'remote "name"'
-    for name, val in conf["remote"].items():
-        result[f'remote "{name}"'] = val
-    result.pop("remote", None)
+    for key in ("remote", "machine"):
+        for name, val in conf[key].items():
+            result[f'{key} "{name}"'] = val
+        result.pop(key, None)
 
     return result
 

dvc/config_schema.py

@@ -93,7 +93,7 @@ HTTP_COMMON = {
     "user": str,
     "password": str,
     "ask_password": Bool,
-    "ssl_verify": Bool,
+    "ssl_verify": Any(Bool, str),
     "method": str,
 }
 WEBDAV_COMMON = {
@@ -104,6 +104,7 @@ WEBDAV_COMMON = {
     "cert_path": str,
     "key_path": str,
     "timeout": Coerce(int),
+    "ssl_verify": Any(Bool, str),
 }
 
 SCHEMA = {
@@ -117,6 +118,7 @@ SCHEMA = {
         Optional("autostage", default=False): Bool,
         Optional("experiments"): Bool,  # obsoleted
         Optional("check_update", default=True): Bool,
+        "machine": Lower,
     },
     "cache": {
         "local": str,
@@ -145,7 +147,7 @@ SCHEMA = {
                     "session_token": str,
                     Optional("listobjects", default=False): Bool,  # obsoleted
                     Optional("use_ssl", default=True): Bool,
-                    Optional("ssl_verify", default=True): Bool,
+                    "ssl_verify": Any(Bool, str),
                     "sse": str,
                     "sse_kms_key_id": str,
                     "acl": str,
@@ -153,6 +155,9 @@ SCHEMA = {
                     "grant_read_acp": str,
                     "grant_write_acp": str,
                     "grant_full_control": str,
+                    "cache_regions": bool,
+                    "read_timeout": Coerce(int),
+                    "connect_timeout": Coerce(int),
                     **REMOTE_COMMON,
                 },
                 "gs": {
@@ -188,6 +193,11 @@ SCHEMA = {
                     "tenant_id": str,
                     "client_id": str,
                     "client_secret": str,
+                    "allow_anonymous_login": Bool,
+                    "exclude_environment_credential": Bool,
+                    "exclude_visual_studio_code_credential": Bool,
+                    "exclude_shared_token_cache_credential": Bool,
+                    "exclude_managed_identity_credential": Bool,
                     **REMOTE_COMMON,
                 },
                 "oss": {
@@ -215,13 +225,44 @@ SCHEMA = {
         )
     },
     "state": {
+        "dir": str,
         "row_limit": All(Coerce(int), Range(1)),  # obsoleted
         "row_cleanup_quota": All(Coerce(int), Range(0, 100)),  # obsoleted
     },
+    "index": {
+        "dir": str,
+    },
+    "machine": {
+        str: {
+            "cloud": All(Lower, Choices("aws", "azure")),
+            "region": All(
+                Lower, Choices("us-west", "us-east", "eu-west", "eu-north")
+            ),
+            "image": str,
+            "name": str,
+            "spot": Bool,
+            "spot_price": Coerce(float),
+            "instance_hdd_size": Coerce(int),
+            "instance_type": Lower,
+            "instance_gpu": Lower,
+            "ssh_private": str,
+            "startup_script": str,
+        },
+    },
     # section for experimental features
     "feature": {
+        Optional("machine", default=False): Bool,
         # enabled by default. It's of no use, kept for backward compatibility.
-        Optional("parametrization", default=True): Bool
+        Optional("parametrization", default=True): Bool,
     },
     "plots": {"html_template": str},
+    "exp": {
+        "code": str,
+        "data": str,
+        "models": str,
+        "metrics": str,
+        "params": str,
+        "plots": str,
+        "live": str,
+    },
 }

dvc/daemon.py

@@ -12,29 +12,34 @@ from dvc.utils import fix_env, is_binary
 
 logger = logging.getLogger(__name__)
 
-CREATE_NEW_PROCESS_GROUP = 0x00000200
-DETACHED_PROCESS = 0x00000008
+CREATE_NO_WINDOW = 0x08000000  # only available since Python 3.7 in subprocess.
 
 
 def _popen(cmd, **kwargs):
     prefix = [sys.executable]
     if not is_binary():
-        prefix += [sys.argv[0]]
-
+        main_entrypoint = os.path.join(
+            os.path.abspath(os.path.dirname(__file__)), "__main__.py"
+        )
+        prefix += [main_entrypoint]
     return Popen(prefix + cmd, close_fds=True, shell=False, **kwargs)
 
 
 def _spawn_windows(cmd, env):
-    from subprocess import STARTF_USESHOWWINDOW, STARTUPINFO
+    from subprocess import (
+        CREATE_NEW_PROCESS_GROUP,
+        STARTF_USESHOWWINDOW,
+        STARTUPINFO,
+    )
 
-    creationflags = CREATE_NEW_PROCESS_GROUP | DETACHED_PROCESS
+    # https://stackoverflow.com/a/7006424
+    # https://bugs.python.org/issue41619
+    creationflags = CREATE_NEW_PROCESS_GROUP | CREATE_NO_WINDOW
 
     startupinfo = STARTUPINFO()
     startupinfo.dwFlags |= STARTF_USESHOWWINDOW
 
-    _popen(
-        cmd, env=env, creationflags=creationflags, startupinfo=startupinfo
-    ).communicate()
+    _popen(cmd, env=env, creationflags=creationflags, startupinfo=startupinfo)
 
 
 def _spawn_posix(cmd, env):

dvc/dagascii.py

@@ -163,7 +163,7 @@ class AsciiCanvas:
         self.point(x0 + width, y0 + height, "+")
 
 
-def _build_sugiyama_layout(vertexes, edges):
+def _build_sugiyama_layout(vertices, edges):
     #
     # Just a reminder about naming conventions:
     # +------------X
@@ -174,17 +174,17 @@ def _build_sugiyama_layout(vertexes, edges):
     # Y
     #
 
-    vertexes = {v: Vertex(f" {v} ") for v in vertexes}
+    vertices = {v: Vertex(f" {v} ") for v in vertices}
     # NOTE: reverting edges to correctly orientate the graph
-    edges = [Edge(vertexes[e], vertexes[s]) for s, e in edges]
-    vertexes = vertexes.values()
-    graph = Graph(vertexes, edges)
+    edges = [Edge(vertices[e], vertices[s]) for s, e in edges]
+    vertices = vertices.values()
+    graph = Graph(vertices, edges)
 
-    for vertex in vertexes:
+    for vertex in vertices:
         vertex.view = VertexViewer(vertex.data)
 
     # NOTE: determine min box length to create the best layout
-    minw = min(v.view.w for v in vertexes)
+    minw = min(v.view.w for v in vertices)
 
     for edge in edges:
         edge.view = EdgeViewer()
@@ -204,11 +204,11 @@ def _build_sugiyama_layout(vertexes, edges):
     return sug
 
 
-def draw(vertexes, edges):
+def draw(vertices, edges):
     """Build a DAG and draw it in ASCII.
 
     Args:
-        vertexes (list): list of graph vertexes.
+        vertices (list): list of graph vertices.
         edges (list): list of graph edges.
     """
     # pylint: disable=too-many-locals
@@ -217,7 +217,7 @@ def draw(vertexes, edges):
     Xs = []  # pylint: disable=invalid-name
     Ys = []  # pylint: disable=invalid-name
 
-    sug = _build_sugiyama_layout(vertexes, edges)
+    sug = _build_sugiyama_layout(vertices, edges)
 
     for vertex in sug.g.sV:
         # NOTE: moving boxes w/2 to the left

dvc/data_cloud.py

@@ -1,6 +1,13 @@
 """Manages dvc remotes that user can use with push/pull/status commands."""
 
 import logging
+from typing import TYPE_CHECKING, Iterable, Optional
+
+from dvc.objects.db import get_index
+
+if TYPE_CHECKING:
+    from dvc.hash_info import HashInfo
+    from dvc.objects.db.base import ObjectDB
 
 logger = logging.getLogger(__name__)
 
@@ -19,14 +26,18 @@ class DataCloud:
     def __init__(self, repo):
         self.repo = repo
 
-    def get_remote(self, name=None, command="<command>"):
+    def get_remote_odb(
+        self,
+        name: Optional[str] = None,
+        command: str = "<command>",
+    ) -> "ObjectDB":
         from dvc.config import NoRemoteError
 
         if not name:
             name = self.repo.config["core"].get("remote")
 
         if name:
-            return self._init_remote(name)
+            return self._init_odb(name)
 
         if bool(self.repo.config["remote"]):
             error_msg = (
@@ -43,81 +54,107 @@ class DataCloud:
 
         raise NoRemoteError(error_msg)
 
-    def _init_remote(self, name):
-        from dvc.remote import get_remote
+    def _init_odb(self, name):
+        from dvc.fs import get_cloud_fs
+        from dvc.objects.db import get_odb
 
-        return get_remote(self.repo, name=name)
+        cls, config, path_info = get_cloud_fs(self.repo, name=name)
+        config["tmp_dir"] = self.repo.index_db_dir
+        return get_odb(cls(**config), path_info, **config)
 
-    def push(self, cache, jobs=None, remote=None, show_checksums=False):
+    def push(
+        self,
+        objs: Iterable["HashInfo"],
+        jobs: Optional[int] = None,
+        remote: Optional[str] = None,
+        odb: Optional["ObjectDB"] = None,
+    ):
         """Push data items in a cloud-agnostic way.
 
         Args:
-            cache (NamedCache): named checksums to push to the cloud.
-            jobs (int): number of jobs that can be running simultaneously.
-            remote (dvc.remote.base.BaseRemote): optional remote to push to.
+            objs: objects to push to the cloud.
+            jobs: number of jobs that can be running simultaneously.
+            remote: optional name of remote to push to.
                 By default remote from core.remote config option is used.
-            show_checksums (bool): show checksums instead of file names in
-                information messages.
+            odb: optional ODB to push to. Overrides remote.
         """
-        remote = self.get_remote(remote, "push")
+        from dvc.objects.transfer import transfer
 
-        return remote.push(
+        if not odb:
+            odb = self.get_remote_odb(remote, "push")
+        return transfer(
             self.repo.odb.local,
-            cache,
+            odb,
+            objs,
             jobs=jobs,
-            show_checksums=show_checksums,
+            dest_index=get_index(odb),
+            cache_odb=self.repo.odb.local,
         )
 
-    def pull(self, cache, jobs=None, remote=None, show_checksums=False):
+    def pull(
+        self,
+        objs: Iterable["HashInfo"],
+        jobs: Optional[int] = None,
+        remote: Optional[str] = None,
+        odb: Optional["ObjectDB"] = None,
+    ):
         """Pull data items in a cloud-agnostic way.
 
         Args:
-            cache (NamedCache): named checksums to pull from the cloud.
-            jobs (int): number of jobs that can be running simultaneously.
-            remote (dvc.remote.base.BaseRemote): optional remote to pull from.
+            objs: objects to pull from the cloud.
+            jobs: number of jobs that can be running simultaneously.
+            remote: optional name of remote to pull from.
                 By default remote from core.remote config option is used.
-            show_checksums (bool): show checksums instead of file names in
-                information messages.
+            odb: optional ODB to pull from. Overrides remote.
         """
-        remote = self.get_remote(remote, "pull")
+        from dvc.objects.transfer import transfer
 
-        return remote.pull(
+        if not odb:
+            odb = self.get_remote_odb(remote, "pull")
+        return transfer(
+            odb,
             self.repo.odb.local,
-            cache,
+            objs,
             jobs=jobs,
-            show_checksums=show_checksums,
+            src_index=get_index(odb),
+            cache_odb=self.repo.odb.local,
+            verify=odb.verify,
         )
 
     def status(
         self,
-        cache,
-        jobs=None,
-        remote=None,
-        show_checksums=False,
-        log_missing=True,
+        objs: Iterable["HashInfo"],
+        jobs: Optional[int] = None,
+        remote: Optional[str] = None,
+        odb: Optional["ObjectDB"] = None,
+        log_missing: bool = True,
     ):
         """Check status of data items in a cloud-agnostic way.
 
         Args:
-            cache (NamedCache): named checksums to check status for.
-            jobs (int): number of jobs that can be running simultaneously.
-            remote (dvc.remote.base.BaseRemote): optional remote to compare
+            objs: objects to check status for.
+            jobs: number of jobs that can be running simultaneously.
+            remote: optional remote to compare
                 cache to. By default remote from core.remote config option
                 is used.
-            show_checksums (bool): show checksums instead of file names in
-                information messages.
-            log_missing (bool): log warning messages if file doesn't exist
+            odb: optional ODB to check status from. Overrides remote.
+            log_missing: log warning messages if file doesn't exist
                 neither in cache, neither in cloud.
         """
-        remote = self.get_remote(remote, "status")
-        return remote.status(
+        from dvc.objects.status import compare_status
+
+        if not odb:
+            odb = self.get_remote_odb(remote, "status")
+        return compare_status(
             self.repo.odb.local,
-            cache,
+            odb,
+            objs,
             jobs=jobs,
-            show_checksums=show_checksums,
             log_missing=log_missing,
+            dest_index=get_index(odb),
+            cache_odb=self.repo.odb.local,
         )
 
     def get_url_for(self, remote, checksum):
-        remote = self.get_remote(remote)
-        return str(remote.odb.hash_to_path_info(checksum))
+        remote_odb = self.get_remote_odb(remote)
+        return str(remote_odb.hash_to_path_info(checksum))

dvc/dependency/param.py

@@ -98,7 +98,7 @@ class ParamsDependency(Dependency):
                 f"Unable to read parameters from '{self}'"
             ) from exc
 
-    def read_params_d(self):
+    def read_params_d(self, **kwargs):
         config = self._read()
 
         ret = {}

dvc/dependency/repo.py

@@ -1,9 +1,19 @@
+import os
+from collections import defaultdict
+from copy import copy
+from typing import TYPE_CHECKING, Dict, Optional, Set, Tuple
+
 from voluptuous import Required
 
 from dvc.path_info import PathInfo
 
 from .base import Dependency
 
+if TYPE_CHECKING:
+    from dvc.hash_info import HashInfo
+    from dvc.objects.db.base import ObjectDB
+    from dvc.objects.file import HashFile
+
 
 class RepoDependency(Dependency):
     PARAM_REPO = "repo"
@@ -21,6 +31,7 @@ class RepoDependency(Dependency):
 
     def __init__(self, def_repo, stage, *args, **kwargs):
         self.def_repo = def_repo
+        self._staged_objs: Dict[str, "HashFile"] = {}
         super().__init__(stage, *args, **kwargs)
 
     def _parse_path(self, fs, path_info):
@@ -30,37 +41,12 @@ class RepoDependency(Dependency):
     def is_in_repo(self):
         return False
 
-    @property
-    def repo_pair(self):
-        d = self.def_repo
-        rev = d.get(self.PARAM_REV_LOCK) or d.get(self.PARAM_REV)
-        return d[self.PARAM_URL], rev
-
     def __str__(self):
-        return "{} ({})".format(self.def_path, self.def_repo[self.PARAM_URL])
-
-    def _make_repo(self, *, locked=True, **kwargs):
-        from dvc.external_repo import external_repo
-
-        d = self.def_repo
-        rev = (d.get("rev_lock") if locked else None) or d.get("rev")
-        return external_repo(d["url"], rev=rev, **kwargs)
-
-    def _get_hash(self, locked=True):
-        from dvc.objects.stage import stage
-
-        with self._make_repo(locked=locked) as repo:
-            path_info = PathInfo(repo.root_dir) / self.def_path
-            return stage(
-                self.repo.odb.local,
-                path_info,
-                repo.repo_fs,
-                self.repo.odb.local.fs.PARAM_CHECKSUM,
-            ).hash_info
+        return f"{self.def_path} ({self.def_repo[self.PARAM_URL]})"
 
     def workspace_status(self):
-        current = self._get_hash(locked=True)
-        updated = self._get_hash(locked=False)
+        current = self.get_obj(locked=True).hash_info
+        updated = self.get_obj(locked=False).hash_info
 
         if current != updated:
             return {str(self): "update available"}
@@ -77,32 +63,17 @@ class RepoDependency(Dependency):
         return {self.PARAM_PATH: self.def_path, self.PARAM_REPO: self.def_repo}
 
     def download(self, to, jobs=None):
-        from dvc.checkout import checkout
-        from dvc.config import NoRemoteError
-        from dvc.exceptions import NoOutputOrStageError
-        from dvc.objects import save
-        from dvc.objects.stage import stage
+        from dvc.objects.checkout import checkout
 
-        odb = self.repo.odb.local
-
-        with self._make_repo(cache_dir=odb.cache_dir) as repo:
-            if self.def_repo.get(self.PARAM_REV_LOCK) is None:
-                self.def_repo[self.PARAM_REV_LOCK] = repo.get_rev()
-            path_info = PathInfo(repo.root_dir) / self.def_path
-            try:
-                repo.fetch([path_info.fspath], jobs=jobs, recursive=True)
-            except (NoOutputOrStageError, NoRemoteError):
-                pass
-            obj = stage(
-                odb, path_info, repo.repo_fs, odb.fs.PARAM_CHECKSUM, jobs=jobs
-            )
-            save(odb, obj, jobs=jobs)
+        for odb, objs in self.get_used_objs().items():
+            self.repo.cloud.pull(objs, jobs=jobs, odb=odb)
 
+        obj = self.get_obj()
         checkout(
             to.path_info,
             to.fs,
             obj,
-            odb,
+            self.repo.odb.local,
             dvcignore=None,
             state=self.repo.state,
         )
@@ -110,7 +81,6 @@ class RepoDependency(Dependency):
     def update(self, rev=None):
         if rev:
             self.def_repo[self.PARAM_REV] = rev
-
         with self._make_repo(locked=False) as repo:
             self.def_repo[self.PARAM_REV_LOCK] = repo.get_rev()
 
@@ -119,3 +89,124 @@ class RepoDependency(Dependency):
         # origin project url and rev_lock, and it makes RepoDependency
         # immutable, hence its impossible for checksum to change.
         return False
+
+    def get_used_objs(
+        self, **kwargs
+    ) -> Dict[Optional["ObjectDB"], Set["HashInfo"]]:
+        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"]:
+        from dvc.config import NoRemoteError
+        from dvc.exceptions import NoOutputOrStageError, PathMissingError
+        from dvc.objects.stage import stage
+        from dvc.objects.tree import Tree
+
+        local_odb = self.repo.odb.local
+        locked = kwargs.pop("locked", True)
+        with self._make_repo(
+            locked=locked, cache_dir=local_odb.cache_dir
+        ) as repo:
+            used_obj_ids = defaultdict(set)
+            rev = repo.get_rev()
+            if locked and self.def_repo.get(self.PARAM_REV_LOCK) is None:
+                self.def_repo[self.PARAM_REV_LOCK] = rev
+
+            path_info = PathInfo(repo.root_dir) / str(self.def_path)
+            if not obj_only:
+                try:
+                    for odb, obj_ids in repo.used_objs(
+                        [os.fspath(path_info)],
+                        force=True,
+                        jobs=kwargs.get("jobs"),
+                        recursive=True,
+                    ).items():
+                        if odb is None:
+                            odb = repo.cloud.get_remote_odb()
+                            odb.read_only = True
+                        self._check_circular_import(odb, obj_ids)
+                        used_obj_ids[odb].update(obj_ids)
+                except (NoRemoteError, NoOutputOrStageError):
+                    pass
+
+            try:
+                staging, staged_obj = stage(
+                    local_odb,
+                    path_info,
+                    repo.repo_fs,
+                    local_odb.fs.PARAM_CHECKSUM,
+                )
+            except FileNotFoundError as exc:
+                raise PathMissingError(
+                    self.def_path, self.def_repo[self.PARAM_URL]
+                ) from exc
+            staging = copy(staging)
+            staging.read_only = True
+
+            self._staged_objs[rev] = staged_obj
+            used_obj_ids[staging].add(staged_obj.hash_info)
+            if isinstance(staged_obj, Tree):
+                used_obj_ids[staging].update(
+                    entry.hash_info for _, entry in staged_obj
+                )
+            return used_obj_ids, staged_obj
+
+    def _check_circular_import(self, odb, obj_ids):
+        from dvc.exceptions import CircularImportError
+        from dvc.fs.repo import RepoFileSystem
+        from dvc.objects.db.reference import ReferenceObjectDB
+        from dvc.objects.tree import Tree
+
+        if not isinstance(odb, ReferenceObjectDB):
+            return
+
+        def iter_objs():
+            for hash_info in obj_ids:
+                if hash_info.isdir:
+                    tree = Tree.load(odb, hash_info)
+                    yield from (odb.get(entry.hash_info) for _, entry in tree)
+                else:
+                    yield odb.get(hash_info)
+
+        checked_urls = set()
+        for obj in iter_objs():
+            if not isinstance(obj.fs, RepoFileSystem):
+                continue
+            if (
+                obj.fs.repo_url in checked_urls
+                or obj.fs.root_dir in checked_urls
+            ):
+                continue
+            self_url = self.repo.url or self.repo.root_dir
+            if (
+                obj.fs.repo_url is not None
+                and obj.fs.repo_url == self_url
+                or obj.fs.root_dir == self.repo.root_dir
+            ):
+                raise CircularImportError(self, obj.fs.repo_url, self_url)
+            checked_urls.update([obj.fs.repo_url, obj.fs.root_dir])
+
+    def get_obj(self, filter_info=None, **kwargs):
+        locked = kwargs.get("locked", True)
+        rev = self._get_rev(locked=locked)
+        if rev in self._staged_objs:
+            return self._staged_objs[rev]
+        _, obj = self._get_used_and_obj(
+            obj_only=True, filter_info=filter_info, **kwargs
+        )
+        return obj
+
+    def _make_repo(self, locked=True, **kwargs):
+        from dvc.external_repo import external_repo
+
+        d = self.def_repo
+        rev = self._get_rev(locked=locked)
+        return external_repo(d[self.PARAM_URL], rev=rev, **kwargs)
+
+    def _get_rev(self, locked=True):
+        d = self.def_repo
+        return (d.get(self.PARAM_REV_LOCK) if locked else None) or d.get(
+            self.PARAM_REV
+        )

dvc/dvcfile.py

@@ -1,10 +1,7 @@
-import collections
 import contextlib
 import logging
 import os
-from typing import TYPE_CHECKING, Any, Union
-
-from voluptuous import MultipleInvalid
+from typing import TYPE_CHECKING, Any, Callable, Tuple, TypeVar, Union
 
 from dvc.exceptions import DvcException
 from dvc.parsing.versions import LOCKFILE_VERSION, SCHEMA_KWD
@@ -12,23 +9,18 @@ from dvc.stage import serialize
 from dvc.stage.exceptions import (
     StageFileBadNameError,
     StageFileDoesNotExistError,
-    StageFileFormatError,
     StageFileIsNotDvcFileError,
 )
 from dvc.types import AnyPath
 from dvc.utils import relpath
 from dvc.utils.collections import apply_diff
-from dvc.utils.serialize import (
-    dump_yaml,
-    modify_yaml,
-    parse_yaml,
-    parse_yaml_for_update,
-)
+from dvc.utils.serialize import dump_yaml, modify_yaml
 
 if TYPE_CHECKING:
     from dvc.repo import Repo
 
 logger = logging.getLogger(__name__)
+_T = TypeVar("_T")
 
 DVC_FILE = "Dvcfile"
 DVC_FILE_SUFFIX = ".dvc"
@@ -45,10 +37,6 @@ class FileIsGitIgnored(DvcException):
         )
 
 
-class LockfileCorruptedError(DvcException):
-    pass
-
-
 class ParametrizedDumpError(DvcException):
     pass
 
@@ -96,7 +84,7 @@ def check_dvcfile_path(repo, path):
 
 
 class FileMixin:
-    SCHEMA = None
+    SCHEMA: Callable[[_T], _T]
 
     def __init__(self, repo, path, verify=True, **kwargs):
         self.repo = repo
@@ -138,7 +126,11 @@ class FileMixin:
         if self._is_git_ignored():
             raise FileIsGitIgnored(self.path)
 
-    def _load(self):
+    def load(self, **kwargs: Any) -> Any:
+        d, _ = self._load(**kwargs)
+        return d
+
+    def _load(self, **kwargs: Any) -> Tuple[Any, str]:
         # it raises the proper exceptions by priority:
         # 1. when the file doesn't exists
         # 2. filename is not a DVC file
@@ -155,18 +147,23 @@ class FileMixin:
             raise StageFileIsNotDvcFileError(self.path)
 
         self._check_gitignored()
-        with self.repo.fs.open(self.path, encoding="utf-8") as fd:
-            stage_text = fd.read()
-        d = parse_yaml(stage_text, self.path)
-        return self.validate(d, self.relpath), stage_text
+        return self._load_yaml(**kwargs)
 
     @classmethod
-    def validate(cls, d, fname=None):
-        assert isinstance(cls.SCHEMA, collections.abc.Callable)
-        try:
-            return cls.SCHEMA(d)  # pylint: disable=not-callable
-        except MultipleInvalid as exc:
-            raise StageFileFormatError(f"'{fname}' format error: {exc}")
+    def validate(cls, d: _T, fname: str = None) -> _T:
+        from dvc.utils.strictyaml import validate
+
+        return validate(d, cls.SCHEMA, path=fname)  # type: ignore[arg-type]
+
+    def _load_yaml(self, **kwargs: Any) -> Tuple[Any, str]:
+        from dvc.utils import strictyaml
+
+        return strictyaml.load(
+            self.path,
+            self.SCHEMA,  # type: ignore[arg-type]
+            self.repo.fs,
+            **kwargs,
+        )
 
     def remove(self, force=False):  # pylint: disable=unused-argument
         with contextlib.suppress(FileNotFoundError):
@@ -200,9 +197,7 @@ class SingleStageFile(FileMixin):
         assert not isinstance(stage, PipelineStage)
         if self.verify:
             check_dvcfile_path(self.repo, self.path)
-        logger.debug(
-            "Saving information to '{file}'.".format(file=relpath(self.path))
-        )
+        logger.debug(f"Saving information to '{relpath(self.path)}'.")
         dump_yaml(self.path, serialize.to_single_stage_file(stage))
         self.repo.scm.track_file(self.relpath)
 
@@ -300,10 +295,7 @@ class PipelineFile(FileMixin):
         if not self.exists():
             return
 
-        with open(self.path, "r", encoding="utf-8") as f:
-            d = parse_yaml_for_update(f.read(), self.path)
-
-        self.validate(d, self.path)
+        d, _ = self._load_yaml(round_trip=True)
         if stage.name not in d.get("stages", {}):
             return
 
@@ -345,34 +337,25 @@ def migrate_lock_v1_to_v2(d, version_info):
     d["stages"] = stages
 
 
+def lockfile_schema(data: _T) -> _T:
+    schema = get_lockfile_schema(data)
+    return schema(data)
+
+
 class Lockfile(FileMixin):
-    @classmethod
-    def validate(cls, d, fname=None):
-        schema = get_lockfile_schema(d)
-        try:
-            return schema(d)
-        except MultipleInvalid as exc:
-            raise StageFileFormatError(f"'{fname}' format error: {exc}")
+    SCHEMA = staticmethod(lockfile_schema)  # type: ignore[assignment]
 
     def _verify_filename(self):
         pass  # lockfile path is hardcoded, so no need to verify here
 
-    def _load(self):
+    def _load(self, **kwargs: Any):
         try:
-            return super()._load()
+            return super()._load(**kwargs)
         except StageFileDoesNotExistError:
             # we still need to account for git-ignored dvc.lock file
             # even though it may not exist or have been .dvcignored
             self._check_gitignored()
             return {}, ""
-        except StageFileFormatError as exc:
-            raise LockfileCorruptedError(
-                f"Lockfile '{self.relpath}' is corrupted."
-            ) from exc
-
-    def load(self):
-        d, _ = self._load()
-        return d
 
     @property
     def latest_version_info(self):
@@ -411,10 +394,7 @@ class Lockfile(FileMixin):
         if not self.exists():
             return
 
-        with open(self.path, encoding="utf-8") as f:
-            d = parse_yaml_for_update(f.read(), self.path)
-        self.validate(d, self.path)
-
+        d, _ = self._load_yaml(round_trip=True)
         version = LOCKFILE_VERSION.from_dict(d)
         data = d if version == LOCKFILE_VERSION.V1 else d.get("stages", {})
         if stage.name not in data:

dvc/env.py

@@ -6,3 +6,7 @@ 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_EXP_AUTO_PUSH = "DVC_EXP_AUTO_PUSH"
+DVC_NO_ANALYTICS = "DVC_NO_ANALYTICS"

dvc/exceptions.py

@@ -1,5 +1,4 @@
 """Exceptions raised by the dvc."""
-from typing import List
 
 
 class DvcException(Exception):
@@ -173,36 +172,6 @@ class BadMetricError(DvcException):
         )
 
 
-class MetricsError(DvcException):
-    pass
-
-
-class NoMetricsParsedError(MetricsError):
-    def __init__(self, command):
-        super().__init__(
-            f"Could not parse {command} files. Use `-v` option to see more "
-            "details."
-        )
-
-
-class NoMetricsFoundError(MetricsError):
-    def __init__(self, command, run_options):
-        super().__init__(
-            f"No {command} files in this repository. "
-            f"Use `{run_options}` options for "
-            f"`dvc run` to mark stage outputs as {command}."
-        )
-
-
-class MetricDoesNotExistError(MetricsError):
-    def __init__(self, targets: List[str]):
-        if len(targets) == 1:
-            msg = "'{}' does not exist."
-        else:
-            msg = "'{}' do not exist."
-        super().__init__(msg.format(", ".join(targets)))
-
-
 class RecursiveAddingWhileUsingFilename(DvcException):
     def __init__(self):
         super().__init__(
@@ -259,18 +228,21 @@ class GitHookAlreadyExistsError(DvcException):
         )
 
 
-class DownloadError(DvcException):
+class FileTransferError(DvcException):
+    _METHOD = "transfer"
+
     def __init__(self, amount):
         self.amount = amount
 
-        super().__init__(f"{amount} files failed to download")
+        super().__init__(f"{amount} files failed to {self._METHOD}")
 
 
-class UploadError(DvcException):
-    def __init__(self, amount):
-        self.amount = amount
+class DownloadError(FileTransferError):
+    _METHOD = "download"
 
-        super().__init__(f"{amount} files failed to upload")
+
+class UploadError(FileTransferError):
+    _METHOD = "upload"
 
 
 class CheckoutError(DvcException):
@@ -384,3 +356,16 @@ class CacheLinkError(DvcException):
         )
         super().__init__(msg)
         self.path_infos = path_infos
+
+
+class CircularImportError(DvcException):
+    def __init__(self, dep, a, b):
+        super().__init__(
+            f"'{dep}' contains invalid circular import. "
+            f"DVC repo '{a}' already imports from '{b}'."
+        )
+
+
+class PrettyDvcException(DvcException):
+    def __pretty_exc__(self, **kwargs):
+        """Print prettier exception message."""

dvc/external_repo.py

@@ -42,14 +42,6 @@ def external_repo(
     config = _get_remote_config(url) if os.path.isdir(url) else {}
     config.update(cache_config)
 
-    def make_repo(path, **_kwargs):
-        _config = cache_config.copy()
-        if os.path.isdir(url):
-            rel = os.path.relpath(path, _kwargs["scm"].root_dir)
-            repo_path = os.path.join(url, rel)
-            _config.update(_get_remote_config(repo_path))
-        return Repo(path, config=_config, **_kwargs)
-
     root_dir = path if for_write else os.path.realpath(path)
     repo_kwargs = dict(
         root_dir=root_dir,
@@ -57,7 +49,7 @@ def external_repo(
         scm=None if for_write else Git(root_dir),
         rev=None if for_write else rev,
         config=config,
-        repo_factory=make_repo,
+        repo_factory=erepo_factory(url, cache_config),
         **kwargs,
     )
 
@@ -87,6 +79,18 @@ def external_repo(
             _remove(path)
 
 
+def erepo_factory(url, cache_config, *args, **kwargs):
+    def make_repo(path, **_kwargs):
+        _config = cache_config.copy()
+        if os.path.isdir(url):
+            rel = os.path.relpath(path, _kwargs["scm"].root_dir)
+            repo_path = os.path.join(url, rel)
+            _config.update(_get_remote_config(repo_path))
+        return Repo(path, config=_config, **_kwargs)
+
+    return make_repo
+
+
 CLONES: Dict[str, str] = {}
 CACHE_DIRS: Dict[str, str] = {}
 

dvc/fs/__init__.py

@@ -2,6 +2,7 @@ import posixpath
 from urllib.parse import urlparse
 
 from ..scheme import Schemes
+from . import utils  # noqa: F401
 from .azure import AzureFileSystem
 from .gdrive import GDriveFileSystem
 from .gs import GSFileSystem
@@ -12,8 +13,7 @@ from .local import LocalFileSystem
 from .oss import OSSFileSystem
 from .s3 import S3FileSystem
 from .ssh import SSHFileSystem
-from .webdav import WebDAVFileSystem
-from .webdavs import WebDAVSFileSystem
+from .webdav import WebDAVFileSystem, WebDAVSFileSystem
 from .webhdfs import WebHDFSFileSystem
 
 FS_MAP = {
@@ -33,15 +33,21 @@ FS_MAP = {
 }
 
 
-def get_fs_cls(remote_conf):
-    scheme = urlparse(remote_conf["url"]).scheme
+def get_fs_cls(remote_conf, scheme=None):
+    if not scheme:
+        scheme = urlparse(remote_conf["url"]).scheme
     return FS_MAP.get(scheme, LocalFileSystem)
 
 
 def get_fs_config(config, **kwargs):
     name = kwargs.get("name")
     if name:
-        remote_conf = config["remote"][name.lower()]
+        try:
+            remote_conf = config["remote"][name.lower()]
+        except KeyError:
+            from dvc.config import RemoteNotFoundError
+
+            raise RemoteNotFoundError(f"remote '{name}' doesn't exist")
     else:
         remote_conf = kwargs
     return _resolve_remote_refs(config, remote_conf)
@@ -106,4 +112,11 @@ def get_cloud_fs(repo, **kwargs):
     if cls == GDriveFileSystem and repo:
         remote_conf["gdrive_credentials_tmp_dir"] = repo.tmp_dir
 
-    return cls, remote_conf
+    url = remote_conf.pop("url")
+    path_info = cls.PATH_CLS(
+        cls._strip_protocol(url)  # pylint:disable=protected-access
+    )
+
+    extras = cls._get_kwargs_from_urls(url)  # pylint:disable=protected-access
+    conf = {**extras, **remote_conf}  # remote config takes priority
+    return cls, conf, path_info

dvc/fs/azure.py

@@ -1,18 +1,17 @@
-import asyncio
 import logging
 import os
-import sys
 import threading
-from contextlib import contextmanager
 
-from funcy import cached_property, wrap_prop
+from fsspec.asyn import fsspec_loop
+from fsspec.utils import infer_storage_options
+from funcy import cached_property, memoize, wrap_prop
 
 from dvc.exceptions import DvcException
 from dvc.path_info import CloudURLInfo
 from dvc.scheme import Schemes
 from dvc.utils import format_link
 
-from .fsspec_wrapper import ObjectFSWrapper
+from .fsspec_wrapper import CallbackMixin, ObjectFSWrapper
 
 logger = logging.getLogger(__name__)
 _DEFAULT_CREDS_STEPS = (
@@ -22,53 +21,25 @@ _DEFAULT_CREDS_STEPS = (
 )
 
 
-@contextmanager
-def _temp_event_loop():
-    """When trying to initalize azure filesystem instances
-    with DefaultCredentials, the authentication process requires
-    to have an access to a separate event loop. The normal calls
-    are run in a separate loop managed by the fsspec, but the
-    DefaultCredentials assumes that the callee is managing their
-    own event loop. This function checks whether is there any
-    event loop set, and if not it creates a temporary event loop
-    and set it. After the context is finalized, it restores the
-    original event loop back (if there is any)."""
-
-    try:
-        original_loop = asyncio.get_event_loop()
-        original_policy = asyncio.get_event_loop_policy()
-    except RuntimeError:
-        original_loop = None
-        original_policy = None
-
-    # From 3.8>= and onwards, asyncio changed the default
-    # loop policy for windows to use proactor loops instead
-    # of selector based ones. Due to that, proxied connections
-    # doesn't work with the aiohttp and this is most likely an
-    # upstream bug that needs to be solved outside of DVC. Until
-    # such issue is resolved, we need to manage this;
-    # https://github.com/aio-libs/aiohttp/issues/4536
-    if sys.version_info >= (3, 8) and os.name == "nt":
-        asyncio.set_event_loop_policy(asyncio.WindowsSelectorEventLoopPolicy())
-
-    loop = original_loop or asyncio.new_event_loop()
-
-    try:
-        asyncio.set_event_loop(loop)
-        yield
-    finally:
-        if original_loop is None:
-            loop.close()
-        asyncio.set_event_loop(original_loop)
-        asyncio.set_event_loop_policy(original_policy)
-
-
 class AzureAuthError(DvcException):
     pass
 
 
+@memoize
+def _az_config():
+    # NOTE: ideally we would've used get_default_cli().config from
+    # azure.cli.core, but azure-cli-core has a lot of conflicts with other
+    # dependencies. So instead we are just use knack directly
+    from knack.config import CLIConfig
+
+    config_dir = os.getenv(
+        "AZURE_CONFIG_DIR", os.path.expanduser(os.path.join("~", ".azure"))
+    )
+    return CLIConfig(config_dir=config_dir, config_env_var_prefix="AZURE")
+
+
 # pylint:disable=abstract-method
-class AzureFileSystem(ObjectFSWrapper):
+class AzureFileSystem(CallbackMixin, ObjectFSWrapper):
     scheme = Schemes.AZURE
     PATH_CLS = CloudURLInfo
     PARAM_CHECKSUM = "etag"
@@ -79,19 +50,21 @@ class AzureFileSystem(ObjectFSWrapper):
         "azure-identity": "azure.identity",
     }
 
-    def __init__(self, **config):
-        super().__init__(**config)
+    @classmethod
+    def _strip_protocol(cls, path: str):
+        bucket = infer_storage_options(path).get("host")
+        if bucket:
+            return path
 
-        url = config.get("url")
-        self.path_info = self.PATH_CLS(url)
-        self.bucket = self.path_info.bucket
+        bucket = _az_config().get("storage", "container_name", None)
+        return f"azure://{bucket}"
 
-        if not self.bucket:
-            container = self._az_config.get("storage", "container_name", None)
-            url = f"azure://{container}"
-
-        self.path_info = self.PATH_CLS(url)
-        self.bucket = self.path_info.bucket
+    @staticmethod
+    def _get_kwargs_from_urls(urlpath):
+        ops = infer_storage_options(urlpath)
+        if "host" in ops:
+            return {"bucket": ops["host"]}
+        return {}
 
     def _prepare_credentials(self, **config):
         from azure.identity.aio import DefaultAzureCredential
@@ -102,28 +75,54 @@ class AzureFileSystem(ObjectFSWrapper):
         login_info = {}
         login_info["connection_string"] = config.get(
             "connection_string",
-            self._az_config.get("storage", "connection_string", None),
+            _az_config().get("storage", "connection_string", None),
         )
         login_info["account_name"] = config.get(
-            "account_name", self._az_config.get("storage", "account", None)
+            "account_name", _az_config().get("storage", "account", None)
         )
         login_info["account_key"] = config.get(
-            "account_key", self._az_config.get("storage", "key", None)
+            "account_key", _az_config().get("storage", "key", None)
         )
         login_info["sas_token"] = config.get(
-            "sas_token", self._az_config.get("storage", "sas_token", None)
+            "sas_token", _az_config().get("storage", "sas_token", None)
         )
         login_info["tenant_id"] = config.get("tenant_id")
         login_info["client_id"] = config.get("client_id")
         login_info["client_secret"] = config.get("client_secret")
 
-        if not any(
-            value for key, value in login_info.items() if key != "account_name"
-        ):
-            login_info["credential"] = DefaultAzureCredential(
-                exclude_interactive_browser_credential=False
+        if not (login_info["account_name"] or login_info["connection_string"]):
+            raise AzureAuthError(
+                "Authentication to Azure Blob Storage requires either "
+                "account_name or connection_string.\nLearn more about "
+                "configuration settings at "
+                + format_link("https://man.dvc.org/remote/modify")
             )
 
+        any_secondary = any(
+            value for key, value in login_info.items() if key != "account_name"
+        )
+        if (
+            login_info["account_name"]
+            and not any_secondary
+            and not config.get("allow_anonymous_login", False)
+        ):
+            with fsspec_loop():
+                login_info["credential"] = DefaultAzureCredential(
+                    exclude_interactive_browser_credential=False,
+                    exclude_environment_credential=config.get(
+                        "exclude_environment_credential", False
+                    ),
+                    exclude_visual_studio_code_credential=config.get(
+                        "exclude_visual_studio_code_credential", False
+                    ),
+                    exclude_shared_token_cache_credential=config.get(
+                        "exclude_shared_token_cache_credential", False
+                    ),
+                    exclude_managed_identity_credential=config.get(
+                        "exclude_managed_identity_credential", False
+                    ),
+                )
+
         for login_method, required_keys in [  # noqa
             ("connection string", ["connection_string"]),
             (
@@ -146,18 +145,6 @@ class AzureFileSystem(ObjectFSWrapper):
         self.login_method = login_method
         return login_info
 
-    @cached_property
-    def _az_config(self):
-        # NOTE: ideally we would've used get_default_cli().config from
-        # azure.cli.core, but azure-cli-core has a lot of conflicts with other
-        # dependencies. So instead we are just use knack directly
-        from knack.config import CLIConfig
-
-        config_dir = os.getenv(
-            "AZURE_CONFIG_DIR", os.path.expanduser(os.path.join("~", ".azure"))
-        )
-        return CLIConfig(config_dir=config_dir, config_env_var_prefix="AZURE")
-
     @wrap_prop(threading.Lock())
     @cached_property
     def fs(self):
@@ -165,23 +152,10 @@ class AzureFileSystem(ObjectFSWrapper):
         from azure.core.exceptions import AzureError
 
         try:
-            with _temp_event_loop():
-                file_system = AzureBlobFileSystem(**self.fs_args)
-                if self.bucket not in [
-                    container.rstrip("/") for container in file_system.ls("/")
-                ]:
-                    file_system.mkdir(self.bucket)
+            return AzureBlobFileSystem(**self.fs_args)
         except (ValueError, AzureError) as e:
             raise AzureAuthError(
                 f"Authentication to Azure Blob Storage via {self.login_method}"
                 " failed.\nLearn more about configuration settings at"
                 f" {format_link('https://man.dvc.org/remote/modify')}"
             ) from e
-
-        return file_system
-
-    def open(
-        self, path_info, mode="r", **kwargs
-    ):  # pylint: disable=arguments-differ
-        with _temp_event_loop():
-            return self.fs.open(self._with_bucket(path_info), mode=mode)

dvc/fs/base.py

@@ -1,15 +1,19 @@
+import contextlib
 import logging
+import os
 from concurrent.futures import ThreadPoolExecutor, as_completed
-from functools import partial, partialmethod
+from functools import partialmethod
 from multiprocessing import cpu_count
 from typing import Any, ClassVar, Dict, FrozenSet, Optional
 
+from tqdm.utils import CallbackIOWrapper
+
 from dvc.exceptions import DvcException
 from dvc.path_info import URLInfo
-from dvc.progress import Tqdm
+from dvc.progress import DEFAULT_CALLBACK, FsspecCallback
+from dvc.ui import ui
 from dvc.utils import tmp_fname
 from dvc.utils.fs import makedirs, move
-from dvc.utils.http import open_url
 
 logger = logging.getLogger(__name__)
 
@@ -33,6 +37,8 @@ class RemoteMissingDepsError(DvcException):
 
 
 class BaseFileSystem:
+    sep = "/"
+
     scheme = "base"
     REQUIRES: ClassVar[Dict[str, str]] = {}
     PATH_CLS = URLInfo  # type: Any
@@ -55,10 +61,21 @@ class BaseFileSystem:
     def __init__(self, **kwargs):
         self._check_requires(**kwargs)
 
-        self.path_info = None
-
         self.jobs = kwargs.get("jobs") or self._JOBS
         self.hash_jobs = kwargs.get("checksum_jobs") or self.HASH_JOBS
+        self._config = kwargs
+
+    @property
+    def config(self):
+        return self._config
+
+    @classmethod
+    def _strip_protocol(cls, path: str):
+        return path
+
+    @staticmethod
+    def _get_kwargs_from_urls(urlpath):  # pylint:disable=unused-argument
+        return {}
 
     @classmethod
     def get_missing_deps(cls):
@@ -112,13 +129,10 @@ class BaseFileSystem:
             f"dependencies: {missing}. {hint}"
         )
 
-    def open(self, path_info, mode: str = "r", encoding: str = None, **kwargs):
-        if hasattr(self, "_generate_download_url"):
-            # pylint:disable=no-member
-            func = self._generate_download_url  # type: ignore[attr-defined]
-            get_url = partial(func, path_info)
-            return open_url(get_url, mode=mode, encoding=encoding, **kwargs)
+    def checksum(self, path_info) -> str:
+        raise NotImplementedError
 
+    def open(self, path_info, mode: str = "r", encoding: str = None, **kwargs):
         raise RemoteActionNotImplemented("open", self.scheme)
 
     def exists(self, path_info) -> bool:
@@ -161,12 +175,6 @@ class BaseFileSystem:
         """
         raise NotImplementedError
 
-    def ls(self, path_info, detail=False):
-        raise RemoteActionNotImplemented("ls", self.scheme)
-
-    def find(self, path_info, detail=False):
-        raise RemoteActionNotImplemented("find", self.scheme)
-
     def is_empty(self, path_info):
         return False
 
@@ -179,7 +187,7 @@ class BaseFileSystem:
     def remove(self, path_info):
         raise RemoteActionNotImplemented("remove", self.scheme)
 
-    def makedirs(self, path_info):
+    def makedirs(self, path_info, **kwargs):
         """Optional: Implement only if the remote needs to create
         directories before copying/linking/moving data
         """
@@ -208,119 +216,164 @@ class BaseFileSystem:
             return False
         return hash_.endswith(cls.CHECKSUM_DIR_SUFFIX)
 
-    def upload(self, from_info, to_info, name=None, no_progress_bar=False):
-        if not hasattr(self, "_upload"):
-            raise RemoteActionNotImplemented("upload", self.scheme)
+    def upload(
+        self,
+        from_info,
+        to_info,
+        total=None,
+        desc=None,
+        callback=None,
+        no_progress_bar=False,
+        **pbar_args,
+    ):
+        is_file_obj = hasattr(from_info, "read")
+        method = "upload_fobj" if is_file_obj else "put_file"
+        if not hasattr(self, method):
+            raise RemoteActionNotImplemented(method, self.scheme)
 
         if to_info.scheme != self.scheme:
             raise NotImplementedError
 
-        if from_info.scheme != "local":
-            raise NotImplementedError
+        if not is_file_obj:
+            desc = desc or from_info.name
 
-        logger.debug("Uploading '%s' to '%s'", from_info, to_info)
+        stack = contextlib.ExitStack()
+        if not callback:
+            pbar = ui.progress(
+                desc=desc,
+                disable=no_progress_bar,
+                bytes=True,
+                total=total or -1,
+                **pbar_args,
+            )
+            stack.enter_context(pbar)
+            callback = pbar.as_callback()
+            if total:
+                callback.set_size(total)
 
-        name = name or from_info.name
+        with stack:
+            if is_file_obj:
+                wrapped = CallbackIOWrapper(
+                    callback.relative_update, from_info
+                )
+                # `size` is used to provide hints to the WebdavFileSystem
+                # for legacy servers.
+                # pylint: disable=no-member
+                return self.upload_fobj(wrapped, to_info, size=total)
 
-        self._upload(  # noqa, pylint: disable=no-member
-            from_info.fspath,
-            to_info,
-            name=name,
-            no_progress_bar=no_progress_bar,
-        )
+            if from_info.scheme != "local":
+                raise NotImplementedError
 
-    def upload_fobj(self, fobj, to_info, no_progress_bar=False, **pbar_args):
-        if not hasattr(self, "_upload_fobj"):
-            raise RemoteActionNotImplemented("upload_fobj", self.scheme)
-
-        with Tqdm.wrapattr(
-            fobj, "read", disable=no_progress_bar, bytes=True, **pbar_args
-        ) as wrapped:
-            self._upload_fobj(wrapped, to_info)  # pylint: disable=no-member
+            logger.debug("Uploading '%s' to '%s'", from_info, to_info)
+            # pylint: disable=no-member
+            return self.put_file(
+                os.fspath(from_info), to_info, callback=callback
+            )
 
     def download(
         self,
         from_info,
         to_info,
         name=None,
+        callback=None,
         no_progress_bar=False,
         jobs=None,
         _only_file=False,
         **kwargs,
     ):
-        if not hasattr(self, "_download"):
-            raise RemoteActionNotImplemented("download", self.scheme)
+        if not hasattr(self, "get_file"):
+            raise RemoteActionNotImplemented("get_file", self.scheme)
 
         if from_info.scheme != self.scheme:
             raise NotImplementedError
 
-        if to_info.scheme == self.scheme != "local":
-            self.copy(from_info, to_info)
-            return 0
-
         if to_info.scheme != "local":
             raise NotImplementedError
 
-        if not _only_file and self.isdir(from_info):
-            return self._download_dir(
-                from_info, to_info, name, no_progress_bar, jobs, **kwargs
+        download_dir = not _only_file and self.isdir(from_info)
+
+        desc = name or to_info.name
+        stack = contextlib.ExitStack()
+        if not callback:
+            pbar_kwargs = {"unit": "Files"} if download_dir else {}
+            pbar = ui.progress(
+                total=-1,
+                desc="Downloading directory" if download_dir else desc,
+                bytes=not download_dir,
+                disable=no_progress_bar,
+                **pbar_kwargs,
             )
-        return self._download_file(from_info, to_info, name, no_progress_bar)
+            stack.enter_context(pbar)
+            callback = pbar.as_callback()
+
+        with stack:
+            if download_dir:
+                return self._download_dir(
+                    from_info, to_info, callback=callback, jobs=jobs, **kwargs
+                )
+            return self._download_file(from_info, to_info, callback=callback)
 
     download_file = partialmethod(download, _only_file=True)
 
     def _download_dir(
-        self, from_info, to_info, name, no_progress_bar, jobs, **kwargs
+        self,
+        from_info,
+        to_info,
+        callback=DEFAULT_CALLBACK,
+        jobs=None,
+        **kwargs,
     ):
         from_infos = list(self.walk_files(from_info, **kwargs))
         if not from_infos:
             makedirs(to_info, exist_ok=True)
             return None
+
         to_infos = (
             to_info / info.relative_to(from_info) for info in from_infos
         )
+        callback.set_size(len(from_infos))
 
-        with Tqdm(
-            total=len(from_infos),
-            desc="Downloading directory",
-            unit="Files",
-            disable=no_progress_bar,
-        ) as pbar:
-            download_files = pbar.wrap_fn(
-                partial(self._download_file, name=name, no_progress_bar=True)
-            )
-            max_workers = jobs or self.jobs
-            with ThreadPoolExecutor(max_workers=max_workers) as executor:
-                futures = [
-                    executor.submit(download_files, from_info, to_info)
-                    for from_info, to_info in zip(from_infos, to_infos)
-                ]
+        download_files = FsspecCallback.wrap_fn(callback, self._download_file)
+        max_workers = jobs or self.jobs
+        with ThreadPoolExecutor(max_workers=max_workers) as executor:
+            futures = [
+                executor.submit(download_files, from_info, to_info)
+                for from_info, to_info in zip(from_infos, to_infos)
+            ]
 
-                # NOTE: unlike pulling/fetching cache, where we need to
-                # download everything we can, not raising an error here might
-                # turn very ugly, as the user might think that he has
-                # downloaded a complete directory, while having a partial one,
-                # which might cause unexpected results in his pipeline.
-                for future in as_completed(futures):
-                    # NOTE: executor won't let us raise until all futures that
-                    # it has are finished, so we need to cancel them ourselves
-                    # before re-raising.
-                    exc = future.exception()
-                    if exc:
-                        for entry in futures:
-                            entry.cancel()
-                        raise exc
+            # NOTE: unlike pulling/fetching cache, where we need to
+            # download everything we can, not raising an error here might
+            # turn very ugly, as the user might think that he has
+            # downloaded a complete directory, while having a partial one,
+            # which might cause unexpected results in his pipeline.
+            for future in as_completed(futures):
+                # NOTE: executor won't let us raise until all futures that
+                # it has are finished, so we need to cancel them ourselves
+                # before re-raising.
+                exc = future.exception()
+                if exc:
+                    for entry in futures:
+                        entry.cancel()
+                    raise exc
 
-    def _download_file(self, from_info, to_info, name, no_progress_bar):
+    def _download_file(
+        self,
+        from_info,
+        to_info,
+        callback=DEFAULT_CALLBACK,
+    ):
         makedirs(to_info.parent, exist_ok=True)
-
-        logger.debug("Downloading '%s' to '%s'", from_info, to_info)
-        name = name or to_info.name
-
         tmp_file = tmp_fname(to_info)
 
-        self._download(  # noqa, pylint: disable=no-member
-            from_info, tmp_file, name=name, no_progress_bar=no_progress_bar
-        )
+        logger.debug("Downloading '%s' to '%s'", from_info, to_info)
+        try:
+            # noqa, pylint: disable=no-member
+            self.get_file(from_info, tmp_file, callback=callback)
+        except Exception:  # pylint: disable=broad-except
+            # do we need to rollback makedirs for previously not-existing
+            # directories?
+            with contextlib.suppress(FileNotFoundError):
+                os.unlink(tmp_file)
+            raise
 
         move(tmp_file, to_info)

dvc/fs/dvc.py

@@ -6,6 +6,7 @@ from dvc.exceptions import OutputNotFoundError
 from dvc.path_info import PathInfo
 from dvc.utils import relpath
 
+from ..progress import DEFAULT_CALLBACK
 from ._metadata import Metadata
 from .base import BaseFileSystem
 
@@ -23,6 +24,8 @@ class DvcFileSystem(BaseFileSystem):  # pylint:disable=abstract-method
         repo: DVC repo.
     """
 
+    sep = os.sep
+
     scheme = "local"
     PARAM_CHECKSUM = "md5"
 
@@ -30,6 +33,10 @@ class DvcFileSystem(BaseFileSystem):  # pylint:disable=abstract-method
         super().__init__(**kwargs)
         self.repo = kwargs["repo"]
 
+    @property
+    def config(self):
+        raise NotImplementedError
+
     def _find_outs(self, path, *args, **kwargs):
         outs = self.repo.find_outs_by_path(path, *args, **kwargs)
 
@@ -49,14 +56,14 @@ class DvcFileSystem(BaseFileSystem):  # pylint:disable=abstract-method
         # NOTE: use string paths here for performance reasons
         key = tuple(relpath(path_info, out.path_info).split(os.sep))
         out.get_dir_cache(remote=remote)
+        if out.obj is None:
+            raise FileNotFoundError
         obj = out.obj.trie.get(key)
         if obj:
             return obj.hash_info
         raise FileNotFoundError
 
-    def open(  # type: ignore
-        self, path: PathInfo, mode="r", encoding=None, remote=None, **kwargs
-    ):  # pylint: disable=arguments-differ
+    def _get_fs_path(self, path: PathInfo, remote=None):
         try:
             outs = self._find_outs(path, strict=False)
         except OutputNotFoundError as exc:
@@ -76,33 +83,37 @@ class DvcFileSystem(BaseFileSystem):  # pylint:disable=abstract-method
             from dvc.config import NoRemoteError
 
             try:
-                remote_obj = self.repo.cloud.get_remote(remote)
+                remote_odb = self.repo.cloud.get_remote_odb(remote)
             except NoRemoteError as exc:
                 raise FileNotFoundError from exc
             if out.is_dir_checksum:
                 checksum = self._get_granular_hash(path, out).value
             else:
                 checksum = out.hash_info.value
-            remote_info = remote_obj.odb.hash_to_path_info(checksum)
-            return remote_obj.fs.open(
-                remote_info, mode=mode, encoding=encoding
-            )
+            remote_info = remote_odb.hash_to_path_info(checksum)
+            return remote_odb.fs, remote_info
 
         if out.is_dir_checksum:
             checksum = self._get_granular_hash(path, out).value
             cache_path = out.odb.hash_to_path_info(checksum).url
         else:
             cache_path = out.cache_path
-        return open(cache_path, mode=mode, encoding=encoding)
+        return out.odb.fs, cache_path
 
-    def exists(self, path):  # pylint: disable=arguments-differ
+    def open(  # type: ignore
+        self, path: PathInfo, mode="r", encoding=None, **kwargs
+    ):  # pylint: disable=arguments-renamed
+        fs, fspath = self._get_fs_path(path, **kwargs)
+        return fs.open(fspath, mode=mode, encoding=encoding)
+
+    def exists(self, path):  # pylint: disable=arguments-renamed
         try:
             self.metadata(path)
             return True
         except FileNotFoundError:
             return False
 
-    def isdir(self, path):  # pylint: disable=arguments-differ
+    def isdir(self, path):  # pylint: disable=arguments-renamed
         try:
             meta = self.metadata(path)
             return meta.isdir
@@ -125,7 +136,7 @@ class DvcFileSystem(BaseFileSystem):  # pylint:disable=abstract-method
         except FileNotFoundError:
             return True
 
-    def isfile(self, path):  # pylint: disable=arguments-differ
+    def isfile(self, path):  # pylint: disable=arguments-renamed
         try:
             meta = self.metadata(path)
             return meta.isfile
@@ -231,7 +242,7 @@ class DvcFileSystem(BaseFileSystem):  # pylint:disable=abstract-method
 
     def info(self, path_info):
         meta = self.metadata(path_info)
-        ret = {"type": "dir" if meta.isdir else "file"}
+        ret = {"type": "directory" if meta.isdir else "file"}
         if meta.is_output and len(meta.outs) == 1 and meta.outs[0].hash_info:
             hash_info = meta.outs[0].hash_info
             ret["size"] = hash_info.size
@@ -245,3 +256,18 @@ class DvcFileSystem(BaseFileSystem):  # pylint:disable=abstract-method
                 ret[obj.hash_info.name] = obj.hash_info.value
 
         return ret
+
+    def get_file(
+        self, from_info, to_file, callback=DEFAULT_CALLBACK, **kwargs
+    ):
+        fs, path = self._get_fs_path(from_info)
+        fs.get_file(  # pylint: disable=protected-access
+            path, to_file, callback=callback, **kwargs
+        )
+
+    def checksum(self, path_info):
+        info = self.info(path_info)
+        md5 = info.get("md5")
+        if md5:
+            return md5
+        raise NotImplementedError

dvc/fs/fsspec_wrapper.py

@@ -1,40 +1,78 @@
 import os
 import shutil
 from functools import lru_cache
+from typing import (
+    IO,
+    TYPE_CHECKING,
+    Any,
+    Dict,
+    Iterator,
+    Optional,
+    Union,
+    overload,
+)
 
 from funcy import cached_property
+from tqdm.utils import CallbackIOWrapper
 
-from dvc.progress import Tqdm
+from dvc.path_info import URLInfo
+from dvc.progress import DEFAULT_CALLBACK
 
 from .base import BaseFileSystem
 
+FSPath = URLInfo
+AnyFSPath = Union[FSPath, str]
+
+if TYPE_CHECKING:
+    from typing import Iterable
+
+    from typing_extensions import Literal
+
+
+# An info() entry, might evolve to a TypedDict
+# in the future (e.g for properly type 'size' etc).
+Entry = Dict[str, Any]
+
 
 # pylint: disable=no-member
 class FSSpecWrapper(BaseFileSystem):
+    TRAVERSE_PREFIX_LEN = 2
+
     def __init__(self, **kwargs):
         super().__init__(**kwargs)
         self.fs_args = {"skip_instance_cache": True}
         self.fs_args.update(self._prepare_credentials(**kwargs))
 
+    @staticmethod
+    def _get_kwargs_from_urls(urlpath: str) -> "Dict[str, Any]":
+        from fsspec.utils import infer_storage_options
+
+        options = infer_storage_options(urlpath)
+        options.pop("path", None)
+        options.pop("protocol", None)
+        return options
+
     @cached_property
     def fs(self):
         raise NotImplementedError
 
-    @lru_cache(512)
-    def _with_bucket(self, path):
-        if isinstance(path, self.PATH_CLS):
-            return f"{path.bucket}/{path.path}"
-        return path
+    def _with_bucket(self, path: AnyFSPath) -> str:
+        return str(path)
 
-    def _strip_bucket(self, entry):
-        try:
-            bucket, path = entry.split("/", 1)
-        except ValueError:
-            # If there is no path attached, only returns
-            # the bucket (top-level).
-            bucket, path = entry, None
+    def _strip_bucket(self, entry: str) -> str:
+        return entry
 
-        return path or bucket
+    @overload
+    def _strip_buckets(
+        self, entries: "Iterable[Entry]", detail: "Literal[True]"
+    ) -> "Iterator[Entry]":
+        ...
+
+    @overload
+    def _strip_buckets(
+        self, entries: "Iterable[str]", detail: "Literal[False]" = False
+    ) -> "Iterator[str]":
+        ...
 
     def _strip_buckets(self, entries, detail=False):
         for entry in entries:
@@ -45,56 +83,93 @@ class FSSpecWrapper(BaseFileSystem):
                 entry = self._strip_bucket(entry)
             yield entry
 
-    def _entry_hook(self, entry):
-        """Simple hook method to be overriden when wanted to process
+    def _entry_hook(self, entry: "Entry") -> "Entry":
+        """Simple hook method to be overridden when wanted to process
         entries within info() and ls(detail=True) calls"""
         return entry
 
     def _prepare_credentials(
-        self, **config
-    ):  # pylint: disable=unused-argument
+        self, **config: Dict[str, Any]  # pylint: disable=unused-argument
+    ) -> Dict[str, Any]:
         """Prepare the arguments for authentication to the
         host filesystem"""
         return {}
 
-    def _isdir(self, path_info):
+    def _isdir(self, path_info: FSPath) -> bool:
         return self.fs.isdir(self._with_bucket(path_info))
 
-    def isdir(self, path_info):
+    def isdir(self, path_info: FSPath) -> bool:
         try:
             return self._isdir(path_info)
         except FileNotFoundError:
             return False
 
-    def isfile(self, path_info):
+    def isfile(self, path_info: FSPath) -> bool:
         try:
             return not self._isdir(path_info)
         except FileNotFoundError:
             return False
 
-    def is_empty(self, path_info):
+    def is_empty(self, path_info: FSPath) -> bool:
         entry = self.info(path_info)
         if entry["type"] == "directory":
             return not self.fs.ls(self._with_bucket(path_info))
         return entry["size"] == 0
 
     def open(
-        self, path_info, mode="r", **kwargs
-    ):  # pylint: disable=arguments-differ
+        self,
+        path_info: FSPath,
+        mode: str = "r",
+        encoding: Optional[str] = None,
+        **kwargs,
+    ) -> "IO":  # pylint: disable=arguments-differ
         return self.fs.open(self._with_bucket(path_info), mode=mode)
 
-    def copy(self, from_info, to_info):
+    def checksum(self, path_info: FSPath) -> str:
+        return self.fs.checksum(self._with_bucket(path_info))
+
+    def copy(self, from_info: FSPath, to_info: FSPath) -> None:
+        self.makedirs(to_info.parent)
         self.fs.copy(self._with_bucket(from_info), self._with_bucket(to_info))
 
-    def exists(self, path_info) -> bool:
+    def exists(self, path_info: FSPath) -> bool:
         return self.fs.exists(self._with_bucket(path_info))
 
+    @overload
+    def ls(
+        self, path_info: FSPath, detail: "Literal[True]"
+    ) -> "Iterator[Entry]":
+        ...
+
+    @overload
+    def ls(self, path_info: FSPath, detail: "Literal[False]") -> Iterator[str]:
+        ...
+
     def ls(self, path_info, detail=False):
         path = self._with_bucket(path_info)
         files = self.fs.ls(path, detail=detail)
         yield from self._strip_buckets(files, detail=detail)
 
-    def find(self, path_info, detail=False):
+    @overload
+    def find(
+        self,
+        path_info: FSPath,
+        detail: "Literal[True]",
+        prefix: Optional[bool],
+    ) -> "Iterator[Entry]":
+        ...
+
+    @overload
+    def find(
+        self,
+        path_info: FSPath,
+        detail: "Literal[False]",
+        prefix: Optional[bool],
+    ) -> Iterator[str]:
+        ...
+
+    # pylint: disable=unused-argument
+    def find(self, path_info, detail=False, prefix=None):
         path = self._with_bucket(path_info)
         files = self.fs.find(path, detail=detail)
         if detail:
@@ -102,58 +177,86 @@ class FSSpecWrapper(BaseFileSystem):
 
         yield from self._strip_buckets(files, detail=detail)
 
-    def walk_files(self, path_info, **kwargs):
-        for file in self.find(path_info):
+    def walk_files(self, path_info: FSPath, **kwargs) -> Iterator[FSPath]:
+        for file in self.find(path_info, **kwargs):
             yield path_info.replace(path=file)
 
-    def remove(self, path_info):
-        self.fs.rm(self._with_bucket(path_info))
+    def move(self, from_info: FSPath, to_info: FSPath) -> None:
+        self.fs.move(self._with_bucket(from_info), self._with_bucket(to_info))
 
-    def info(self, path_info):
+    def remove(self, path_info: FSPath) -> None:
+        self.fs.rm_file(self._with_bucket(path_info))
+
+    def info(self, path_info: FSPath) -> "Entry":
         info = self.fs.info(self._with_bucket(path_info)).copy()
         info = self._entry_hook(info)
         info["name"] = self._strip_bucket(info["name"])
         return info
 
-    def _upload_fobj(self, fobj, to_info):
-        with self.open(to_info, "wb") as fdest:
-            shutil.copyfileobj(fobj, fdest, length=fdest.blocksize)
+    def makedirs(self, path_info: FSPath, **kwargs) -> None:
+        self.fs.makedirs(
+            self._with_bucket(path_info), exist_ok=kwargs.pop("exist_ok", True)
+        )
 
-    def _upload(
-        self, from_file, to_info, name=None, no_progress_bar=False, **kwargs
-    ):
-        total = os.path.getsize(from_file)
-        with open(from_file, "rb") as fobj:
-            self.upload_fobj(
-                fobj,
-                self._with_bucket(to_info),
-                desc=name,
-                total=total,
-                no_progress_bar=no_progress_bar,
-            )
+    def put_file(
+        self,
+        from_file: FSPath,
+        to_info: FSPath,
+        callback: Any = DEFAULT_CALLBACK,
+        **kwargs,
+    ) -> None:
+        self.fs.put_file(
+            from_file, self._with_bucket(to_info), callback=callback, **kwargs
+        )
         self.fs.invalidate_cache(self._with_bucket(to_info.parent))
 
-    def _download(
-        self, from_info, to_file, name=None, no_progress_bar=False, **pbar_args
-    ):
-        total = self.getsize(self._with_bucket(from_info))
-        with self.open(from_info, "rb") as fobj:
-            with Tqdm.wrapattr(
-                fobj,
-                "read",
-                desc=name,
-                disable=no_progress_bar,
-                bytes=True,
-                total=total,
-                **pbar_args,
-            ) as wrapped:
-                with open(to_file, "wb") as fdest:
-                    shutil.copyfileobj(wrapped, fdest, length=fobj.blocksize)
+    def get_file(
+        self,
+        from_info: FSPath,
+        to_info: FSPath,
+        callback: Any = DEFAULT_CALLBACK,
+        **kwargs,
+    ) -> None:
+        self.fs.get_file(
+            self._with_bucket(from_info), to_info, callback=callback, **kwargs
+        )
+
+    def upload_fobj(self, fobj: IO, to_info: FSPath, **kwargs) -> None:
+        self.makedirs(to_info.parent)
+        with self.open(to_info, "wb") as fdest:
+            shutil.copyfileobj(
+                fobj, fdest, length=getattr(fdest, "blocksize", None)
+            )
 
 
 # pylint: disable=abstract-method
 class ObjectFSWrapper(FSSpecWrapper):
-    def _isdir(self, path_info):
+    TRAVERSE_PREFIX_LEN = 3
+
+    @lru_cache(512)
+    def _with_bucket(self, path: AnyFSPath) -> str:
+        if isinstance(path, self.PATH_CLS):
+            return f"{path.bucket}/{path.path}"
+        return str(path)
+
+    def _strip_bucket(self, entry: str) -> str:
+        try:
+            bucket, path = entry.split("/", 1)
+        except ValueError:
+            # If there is no path attached, only returns
+            # the bucket (top-level).
+            bucket, path = entry, ""
+        return path or bucket
+
+    def makedirs(self, path_info: FSPath, **kwargs) -> None:
+        # For object storages make this method a no-op. The original
+        # fs.makedirs() method will only check if the bucket exists
+        # and create if it doesn't though we don't want to support
+        # that behavior, and the check will cost some time so we'll
+        # simply ignore all mkdir()/makedirs() calls.
+        return None
+
+    def _isdir(self, path_info: FSPath) -> bool:
         # Directory in object storages are interpreted differently
         # among different fsspec providers, so this logic is a temporary
         # measure for us to adapt as of now. It checks whether it is a
@@ -167,11 +270,18 @@ class ObjectFSWrapper(FSSpecWrapper):
             and entry["name"].endswith("/")
         )
 
-    def find(self, path_info, detail=False):
-        path = self._with_bucket(path_info)
-        files = self.fs.find(path, detail=detail)
+    def find(self, path_info, detail=False, prefix=None):
+        if prefix:
+            path = self._with_bucket(path_info.parent)
+            files = self.fs.find(
+                path, detail=detail, prefix=path_info.parts[-1]
+            )
+        else:
+            path = self._with_bucket(path_info)
+            files = self.fs.find(path, detail=detail)
+
         if detail:
-            files = files.values()
+            files = list(files.values())
 
         # When calling find() on a file, it returns the same file in a list.
         # For object-based storages, the same behavior applies to empty
@@ -181,4 +291,64 @@ class ObjectFSWrapper(FSSpecWrapper):
         if len(files) == 1 and files[0] == path and self.isdir(path_info):
             return None
 
-        yield from self._strip_buckets(files, detail=detail)
+        yield from self._strip_buckets(  # pylint: disable=not-an-iterable
+            files, detail=detail
+        )
+
+
+# pylint: disable=arguments-differ
+class NoDirectoriesMixin:
+    def isdir(self, *args, **kwargs):
+        return False
+
+    def isfile(self, *args, **kwargs):
+        return True
+
+    def find(self, *args, **kwargs):
+        raise NotImplementedError
+
+    def walk(self, *args, **kwargs):
+        raise NotImplementedError
+
+    def walk_files(self, *args, **kwargs):
+        raise NotImplementedError
+
+    def ls(self, *args, **kwargs):
+        raise NotImplementedError
+
+
+class CallbackMixin:
+    """Provides callback support for the filesystem that don't support yet."""
+
+    def put_file(
+        self,
+        from_file,
+        to_info,
+        callback=DEFAULT_CALLBACK,
+        **kwargs,
+    ):
+        """Add compatibility support for Callback."""
+        # pylint: disable=protected-access
+        self.makedirs(to_info.parent)
+        size = os.path.getsize(from_file)
+        with open(from_file, "rb") as fobj:
+            callback.set_size(size)
+            wrapped = CallbackIOWrapper(callback.relative_update, fobj)
+            self.upload_fobj(wrapped, to_info)
+            self.fs.invalidate_cache(self._with_bucket(to_info.parent))
+
+    def get_file(
+        self,
+        from_info,
+        to_info,
+        callback=DEFAULT_CALLBACK,
+        **kwargs,
+    ):
+        # pylint: disable=protected-access
+        total: int = self.getsize(from_info)
+        if total:
+            callback.set_size(total)
+
+        with self.open(from_info, "rb") as fobj, open(to_info, "wb") as fdest:
+            wrapped = CallbackIOWrapper(callback.relative_update, fobj)
+            shutil.copyfileobj(wrapped, fdest, length=fobj.blocksize)

dvc/fs/gdrive.py

@@ -1,24 +1,18 @@
-import io
 import logging
 import os
 import posixpath
 import re
 import threading
-from collections import defaultdict
-from contextlib import contextmanager
 from urllib.parse import urlparse
 
-from funcy import cached_property, retry, wrap_prop, wrap_with
-from funcy.py3 import cat
+from funcy import cached_property, retry, wrap_prop
 
-from dvc.exceptions import DvcException, FileMissingError
+from dvc.exceptions import DvcException
 from dvc.path_info import CloudURLInfo
-from dvc.progress import Tqdm
 from dvc.scheme import Schemes
 from dvc.utils import format_link, tmp_fname
-from dvc.utils.stream import IterStream
 
-from .base import BaseFileSystem
+from .fsspec_wrapper import FSSpecWrapper
 
 logger = logging.getLogger(__name__)
 FOLDER_MIME_TYPE = "application/vnd.google-apps.folder"
@@ -85,7 +79,7 @@ class GDriveURLInfo(CloudURLInfo):
         self._spath = re.sub("/{2,}", "/", self._spath.rstrip("/"))
 
 
-class GDriveFileSystem(BaseFileSystem):  # pylint:disable=abstract-method
+class GDriveFileSystem(FSSpecWrapper):  # pylint:disable=abstract-method
     scheme = Schemes.GDRIVE
     PATH_CLS = GDriveURLInfo
     PARAM_CHECKSUM = "checksum"
@@ -142,6 +136,10 @@ class GDriveFileSystem(BaseFileSystem):  # pylint:disable=abstract-method
             )
         )
 
+    @staticmethod
+    def _get_kwargs_from_urls(urlpath):
+        return {"url": urlpath}
+
     def _validate_config(self):
         # Validate Service Account configuration
         if (
@@ -209,9 +207,9 @@ class GDriveFileSystem(BaseFileSystem):  # pylint:disable=abstract-method
 
     @wrap_prop(threading.RLock())
     @cached_property
-    def _drive(self):
+    def fs(self):
         from pydrive2.auth import GoogleAuth
-        from pydrive2.drive import GoogleDrive
+        from pydrive2.fs import GDriveFileSystem as _GDriveFileSystem
 
         temporary_save_path = self._gdrive_user_credentials_path
         is_credentials_temp = os.getenv(
@@ -286,352 +284,28 @@ class GDriveFileSystem(BaseFileSystem):  # pylint:disable=abstract-method
             if is_credentials_temp:
                 os.remove(temporary_save_path)
 
-        return GoogleDrive(gauth)
+        return _GDriveFileSystem(
+            self._with_bucket(self.path_info),
+            gauth,
+            trash_only=self._trash_only,
+        )
 
-    @wrap_prop(threading.RLock())
-    @cached_property
-    def _ids_cache(self):
-        cache = {
-            "dirs": defaultdict(list),
-            "ids": {},
-            "root_id": self._get_item_id(
-                self.path_info,
-                use_cache=False,
-                hint="Confirm the directory exists and you can access it.",
-            ),
-        }
+    def _with_bucket(self, path):
+        if isinstance(path, self.PATH_CLS):
+            return posixpath.join(path.bucket, path.path)
 
-        self._cache_path_id(self._path, cache["root_id"], cache=cache)
+        return super()._with_bucket(path)
 
-        for item in self._gdrive_list(
-            "'{}' in parents and trashed=false".format(cache["root_id"])
-        ):
-            item_path = (self.path_info / item["title"]).path
-            self._cache_path_id(item_path, item["id"], cache=cache)
-
-        return cache
-
-    def _cache_path_id(self, path, *item_ids, cache=None):
-        cache = cache or self._ids_cache
-        for item_id in item_ids:
-            cache["dirs"][path].append(item_id)
-            cache["ids"][item_id] = path
-
-    @cached_property
-    def _list_params(self):
-        params = {"corpora": "default"}
-        if self._bucket != "root" and self._bucket != "appDataFolder":
-            drive_id = self._gdrive_shared_drive_id(self._bucket)
-            if drive_id:
-                logger.debug(
-                    "GDrive remote '{}' is using shared drive id '{}'.".format(
-                        self.path_info, drive_id
-                    )
-                )
-                params["driveId"] = drive_id
-                params["corpora"] = "drive"
-        return params
-
-    @_gdrive_retry
-    def _gdrive_shared_drive_id(self, item_id):
-        from pydrive2.files import ApiRequestError
-
-        param = {"id": item_id}
-        # it does not create a file on the remote
-        item = self._drive.CreateFile(param)
-        # ID of the shared drive the item resides in.
-        # Only populated for items in shared drives.
+    def _strip_bucket(self, entry):
         try:
-            item.FetchMetadata("driveId")
-        except ApiRequestError as exc:
-            error_code = exc.error.get("code", 0)
-            if error_code == 404:
-                raise DvcException(
-                    "'{}' for '{}':\n\n"
-                    "1. Confirm the directory exists and you can access it.\n"
-                    "2. Make sure that credentials in '{}'\n"
-                    "   are correct for this remote e.g. "
-                    "use the `gdrive_user_credentials_file` config\n"
-                    "   option if you use multiple GDrive remotes with "
-                    "different email accounts.\n\nDetails".format(
-                        item_id, self.path_info, self.credentials_location
-                    )
-                ) from exc
-            raise
+            bucket, path = entry.split("/", 1)
+        except ValueError:
+            # If there is no path attached, only returns
+            # the bucket (top-level).
+            bucket, path = entry, None
+        return path or bucket
 
-        return item.get("driveId", None)
-
-    @_gdrive_retry
-    def _gdrive_upload_fobj(self, fobj, parent_id, title):
-        item = self._drive.CreateFile(
-            {"title": title, "parents": [{"id": parent_id}]}
-        )
-        item.content = fobj
-        item.Upload()
-        return item
-
-    @_gdrive_retry
-    def _gdrive_download_file(
-        self, item_id, to_file, progress_desc, no_progress_bar
-    ):
-        param = {"id": item_id}
-        # it does not create a file on the remote
-        gdrive_file = self._drive.CreateFile(param)
-
-        with Tqdm(
-            desc=progress_desc,
-            disable=no_progress_bar,
-            bytes=True,
-            # explicit `bar_format` as `total` will be set by `update_to`
-            bar_format=Tqdm.BAR_FMT_DEFAULT,
-        ) as pbar:
-            gdrive_file.GetContentFile(to_file, callback=pbar.update_to)
-
-    @contextmanager
-    @_gdrive_retry
-    def open(self, path_info, mode="r", encoding=None, **kwargs):
-        assert mode in {"r", "rt", "rb"}
-
-        item_id = self._get_item_id(path_info)
-        param = {"id": item_id}
-        # it does not create a file on the remote
-        gdrive_file = self._drive.CreateFile(param)
-        fd = gdrive_file.GetContentIOBuffer()
-        stream = IterStream(iter(fd))
-
-        if mode != "rb":
-            stream = io.TextIOWrapper(stream, encoding=encoding)
-
-        yield stream
-
-    @_gdrive_retry
-    def gdrive_delete_file(self, item_id):
-        from pydrive2.files import ApiRequestError
-
-        param = {"id": item_id}
-        # it does not create a file on the remote
-        item = self._drive.CreateFile(param)
-
-        try:
-            item.Trash() if self._trash_only else item.Delete()
-        except ApiRequestError as exc:
-            http_error_code = exc.error.get("code", 0)
-            if (
-                http_error_code == 403
-                and self._list_params["corpora"] == "drive"
-                and exc.GetField("location") == "file.permissions"
-            ):
-                raise DvcException(
-                    "Insufficient permissions to {}. You should have {} "
-                    "access level for the used shared drive. More details "
-                    "at {}.".format(
-                        "move the file into Trash"
-                        if self._trash_only
-                        else "permanently delete the file",
-                        "Manager or Content Manager"
-                        if self._trash_only
-                        else "Manager",
-                        "https://support.google.com/a/answer/7337554",
-                    )
-                ) from exc
-            raise
-
-    def _gdrive_list(self, query):
-        param = {"q": query, "maxResults": 1000}
-        param.update(self._list_params)
-        file_list = self._drive.ListFile(param)
-
-        # Isolate and decorate fetching of remote drive items in pages.
-        get_list = _gdrive_retry(lambda: next(file_list, None))
-
-        # Fetch pages until None is received, lazily flatten the thing.
-        return cat(iter(get_list, None))
-
-    @_gdrive_retry
-    def _gdrive_create_dir(self, parent_id, title):
-        parent = {"id": parent_id}
-        item = self._drive.CreateFile(
-            {"title": title, "parents": [parent], "mimeType": FOLDER_MIME_TYPE}
-        )
-        item.Upload()
-        return item
-
-    @wrap_with(threading.RLock())
-    def _create_dir(self, parent_id, title, remote_path):
-        cached = self._ids_cache["dirs"].get(remote_path)
-        if cached:
-            return cached[0]
-
-        item = self._gdrive_create_dir(parent_id, title)
-
-        if parent_id == self._ids_cache["root_id"]:
-            self._cache_path_id(remote_path, item["id"])
-
-        return item["id"]
-
-    def _get_remote_item_ids(self, parent_ids, title):
-        if not parent_ids:
-            return None
-        query = "trashed=false and ({})".format(
-            " or ".join(
-                f"'{parent_id}' in parents" for parent_id in parent_ids
-            )
-        )
-        query += " and title='{}'".format(title.replace("'", "\\'"))
-
-        # GDrive list API is case insensitive, we need to compare
-        # all results and pick the ones with the right title
-        return [
-            item["id"]
-            for item in self._gdrive_list(query)
-            if item["title"] == title
-        ]
-
-    def _get_cached_item_ids(self, path, use_cache):
-        if not path:
-            return [self._bucket]
-        if use_cache:
-            return self._ids_cache["dirs"].get(path, [])
-        return []
-
-    def _path_to_item_ids(self, path, create=False, use_cache=True):
-        item_ids = self._get_cached_item_ids(path, use_cache)
-        if item_ids:
-            return item_ids
-
-        parent_path, title = posixpath.split(path)
-        parent_ids = self._path_to_item_ids(parent_path, create, use_cache)
-        item_ids = self._get_remote_item_ids(parent_ids, title)
-        if item_ids:
-            return item_ids
-
-        return (
-            [self._create_dir(min(parent_ids), title, path)] if create else []
-        )
-
-    def _get_item_id(self, path_info, create=False, use_cache=True, hint=None):
-        assert path_info.bucket == self._bucket
-
-        item_ids = self._path_to_item_ids(path_info.path, create, use_cache)
-        if item_ids:
-            return min(item_ids)
-
-        assert not create
-        raise FileMissingError(path_info, hint)
-
-    def exists(self, path_info) -> bool:
-        try:
-            self._get_item_id(path_info)
-        except FileMissingError:
-            return False
-        else:
-            return True
-
-    def _gdrive_list_ids(self, query_ids):
-        query = " or ".join(
-            f"'{query_id}' in parents" for query_id in query_ids
-        )
-        query = f"({query}) and trashed=false"
-        return self._gdrive_list(query)
-
-    def find(self, path_info, detail=False):
-        root_path = path_info.path
-        seen_paths = set()
-
-        dir_ids = [self._ids_cache["ids"].copy()]
-        while dir_ids:
-            query_ids = {
-                dir_id: dir_name
-                for dir_id, dir_name in dir_ids.pop().items()
-                if posixpath.commonpath([root_path, dir_name]) == root_path
-                if dir_id not in seen_paths
-            }
-            if not query_ids:
-                continue
-
-            seen_paths |= query_ids.keys()
-
-            new_query_ids = {}
-            dir_ids.append(new_query_ids)
-            for item in self._gdrive_list_ids(query_ids):
-                parent_id = item["parents"][0]["id"]
-                item_path = posixpath.join(query_ids[parent_id], item["title"])
-                if item["mimeType"] == FOLDER_MIME_TYPE:
-                    new_query_ids[item["id"]] = item_path
-                    self._cache_path_id(item_path, item["id"])
-                    continue
-
-                if detail:
-                    yield {
-                        "type": "file",
-                        "name": item_path,
-                        "size": item["fileSize"],
-                        "checksum": item["md5Checksum"],
-                    }
-                else:
-                    yield item_path
-
-    def ls(self, path_info, detail=False):
-        cached = path_info.path in self._ids_cache["dirs"]
-        if cached:
-            dir_ids = self._ids_cache["dirs"][path_info.path]
-        else:
-            dir_ids = self._path_to_item_ids(path_info.path)
-
-        if not dir_ids:
-            return None
-
-        root_path = path_info.path
-        for item in self._gdrive_list_ids(dir_ids):
-            item_path = posixpath.join(root_path, item["title"])
-            if detail:
-                if item["mimeType"] == FOLDER_MIME_TYPE:
-                    yield {"type": "directory", "name": item_path}
-                else:
-                    yield {
-                        "type": "file",
-                        "name": item_path,
-                        "size": item["fileSize"],
-                        "checksum": item["md5Checksum"],
-                    }
-            else:
-                yield item_path
-
-        if not cached:
-            self._cache_path_id(root_path, *dir_ids)
-
-    def walk_files(self, path_info, **kwargs):
-        for file in self.find(path_info):
-            yield path_info.replace(path=file)
-
-    def remove(self, path_info):
-        item_id = self._get_item_id(path_info)
-        self.gdrive_delete_file(item_id)
-
-    def info(self, path_info):
-        item_id = self._get_item_id(path_info)
-        gdrive_file = self._drive.CreateFile({"id": item_id})
-        gdrive_file.FetchMetadata(fields="fileSize")
-        return {"size": gdrive_file.get("fileSize")}
-
-    def _upload_fobj(self, fobj, to_info):
-        dirname = to_info.parent
-        assert dirname
-        parent_id = self._get_item_id(dirname, create=True)
-        self._gdrive_upload_fobj(fobj, parent_id, to_info.name)
-
-    def _upload(
-        self, from_file, to_info, name=None, no_progress_bar=False, **_kwargs
-    ):
-        with open(from_file, "rb") as fobj:
-            self.upload_fobj(
-                fobj,
-                to_info,
-                no_progress_bar=no_progress_bar,
-                desc=name or to_info.name,
-                total=os.path.getsize(from_file),
-            )
-
-    def _download(self, from_info, to_file, name=None, no_progress_bar=False):
-        item_id = self._get_item_id(from_info)
-        self._gdrive_download_file(item_id, to_file, name, no_progress_bar)
+    def upload_fobj(self, fobj, to_info, **kwargs):
+        rpath = self._with_bucket(to_info)
+        self.makedirs(os.path.dirname(rpath))
+        return self.fs.upload_fobj(fobj, rpath, **kwargs)

dvc/fs/git.py

@@ -1,14 +1,19 @@
 import errno
 import os
 
+from tqdm.utils import CallbackIOWrapper
+
 from dvc.utils import is_exec, relpath
 
+from ..progress import DEFAULT_CALLBACK
 from .base import BaseFileSystem
 
 
 class GitFileSystem(BaseFileSystem):  # pylint:disable=abstract-method
     """Proxies the repo file access methods to Git objects"""
 
+    sep = os.sep
+
     scheme = "local"
 
     def __init__(self, root_dir, trie):
@@ -33,8 +38,8 @@ class GitFileSystem(BaseFileSystem):  # pylint:disable=abstract-method
         return tuple(relparts)
 
     def open(
-        self, path, mode="r", encoding=None
-    ):  # pylint: disable=arguments-differ
+        self, path, mode="r", encoding=None, **kwargs
+    ):  # pylint: disable=arguments-renamed
         # NOTE: this is incorrect, we need to use locale to determine default
         # encoding.
         encoding = encoding or "utf-8"
@@ -93,30 +98,39 @@ class GitFileSystem(BaseFileSystem):  # pylint:disable=abstract-method
         if not self.exists(path_info):
             return False
 
-        mode = self.stat(path_info).st_mode
+        mode = self.info(path_info)["mode"]
         return is_exec(mode)
 
     def info(self, path_info):
         key = self._get_key(path_info)
         try:
-            st = self.trie.stat(key)
+            return self.trie.info(key)
         except KeyError:
             raise FileNotFoundError(
                 errno.ENOENT, os.strerror(errno.ENOENT), path_info
             )
-        return {"size": st.st_size}
 
-    def stat(self, path):
-        key = self._get_key(path)
-        try:
-            return self.trie.stat(key)
-        except KeyError:
-            raise FileNotFoundError(
-                errno.ENOENT, os.strerror(errno.ENOENT), path
-            )
+    def checksum(self, path_info):
+        return self.info(path_info)["sha"]
 
     def walk_files(self, path_info, **kwargs):
         for root, _, files in self.walk(path_info, **kwargs):
             for file in files:
                 # NOTE: os.path.join is ~5.5 times slower
                 yield f"{root}{os.sep}{file}"
+
+    def get_file(
+        self, from_info, to_file, callback=DEFAULT_CALLBACK, **kwargs
+    ):
+        import shutil
+
+        total = self.getsize(from_info)
+        if total:
+            callback.set_size(total)
+
+        with self.open(from_info, "rb", **kwargs) as from_fobj:
+            with open(to_file, "wb+") as to_fobj:
+                wrapped = CallbackIOWrapper(
+                    callback.relative_update, from_fobj
+                )
+                shutil.copyfileobj(wrapped, to_fobj)

dvc/fs/gs.py

@@ -6,23 +6,17 @@ from funcy import cached_property, wrap_prop
 from dvc.path_info import CloudURLInfo
 from dvc.scheme import Schemes
 
-from .fsspec_wrapper import ObjectFSWrapper
-
-
 # pylint:disable=abstract-method
-class GSFileSystem(ObjectFSWrapper):
+from .fsspec_wrapper import CallbackMixin, ObjectFSWrapper
+
+
+class GSFileSystem(CallbackMixin, ObjectFSWrapper):
     scheme = Schemes.GS
     PATH_CLS = CloudURLInfo
     REQUIRES = {"gcsfs": "gcsfs"}
     PARAM_CHECKSUM = "etag"
     DETAIL_FIELDS = frozenset(("etag", "size"))
 
-    def __init__(self, **config):
-        super().__init__(**config)
-
-        url = config.get("url", "gs://")
-        self.path_info = self.PATH_CLS(url)
-
     def _prepare_credentials(self, **config):
         login_info = {"consistency": None}
         login_info["project"] = config.get("projectname")

dvc/fs/hdfs.py

@@ -1,277 +1,90 @@
-import io
-import logging
 import os
 import re
-import shutil
 import subprocess
-from collections import deque
-from contextlib import closing, contextmanager
-from urllib.parse import urlparse
+import threading
+
+from funcy import cached_property, wrap_prop
 
-from dvc.hash_info import HashInfo
-from dvc.progress import Tqdm
 from dvc.scheme import Schemes
-from dvc.utils import fix_env, tmp_fname
+from dvc.utils import fix_env
 
-from .base import BaseFileSystem, RemoteCmdError
-from .pool import get_connection
+from .fsspec_wrapper import CallbackMixin, FSSpecWrapper
 
-logger = logging.getLogger(__name__)
+CHECKSUM_REGEX = re.compile(r".*\t.*\t(?P<checksum>.*)")
 
 
-def _hadoop_fs(cmd, user=None):
-    cmd = "hadoop fs -" + cmd
-    if user:
-        cmd = f"HADOOP_USER_NAME={user} " + cmd
-
-    # NOTE: close_fds doesn't work with redirected stdin/stdout/stderr.
-    # See https://github.com/iterative/dvc/issues/1197.
-    close_fds = os.name != "nt"
-
-    executable = os.getenv("SHELL") if os.name != "nt" else None
-    p = subprocess.Popen(
-        cmd,
-        shell=True,
-        close_fds=close_fds,
-        executable=executable,
-        env=fix_env(os.environ),
-        stdin=subprocess.PIPE,
-        stdout=subprocess.PIPE,
-        stderr=subprocess.PIPE,
-    )
-    out, err = p.communicate()
-    if p.returncode != 0:
-        raise RemoteCmdError("hdfs", cmd, p.returncode, err)
-    return out.decode("utf-8")
-
-
-def _group(regex, s, gname):
-    match = re.match(regex, s)
-    assert match is not None
-    return match.group(gname)
-
-
-def _hadoop_fs_checksum(path_info):
-    # NOTE: pyarrow doesn't support checksum, so we need to use hadoop
-    regex = r".*\t.*\t(?P<checksum>.*)"
-    stdout = _hadoop_fs(f"checksum {path_info.url}", user=path_info.user)
-    return _group(regex, stdout, "checksum")
-
-
-class HDFSFileSystem(BaseFileSystem):
+# pylint: disable=abstract-method
+class HDFSFileSystem(CallbackMixin, FSSpecWrapper):
     scheme = Schemes.HDFS
-    REQUIRES = {"pyarrow": "pyarrow"}
-    REGEX = r"^hdfs://((?P<user>.*)@)?.*$"
+    REQUIRES = {"fsspec": "fsspec", "pyarrow": "pyarrow"}
     PARAM_CHECKSUM = "checksum"
-    TRAVERSE_PREFIX_LEN = 2
 
-    def __init__(self, **config):
-        super().__init__(**config)
+    def _with_bucket(self, path):
+        if isinstance(path, self.PATH_CLS):
+            return path.path
+        return super()._with_bucket(path)
 
-        self.path_info = None
-        url = config.get("url")
-        if not url:
-            return
+    @staticmethod
+    def _get_kwargs_from_urls(urlpath):
+        from fsspec.implementations.arrow import HadoopFileSystem
 
-        parsed = urlparse(url)
-        user = parsed.username or config.get("user")
+        # pylint:disable=protected-access
+        return HadoopFileSystem._get_kwargs_from_urls(urlpath)
 
-        self.path_info = self.PATH_CLS.from_parts(
-            scheme=self.scheme,
-            host=parsed.hostname,
-            user=user,
-            port=parsed.port,
-            path=parsed.path,
-        )
+    def _prepare_credentials(self, **config):
+        return config
 
-        self.kerb_ticket = config.get("kerb_ticket")
+    @wrap_prop(threading.Lock())
+    @cached_property
+    def fs(self):
+        from fsspec.implementations.arrow import HadoopFileSystem
 
-    def hdfs(self, path_info):
-        import pyarrow.fs
-
-        # NOTE: HadoopFileSystem is not meant to be closed by us and doesn't
-        # have close() method or alternative, so we add a noop one to satisfy
-        # our connection pool.
-        class HDFSConnection(pyarrow.fs.HadoopFileSystem):
-            def close(self):
-                pass
-
-        return get_connection(
-            HDFSConnection,
-            path_info.host,
-            path_info.port,
-            user=path_info.user,
-            kerb_ticket=self.kerb_ticket,
-        )
-
-    @contextmanager
-    def open(self, path_info, mode="r", encoding=None, **kwargs):
-        assert mode in {"r", "rt", "rb"}
-
-        try:
-            with self.hdfs(path_info) as hdfs, closing(
-                hdfs.open_input_stream(path_info.path)
-            ) as fd:
-                if mode == "rb":
-                    yield fd
-                else:
-                    yield io.TextIOWrapper(fd, encoding=encoding)
-        except OSError as e:
-            # Empty .errno and not specific enough error class in pyarrow,
-            # see https://issues.apache.org/jira/browse/ARROW-6248
-            if "file does not exist" in str(e):
-                raise FileNotFoundError(*e.args)
-            raise
-
-    def exists(self, path_info) -> bool:
-        assert not isinstance(path_info, list)
-        assert path_info.scheme == "hdfs"
-        with self.hdfs(path_info) as hdfs:
-            import pyarrow.fs
-
-            file_info = hdfs.get_file_info(path_info.path)
-            return file_info.type != pyarrow.fs.FileType.NotFound
-
-    def _walk(self, hdfs, root, topdown=True):
-        import posixpath
-
-        from pyarrow.fs import FileSelector, FileType
-
-        dirs = deque()
-        nondirs = deque()
-
-        selector = FileSelector(root)
-        for entry in hdfs.get_file_info(selector):
-            if entry.type == FileType.Directory:
-                dirs.append(entry.base_name)
-            else:
-                nondirs.append(entry.base_name)
-
-        if topdown:
-            yield root, dirs, nondirs
-
-        for dname in dirs:
-            # NOTE: posixpath.join() is slower
-            yield from self._walk(
-                hdfs, f"{root}{posixpath.sep}{dname}", topdown=topdown
-            )
-
-        if not topdown:
-            yield root, dirs, nondirs
-
-    def walk(self, top, topdown=True, onerror=None, **kwargs):
-        if not self.isdir(top):
-            return
-
-        with self.hdfs(top) as hdfs:
-            for root, dnames, fnames in self._walk(
-                hdfs, top.path, topdown=topdown
-            ):
-                yield top.replace(path=root), dnames, fnames
-
-    def walk_files(self, path_info, **kwargs):
-        for root, _, fnames in self.walk(path_info):
-            yield from (root / fname for fname in fnames)
-
-    def remove(self, path_info):
-        if path_info.scheme != "hdfs":
-            raise NotImplementedError
-
-        if self.exists(path_info):
-            logger.debug(f"Removing {path_info.path}")
-            with self.hdfs(path_info) as hdfs:
-                import pyarrow.fs
-
-                file_info = hdfs.get_file_info(path_info.path)
-                if file_info.type == pyarrow.fs.FileType.Directory:
-                    hdfs.delete_dir(path_info.path)
-                else:
-                    hdfs.delete_file(path_info.path)
-
-    def makedirs(self, path_info):
-        with self.hdfs(path_info) as hdfs:
-            # NOTE: fs.create_dir creates parents by default
-            hdfs.create_dir(path_info.path)
-
-    def copy(self, from_info, to_info, **_kwargs):
-        # NOTE: hdfs.copy_file is not supported yet in pyarrow
-        with self.hdfs(to_info) as hdfs:
-            # NOTE: this is how `hadoop fs -cp` works too: it copies through
-            # your local machine.
-            with closing(hdfs.open_input_stream(from_info.path)) as from_fobj:
-                tmp_info = to_info.parent / tmp_fname(to_info.name)
-                try:
-                    with closing(
-                        hdfs.open_output_stream(tmp_info.path)
-                    ) as tmp_fobj:
-                        shutil.copyfileobj(from_fobj, tmp_fobj)
-                    hdfs.move(tmp_info.path, to_info.path)
-                except Exception:
-                    self.remove(tmp_info)
-                    raise
-
-    def isfile(self, path_info):
-        with self.hdfs(path_info) as hdfs:
-            import pyarrow.fs
-
-            file_info = hdfs.get_file_info(path_info.path)
-            return file_info.type == pyarrow.fs.FileType.File
-
-    def isdir(self, path_info):
-        with self.hdfs(path_info) as hdfs:
-            import pyarrow.fs
-
-            file_info = hdfs.get_file_info(path_info.path)
-            return file_info.type == pyarrow.fs.FileType.Directory
-
-    def info(self, path_info):
-        with self.hdfs(path_info) as hdfs:
-            finfo = hdfs.get_file_info(path_info.path)
-            return {"size": finfo.size}
+        return HadoopFileSystem(**self.fs_args)
 
     def checksum(self, path_info):
-        return HashInfo(
-            "checksum",
-            _hadoop_fs_checksum(path_info),
-            size=self.getsize(path_info),
+        return self._checksum(path_info)
+
+    def _checksum(self, path_info, **kwargs):
+        # PyArrow doesn't natively support retrieving the
+        # checksum, so we have to use hadoop fs
+
+        result = self._run_command(
+            f"checksum {path_info.url}",
+            env=fix_env(os.environ),
+            user=path_info.user,
         )
+        if result is None:
+            return None
 
-    def _upload_fobj(self, fobj, to_info):
-        with self.hdfs(to_info) as hdfs:
-            with hdfs.open_output_stream(to_info.path) as fdest:
-                shutil.copyfileobj(fobj, fdest)
+        match = CHECKSUM_REGEX.match(result)
+        if match is None:
+            return None
 
-    def _upload(
-        self, from_file, to_info, name=None, no_progress_bar=False, **_kwargs
-    ):
-        with self.hdfs(to_info) as hdfs:
-            tmp_file = tmp_fname(to_info.path)
-            total = os.path.getsize(from_file)
-            with open(from_file, "rb") as fobj:
-                with Tqdm.wrapattr(
-                    fobj,
-                    "read",
-                    desc=name,
-                    total=total,
-                    disable=no_progress_bar,
-                ) as wrapped:
-                    with hdfs.open_output_stream(tmp_file) as sobj:
-                        sobj.write(wrapped.read())
-            hdfs.move(tmp_file, to_info.path)
+        return match.group("checksum")
 
-    def _download(
-        self, from_info, to_file, name=None, no_progress_bar=False, **_kwargs
-    ):
-        with self.hdfs(from_info) as hdfs:
-            file_info = hdfs.get_file_info(from_info.path)
-            total = file_info.size
-            with open(to_file, "wb+") as fobj:
-                with Tqdm.wrapattr(
-                    fobj,
-                    "write",
-                    desc=name,
-                    total=total,
-                    disable=no_progress_bar,
-                ) as wrapped:
-                    with hdfs.open_input_stream(from_info.path) as sobj:
-                        wrapped.write(sobj.read())
+    def _run_command(self, cmd, env=None, user=None):
+        cmd = "hadoop fs -" + cmd
+        if user:
+            cmd = f"HADOOP_USER_NAME={user} " + cmd
+
+        # NOTE: close_fds doesn't work with redirected stdin/stdout/stderr.
+        # See https://github.com/iterative/dvc/issues/1197.
+        close_fds = os.name != "nt"
+
+        executable = os.getenv("SHELL") if os.name != "nt" else None
+        p = subprocess.Popen(
+            cmd,
+            shell=True,
+            close_fds=close_fds,
+            executable=executable,
+            env=env or os.environ,
+            stdin=subprocess.PIPE,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+        )
+        out, err = p.communicate()
+
+        if p.returncode != 0:
+            raise subprocess.CalledProcessError(p.returncode, cmd, out, err)
+        else:
+            return out.decode("utf-8")

dvc/fs/http.py

@@ -1,19 +1,12 @@
-import logging
-import os.path
 import threading
-from typing import Optional
 
-from funcy import cached_property, memoize, wrap_prop, wrap_with
+from funcy import cached_property, memoize, wrap_with
 
 from dvc import prompt
-from dvc.exceptions import DvcException, HTTPError
 from dvc.path_info import HTTPURLInfo
-from dvc.progress import Tqdm
 from dvc.scheme import Schemes
 
-from .base import BaseFileSystem
-
-logger = logging.getLogger(__name__)
+from .fsspec_wrapper import FSSpecWrapper, NoDirectoriesMixin
 
 
 @wrap_with(threading.Lock())
@@ -25,176 +18,115 @@ def ask_password(host, user):
     )
 
 
-class HTTPFileSystem(BaseFileSystem):  # pylint:disable=abstract-method
+def make_context(ssl_verify):
+    if isinstance(ssl_verify, bool) or ssl_verify is None:
+        return ssl_verify
+
+    # If this is a path, then we will create an
+    # SSL context for it, and load the given certificate.
+    import ssl
+
+    context = ssl.create_default_context()
+    context.load_verify_locations(ssl_verify)
+    return context
+
+
+# pylint: disable=abstract-method
+class HTTPFileSystem(NoDirectoriesMixin, FSSpecWrapper):
     scheme = Schemes.HTTP
     PATH_CLS = HTTPURLInfo
-    PARAM_CHECKSUM = "etag"
+    PARAM_CHECKSUM = "checksum"
+    REQUIRES = {"aiohttp": "aiohttp", "aiohttp-retry": "aiohttp_retry"}
     CAN_TRAVERSE = False
 
     SESSION_RETRIES = 5
     SESSION_BACKOFF_FACTOR = 0.1
     REQUEST_TIMEOUT = 60
-    CHUNK_SIZE = 2 ** 16
 
-    def __init__(self, **config):
-        super().__init__(**config)
+    def _prepare_credentials(self, **config):
+        import aiohttp
+        from fsspec.asyn import fsspec_loop
 
-        url = config.get("url")
-        if url:
-            self.path_info = self.PATH_CLS(url)
-            self.user = config.get("user", None)
-            self.host = self.path_info.host
-        else:
-            self.path_info = None
+        from dvc.config import ConfigError
 
-        self.auth = config.get("auth", None)
-        self.custom_auth_header = config.get("custom_auth_header", None)
-        self.password = config.get("password", None)
-        self.ask_password = config.get("ask_password", False)
-        self.headers = {}
-        self.ssl_verify = config.get("ssl_verify", True)
-        self.method = config.get("method", "POST")
+        credentials = {}
+        client_kwargs = credentials.setdefault("client_kwargs", {})
 
-    def _auth_method(self):
-        from requests.auth import HTTPBasicAuth, HTTPDigestAuth
+        if config.get("auth"):
+            user = config.get("user")
+            password = config.get("password")
+            custom_auth_header = config.get("custom_auth_header")
 
-        if self.auth:
-            if self.ask_password and self.password is None:
-                self.password = ask_password(self.host, self.user)
-            if self.auth == "basic":
-                return HTTPBasicAuth(self.user, self.password)
-            if self.auth == "digest":
-                return HTTPDigestAuth(self.user, self.password)
-            if self.auth == "custom" and self.custom_auth_header:
-                self.headers.update({self.custom_auth_header: self.password})
-        return None
+            if password is None and config.get("ask_password"):
+                password = ask_password(config.get("url"), user or "custom")
 
-    def _generate_download_url(self, path_info):
-        return path_info.url
+            auth_method = config["auth"]
+            if auth_method == "basic":
+                if user is None or password is None:
+                    raise ConfigError(
+                        "HTTP 'basic' authentication require both "
+                        "'user' and 'password'"
+                    )
 
-    @wrap_prop(threading.Lock())
-    @cached_property
-    def _session(self):
-        import requests
-        from requests.adapters import HTTPAdapter
-        from urllib3.util.retry import Retry
+                client_kwargs["auth"] = aiohttp.BasicAuth(user, password)
+            elif auth_method == "custom":
+                if custom_auth_header is None or password is None:
+                    raise ConfigError(
+                        "HTTP 'custom' authentication require both "
+                        "'custom_auth_header' and 'password'"
+                    )
+                credentials["headers"] = {custom_auth_header: password}
+            else:
+                raise NotImplementedError(
+                    f"Auth method {auth_method!r} is not supported."
+                )
 
-        session = requests.Session()
+        if "ssl_verify" in config:
+            with fsspec_loop():
+                client_kwargs["connector"] = aiohttp.TCPConnector(
+                    ssl=make_context(config["ssl_verify"])
+                )
 
-        session.verify = self.ssl_verify
+        # Allow reading proxy configurations from the environment.
+        client_kwargs["trust_env"] = True
 
-        retries = Retry(
-            total=self.SESSION_RETRIES,
-            backoff_factor=self.SESSION_BACKOFF_FACTOR,
+        credentials["get_client"] = self.get_client
+        self.upload_method = config.get("method", "POST")
+        return credentials
+
+    async def get_client(self, **kwargs):
+        import aiohttp
+        from aiohttp_retry import ExponentialRetry, RetryClient
+
+        kwargs["retry_options"] = ExponentialRetry(
+            attempts=self.SESSION_RETRIES,
+            factor=self.SESSION_BACKOFF_FACTOR,
+            max_timeout=self.REQUEST_TIMEOUT,
+            exceptions=[aiohttp.ClientError],
         )
 
-        session.mount("http://", HTTPAdapter(max_retries=retries))
-        session.mount("https://", HTTPAdapter(max_retries=retries))
+        # The default timeout for the aiohttp is 300 seconds
+        # which is too low for DVC's interactions (especially
+        # on the read) when dealing with large data blobs. We
+        # unlimit the total time to read, and only limit the
+        # time that is spent when connecting to the remote server.
+        kwargs["timeout"] = aiohttp.ClientTimeout(
+            total=None,
+            connect=self.REQUEST_TIMEOUT,
+            sock_connect=self.REQUEST_TIMEOUT,
+            sock_read=None,
+        )
 
-        return session
+        return RetryClient(**kwargs)
 
-    def request(self, method, url, **kwargs):
-        import requests
+    @cached_property
+    def fs(self):
+        from fsspec.implementations.http import (
+            HTTPFileSystem as _HTTPFileSystem,
+        )
 
-        kwargs.setdefault("allow_redirects", True)
-        kwargs.setdefault("timeout", self.REQUEST_TIMEOUT)
+        return _HTTPFileSystem(**self.fs_args)
 
-        try:
-            res = self._session.request(
-                method,
-                url,
-                auth=self._auth_method(),
-                headers=self.headers,
-                **kwargs,
-            )
-
-            redirect_no_location = (
-                kwargs["allow_redirects"]
-                and res.status_code in (301, 302)
-                and "location" not in res.headers
-            )
-
-            if redirect_no_location:
-                # AWS s3 doesn't like to add a location header to its redirects
-                # from https://s3.amazonaws.com/<bucket name>/* type URLs.
-                # This should be treated as an error
-                raise requests.exceptions.RequestException
-
-            return res
-
-        except requests.exceptions.RequestException:
-            raise DvcException(f"could not perform a {method} request")
-
-    def _head(self, url):
-        response = self.request("HEAD", url)
-        if response.ok:
-            return response
-
-        # Sometimes servers are configured to forbid HEAD requests
-        # Context: https://github.com/iterative/dvc/issues/4131
-        with self.request("GET", url, stream=True) as r:
-            if r.ok:
-                return r
-
-        return response
-
-    def exists(self, path_info) -> bool:
-        res = self._head(path_info.url)
-        if res.status_code == 404:
-            return False
-        if bool(res):
-            return True
-        raise HTTPError(res.status_code, res.reason)
-
-    def info(self, path_info):
-        resp = self._head(path_info.url)
-        etag = resp.headers.get("ETag") or resp.headers.get("Content-MD5")
-        size = self._content_length(resp)
-        return {"etag": etag, "size": size}
-
-    def _upload_fobj(self, fobj, to_info):
-        def chunks(fobj):
-            while True:
-                chunk = fobj.read(self.CHUNK_SIZE)
-                if not chunk:
-                    break
-                yield chunk
-
-        response = self.request(self.method, to_info.url, data=chunks(fobj))
-        if response.status_code not in (200, 201):
-            raise HTTPError(response.status_code, response.reason)
-
-    def _download(self, from_info, to_file, name=None, no_progress_bar=False):
-        response = self.request("GET", from_info.url, stream=True)
-        if response.status_code != 200:
-            raise HTTPError(response.status_code, response.reason)
-        with open(to_file, "wb") as fd:
-            with Tqdm.wrapattr(
-                fd,
-                "write",
-                total=None
-                if no_progress_bar
-                else self._content_length(response),
-                leave=False,
-                desc=from_info.url if name is None else name,
-                disable=no_progress_bar,
-            ) as fd_wrapped:
-                for chunk in response.iter_content(chunk_size=self.CHUNK_SIZE):
-                    fd_wrapped.write(chunk)
-
-    def _upload(
-        self, from_file, to_info, name=None, no_progress_bar=False, **_kwargs
-    ):
-        with open(from_file, "rb") as fobj:
-            self.upload_fobj(
-                fobj,
-                to_info,
-                no_progress_bar=no_progress_bar,
-                desc=name or to_info.url,
-                total=None if no_progress_bar else os.path.getsize(from_file),
-            )
-
-    @staticmethod
-    def _content_length(response) -> Optional[int]:
-        res = response.headers.get("Content-Length")
-        return int(res) if res else None
+    def _entry_hook(self, entry):
+        entry["checksum"] = entry.get("ETag") or entry.get("Content-MD5")
+        return entry

dvc/fs/local.py

@@ -1,6 +1,5 @@
 import logging
 import os
-import stat
 
 from dvc.path_info import PathInfo
 from dvc.scheme import Schemes
@@ -8,12 +7,15 @@ from dvc.system import System
 from dvc.utils import is_exec, tmp_fname
 from dvc.utils.fs import copy_fobj_to_file, copyfile, makedirs, move, remove
 
+from ..progress import DEFAULT_CALLBACK
 from .base import BaseFileSystem
 
 logger = logging.getLogger(__name__)
 
 
 class LocalFileSystem(BaseFileSystem):
+    sep = os.sep
+
     scheme = Schemes.LOCAL
     PATH_CLS = PathInfo
     PARAM_CHECKSUM = "md5"
@@ -25,8 +27,6 @@ class LocalFileSystem(BaseFileSystem):
 
         super().__init__(**config)
         self.fs = LocalFS()
-        url = config.get("url")
-        self.path_info = self.PATH_CLS(url) if url else None
 
     @staticmethod
     def open(path_info, mode="r", encoding=None, **kwargs):
@@ -34,7 +34,12 @@ class LocalFileSystem(BaseFileSystem):
 
     def exists(self, path_info) -> bool:
         assert isinstance(path_info, str) or path_info.scheme == "local"
-        return self.fs.exists(path_info)
+        # TODO: replace this with os.path.exists once the problem is fixed on
+        # the fsspec https://github.com/intake/filesystem_spec/issues/742
+        return os.path.lexists(path_info)
+
+    def checksum(self, path_info) -> str:
+        return self.fs.checksum(path_info)
 
     def isfile(self, path_info) -> bool:
         return os.path.isfile(path_info)
@@ -79,18 +84,17 @@ class LocalFileSystem(BaseFileSystem):
                 raise NotImplementedError
         remove(path_info)
 
-    def makedirs(self, path_info):
-        makedirs(path_info, exist_ok=True)
+    def makedirs(self, path_info, **kwargs):
+        makedirs(path_info, exist_ok=kwargs.pop("exist_ok", True))
 
     def isexec(self, path_info):
-        mode = self.stat(path_info).st_mode
+        mode = self.info(path_info)["mode"]
         return is_exec(mode)
 
-    def stat(self, path):
-        return os.stat(path)
-
     def move(self, from_info, to_info):
-        if from_info.scheme != "local" or to_info.scheme != "local":
+        if (
+            isinstance(from_info, PathInfo) and from_info.scheme != "local"
+        ) or (isinstance(to_info, PathInfo) and to_info.scheme != "local"):
             raise NotImplementedError
 
         self.makedirs(to_info.parent)
@@ -105,7 +109,7 @@ class LocalFileSystem(BaseFileSystem):
             self.remove(tmp_info)
             raise
 
-    def _upload_fobj(self, fobj, to_info):
+    def upload_fobj(self, fobj, to_info, **kwargs):
         self.makedirs(to_info.parent)
         tmp_info = to_info.parent / tmp_fname("")
         try:
@@ -152,29 +156,18 @@ class LocalFileSystem(BaseFileSystem):
     def reflink(self, from_info, to_info):
         System.reflink(from_info, to_info)
 
-    @staticmethod
-    def info(path_info):
-        st = os.stat(path_info)
-        return {
-            "size": st.st_size,
-            "type": "dir" if stat.S_ISDIR(st.st_mode) else "file",
-        }
+    def info(self, path_info):
+        return self.fs.info(path_info)
 
-    def _upload(
-        self, from_file, to_info, name=None, no_progress_bar=False, **_kwargs
+    def put_file(
+        self, from_file, to_info, callback=DEFAULT_CALLBACK, **kwargs
     ):
         makedirs(to_info.parent, exist_ok=True)
-
         tmp_file = tmp_fname(to_info)
-        copyfile(
-            from_file, tmp_file, name=name, no_progress_bar=no_progress_bar
-        )
+        copyfile(from_file, tmp_file, callback=callback)
         os.replace(tmp_file, to_info)
 
-    @staticmethod
-    def _download(
-        from_info, to_file, name=None, no_progress_bar=False, **_kwargs
+    def get_file(
+        self, from_info, to_file, callback=DEFAULT_CALLBACK, **kwargs
     ):
-        copyfile(
-            from_info, to_file, no_progress_bar=no_progress_bar, name=name
-        )
+        copyfile(from_info, to_file, callback=callback)

dvc/fs/memory.py

@@ -1,34 +1,35 @@
-from .base import BaseFileSystem
+import threading
+
+from funcy import cached_property, wrap_prop
+
+from dvc.path_info import CloudURLInfo
+from dvc.scheme import Schemes
+
+from .fsspec_wrapper import FSSpecWrapper
 
 
-class MemoryFileSystem(BaseFileSystem):
-    scheme = "local"
+class MemoryFileSystem(FSSpecWrapper):  # pylint:disable=abstract-method
+    scheme = Schemes.MEMORY
     PARAM_CHECKSUM = "md5"
+    PATH_CLS = CloudURLInfo
+    TRAVERSE_PREFIX_LEN = 2
+    DEFAULT_BLOCKSIZE = 4096
 
-    def __init__(self, **kwargs):
+    def __eq__(self, other):
+        # NOTE: all fsspec MemoryFileSystem instances are equivalent and use a
+        # single global store
+        return isinstance(other, type(self))
+
+    __hash__ = FSSpecWrapper.__hash__
+
+    @wrap_prop(threading.Lock())
+    @cached_property
+    def fs(self):
         from fsspec.implementations.memory import MemoryFileSystem as MemFS
 
-        super().__init__(**kwargs)
+        return MemFS(**self.fs_args)
 
-        self.fs = MemFS()
-
-    def exists(self, path_info) -> bool:
-        return self.fs.exists(path_info.fspath)
-
-    def open(self, path_info, mode="r", encoding=None, **kwargs):
-        return self.fs.open(
-            path_info.fspath, mode=mode, encoding=encoding, **kwargs
-        )
-
-    def info(self, path_info):
-        return self.fs.info(path_info.fspath)
-
-    def stat(self, path_info):
-        import os
-
-        info = self.fs.info(path_info.fspath)
-
-        return os.stat_result((0, 0, 0, 0, 0, 0, info["size"], 0, 0, 0))
-
-    def walk_files(self, path_info, **kwargs):
-        raise NotImplementedError
+    def open(self, *args, **kwargs):
+        with super().open(*args, **kwargs) as fobj:
+            fobj.blocksize = self.DEFAULT_BLOCKSIZE
+            return fobj

dvc/fs/oss.py

@@ -5,137 +5,37 @@ import threading
 from funcy import cached_property, wrap_prop
 
 from dvc.path_info import CloudURLInfo
-from dvc.progress import Tqdm
 from dvc.scheme import Schemes
 
-from .base import BaseFileSystem
+from .fsspec_wrapper import ObjectFSWrapper
 
 logger = logging.getLogger(__name__)
 
 
-class OSSFileSystem(BaseFileSystem):  # pylint:disable=abstract-method
-    """
-    oss2 document:
-    https://www.alibabacloud.com/help/doc-detail/32026.htm
-
-
-    Examples
-    ----------
-    $ dvc remote add myremote oss://my-bucket/path
-    Set key id, key secret and endpoint using modify command
-    $ dvc remote modify myremote oss_key_id my-key-id
-    $ dvc remote modify myremote oss_key_secret my-key-secret
-    $ dvc remote modify myremote oss_endpoint endpoint
-    or environment variables
-    $ export OSS_ACCESS_KEY_ID="my-key-id"
-    $ export OSS_ACCESS_KEY_SECRET="my-key-secret"
-    $ export OSS_ENDPOINT="endpoint"
-    """
-
+# pylint:disable=abstract-method
+class OSSFileSystem(ObjectFSWrapper):
     scheme = Schemes.OSS
     PATH_CLS = CloudURLInfo
-    REQUIRES = {"oss2": "oss2"}
+    REQUIRES = {"ossfs": "ossfs"}
     PARAM_CHECKSUM = "etag"
     COPY_POLL_SECONDS = 5
     LIST_OBJECT_PAGE_SIZE = 100
+    DETAIL_FIELDS = frozenset(("etag", "size"))
 
-    def __init__(self, **config):
-        super().__init__(**config)
-
-        url = config.get("url")
-        self.path_info = self.PATH_CLS(url) if url else None
-
-        self.bucket = self.path_info.bucket
-        self.endpoint = config.get("oss_endpoint") or os.getenv("OSS_ENDPOINT")
-
-        self.key_id = (
-            config.get("oss_key_id")
-            or os.getenv("OSS_ACCESS_KEY_ID")
-            or "defaultId"
+    def _prepare_credentials(self, **config):
+        login_info = {}
+        login_info["key"] = config.get("oss_key_id") or os.getenv(
+            "OSS_ACCESS_KEY_ID"
         )
-
-        self.key_secret = (
-            config.get("oss_key_secret")
-            or os.getenv("OSS_ACCESS_KEY_SECRET")
-            or "defaultSecret"
+        login_info["secret"] = config.get("oss_key_secret") or os.getenv(
+            "OSS_ACCESS_KEY_SECRET"
         )
+        login_info["endpoint"] = config.get("oss_endpoint")
+        return login_info
 
     @wrap_prop(threading.Lock())
     @cached_property
-    def oss_service(self):
-        import oss2
+    def fs(self):
+        from ossfs import OSSFileSystem as _OSSFileSystem
 
-        logger.debug(f"key id: {self.key_id}")
-        logger.debug(f"key secret: {self.key_secret}")
-
-        auth = oss2.Auth(self.key_id, self.key_secret)
-        bucket = oss2.Bucket(auth, self.endpoint, self.bucket)
-
-        # Ensure bucket exists
-        try:
-            bucket.get_bucket_info()
-        except oss2.exceptions.NoSuchBucket:
-            bucket.create_bucket(
-                oss2.BUCKET_ACL_PUBLIC_READ,
-                oss2.models.BucketCreateConfig(
-                    oss2.BUCKET_STORAGE_CLASS_STANDARD
-                ),
-            )
-        return bucket
-
-    def _generate_download_url(self, path_info, expires=3600):
-        assert path_info.bucket == self.bucket
-
-        return self.oss_service.sign_url("GET", path_info.path, expires)
-
-    def exists(self, path_info) -> bool:
-        paths = self._list_paths(path_info)
-        return any(path_info.path == path for path in paths)
-
-    def _list_paths(self, path_info):
-        import oss2
-
-        for blob in oss2.ObjectIterator(
-            self.oss_service, prefix=path_info.path
-        ):
-            yield blob.key
-
-    def walk_files(self, path_info, **kwargs):
-        if not kwargs.pop("prefix", False):
-            path_info = path_info / ""
-        for fname in self._list_paths(path_info):
-            if fname.endswith("/"):
-                continue
-
-            yield path_info.replace(path=fname)
-
-    def remove(self, path_info):
-        if path_info.scheme != self.scheme:
-            raise NotImplementedError
-
-        logger.debug(f"Removing oss://{path_info}")
-        self.oss_service.delete_object(path_info.path)
-
-    def _upload_fobj(self, fobj, to_info):
-        self.oss_service.put_object(to_info.path, fobj)
-
-    def _upload(
-        self, from_file, to_info, name=None, no_progress_bar=False, **_kwargs
-    ):
-        with Tqdm(desc=name, disable=no_progress_bar, bytes=True) as pbar:
-            self.oss_service.put_object_from_file(
-                to_info.path, from_file, progress_callback=pbar.update_to
-            )
-
-    def _download(
-        self, from_info, to_file, name=None, no_progress_bar=False, **_kwargs
-    ):
-        with Tqdm(desc=name, disable=no_progress_bar, bytes=True) as pbar:
-            import oss2
-
-            oss2.resumable_download(
-                self.oss_service,
-                from_info.path,
-                to_file,
-                progress_callback=pbar.update_to,
-            )
+        return _OSSFileSystem(**self.fs_args)

dvc/fs/repo.py

@@ -1,6 +1,5 @@
 import logging
 import os
-import stat
 import threading
 from contextlib import suppress
 from itertools import takewhile
@@ -10,6 +9,7 @@ from funcy import lfilter, wrap_with
 
 from dvc.path_info import PathInfo
 
+from ..progress import DEFAULT_CALLBACK
 from .base import BaseFileSystem
 from .dvc import DvcFileSystem
 
@@ -31,16 +31,33 @@ class RepoFileSystem(BaseFileSystem):  # pylint:disable=abstract-method
         kwargs: Additional keyword arguments passed to the `DvcFileSystem()`.
     """
 
+    sep = os.sep
+
     scheme = "local"
     PARAM_CHECKSUM = "md5"
+    PARAM_REPO_URL = "repo_url"
+    PARAM_REPO_ROOT = "repo_root"
+    PARAM_REV = "rev"
+    PARAM_CACHE_DIR = "cache_dir"
+    PARAM_CACHE_TYPES = "cache_types"
+    PARAM_SUBREPOS = "subrepos"
 
     def __init__(
-        self, repo=None, subrepos=False, repo_factory: RepoFactory = None
+        self,
+        repo: Optional["Repo"] = None,
+        subrepos=False,
+        repo_factory: RepoFactory = None,
+        **kwargs,
     ):
         super().__init__()
 
         from dvc.utils.collections import PathStringTrie
 
+        if repo is None:
+            repo, repo_factory = self._repo_from_fs_config(
+                subrepos=subrepos, **kwargs
+            )
+
         if not repo_factory:
             from dvc.repo import Repo
 
@@ -64,6 +81,73 @@ class RepoFileSystem(BaseFileSystem):  # pylint:disable=abstract-method
         if hasattr(repo, "dvc_dir"):
             self._dvcfss[repo.root_dir] = DvcFileSystem(repo=repo)
 
+    @property
+    def repo_url(self):
+        if self._main_repo is None:
+            return None
+        return self._main_repo.url
+
+    @property
+    def config(self):
+        return {
+            self.PARAM_REPO_URL: self.repo_url,
+            self.PARAM_REPO_ROOT: self.root_dir,
+            self.PARAM_REV: getattr(self._main_repo.fs, "rev", None),
+            self.PARAM_CACHE_DIR: os.path.abspath(
+                self._main_repo.odb.local.cache_dir
+            ),
+            self.PARAM_CACHE_TYPES: self._main_repo.odb.local.cache_types,
+            self.PARAM_SUBREPOS: self._traverse_subrepos,
+        }
+
+    @classmethod
+    def _repo_from_fs_config(
+        cls, **config
+    ) -> Tuple["Repo", Optional["RepoFactory"]]:
+        from dvc.external_repo import erepo_factory, external_repo
+        from dvc.repo import Repo
+
+        url = config.get(cls.PARAM_REPO_URL)
+        root = config.get(cls.PARAM_REPO_ROOT)
+        assert url or root
+
+        def _open(*args, **kwargs):
+            # NOTE: if original repo was an erepo (and has a URL),
+            # we cannot use Repo.open() since it will skip erepo
+            # cache/remote setup for local URLs
+            if url is None:
+                return Repo.open(*args, **kwargs)
+            return external_repo(*args, **kwargs)
+
+        cache_dir = config.get(cls.PARAM_CACHE_DIR)
+        cache_config = (
+            {}
+            if not cache_dir
+            else {
+                "cache": {
+                    "dir": cache_dir,
+                    "type": config.get(cls.PARAM_CACHE_TYPES),
+                }
+            }
+        )
+        repo_kwargs: dict = {
+            "rev": config.get(cls.PARAM_REV),
+            "subrepos": config.get(cls.PARAM_SUBREPOS, False),
+            "uninitialized": True,
+        }
+        factory: Optional["RepoFactory"] = None
+        if url is None:
+            repo_kwargs["config"] = cache_config
+        else:
+            repo_kwargs["cache_dir"] = cache_dir
+            factory = erepo_factory(url, cache_config)
+
+        with _open(
+            url if url else root,
+            **repo_kwargs,
+        ) as repo:
+            return repo, factory
+
     def _get_repo(self, path: str) -> Optional["Repo"]:
         """Returns repo that the path falls in, using prefix.
 
@@ -128,7 +212,7 @@ class RepoFileSystem(BaseFileSystem):  # pylint:disable=abstract-method
 
     def open(
         self, path, mode="r", encoding="utf-8", **kwargs
-    ):  # pylint: disable=arguments-differ
+    ):  # pylint: disable=arguments-renamed
         if "b" in mode:
             encoding = None
 
@@ -159,21 +243,21 @@ class RepoFileSystem(BaseFileSystem):  # pylint:disable=abstract-method
         except FileNotFoundError:
             return False
 
-        (out,) = meta.outs
-        assert len(meta.outs) == 1
-        if fs.exists(out.path_info):
-            return False
+        for out in meta.outs:
+            if fs.exists(out.path_info):
+                return False
+
         return True
 
-    def isdir(self, path):  # pylint: disable=arguments-differ
+    def isdir(self, path):  # pylint: disable=arguments-renamed
         fs, dvc_fs = self._get_fs_pair(path)
 
         if dvc_fs and dvc_fs.repo.dvcignore.is_ignored_dir(path):
             return False
 
         try:
-            st = fs.stat(path)
-            return stat.S_ISDIR(st.st_mode)
+            info = fs.info(path)
+            return info["type"] == "directory"
         except (OSError, ValueError):
             # from CPython's os.path.isdir()
             pass
@@ -186,25 +270,25 @@ class RepoFileSystem(BaseFileSystem):  # pylint:disable=abstract-method
         except FileNotFoundError:
             return False
 
-        (out,) = meta.outs
-        assert len(meta.outs) == 1
-        if fs.exists(out.path_info):
-            return False
+        for out in meta.outs:
+            if fs.exists(out.path_info):
+                return False
+
         return meta.isdir
 
     def isdvc(self, path, **kwargs):
         _, dvc_fs = self._get_fs_pair(path)
         return dvc_fs is not None and dvc_fs.isdvc(path, **kwargs)
 
-    def isfile(self, path):  # pylint: disable=arguments-differ
+    def isfile(self, path):  # pylint: disable=arguments-renamed
         fs, dvc_fs = self._get_fs_pair(path)
 
         if dvc_fs and dvc_fs.repo.dvcignore.is_ignored_file(path):
             return False
 
         try:
-            st = fs.stat(path)
-            return stat.S_ISREG(st.st_mode)
+            info = fs.info(path)
+            return info["type"] == "file"
         except (OSError, ValueError):
             # from CPython's os.path.isfile()
             pass
@@ -229,10 +313,6 @@ class RepoFileSystem(BaseFileSystem):  # pylint:disable=abstract-method
             return dvc_fs.isexec(path_info)
         return fs.isexec(path_info)
 
-    def stat(self, path):
-        fs, _ = self._get_fs_pair(path)
-        return fs.stat(path)
-
     def _dvc_walk(self, walk):
         try:
             root, dirs, files = next(walk)
@@ -369,19 +449,22 @@ class RepoFileSystem(BaseFileSystem):  # pylint:disable=abstract-method
             for fname in files:
                 yield PathInfo(root) / fname
 
-    def _download(
-        self, from_info, to_file, name=None, no_progress_bar=False, **kwargs
+    def get_file(
+        self, from_info, to_file, callback=DEFAULT_CALLBACK, **kwargs
     ):
-        import shutil
+        fs, dvc_fs = self._get_fs_pair(from_info)
+        try:
+            fs.get_file(  # pylint: disable=protected-access
+                from_info, to_file, callback=callback, **kwargs
+            )
+            return
+        except FileNotFoundError:
+            if not dvc_fs:
+                raise
 
-        from dvc.progress import Tqdm
-
-        with open(to_file, "wb+") as to_fobj:
-            with Tqdm.wrapattr(
-                to_fobj, "write", desc=name, disable=no_progress_bar
-            ) as wrapped:
-                with self.open(from_info, "rb", **kwargs) as from_fobj:
-                    shutil.copyfileobj(from_fobj, wrapped)
+        dvc_fs.get_file(  # pylint: disable=protected-access
+            from_info, to_file, callback=callback, **kwargs
+        )
 
     def metadata(self, path):
         abspath = os.path.abspath(path)
@@ -393,11 +476,11 @@ class RepoFileSystem(BaseFileSystem):  # pylint:disable=abstract-method
             with suppress(FileNotFoundError):
                 dvc_meta = dvc_fs.metadata(path_info)
 
-        stat_result = None
+        info_result = None
         with suppress(FileNotFoundError):
-            stat_result = fs.stat(path_info)
+            info_result = fs.info(path_info)
 
-        if not stat_result and not dvc_meta:
+        if not info_result and not dvc_meta:
             raise FileNotFoundError
 
         from ._metadata import Metadata
@@ -407,13 +490,13 @@ class RepoFileSystem(BaseFileSystem):  # pylint:disable=abstract-method
             repo=self._get_repo(abspath) or self._main_repo,
         )
 
-        isdir = bool(stat_result) and stat.S_ISDIR(stat_result.st_mode)
+        isdir = bool(info_result) and info_result["type"] == "directory"
         meta.isdir = meta.isdir or isdir
 
         if not dvc_meta:
             from dvc.utils import is_exec
 
-            meta.is_exec = bool(stat_result) and is_exec(stat_result.st_mode)
+            meta.is_exec = bool(info_result) and is_exec(info_result["mode"])
         return meta
 
     def info(self, path_info):
@@ -423,3 +506,11 @@ class RepoFileSystem(BaseFileSystem):  # pylint:disable=abstract-method
             return fs.info(path_info)
         except FileNotFoundError:
             return dvc_fs.info(path_info)
+
+    def checksum(self, path_info):
+        fs, dvc_fs = self._get_fs_pair(path_info)
+
+        try:
+            return fs.checksum(path_info)
+        except FileNotFoundError:
+            return dvc_fs.checksum(path_info)

dvc/fs/s3.py

@@ -6,7 +6,7 @@ from collections import defaultdict
 from funcy import cached_property, wrap_prop
 
 from dvc.path_info import CloudURLInfo
-from dvc.progress import Tqdm
+from dvc.progress import DEFAULT_CALLBACK
 from dvc.scheme import Schemes
 
 from .fsspec_wrapper import ObjectFSWrapper
@@ -29,12 +29,6 @@ class BaseS3FileSystem(ObjectFSWrapper):
         "grant_write_acp": "GrantWriteACP",
     }
 
-    def __init__(self, **config):
-        super().__init__(**config)
-
-        url = config.get("url", "s3://")
-        self.path_info = self.PATH_CLS(url)
-
     _TRANSFER_CONFIG_ALIASES = {
         "max_queue_size": "max_io_queue",
         "max_concurrent_requests": "max_concurrency",
@@ -74,12 +68,12 @@ class BaseS3FileSystem(ObjectFSWrapper):
         self._transfer_config = None
         config_path = os.environ.get("AWS_CONFIG_FILE", _AWS_CONFIG_PATH)
         if not os.path.exists(config_path):
-            return None
+            return {}
 
         config = load_config(config_path)
         profile_config = config["profiles"].get(profile or "default")
         if not profile_config:
-            return None
+            return {}
 
         s3_config = profile_config.get("s3", {})
         return self._split_s3_config(s3_config)
@@ -103,7 +97,12 @@ class BaseS3FileSystem(ObjectFSWrapper):
         client = login_info["client_kwargs"]
         client["region_name"] = config.get("region")
         client["endpoint_url"] = config.get("endpointurl")
-        client["verify"] = config.get("ssl_verify", True)
+        client["verify"] = config.get("ssl_verify")
+
+        # timeout configuration
+        config_kwargs = login_info["config_kwargs"]
+        config_kwargs["read_timeout"] = config.get("read_timeout")
+        config_kwargs["connect_timeout"] = config.get("connect_timeout")
 
         # encryptions
         additional = login_info["s3_additional_kwargs"]
@@ -129,6 +128,14 @@ class BaseS3FileSystem(ObjectFSWrapper):
         if shared_creds:
             os.environ.setdefault("AWS_SHARED_CREDENTIALS_FILE", shared_creds)
 
+        if (
+            client["region_name"] is None
+            and session_config["s3"].get("region_name") is None
+            and os.getenv("AWS_REGION") is None
+        ):
+            # Enable bucket region caching
+            login_info["cache_regions"] = config.get("cache_regions", True)
+
         config_path = config.get("configpath")
         if config_path:
             os.environ.setdefault("AWS_CONFIG_FILE", config_path)
@@ -194,6 +201,7 @@ class S3FileSystem(BaseS3FileSystem):  # pylint:disable=abstract-method
             "s3",
             endpoint_url=client_kwargs.get("endpoint_url"),
             use_ssl=login_info["use_ssl"],
+            verify=client_kwargs.get("verify"),
         )
 
     def _get_obj(self, path_info):
@@ -201,36 +209,23 @@ class S3FileSystem(BaseS3FileSystem):  # pylint:disable=abstract-method
         return bucket.Object(path_info.path)
 
     @_translate_exceptions
-    def _upload(
-        self, from_file, to_info, name=None, no_progress_bar=False, **pbar_args
+    def put_file(
+        self, from_file, to_info, callback=DEFAULT_CALLBACK, **kwargs
     ):
-        total = os.path.getsize(from_file)
-        with Tqdm(
-            disable=no_progress_bar,
-            total=total,
-            bytes=True,
-            desc=name,
-            **pbar_args,
-        ) as pbar:
-            obj = self._get_obj(to_info)
-            obj.upload_file(
-                from_file,
-                Callback=pbar.update,
-                ExtraArgs=self.fs_args.get("s3_additional_kwargs"),
-                Config=self._transfer_config,
-            )
+        callback.set_size(os.path.getsize(from_file))
+        obj = self._get_obj(to_info)
+        obj.upload_file(
+            from_file,
+            Callback=callback.relative_update,
+            ExtraArgs=self.fs_args.get("s3_additional_kwargs"),
+            Config=self._transfer_config,
+        )
         self.fs.invalidate_cache(self._with_bucket(to_info.parent))
 
     @_translate_exceptions
-    def _download(
-        self, from_info, to_file, name=None, no_progress_bar=False, **pbar_args
+    def get_file(
+        self, from_info, to_info, callback=DEFAULT_CALLBACK, **kwargs
     ):
         obj = self._get_obj(from_info)
-        with Tqdm(
-            disable=no_progress_bar,
-            total=obj.content_length,
-            bytes=True,
-            desc=name,
-            **pbar_args,
-        ) as pbar:
-            obj.download_file(to_file, Callback=pbar.update)
+        callback.set_size(obj.content_length)
+        obj.download_file(to_info, Callback=callback.relative_update)

dvc/fs/ssh.py

@@ -0,0 +1,130 @@
+import getpass
+import os.path
+import threading
+
+from funcy import cached_property, memoize, silent, wrap_prop, wrap_with
+
+from dvc import prompt
+from dvc.scheme import Schemes
+from dvc.utils.fs import as_atomic
+
+from ..progress import DEFAULT_CALLBACK
+from .fsspec_wrapper import FSSpecWrapper
+
+_SSH_TIMEOUT = 60 * 30
+_SSH_CONFIG_FILE = os.path.expanduser(os.path.join("~", ".ssh", "config"))
+
+
+@wrap_with(threading.Lock())
+@memoize
+def ask_password(host, user, port):
+    return prompt.password(
+        "Enter a private key passphrase or a password for "
+        "host '{host}' port '{port}' user '{user}'".format(
+            host=host, port=port, user=user
+        )
+    )
+
+
+# pylint:disable=abstract-method
+class SSHFileSystem(FSSpecWrapper):
+    scheme = Schemes.SSH
+    REQUIRES = {"sshfs": "sshfs"}
+
+    DEFAULT_PORT = 22
+    PARAM_CHECKSUM = "md5"
+
+    def _with_bucket(self, path):
+        if isinstance(path, self.PATH_CLS):
+            return path.path
+        return super()._with_bucket(path)
+
+    def _prepare_credentials(self, **config):
+        self.CAN_TRAVERSE = True
+        from sshfs.config import parse_config
+
+        login_info = {}
+
+        try:
+            user_ssh_config = parse_config(host=config["host"])
+        except FileNotFoundError:
+            user_ssh_config = {}
+
+        login_info["host"] = user_ssh_config.get("Hostname", config["host"])
+
+        login_info["username"] = (
+            config.get("user")
+            or config.get("username")
+            or user_ssh_config.get("User")
+            or getpass.getuser()
+        )
+
+        login_info["port"] = (
+            config.get("port")
+            or silent(int)(user_ssh_config.get("Port"))
+            or self.DEFAULT_PORT
+        )
+
+        if config.get("ask_password") and config.get("password") is None:
+            config["password"] = ask_password(
+                login_info["host"], login_info["username"], login_info["port"]
+            )
+
+        login_info["password"] = config.get("password")
+        login_info["passphrase"] = config.get("password")
+
+        raw_keys = []
+        if config.get("keyfile"):
+            raw_keys.append(config.get("keyfile"))
+        elif user_ssh_config.get("IdentityFile"):
+            raw_keys.extend(user_ssh_config.get("IdentityFile"))
+
+        if raw_keys:
+            login_info["client_keys"] = [
+                os.path.expanduser(key) for key in raw_keys
+            ]
+
+        login_info["timeout"] = config.get("timeout", _SSH_TIMEOUT)
+
+        # These two settings fine tune the asyncssh to use the
+        # fastest encryption algorithm and disable compression
+        # altogether (since it blocking, it is slowing down
+        # the transfers in a considerable rate, and even for
+        # compressible data it is making it extremely slow).
+        # See: https://github.com/ronf/asyncssh/issues/374
+        login_info["encryption_algs"] = [
+            "[email protected]",
+            "aes256-ctr",
+            "aes192-ctr",
+            "aes128-ctr",
+        ]
+        login_info["compression_algs"] = None
+
+        login_info["gss_auth"] = config.get("gss_auth", False)
+        login_info["agent_forwarding"] = config.get("agent_forwarding", True)
+        login_info["proxy_command"] = user_ssh_config.get("ProxyCommand")
+
+        # We are going to automatically add stuff to known_hosts
+        # something like paramiko's AutoAddPolicy()
+        login_info["known_hosts"] = None
+        return login_info
+
+    @wrap_prop(threading.Lock())
+    @cached_property
+    def fs(self):
+        from sshfs import SSHFileSystem as _SSHFileSystem
+
+        return _SSHFileSystem(**self.fs_args)
+
+    # Ensure that if an interrupt happens during the transfer, we don't
+    # pollute the cache.
+
+    def upload_fobj(self, fobj, to_info, **kwargs):
+        with as_atomic(self, to_info) as tmp_file:
+            super().upload_fobj(fobj, tmp_file, **kwargs)
+
+    def put_file(
+        self, from_file, to_info, callback=DEFAULT_CALLBACK, **kwargs
+    ):
+        with as_atomic(self, to_info) as tmp_file:
+            super().put_file(from_file, tmp_file, callback=callback, **kwargs)

dvc/fs/ssh/__init__.py

@@ -1,273 +0,0 @@
-import getpass
-import io
-import logging
-import os
-import shutil
-import threading
-from contextlib import closing, contextmanager
-from urllib.parse import urlparse
-
-from funcy import first, memoize, silent, wrap_with
-
-from dvc import prompt
-from dvc.hash_info import HashInfo
-from dvc.scheme import Schemes
-
-from ..base import BaseFileSystem
-from ..pool import get_connection
-
-logger = logging.getLogger(__name__)
-
-
-@wrap_with(threading.Lock())
-@memoize
-def ask_password(host, user, port):
-    return prompt.password(
-        "Enter a private key passphrase or a password for "
-        "host '{host}' port '{port}' user '{user}'".format(
-            host=host, port=port, user=user
-        )
-    )
-
-
-class SSHFileSystem(BaseFileSystem):  # pylint:disable=abstract-method
-    scheme = Schemes.SSH
-    REQUIRES = {"paramiko": "paramiko"}
-    _JOBS = 4
-
-    PARAM_CHECKSUM = "md5"
-    # At any given time some of the connections will go over network and
-    # paramiko stuff, so we would ideally have it double of server processors.
-    # We use conservative setting of 4 instead to not exhaust max sessions.
-    CHECKSUM_JOBS = 4
-    DEFAULT_CACHE_TYPES = ["copy"]
-    TRAVERSE_PREFIX_LEN = 2
-
-    DEFAULT_PORT = 22
-    TIMEOUT = 1800
-
-    def __init__(self, **config):
-        super().__init__(**config)
-        url = config.get("url")
-        if url:
-            parsed = urlparse(url)
-            user_ssh_config = self._load_user_ssh_config(parsed.hostname)
-
-            host = user_ssh_config.get("hostname", parsed.hostname)
-            user = (
-                config.get("user")
-                or parsed.username
-                or user_ssh_config.get("user")
-                or getpass.getuser()
-            )
-            port = (
-                config.get("port")
-                or parsed.port
-                or self._try_get_ssh_config_port(user_ssh_config)
-                or self.DEFAULT_PORT
-            )
-            self.path_info = self.PATH_CLS.from_parts(
-                scheme=self.scheme,
-                host=host,
-                user=user,
-                port=port,
-                path=parsed.path,
-            )
-        else:
-            self.path_info = None
-            user_ssh_config = {}
-
-        self.keyfile = config.get(
-            "keyfile"
-        ) or self._try_get_ssh_config_keyfile(user_ssh_config)
-        self.timeout = config.get("timeout", self.TIMEOUT)
-        self.password = config.get("password", None)
-        self.ask_password = config.get("ask_password", False)
-        self.gss_auth = config.get("gss_auth", False)
-        proxy_command = user_ssh_config.get("proxycommand", False)
-        if proxy_command:
-            import paramiko
-
-            self.sock = paramiko.ProxyCommand(proxy_command)
-        else:
-            self.sock = None
-        self.allow_agent = config.get("allow_agent", True)
-
-    @staticmethod
-    def ssh_config_filename():
-        return os.path.expanduser(os.path.join("~", ".ssh", "config"))
-
-    @staticmethod
-    def _load_user_ssh_config(hostname):
-        import paramiko
-
-        user_config_file = SSHFileSystem.ssh_config_filename()
-        user_ssh_config = {}
-        if hostname and os.path.exists(user_config_file):
-            ssh_config = paramiko.SSHConfig()
-            with open(user_config_file) as f:
-                # For whatever reason parsing directly from f is unreliable
-                f_copy = io.StringIO(f.read())
-                ssh_config.parse(f_copy)
-            user_ssh_config = ssh_config.lookup(hostname)
-        return user_ssh_config
-
-    @staticmethod
-    def _try_get_ssh_config_port(user_ssh_config):
-        return silent(int)(user_ssh_config.get("port"))
-
-    @staticmethod
-    def _try_get_ssh_config_keyfile(user_ssh_config):
-        return first(user_ssh_config.get("identityfile") or ())
-
-    def ensure_credentials(self, path_info=None):
-        if path_info is None:
-            path_info = self.path_info
-
-        # NOTE: we use the same password regardless of the server :(
-        if self.ask_password and self.password is None:
-            host, user, port = path_info.host, path_info.user, path_info.port
-            self.password = ask_password(host, user, port)
-
-    def ssh(self, path_info):
-        self.ensure_credentials(path_info)
-
-        from .connection import SSHConnection
-
-        return get_connection(
-            SSHConnection,
-            path_info.host,
-            username=path_info.user,
-            port=path_info.port,
-            key_filename=self.keyfile,
-            timeout=self.timeout,
-            password=self.password,
-            gss_auth=self.gss_auth,
-            sock=self.sock,
-            allow_agent=self.allow_agent,
-        )
-
-    @contextmanager
-    def open(self, path_info, mode="r", encoding=None, **kwargs):
-        assert mode in {"r", "rt", "rb", "wb"}
-
-        with self.ssh(path_info) as ssh, closing(
-            ssh.sftp.open(path_info.path, mode)
-        ) as fd:
-            if "b" in mode:
-                yield fd
-            else:
-                yield io.TextIOWrapper(fd, encoding=encoding)
-
-    def exists(self, path_info) -> bool:
-        with self.ssh(path_info) as ssh:
-            return ssh.exists(path_info.path)
-
-    def isdir(self, path_info):
-        with self.ssh(path_info) as ssh:
-            return ssh.isdir(path_info.path)
-
-    def isfile(self, path_info):
-        with self.ssh(path_info) as ssh:
-            return ssh.isfile(path_info.path)
-
-    def walk_files(self, path_info, **kwargs):
-        with self.ssh(path_info) as ssh:
-            for fname in ssh.walk_files(path_info.path):
-                yield path_info.replace(path=fname)
-
-    def remove(self, path_info):
-        if path_info.scheme != self.scheme:
-            raise NotImplementedError
-
-        with self.ssh(path_info) as ssh:
-            ssh.remove(path_info.path)
-
-    def makedirs(self, path_info):
-        with self.ssh(path_info) as ssh:
-            ssh.makedirs(path_info.path)
-
-    def move(self, from_info, to_info):
-        if from_info.scheme != self.scheme or to_info.scheme != self.scheme:
-            raise NotImplementedError
-
-        with self.ssh(from_info) as ssh:
-            ssh.move(from_info.path, to_info.path)
-
-    def copy(self, from_info, to_info):
-        if not from_info.scheme == to_info.scheme == self.scheme:
-            raise NotImplementedError
-
-        with self.ssh(from_info) as ssh:
-            ssh.atomic_copy(from_info.path, to_info.path)
-
-    def symlink(self, from_info, to_info):
-        if not from_info.scheme == to_info.scheme == self.scheme:
-            raise NotImplementedError
-
-        with self.ssh(from_info) as ssh:
-            ssh.symlink(from_info.path, to_info.path)
-
-    def hardlink(self, from_info, to_info):
-        if not from_info.scheme == to_info.scheme == self.scheme:
-            raise NotImplementedError
-
-        # See dvc/remote/local/__init__.py - hardlink()
-        if self.getsize(from_info) == 0:
-
-            with self.ssh(to_info) as ssh:
-                ssh.sftp.open(to_info.path, "w").close()
-
-            logger.debug(
-                "Created empty file: {src} -> {dest}".format(
-                    src=str(from_info), dest=str(to_info)
-                )
-            )
-            return
-
-        with self.ssh(from_info) as ssh:
-            ssh.hardlink(from_info.path, to_info.path)
-
-    def reflink(self, from_info, to_info):
-        if from_info.scheme != self.scheme or to_info.scheme != self.scheme:
-            raise NotImplementedError
-
-        with self.ssh(from_info) as ssh:
-            ssh.reflink(from_info.path, to_info.path)
-
-    def md5(self, path_info):
-        with self.ssh(path_info) as ssh:
-            return HashInfo(
-                "md5",
-                ssh.md5(path_info.path),
-                size=ssh.getsize(path_info.path),
-            )
-
-    def info(self, path_info):
-        with self.ssh(path_info) as ssh:
-            return ssh.info(path_info.path)
-
-    def _upload_fobj(self, fobj, to_info):
-        self.makedirs(to_info.parent)
-        with self.open(to_info, mode="wb") as fdest:
-            shutil.copyfileobj(fobj, fdest)
-
-    def _download(self, from_info, to_file, name=None, no_progress_bar=False):
-        with self.ssh(from_info) as ssh:
-            ssh.download(
-                from_info.path,
-                to_file,
-                progress_title=name,
-                no_progress_bar=no_progress_bar,
-            )
-
-    def _upload(
-        self, from_file, to_info, name=None, no_progress_bar=False, **_kwargs
-    ):
-        with self.ssh(to_info) as ssh:
-            ssh.upload(
-                from_file,
-                to_info.path,
-                progress_title=name,
-                no_progress_bar=no_progress_bar,
-            )

dvc/fs/ssh/connection.py

@@ -1,356 +0,0 @@
-import errno
-import logging
-import os
-import posixpath
-import shlex
-import stat
-from contextlib import suppress
-
-from funcy import cached_property
-
-from dvc.exceptions import DvcException
-from dvc.progress import Tqdm
-from dvc.utils import tmp_fname
-
-from ..base import RemoteCmdError
-
-try:
-    import paramiko
-except ImportError:
-    paramiko = None  # type: ignore
-
-
-logger = logging.getLogger(__name__)
-
-
-def sizeof_fmt(num, suffix="B"):
-    """Convert number of bytes to human-readable string"""
-    for unit in ["", "K", "M", "G", "T", "P", "E", "Z"]:
-        if abs(num) < 1024.0:
-            return f"{num:3.1f}{unit}{suffix}"
-        num /= 1024.0
-    return "{:.1f}{}{}".format(num, "Y", suffix)
-
-
-class SSHConnection:
-    def __init__(self, host, *args, **kwargs):
-        logger.debug(
-            "Establishing ssh connection with '{host}' "
-            "through port '{port}' as user '{username}'".format(
-                host=host, **kwargs
-            )
-        )
-
-        kwargs.setdefault("timeout", 1800)
-        self.timeout = kwargs["timeout"]
-
-        self._ssh = paramiko.SSHClient()
-
-        # Explicitly disable paramiko logger. Due to how paramiko dynamically
-        # loads loggers, it is not disabled by DVC disable_other_loggers().
-        # See https://github.com/iterative/dvc/issues/3482
-        self._ssh.set_log_channel("dvc.paramiko")
-        logging.getLogger("dvc.paramiko").disabled = True
-        logging.getLogger("dvc.paramiko.sftp").disabled = True
-
-        self._ssh.load_system_host_keys()
-        self._ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())
-
-        self._ssh.connect(host, *args, **kwargs)
-        self._ssh.get_transport().set_keepalive(10)
-        self._sftp_channels = []
-
-    @property
-    def sftp(self):
-        if not self._sftp_channels:
-            self._sftp_channels = [self._ssh.open_sftp()]
-        return self._sftp_channels[0]
-
-    def close(self):
-        for sftp in self._sftp_channels:
-            sftp.close()
-        self._ssh.close()
-
-    def st_mode(self, path):
-        lstat = None
-        with suppress(FileNotFoundError):
-            lstat = self.sftp.lstat(path)
-
-        return lstat.st_mode if lstat else 0
-
-    def info(self, path):
-        st = self.sftp.stat(path)
-        return {
-            "size": st.st_size,
-            "type": "dir" if stat.S_ISDIR(st.st_mode) else "file",
-        }
-
-    def getsize(self, path):
-        return self.info(path)["size"]
-
-    def exists(self, path):
-        return bool(self.st_mode(path))
-
-    def isdir(self, path):
-        return stat.S_ISDIR(self.st_mode(path))
-
-    def isfile(self, path):
-        return stat.S_ISREG(self.st_mode(path))
-
-    def islink(self, path):
-        return stat.S_ISLNK(self.st_mode(path))
-
-    def makedirs(self, path):
-        # Single stat call will say whether this is a dir, a file or a link
-        st_mode = self.st_mode(path)
-
-        if stat.S_ISDIR(st_mode):
-            return
-
-        if stat.S_ISREG(st_mode) or stat.S_ISLNK(st_mode):
-            raise DvcException(
-                f"a file with the same name '{path}' already exists"
-            )
-
-        head, tail = posixpath.split(path)
-
-        if head:
-            self.makedirs(head)
-
-        if tail:
-            try:
-                self.sftp.mkdir(path)
-            except OSError as exc:
-                # Since paramiko errors are very vague we need to recheck
-                # whether it's because path already exists or something else
-                if exc.errno == errno.EACCES or not self.exists(path):
-                    raise DvcException(
-                        f"unable to create remote directory '{path}'"
-                    ) from exc
-
-    def walk(self, directory, topdown=True):
-        # NOTE: original os.walk() implementation [1] with default options was
-        # used as a template.
-        #
-        # [1] https://github.com/python/cpython/blob/master/Lib/os.py
-        try:
-            dir_entries = self.sftp.listdir_attr(directory)
-        except OSError as exc:
-            raise DvcException(
-                "couldn't get the '{}' remote directory files list".format(
-                    directory
-                )
-            ) from exc
-
-        dirs = []
-        nondirs = []
-        for entry in dir_entries:
-            name = entry.filename
-            if stat.S_ISDIR(entry.st_mode):
-                dirs.append(name)
-            else:
-                nondirs.append(name)
-
-        if topdown:
-            yield directory, dirs, nondirs
-
-        for dname in dirs:
-            newpath = posixpath.join(directory, dname)
-            yield from self.walk(newpath, topdown=topdown)
-
-        if not topdown:
-            yield directory, dirs, nondirs
-
-    def walk_files(self, directory):
-        for root, _, files in self.walk(directory):
-            for fname in files:
-                yield posixpath.join(root, fname)
-
-    def _remove_file(self, path):
-        with suppress(FileNotFoundError):
-            self.sftp.remove(path)
-
-    def _remove_dir(self, path):
-        for root, dirs, files in self.walk(path, topdown=False):
-            for fname in files:
-                with suppress(FileNotFoundError):
-                    self._remove_file(posixpath.join(root, fname))
-
-            for dname in dirs:
-                with suppress(FileNotFoundError):
-                    self.sftp.rmdir(posixpath.join(root, dname))
-
-        with suppress(FileNotFoundError):
-            self.sftp.rmdir(path)
-
-    def remove(self, path):
-        if self.isdir(path):
-            self._remove_dir(path)
-        else:
-            self._remove_file(path)
-
-    def download(self, src, dest, no_progress_bar=False, progress_title=None):
-        with Tqdm(
-            desc=progress_title or os.path.basename(src),
-            disable=no_progress_bar,
-            bytes=True,
-            total=self.getsize(src),
-        ) as pbar:
-            self.sftp.get(src, dest, callback=pbar.update_to)
-
-    def move(self, src, dst):
-        """Rename src to dst, if it is not possible (in case src and dst are
-        on different filesystems) and actual physical copying of data is
-        happening.
-        """
-        self.makedirs(posixpath.dirname(dst))
-
-        try:
-            self.sftp.rename(src, dst)
-        except OSError:
-            self.atomic_copy(src, dst)
-            self.remove(src)
-
-    def atomic_copy(self, src, dst):
-        tmp = tmp_fname(dst)
-
-        try:
-            self.copy(src, tmp)
-            self.sftp.rename(tmp, dst)
-        finally:
-            self.remove(tmp)
-
-    def upload(self, src, dest, no_progress_bar=False, progress_title=None):
-        self.makedirs(posixpath.dirname(dest))
-        tmp_file = tmp_fname(dest)
-        if not progress_title:
-            progress_title = posixpath.basename(dest)
-
-        with Tqdm(
-            desc=progress_title,
-            disable=no_progress_bar,
-            bytes=True,
-            total=os.path.getsize(src),
-        ) as pbar:
-            self.sftp.put(src, tmp_file, callback=pbar.update_to)
-
-        self.sftp.rename(tmp_file, dest)
-
-    def execute(self, cmd):
-        stdin, stdout, stderr = self._ssh.exec_command(cmd)
-        channel = stdout.channel
-
-        stdin.close()
-        channel.shutdown_write()
-
-        stdout_chunks = []
-        stderr_chunks = []
-        while (
-            not channel.closed
-            or channel.recv_ready()
-            or channel.recv_stderr_ready()
-        ):
-            import selectors
-
-            selector = selectors.DefaultSelector()
-            selector.register(stdout.channel, selectors.EVENT_READ)
-
-            got_chunk = False
-            events = selector.select(self.timeout)
-            for key, _ in events:
-                c = key.fileobj
-                if c.recv_ready():
-                    stdout_chunks.append(stdout.channel.recv(len(c.in_buffer)))
-                    got_chunk = True
-
-                if c.recv_stderr_ready():
-                    stderr_len = len(c.in_stderr_buffer)
-                    s = stderr.channel.recv_stderr(stderr_len)
-                    stderr_chunks.append(s)
-                    got_chunk = True
-
-            if (
-                not got_chunk
-                and stdout.channel.exit_status_ready()
-                and not stderr.channel.recv_stderr_ready()
-                and not stdout.channel.recv_ready()
-            ):
-                stdout.channel.shutdown_read()
-                stdout.channel.close()
-                break
-
-        stdout.close()
-        stderr.close()
-
-        ret = stdout.channel.recv_exit_status()
-        if ret != 0:
-            err = b"".join(stderr_chunks).decode("utf-8")
-            raise RemoteCmdError("ssh", cmd, ret, err)
-
-        return b"".join(stdout_chunks).decode("utf-8")
-
-    @cached_property
-    def uname(self):
-        return self.execute("uname").strip()
-
-    def md5(self, path):
-        """
-        Use different md5 commands depending on the OS:
-
-         - Darwin's `md5` returns BSD-style checksums by default
-         - Linux's `md5sum` needs the `--tag` flag for a similar output
-
-         Example:
-              MD5 (foo.txt) = f3d220a856b52aabbf294351e8a24300
-        """
-        path = shlex.quote(path)
-        if self.uname == "Linux":
-            md5 = self.execute("md5sum " + path).split()[0]
-        elif self.uname == "Darwin":
-            md5 = self.execute("md5 " + path).split()[-1]
-        else:
-            raise DvcException(
-                f"'{self.uname}' is not supported as a SSH remote"
-            )
-
-        assert len(md5) == 32
-        return md5
-
-    def copy(self, src, dest):
-        dest = shlex.quote(dest)
-        src = shlex.quote(src)
-        self.execute(f"cp {src} {dest}")
-
-    def open_max_sftp_channels(self):
-        # If there are more than 1 it means we've already opened max amount
-        if len(self._sftp_channels) <= 1:
-            while True:
-                try:
-                    self._sftp_channels.append(self._ssh.open_sftp())
-                except paramiko.ssh_exception.ChannelException:
-                    if not self._sftp_channels:
-                        raise
-                    break
-        return self._sftp_channels
-
-    def open(self, *args, **kwargs):
-        return self.sftp.open(*args, **kwargs)
-
-    def symlink(self, src, dest):
-        self.sftp.symlink(src, dest)
-
-    def reflink(self, src, dest):
-        dest = shlex.quote(dest)
-        src = shlex.quote(src)
-        if self.uname == "Linux":
-            return self.execute(f"cp --reflink {src} {dest}")
-
-        if self.uname == "Darwin":
-            return self.execute(f"cp -c {src} {dest}")
-
-        raise DvcException(f"'{self.uname}' is not supported as a SSH remote")
-
-    def hardlink(self, src, dest):
-        dest = shlex.quote(dest)
-        src = shlex.quote(src)
-        self.execute(f"ln {src} {dest}")

dvc/fs/utils.py

@@ -0,0 +1,56 @@
+import logging
+import os
+from typing import TYPE_CHECKING
+
+from .local import LocalFileSystem
+
+if TYPE_CHECKING:
+    from dvc.types import AnyPath, DvcPath
+
+    from .base import BaseFileSystem
+
+logger = logging.getLogger(__name__)
+
+
+def transfer(
+    from_fs: "BaseFileSystem",
+    from_info: "AnyPath",
+    to_fs: "BaseFileSystem",
+    to_info: "DvcPath",
+    move: bool = False,
+) -> None:
+    use_move = isinstance(from_fs, type(to_fs)) and move
+    try:
+        if use_move:
+            return to_fs.move(from_info, to_info)
+
+        if isinstance(from_fs, LocalFileSystem):
+            if not isinstance(from_info, from_fs.PATH_CLS):
+                from_info = from_fs.PATH_CLS(from_info)
+            return to_fs.upload(from_info, to_info)
+
+        if isinstance(to_fs, LocalFileSystem):
+            return from_fs.download_file(from_info, to_info)
+
+        with from_fs.open(from_info, mode="rb") as fobj:
+            size = from_fs.getsize(from_info)
+            return to_fs.upload(fobj, to_info, total=size)
+    except OSError as exc:
+        # If the target file already exists, we are going to simply
+        # ignore the exception (#4992).
+        #
+        # On Windows, it is not always guaranteed that you'll get
+        # FileExistsError (it might be PermissionError or a bare OSError)
+        # but all of those exceptions raised from the original
+        # FileExistsError so we have a separate check for that.
+        if isinstance(exc, FileExistsError) or (
+            os.name == "nt"
+            and exc.__context__
+            and isinstance(exc.__context__, FileExistsError)
+        ):
+            logger.debug("'%s' file already exists, skipping", to_info)
+            if use_move:
+                from_fs.remove(from_info)
+            return None
+
+        raise

dvc/fs/webdav.py

@@ -1,270 +1,91 @@
-import io
 import logging
-import os
 import threading
-from collections import deque
+from functools import lru_cache
 
-from funcy import cached_property, nullcontext, wrap_prop
+from funcy import cached_property, wrap_prop
 
-from dvc.config import ConfigError
-from dvc.exceptions import DvcException
-from dvc.path_info import HTTPURLInfo, WebDAVURLInfo
-from dvc.progress import Tqdm
+from dvc.path_info import WebDAVURLInfo
 from dvc.scheme import Schemes
 
-from .base import BaseFileSystem
+from .fsspec_wrapper import FSSpecWrapper
 from .http import ask_password
 
 logger = logging.getLogger(__name__)
 
 
-class WebDAVConnectionError(DvcException):
-    def __init__(self, host):
-        super().__init__(f"Unable to connect to WebDAV {host}.")
-
-
-class WebDAVFileSystem(BaseFileSystem):  # pylint:disable=abstract-method
-    # Use webdav scheme
+class WebDAVFileSystem(FSSpecWrapper):  # pylint:disable=abstract-method
     scheme = Schemes.WEBDAV
-
-    # URLInfo for Webdav ~ replaces webdav -> http
     PATH_CLS = WebDAVURLInfo
-
-    # Traversable as walk_files is implemented
     CAN_TRAVERSE = True
-
-    # Length of walk_files prefix
     TRAVERSE_PREFIX_LEN = 2
-
-    # Implementation based on webdav3.client
-    REQUIRES = {"webdavclient3": "webdav3.client"}
-
-    # Chunk size for buffered upload/download with progress bar
-    CHUNK_SIZE = 2 ** 16
-
+    REQUIRES = {"webdav4": "webdav4"}
     PARAM_CHECKSUM = "etag"
     DETAIL_FIELDS = frozenset(("etag", "size"))
 
-    # Constructor
     def __init__(self, **config):
-        # Call BaseFileSystem constructor
         super().__init__(**config)
 
-        # Get username from configuration
-        self.user = config.get("user", None)
+        cert_path = config.get("cert_path", None)
+        key_path = config.get("key_path", None)
+        self.prefix = config.get("prefix", "")
+        self.fs_args.update(
+            {
+                "base_url": config["url"],
+                "cert": cert_path if not key_path else (cert_path, key_path),
+                "verify": config.get("ssl_verify", True),
+                "timeout": config.get("timeout", 30),
+            }
+        )
 
-        # Get password from configuration (might be None ~ not set)
-        self.password = config.get("password", None)
-
-        # Whether to ask for password if it is not set
-        self.ask_password = config.get("ask_password", False)
-
-        # Use token for webdav auth
-        self.token = config.get("token", None)
-
-        # Path to certificate
-        self.cert_path = config.get("cert_path", None)
-
-        # Path to private key
-        self.key_path = config.get("key_path", None)
-
-        # Connection timeout
-        self.timeout = config.get("timeout", 30)
-
-        # Get URL from configuration
-        self.url = config.get("url", None)
-
-        # If URL in config parse path_info
-        if self.url:
-            self.path_info = self.PATH_CLS(self.url)
-
-            # If username not specified try to use from URL
-            if self.user is None and self.path_info.user is not None:
-                self.user = self.path_info.user
-
-            # Construct hostname from path_info by stripping path
-            http_info = HTTPURLInfo(self.path_info.url)
-            self.hostname = http_info.replace(path="").url
-
-    # Webdav client
-    @wrap_prop(threading.Lock())
-    @cached_property
-    def _client(self):
-        from webdav3.client import Client
-
-        # Set password or ask for it
-        if self.ask_password and self.password is None and self.token is None:
-            self.password = ask_password(self.hostname, self.user)
-
-        # Setup webdav client options dictionary
-        options = {
-            "webdav_hostname": self.hostname,
-            "webdav_login": self.user,
-            "webdav_password": self.password,
-            "webdav_token": self.token,
-            "webdav_cert_path": self.cert_path,
-            "webdav_key_path": self.key_path,
-            "webdav_timeout": self.timeout,
-            "webdav_chunk_size": self.CHUNK_SIZE,
+    @staticmethod
+    def _get_kwargs_from_urls(urlpath):
+        path_info = WebDAVURLInfo(urlpath)
+        return {
+            "prefix": path_info.path.rstrip("/"),
+            "host": path_info.replace(path="").url,
+            "url": path_info.url.rstrip("/"),
+            "user": path_info.user,
         }
 
-        client = Client(options)
+    def _prepare_credentials(self, **config):
+        user = config.get("user", None)
+        password = config.get("password", None)
 
-        # Check whether client options are valid
-        if not client.valid():
-            raise ConfigError(
-                f"Configuration for WebDAV {self.hostname} is invalid."
-            )
+        headers = {}
+        token = config.get("token")
+        auth = None
+        if token:
+            headers.update({"Authorization": f"Bearer {token}"})
+        elif user:
+            if not password and config.get("ask_password"):
+                password = ask_password(config["host"], user)
+            auth = (user, password)
 
-        # Check whether connection is valid (root should always exist)
-        if not client.check(self.path_info.path):
-            raise WebDAVConnectionError(self.hostname)
+        return {"headers": headers, "auth": auth}
 
-        return client
+    @wrap_prop(threading.Lock())
+    @cached_property
+    def fs(self):
+        from webdav4.fsspec import WebdavFileSystem
 
-    def open(self, path_info, mode="r", encoding=None, **kwargs):
-        from webdav3.exceptions import RemoteResourceNotFound
+        return WebdavFileSystem(**self.fs_args)
 
-        assert mode in {"r", "rt", "rb"}
+    def upload_fobj(self, fobj, to_info, **kwargs):
+        rpath = self.translate_path_info(to_info)
+        size = kwargs.get("size")
+        # using upload_fileobj to directly upload fileobj rather than buffering
+        # and using overwrite=True to avoid check for an extra exists call,
+        # as caller should ensure that the file does not exist beforehand.
+        return self.fs.upload_fileobj(fobj, rpath, overwrite=True, size=size)
 
-        fobj = io.BytesIO()
+    @lru_cache(512)
+    def translate_path_info(self, path):
+        if isinstance(path, self.PATH_CLS):
+            return path.path[len(self.prefix) :].lstrip("/")
+        return path
 
-        try:
-            self._client.download_from(buff=fobj, remote_path=path_info.path)
-        except RemoteResourceNotFound as exc:
-            raise FileNotFoundError from exc
+    _with_bucket = translate_path_info  # type: ignore
 
-        fobj.seek(0)
 
-        if "mode" == "rb":
-            return fobj
-
-        return io.TextIOWrapper(fobj, encoding=encoding)
-
-    # Checks whether file/directory exists at remote
-    def exists(self, path_info) -> bool:
-        # Use webdav check to test for file existence
-        return self._client.check(path_info.path)
-
-    # Checks whether path points to directory
-    def isdir(self, path_info):
-        # Use webdav is_dir to test whether path points to a directory
-        return self._client.is_dir(path_info.path)
-
-    def walk_files(self, path_info, **kwargs):
-        if not self.exists(path_info):
-            return
-
-        for file in self.find(path_info):
-            yield path_info.replace(path=file)
-
-    def ls(self, path_info, detail=False):
-        for entry in self._client.list(path_info.path):
-            path = entry["path"]
-            if detail:
-                if entry["isdir"]:
-                    yield {"type": "directory", "name": path}
-                else:
-                    yield {
-                        "type": "file",
-                        "name": path,
-                        "size": entry["size"],
-                        "etag": entry["etag"],
-                    }
-            else:
-                yield path
-
-    def find(self, path_info, detail=False):
-        dirs = deque([path_info.path])
-
-        while dirs:
-            for entry in self._client.list(dirs.pop(), get_info=True):
-                path = entry["path"]
-                if entry["isdir"]:
-                    dirs.append(path)
-                    continue
-
-                if detail:
-                    yield {
-                        "type": "file",
-                        "name": path,
-                        "size": entry["size"],
-                        "etag": entry["etag"],
-                    }
-                else:
-                    yield path
-
-    # Removes file/directory
-    def remove(self, path_info):
-        # Use webdav client clean (DELETE) method to remove file/directory
-        self._client.clean(path_info.path)
-
-    # Creates directories
-    def makedirs(self, path_info):
-        # Terminate recursion
-        if path_info.path == self.path_info.path or self.exists(path_info):
-            return
-
-        # Recursively descent to root
-        self.makedirs(path_info.parent)
-
-        # Construct directory at current recursion depth
-        self._client.mkdir(path_info.path)
-
-    # Moves file/directory at remote
-    def move(self, from_info, to_info):
-        # Webdav client move
-        self._client.move(from_info.path, to_info.path)
-
-    def _upload_fobj(self, fobj, to_info):
-        # In contrast to other upload_fobj implementations, this one does not
-        # exactly do a chunked-upload but rather put everything in one request.
-        self.makedirs(to_info.parent)
-        self._client.upload_to(buff=fobj, remote_path=to_info.path)
-
-    # Downloads file from remote to file
-    def _download(self, from_info, to_file, name=None, no_progress_bar=False):
-        # Progress from HTTPFileSystem
-        with open(to_file, "wb") as fd:
-            with Tqdm.wrapattr(
-                fd,
-                "write",
-                total=None if no_progress_bar else self.getsize(from_info),
-                leave=False,
-                desc=from_info.url if name is None else name,
-                disable=no_progress_bar,
-            ) as fd_wrapped:
-                # Download from WebDAV via buffer
-                self._client.download_from(
-                    buff=fd_wrapped, remote_path=from_info.path
-                )
-
-    # Uploads file to remote
-    def _upload(
-        self, from_file, to_info, name=None, no_progress_bar=False, **_kwargs
-    ):
-        # First try to create parent directories
-        self.makedirs(to_info.parent)
-
-        file_size = os.path.getsize(from_file)
-        with open(from_file, "rb") as fd:
-            progress_context = (
-                nullcontext(fd)
-                if file_size == 0
-                else Tqdm.wrapattr(
-                    fd,
-                    "read",
-                    total=None if no_progress_bar else file_size,
-                    leave=False,
-                    desc=to_info.url if name is None else name,
-                    disable=no_progress_bar,
-                )
-            )
-            with progress_context as fd_wrapped:
-                self._client.upload_to(
-                    buff=fd_wrapped, remote_path=to_info.path
-                )
-
-    def info(self, path_info):
-        info = self._client.info(path_info.path)
-        return {"size": int(info["size"]), "etag": info["etag"]}
+class WebDAVSFileSystem(WebDAVFileSystem):  # pylint:disable=abstract-method
+    scheme = Schemes.WEBDAVS

dvc/fs/webdavs.py

@@ -1,7 +0,0 @@
-from dvc.scheme import Schemes
-
-from .webdav import WebDAVFileSystem
-
-
-class WebDAVSFileSystem(WebDAVFileSystem):  # pylint:disable=abstract-method
-    scheme = Schemes.WEBDAVS

dvc/fs/webhdfs.py

@@ -1,171 +1,49 @@
-import logging
-import os
-import posixpath
-import shutil
 import threading
-from contextlib import contextmanager
-from urllib.parse import urlparse
 
 from funcy import cached_property, wrap_prop
 
-from dvc.hash_info import HashInfo
 from dvc.path_info import CloudURLInfo
-from dvc.progress import Tqdm
 from dvc.scheme import Schemes
 
-from .base import BaseFileSystem
-
-logger = logging.getLogger(__name__)
+# pylint:disable=abstract-method
+from .fsspec_wrapper import CallbackMixin, FSSpecWrapper
 
 
-def update_pbar(pbar, total):
-    """Update pbar to accept the two arguments passed by hdfs"""
-
-    def update(_, bytes_transfered):
-        if bytes_transfered == -1:
-            pbar.update_to(total)
-            return
-        pbar.update_to(bytes_transfered)
-
-    return update
-
-
-class WebHDFSFileSystem(BaseFileSystem):  # pylint:disable=abstract-method
+class WebHDFSFileSystem(CallbackMixin, FSSpecWrapper):
     scheme = Schemes.WEBHDFS
     PATH_CLS = CloudURLInfo
-    REQUIRES = {"hdfs": "hdfs"}
+    REQUIRES = {"fsspec": "fsspec"}
     PARAM_CHECKSUM = "checksum"
-    TRAVERSE_PREFIX_LEN = 2
 
-    def __init__(self, **config):
-        super().__init__(**config)
+    def _with_bucket(self, path):
+        if isinstance(path, self.PATH_CLS):
+            return f"/{path.path.rstrip('/')}"
+        return path
 
-        self.path_info = None
-        url = config.get("url")
-        if not url:
-            return
+    @staticmethod
+    def _get_kwargs_from_urls(urlpath):
+        from fsspec.implementations.webhdfs import WebHDFS
 
-        self.path_info = self.PATH_CLS(url)
+        return (
+            WebHDFS._get_kwargs_from_urls(  # pylint:disable=protected-access
+                urlpath
+            )
+        )
 
-        parsed = urlparse(url)
+    def _prepare_credentials(self, **config):
+        if "webhdfs_token" in config:
+            config["token"] = config.pop("webhdfs_token")
 
-        self.host = parsed.hostname
-        self.user = parsed.username or config.get("user")
-        self.port = parsed.port
-
-        self.hdfscli_config = config.get("hdfscli_config")
-        self.token = config.get("webhdfs_token")
-        self.alias = config.get("webhdfs_alias")
+        return config
 
     @wrap_prop(threading.Lock())
     @cached_property
-    def hdfs_client(self):
-        import hdfs
+    def fs(self):
+        from fsspec.implementations.webhdfs import WebHDFS
 
-        logger.debug("HDFSConfig: %s", self.hdfscli_config)
-
-        try:
-            return hdfs.config.Config(self.hdfscli_config).get_client(
-                self.alias
-            )
-        except hdfs.util.HdfsError as exc:
-            exc_msg = str(exc)
-            errors = (
-                "No alias specified",
-                "Invalid configuration file",
-                f"Alias {self.alias} not found",
-            )
-            if not any(err in exc_msg for err in errors):
-                raise
-
-            http_url = f"http://{self.host}:{self.port}"
-            logger.debug("URL: %s", http_url)
-
-            if self.token is not None:
-                client = hdfs.TokenClient(http_url, token=self.token, root="/")
-            else:
-                client = hdfs.InsecureClient(
-                    http_url, user=self.user, root="/"
-                )
-
-        return client
-
-    @contextmanager
-    def open(self, path_info, mode="r", encoding=None, **kwargs):
-        assert mode in {"r", "rt", "rb"}
-
-        with self.hdfs_client.read(
-            path_info.path, encoding=encoding
-        ) as reader:
-            yield reader
-
-    def walk_files(self, path_info, **kwargs):
-        if not self.exists(path_info):
-            return
-
-        root = path_info.path
-        for path, _, fnames in self.hdfs_client.walk(root):
-            for fname in fnames:
-                yield path_info.replace(path=posixpath.join(path, fname))
-
-    def remove(self, path_info):
-        if path_info.scheme != self.scheme:
-            raise NotImplementedError
-
-        self.hdfs_client.delete(path_info.path)
-
-    def exists(self, path_info) -> bool:
-        assert not isinstance(path_info, list)
-        assert path_info.scheme == "webhdfs"
-
-        status = self.hdfs_client.status(path_info.path, strict=False)
-        return status is not None
-
-    def info(self, path_info):
-        st = self.hdfs_client.status(path_info.path)
-        return {"size": st["length"]}
+        return WebHDFS(**self.fs_args)
 
     def checksum(self, path_info):
-        return HashInfo(
-            "checksum",
-            self.hdfs_client.checksum(path_info.path)["bytes"],
-            size=self.hdfs_client.status(path_info.path)["length"],
-        )
-
-    def copy(self, from_info, to_info, **_kwargs):
-        with self.hdfs_client.read(from_info.path) as reader:
-            with self.hdfs_client.write(to_info.path) as writer:
-                shutil.copyfileobj(reader, writer)
-
-    def move(self, from_info, to_info):
-        self.hdfs_client.makedirs(to_info.parent.path)
-        self.hdfs_client.rename(from_info.path, to_info.path)
-
-    def _upload_fobj(self, fobj, to_info):
-        with self.hdfs_client.write(to_info.path) as fdest:
-            shutil.copyfileobj(fobj, fdest)
-
-    def _upload(
-        self, from_file, to_info, name=None, no_progress_bar=False, **_kwargs
-    ):
-        total = os.path.getsize(from_file)
-        with Tqdm(
-            desc=name, total=total, disable=no_progress_bar, bytes=True
-        ) as pbar:
-            self.hdfs_client.upload(
-                to_info.path,
-                from_file,
-                overwrite=True,
-                progress=update_pbar(pbar, total),
-            )
-
-    def _download(
-        self, from_info, to_file, name=None, no_progress_bar=False, **_kwargs
-    ):
-        total = self.getsize(from_info)
-        with Tqdm(
-            desc=name, total=total, disable=no_progress_bar, bytes=True
-        ) as pbar:
-            self.hdfs_client.download(
-                from_info.path, to_file, progress=update_pbar(pbar, total)
-            )
+        path = self._with_bucket(path_info)
+        ukey = self.fs.ukey(path)
+        return ukey["bytes"]

dvc/hash_info.py

@@ -14,6 +14,7 @@ class HashInfo:
     value: Optional[str]
     size: Optional[int] = field(default=None, compare=False)
     nfiles: Optional[int] = field(default=None, compare=False)
+    obj_name: Optional[str] = field(default=None, compare=False)
 
     def __bool__(self):
         return bool(self.value)
@@ -21,6 +22,9 @@ class HashInfo:
     def __str__(self):
         return f"{self.name}: {self.value}"
 
+    def __hash__(self):
+        return hash((self.name, self.value))
+
     @classmethod
     def from_dict(cls, d):
         _d = d.copy() if d else {}

dvc/ignore.py

@@ -11,7 +11,6 @@ from dvc.fs.base import BaseFileSystem
 from dvc.path_info import PathInfo
 from dvc.pathspec_math import PatternInfo, merge_patterns
 from dvc.scheme import Schemes
-from dvc.system import System
 from dvc.types import AnyPath, List, Optional
 from dvc.utils import relpath
 from dvc.utils.collections import PathStringTrie
@@ -57,7 +56,7 @@ class DvcIgnorePatterns(DvcIgnore):
         dirname = os.path.normpath(os.path.dirname(path))
         with fs.open(path, encoding="utf-8") as fobj:
             path_spec_lines = [
-                PatternInfo(line, "{}:{}:{}".format(name, line_no + 1, line))
+                PatternInfo(line, f"{name}:{line_no + 1}:{line}")
                 for line_no, line in enumerate(
                     map(str.strip, fobj.readlines())
                 )
@@ -84,7 +83,7 @@ class DvcIgnorePatterns(DvcIgnore):
         else:
             return False
 
-        if not System.is_unix():
+        if os.name == "nt":
             path = normalize_file(path)
         return path
 
@@ -166,7 +165,7 @@ class DvcIgnoreFilter:
             ".hg/",
             ".git/",
             ".git",
-            "{}/".format(Repo.DVC_DIR),
+            f"{Repo.DVC_DIR}/",
         ]
 
         self.fs = fs

dvc/info.py

@@ -20,6 +20,11 @@ if PKG is None:
 else:
     package = f"({PKG})"
 
+try:
+    import importlib.metadata as importlib_metadata
+except ImportError:  # < 3.8
+    import importlib_metadata  # type: ignore[no-redef]
+
 
 def get_dvc_info():
     info = [
@@ -27,7 +32,7 @@ def get_dvc_info():
         "---------------------------------",
         f"Platform: Python {platform.python_version()} on "
         f"{platform.platform()}",
-        f"Supports: {_get_supported_remotes()}",
+        f"Supports:{_get_supported_remotes()}",
     ]
 
     try:
@@ -37,9 +42,7 @@ def get_dvc_info():
             # later decides to enable shared cache mode with
             # `dvc config cache.shared group`.
             if os.path.exists(repo.odb.local.cache_dir):
-                info.append(
-                    "Cache types: {}".format(_get_linktype_support_info(repo))
-                )
+                info.append(f"Cache types: {_get_linktype_support_info(repo)}")
                 fs_type = get_fs_type(repo.odb.local.cache_dir)
                 info.append(f"Cache directory: {fs_type}")
             else:
@@ -51,7 +54,7 @@ def get_dvc_info():
             root_directory = repo.root_dir
             fs_root = get_fs_type(os.path.abspath(root_directory))
             info.append(f"Workspace directory: {fs_root}")
-            info.append("Repo: {}".format(_get_dvc_repo_info(repo)))
+            info.append(f"Repo: {_get_dvc_repo_info(repo)}")
     except NotDvcRepoError:
         pass
     except SCMError:
@@ -113,27 +116,34 @@ def _get_linktype_support_info(repo):
 
 
 def _get_supported_remotes():
-
     supported_remotes = []
     for scheme, fs_cls in FS_MAP.items():
         if not fs_cls.get_missing_deps():
-            supported_remotes.append(scheme)
+            dependencies = []
+            for requirement in fs_cls.REQUIRES:
+                dependencies.append(
+                    f"{requirement} = "
+                    f"{importlib_metadata.version(requirement)}"
+                )
 
-    if len(supported_remotes) == len(FS_MAP):
-        return "All remotes"
+            remote_info = scheme
+            if dependencies:
+                remote_info += " (" + ", ".join(dependencies) + ")"
+            supported_remotes.append(remote_info)
 
-    if len(supported_remotes) == 1:
-        return supported_remotes
-
-    return ", ".join(supported_remotes)
+    assert len(supported_remotes) >= 1
+    return "\n\t" + ",\n\t".join(supported_remotes)
 
 
 def get_fs_type(path):
-
-    partition = {
-        pathlib.Path(part.mountpoint): (part.fstype + " on " + part.device)
-        for part in psutil.disk_partitions(all=True)
-    }
+    partition = {}
+    for part in psutil.disk_partitions(all=True):
+        if part.fstype != "":
+            try:
+                mountpoint = pathlib.Path(part.mountpoint).resolve()
+                partition[mountpoint] = part.fstype + " on " + part.device
+            except PermissionError:
+                pass
 
     # need to follow the symlink: https://github.com/iterative/dvc/issues/5065
     path = pathlib.Path(path).resolve()

dvc/istextfile.py

@@ -5,6 +5,7 @@
 
 
 TEXT_CHARS = bytes(range(32, 127)) + b"\n\r\t\f\b"
+DEFAULT_CHUNK_SIZE = 512
 
 
 def istextblock(block):
@@ -22,7 +23,7 @@ def istextblock(block):
     return float(len(nontext)) / len(block) <= 0.30
 
 
-def istextfile(fname, fs, blocksize=512):
+def istextfile(fname, fs, blocksize=DEFAULT_CHUNK_SIZE):
     """Uses heuristics to guess whether the given file is text or binary,
     by reading a single block of bytes from the file.
     If more than 30% of the chars in the block are non-text, or there

dvc/logger.py

@@ -62,7 +62,7 @@ def addLoggingLevel(levelName, levelNum, methodName=None):
 
 class LoggingException(Exception):
     def __init__(self, record):
-        msg = "failed to log {}".format(str(record))
+        msg = f"failed to log {str(record)}"
         super().__init__(msg)
 
 
@@ -142,9 +142,22 @@ class LoggerHandler(logging.StreamHandler):
         super().handleError(record)
         raise LoggingException(record)
 
+    def emit_pretty_exception(self, exc, verbose: bool = False):
+        return exc.__pretty_exc__(verbose=verbose)
+
     def emit(self, record):
         """Write to Tqdm's stream so as to not break progress-bars"""
         try:
+            if record.exc_info:
+                _, exc, *_ = record.exc_info
+                if hasattr(exc, "__pretty_exc__"):
+                    try:
+                        self.emit_pretty_exception(exc, verbose=_is_verbose())
+                        if not _is_verbose():
+                            return
+                    except Exception:  # noqa, pylint: disable=broad-except
+                        pass
+
             msg = self.format(record)
             Tqdm.write(
                 msg, file=self.stream, end=getattr(self, "terminator", "\n")

dvc/machine/__init__.py

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

dvc/machine/backend/base.py

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

dvc/machine/backend/terraform.py

@@ -0,0 +1,35 @@
+from contextlib import contextmanager
+from typing import TYPE_CHECKING, Iterator, Optional
+
+from tpi import TerraformProviderIterative, terraform
+
+from dvc.fs.ssh import SSHFileSystem
+
+from .base import BaseMachineBackend
+
+if TYPE_CHECKING:
+    from dvc.repo.experiments.executor.base import BaseExecutor
+    from dvc.types import StrPath
+
+
+class TerraformBackend(terraform.TerraformBackend, BaseMachineBackend):
+    def __init__(self, tmp_dir: "StrPath", **kwargs):
+        super().__init__(tmp_dir)
+
+    def get_executor(
+        self, name: Optional[str] = None, **config
+    ) -> "BaseExecutor":
+        raise NotImplementedError
+
+    @contextmanager
+    def get_sshfs(  # pylint: disable=unused-argument
+        self, name: Optional[str] = None, **config
+    ) -> Iterator["SSHFileSystem"]:
+        resource = self._default_resource(name)
+        with TerraformProviderIterative.pemfile(resource) as pem:
+            fs = SSHFileSystem(
+                host=resource["instance_ip"],
+                user="ubuntu",
+                keyfile=pem,
+            )
+            yield fs

dvc/objects/__init__.py

@@ -1,45 +1,34 @@
 import logging
-from concurrent.futures import ThreadPoolExecutor, as_completed
-
-from dvc.progress import Tqdm
+from typing import TYPE_CHECKING, Iterator, Union
 
 from .tree import Tree
 
+if TYPE_CHECKING:
+    from dvc.hash_info import HashInfo
+
+    from .db.base import ObjectDB
+    from .file import HashFile
+
 logger = logging.getLogger(__name__)
 
 
-def save(odb, obj, jobs=None, **kwargs):
-    if isinstance(obj, Tree):
-        with ThreadPoolExecutor(max_workers=jobs) as executor:
-            for future in Tqdm(
-                as_completed(
-                    executor.submit(
-                        odb.add,
-                        entry.path_info,
-                        entry.fs,
-                        entry.hash_info,
-                        **kwargs
-                    )
-                    for _, entry in obj
-                ),
-                desc="Saving files",
-                total=len(obj),
-                unit="file",
-            ):
-                future.result()
-
-    odb.add(obj.path_info, obj.fs, obj.hash_info, **kwargs)
-
-
-def check(odb, obj):
-    odb.check(obj.hash_info)
-
+def check(odb: "ObjectDB", obj: "HashFile", **kwargs):
     if isinstance(obj, Tree):
         for _, entry in obj:
-            odb.check(entry.hash_info)
+            odb.check(entry.hash_info, **kwargs)
+
+    odb.check(obj.hash_info, **kwargs)
 
 
-def load(odb, hash_info):
+def load(odb: "ObjectDB", hash_info: "HashInfo") -> "HashFile":
     if hash_info.isdir:
         return Tree.load(odb, hash_info)
     return odb.get(hash_info)
+
+
+def iterobjs(
+    obj: Union["Tree", "HashFile"]
+) -> Iterator[Union["Tree", "HashFile"]]:
+    if isinstance(obj, Tree):
+        yield from (entry_obj for _, entry_obj in obj)
+    yield obj

dvc/objects/checkout.py

@@ -1,4 +1,5 @@
 import logging
+from itertools import chain
 
 from shortuuid import uuid
 
@@ -10,48 +11,19 @@ from dvc.exceptions import (
     DvcException,
 )
 from dvc.ignore import DvcIgnoreFilter
-from dvc.objects import check, load
-from dvc.objects.errors import ObjectFormatError
-from dvc.objects.stage import stage
-from dvc.remote.slow_link_detection import (  # type: ignore[attr-defined]
+from dvc.objects.db.slow_link_detection import (  # type: ignore[attr-defined]
     slow_link_guard,
 )
+from dvc.objects.diff import ROOT
+from dvc.objects.diff import diff as odiff
+from dvc.objects.stage import stage
+from dvc.objects.tree import Tree
 from dvc.types import Optional
 
 logger = logging.getLogger(__name__)
 
 
-def _changed(path_info, fs, obj, cache):
-    logger.trace("checking if '%s'('%s') has changed.", path_info, obj)
-
-    try:
-        check(cache, obj)
-    except (FileNotFoundError, ObjectFormatError):
-        logger.debug(
-            "cache for '%s'('%s') has changed.", path_info, obj.hash_info
-        )
-        return True
-
-    try:
-        actual = stage(cache, path_info, fs, obj.hash_info.name).hash_info
-    except FileNotFoundError:
-        logger.debug("'%s' doesn't exist.", path_info)
-        return True
-
-    if obj.hash_info != actual:
-        logger.debug(
-            "hash value '%s' for '%s' has changed (actual '%s').",
-            obj.hash_info,
-            actual,
-            path_info,
-        )
-        return True
-
-    logger.trace("'%s' hasn't changed.", path_info)
-    return False
-
-
-def _remove(path_info, fs, cache, force=False):
+def _remove(path_info, fs, in_cache, force=False):
     if not fs.exists(path_info):
         return
 
@@ -59,11 +31,7 @@ def _remove(path_info, fs, cache, force=False):
         fs.remove(path_info)
         return
 
-    current = stage(cache, path_info, fs, fs.PARAM_CHECKSUM).hash_info
-    try:
-        obj = load(cache, current)
-        check(cache, obj)
-    except (FileNotFoundError, ObjectFormatError):
+    if not in_cache:
         msg = (
             f"file/directory '{path_info}' is going to be removed. "
             "Are you sure you want to proceed?"
@@ -92,7 +60,7 @@ def _verify_link(cache, path_info, link_type):
 
 def _do_link(cache, from_info, to_info, link_method):
     if cache.fs.exists(to_info):
-        raise DvcException(f"Link '{to_info}' already exists!")
+        cache.fs.remove(to_info)  # broken symlink
 
     link_method(from_info, to_info)
 
@@ -120,9 +88,11 @@ def _try_links(cache, from_info, to_info, link_types):
 
 
 def _link(cache, from_info, to_info):
-    assert cache.fs.isfile(from_info)
     cache.makedirs(to_info.parent)
-    _try_links(cache, from_info, to_info, cache.cache_types)
+    try:
+        _try_links(cache, from_info, to_info, cache.cache_types)
+    except FileNotFoundError as exc:
+        raise CheckoutError([str(to_info)]) from exc
 
 
 def _cache_is_copy(cache, path_info):
@@ -134,7 +104,7 @@ def _cache_is_copy(cache, path_info):
         return True
 
     workspace_file = path_info.with_name("." + uuid())
-    test_cache_file = cache.fs.path_info / ".cache_type_test_file"
+    test_cache_file = cache.path_info / ".cache_type_test_file"
     if not cache.fs.exists(test_cache_file):
         cache.makedirs(test_cache_file.parent)
         with cache.fs.open(test_cache_file, "wb") as fobj:
@@ -152,7 +122,7 @@ def _cache_is_copy(cache, path_info):
 def _checkout_file(
     path_info,
     fs,
-    obj,
+    change,
     cache,
     force,
     progress_callback=None,
@@ -161,24 +131,24 @@ def _checkout_file(
 ):
     """The file is changed we need to checkout a new copy"""
     modified = False
-    cache_info = cache.hash_to_path_info(obj.hash_info.value)
-    if fs.exists(path_info):
-        if not relink and _changed(path_info, fs, obj, cache):
-            modified = True
-            _remove(path_info, fs, cache, force=force)
-            _link(cache, cache_info, path_info)
-        else:
+    cache_info = cache.hash_to_path_info(change.new.obj.hash_info.value)
+    if change.old.obj:
+        if relink:
             if fs.iscopy(path_info) and _cache_is_copy(cache, path_info):
                 cache.unprotect(path_info)
             else:
-                _remove(path_info, fs, cache, force=force)
+                _remove(path_info, fs, change.old.in_cache, force=force)
                 _link(cache, cache_info, path_info)
+        else:
+            modified = True
+            _remove(path_info, fs, change.old.in_cache, force=force)
+            _link(cache, cache_info, path_info)
     else:
         _link(cache, cache_info, path_info)
         modified = True
 
     if state:
-        state.save(path_info, fs, obj.hash_info)
+        state.save(path_info, fs, change.new.obj.hash_info)
 
     if progress_callback:
         progress_callback(str(path_info))
@@ -186,102 +156,83 @@ def _checkout_file(
     return modified
 
 
-def _remove_redundant_files(
-    path_info, fs, obj, cache, force, dvcignore: Optional[DvcIgnoreFilter]
-):
-    if dvcignore:
-        existing_files = set(dvcignore.walk_files(fs, path_info))
-    else:
-        existing_files = set(fs.walk_files(path_info))
-
-    needed_files = {path_info.joinpath(*key) for key, _ in obj}
-    redundant_files = existing_files - needed_files
-    for path in redundant_files:
-        _remove(path, fs, cache, force)
-
-    return bool(redundant_files)
-
-
-def _checkout_dir(
+def _diff(
     path_info,
     fs,
     obj,
     cache,
-    force,
-    progress_callback=None,
     relink=False,
     dvcignore: Optional[DvcIgnoreFilter] = None,
-    state=None,
 ):
-    modified = False
-    # Create dir separately so that dir is created
-    # even if there are no files in it
-    if not fs.exists(path_info):
-        modified = True
-        fs.makedirs(path_info)
-
-    logger.debug("Linking directory '%s'.", path_info)
-
-    for entry_key, entry_obj in obj:
-        entry_modified = _checkout_file(
-            path_info.joinpath(*entry_key),
-            fs,
-            entry_obj,
+    old = None
+    try:
+        _, old = stage(
             cache,
-            force,
-            progress_callback,
-            relink,
-            state=None,
+            path_info,
+            fs,
+            obj.hash_info.name if obj else cache.fs.PARAM_CHECKSUM,
+            dry_run=True,
+            dvcignore=dvcignore,
         )
-        if entry_modified:
-            modified = True
+    except FileNotFoundError:
+        pass
 
-    modified = (
-        _remove_redundant_files(
-            path_info, fs, obj, cache, force, dvcignore=dvcignore
-        )
-        or modified
-    )
+    diff = odiff(old, obj, cache)
 
-    if state:
-        state.save(path_info, fs, obj.hash_info)
+    if relink:
+        diff.modified.extend(diff.unchanged)
 
-    # relink is not modified, assume it as nochange
-    return modified and not relink
+    return diff
 
 
 def _checkout(
+    diff,
     path_info,
     fs,
-    obj,
     cache,
     force=False,
     progress_callback=None,
     relink=False,
-    dvcignore: Optional[DvcIgnoreFilter] = None,
     state=None,
 ):
-    if not obj.hash_info.isdir:
-        ret = _checkout_file(
-            path_info, fs, obj, cache, force, progress_callback, relink, state
-        )
-    else:
-        ret = _checkout_dir(
-            path_info,
-            fs,
-            obj,
-            cache,
-            force,
-            progress_callback,
-            relink,
-            dvcignore=dvcignore,
-            state=state,
-        )
+    if not diff:
+        return
 
-    if state:
-        state.save_link(path_info, fs)
+    for change in diff.deleted:
+        entry_path = (
+            path_info.joinpath(*change.old.key)
+            if change.old.key != ROOT
+            else path_info
+        )
+        _remove(entry_path, fs, change.old.in_cache, force=force)
 
-    return ret
+    failed = []
+    for change in chain(diff.added, diff.modified):
+        entry_path = (
+            path_info.joinpath(*change.new.key)
+            if change.new.key != ROOT
+            else path_info
+        )
+        if isinstance(change.new.obj, Tree):
+            fs.makedirs(entry_path)
+            continue
+
+        try:
+            _checkout_file(
+                entry_path,
+                fs,
+                change,
+                cache,
+                force,
+                progress_callback,
+                relink,
+                state=state,
+            )
+        except CheckoutError as exc:
+            failed.extend(exc.target_infos)
+
+    if failed:
+        raise CheckoutError(failed)
 
 
 def checkout(
@@ -296,53 +247,54 @@ def checkout(
     dvcignore: Optional[DvcIgnoreFilter] = None,
     state=None,
 ):
+
     if path_info.scheme not in ["local", cache.fs.scheme]:
         raise NotImplementedError
 
-    failed = None
-    skip = False
+    diff = _diff(
+        path_info,
+        fs,
+        obj,
+        cache,
+        relink=relink,
+        dvcignore=dvcignore,
+    )
+
+    failed = []
     if not obj:
         if not quiet:
             logger.warning(
                 "No file hash info found for '%s'. It won't be created.",
                 path_info,
             )
-        _remove(path_info, fs, cache, force=force)
-        failed = path_info
-
-    elif not relink and not _changed(path_info, fs, obj, cache):
+        failed.append(str(path_info))
+    elif not diff:
         logger.trace("Data '%s' didn't change.", path_info)  # type: ignore
-        skip = True
-    else:
-        try:
-            check(cache, obj)
-        except (FileNotFoundError, ObjectFormatError):
-            if not quiet:
-                logger.warning(
-                    "Cache '%s' not found. File '%s' won't be created.",
-                    obj.hash_info,
-                    path_info,
-                )
-            _remove(path_info, fs, cache, force=force)
-            failed = path_info
 
-    if failed or skip:
+    try:
+        _checkout(
+            diff,
+            path_info,
+            fs,
+            cache,
+            force=force,
+            progress_callback=progress_callback,
+            relink=relink,
+            state=state,
+        )
+    except CheckoutError as exc:
+        failed.extend(exc.target_infos)
+
+    if diff and state:
+        state.save_link(path_info, fs)
+        if not failed:
+            state.save(path_info, fs, obj.hash_info)
+
+    if failed or not diff:
         if progress_callback and obj:
             progress_callback(str(path_info), len(obj))
         if failed:
-            raise CheckoutError([failed])
+            raise CheckoutError(failed)
         return
 
-    logger.debug("Checking out '%s' with cache '%s'.", path_info, obj)
-
-    return _checkout(
-        path_info,
-        fs,
-        obj,
-        cache,
-        force,
-        progress_callback,
-        relink,
-        dvcignore=dvcignore,
-        state=state,
-    )
+    return bool(diff) and not relink

dvc/objects/db/__init__.py

@@ -1,24 +1,27 @@
-from collections import defaultdict
+from typing import TYPE_CHECKING
 
 from dvc.scheme import Schemes
 
+if TYPE_CHECKING:
+    from .index import ObjectDBIndexBase
 
-def get_odb(fs, **config):
+
+def get_odb(fs, path_info, **config):
     from .base import ObjectDB
     from .gdrive import GDriveObjectDB
     from .local import LocalObjectDB
-    from .ssh import SSHObjectDB
+    from .oss import OSSObjectDB
 
     if fs.scheme == Schemes.LOCAL:
-        return LocalObjectDB(fs, **config)
-
-    if fs.scheme == Schemes.SSH:
-        return SSHObjectDB(fs, **config)
+        return LocalObjectDB(fs, path_info, **config)
 
     if fs.scheme == Schemes.GDRIVE:
-        return GDriveObjectDB(fs, **config)
+        return GDriveObjectDB(fs, path_info, **config)
 
-    return ObjectDB(fs, **config)
+    if fs.scheme == Schemes.OSS:
+        return OSSObjectDB(fs, path_info, **config)
+
+    return ObjectDB(fs, path_info, **config)
 
 
 def _get_odb(repo, settings):
@@ -27,8 +30,22 @@ def _get_odb(repo, settings):
     if not settings:
         return None
 
-    cls, config = get_cloud_fs(repo, **settings)
-    return get_odb(cls(**config), state=repo.state, **config)
+    cls, config, path_info = get_cloud_fs(repo, **settings)
+    config["tmp_dir"] = repo.tmp_dir
+    return get_odb(cls(**config), path_info, state=repo.state, **config)
+
+
+def get_index(odb) -> "ObjectDBIndexBase":
+    import hashlib
+
+    from .index import ObjectDBIndex, ObjectDBIndexNoop
+
+    cls = ObjectDBIndex if odb.tmp_dir else ObjectDBIndexNoop
+    return cls(
+        odb.tmp_dir,
+        hashlib.sha256(odb.path_info.url.encode("utf-8")).hexdigest(),
+        odb.fs.CHECKSUM_DIR_SUFFIX,
+    )
 
 
 class ODBManager:
@@ -80,99 +97,3 @@ class ODBManager:
     def by_scheme(self):
         self._init_odb(self.CLOUD_SCHEMES)
         yield from self._odb.items()
-
-
-class NamedCacheItem:
-    def __init__(self):
-        self.names = set()
-        self.children = defaultdict(NamedCacheItem)
-
-    def __eq__(self, other):
-        return self.names == other.names and self.children == other.children
-
-    def child_keys(self):
-        for key, child in self.children.items():
-            yield key
-            yield from child.child_keys()
-
-    def child_names(self):
-        for key, child in self.children.items():
-            yield key, child.names
-            yield from child.child_names()
-
-    def add(self, checksum, item):
-        self.children[checksum].update(item)
-
-    def update(self, item, suffix=""):
-        if suffix:
-            self.names.update(n + suffix for n in item.names)
-        else:
-            self.names.update(item.names)
-        for checksum, child_item in item.children.items():
-            self.children[checksum].update(child_item)
-
-
-class NamedCache:
-    # pylint: disable=protected-access
-    def __init__(self):
-        self._items = defaultdict(lambda: defaultdict(NamedCacheItem))
-        self.external = defaultdict(set)
-
-    @classmethod
-    def make(cls, scheme, checksum, name):
-        cache = cls()
-        cache.add(scheme, checksum, name)
-        return cache
-
-    def __getitem__(self, key):
-        return self._items[key]
-
-    def add(self, scheme, checksum, name):
-        """Add a mapped name for the specified checksum."""
-        self._items[scheme][checksum].names.add(name)
-
-    def add_child_cache(self, checksum, cache, suffix=""):
-        """Add/update child cache for the specified checksum."""
-        for scheme, src in cache._items.items():
-            dst = self._items[scheme][checksum].children
-            for child_checksum, item in src.items():
-                dst[child_checksum].update(item, suffix=suffix)
-
-        for repo_pair, files in cache.external.items():
-            self.external[repo_pair].update(files)
-
-    def add_external(self, url, rev, path):
-        self.external[url, rev].add(path)
-
-    def update(self, cache, suffix=""):
-        for scheme, src in cache._items.items():
-            dst = self._items[scheme]
-            for checksum, item in src.items():
-                dst[checksum].update(item, suffix=suffix)
-
-        for repo_pair, files in cache.external.items():
-            self.external[repo_pair].update(files)
-
-    def scheme_keys(self, scheme):
-        """Iterate over a flat list of all keys for the specified scheme,
-        including children.
-        """
-        for key, item in self._items[scheme].items():
-            yield key
-            yield from item.child_keys()
-
-    def scheme_names(self, scheme):
-        """Iterate over a flat list of checksum, names items for the specified
-        scheme, including children.
-        """
-        for key, item in self._items[scheme].items():
-            yield key, item.names
-            yield from item.child_names()
-
-    def dir_keys(self, scheme):
-        return (
-            key for key, item in self._items[scheme].items() if item.children
-        )
-
-    def child_keys(self, scheme, checksum):
-        return self._items[scheme][checksum].child_keys()

dvc/objects/db/base.py

@@ -1,14 +1,19 @@
 import itertools
 import logging
-import os
 from concurrent.futures import ThreadPoolExecutor
+from contextlib import suppress
 from copy import copy
-from typing import Optional
+from typing import TYPE_CHECKING, Optional
 
-from dvc.objects.errors import ObjectFormatError
+from dvc.objects.errors import ObjectDBPermissionError, ObjectFormatError
 from dvc.objects.file import HashFile
 from dvc.progress import Tqdm
 
+if TYPE_CHECKING:
+    from dvc.fs.base import BaseFileSystem
+    from dvc.hash_info import HashInfo
+    from dvc.types import AnyPath, DvcPath
+
 logger = logging.getLogger(__name__)
 
 
@@ -18,15 +23,42 @@ class ObjectDB:
     DEFAULT_CACHE_TYPES = ["copy"]
     CACHE_MODE: Optional[int] = None
 
-    def __init__(self, fs, **config):
+    def __init__(self, fs: "BaseFileSystem", path_info: "AnyPath", **config):
         from dvc.state import StateNoop
 
         self.fs = fs
+        self.path_info = path_info
         self.state = config.get("state", StateNoop())
         self.verify = config.get("verify", self.DEFAULT_VERIFY)
         self.cache_types = config.get("type") or copy(self.DEFAULT_CACHE_TYPES)
         self.cache_type_confirmed = False
         self.slow_link_warning = config.get("slow_link_warning", True)
+        self.tmp_dir = config.get("tmp_dir")
+        self.read_only = config.get("read_only", False)
+
+    @property
+    def config(self):
+        return {
+            "state": self.state,
+            "verify": self.verify,
+            "type": self.cache_types,
+            "slow_link_warning": self.slow_link_warning,
+            "tmp_dir": self.tmp_dir,
+            "read_only": self.read_only,
+        }
+
+    def __eq__(self, other):
+        return (
+            self.fs == other.fs
+            and self.path_info == other.path_info
+            and self.read_only == other.read_only
+        )
+
+    def __hash__(self):
+        return hash((self.fs.scheme, self.path_info))
+
+    def exists(self, hash_info: "HashInfo"):
+        return self.fs.exists(self.hash_to_path_info(hash_info.value))
 
     def move(self, from_info, to_info):
         self.fs.move(from_info, to_info)
@@ -34,7 +66,7 @@ class ObjectDB:
     def makedirs(self, path_info):
         self.fs.makedirs(path_info)
 
-    def get(self, hash_info):
+    def get(self, hash_info: "HashInfo"):
         """get raw object"""
         return HashFile(
             # Prefer string path over PathInfo when possible due to performance
@@ -43,51 +75,53 @@ class ObjectDB:
             hash_info,
         )
 
-    def add(self, path_info, fs, hash_info, move=True, **kwargs):
+    def _add_file(
+        self,
+        from_fs: "BaseFileSystem",
+        from_info: "AnyPath",
+        to_info: "DvcPath",
+        _hash_info: "HashInfo",
+        move: bool = False,
+    ):
+        from dvc import fs
+
+        self.makedirs(to_info.parent)
+        return fs.utils.transfer(
+            from_fs, from_info, self.fs, to_info, move=move
+        )
+
+    def add(
+        self,
+        path_info: "AnyPath",
+        fs: "BaseFileSystem",
+        hash_info: "HashInfo",
+        move: bool = True,
+        verify: Optional[bool] = None,
+    ):
+        if self.read_only:
+            raise ObjectDBPermissionError("Cannot add to read-only ODB")
+
+        if verify is None:
+            verify = self.verify
         try:
-            self.check(hash_info, check_hash=self.verify)
+            self.check(hash_info, check_hash=verify)
             return
         except (ObjectFormatError, FileNotFoundError):
             pass
 
         cache_info = self.hash_to_path_info(hash_info.value)
-        # using our makedirs to create dirs with proper permissions
-        self.makedirs(cache_info.parent)
-        use_move = isinstance(fs, type(self.fs)) and move
+        self._add_file(fs, path_info, cache_info, hash_info, move=move)
+
         try:
-            if use_move:
-                self.fs.move(path_info, cache_info)
-            else:
-                with fs.open(path_info, mode="rb") as fobj:
-                    self.fs.upload_fobj(fobj, cache_info)
-        except OSError as exc:
-            # If the target file already exists, we are going to simply
-            # ignore the exception (#4992).
-            #
-            # On Windows, it is not always guaranteed that you'll get
-            # FileExistsError (it might be PermissionError or a bare OSError)
-            # but all of those exceptions raised from the original
-            # FileExistsError so we have a separate check for that.
-            if isinstance(exc, FileExistsError) or (
-                os.name == "nt"
-                and exc.__context__
-                and isinstance(exc.__context__, FileExistsError)
-            ):
-                logger.debug("'%s' file already exists, skipping", path_info)
-                if use_move:
-                    fs.remove(path_info)
-            else:
-                raise
+            if verify:
+                self.check(hash_info, check_hash=True)
+            self.protect(cache_info)
+            self.state.save(cache_info, self.fs, hash_info)
+        except (ObjectFormatError, FileNotFoundError):
+            pass
 
-        self.protect(cache_info)
-        self.state.save(cache_info, self.fs, hash_info)
-
-        callback = kwargs.get("download_callback")
-        if callback:
-            callback(1)
-
-    def hash_to_path_info(self, hash_):
-        return self.fs.path_info / hash_[0:2] / hash_[2:]
+    def hash_to_path_info(self, hash_) -> "DvcPath":
+        return self.path_info / hash_[0:2] / hash_[2:]
 
     # Override to return path as a string instead of PathInfo for clouds
     # which support string paths (see local)
@@ -106,7 +140,11 @@ class ObjectDB:
     def set_exec(self, path_info):  # pylint: disable=unused-argument
         pass
 
-    def check(self, hash_info, check_hash=True):
+    def check(
+        self,
+        hash_info: "HashInfo",
+        check_hash: bool = True,
+    ):
         """Compare the given hash with the (corresponding) actual one if
         check_hash is specified, or just verify the existence of the cache
         files on the filesystem.
@@ -123,7 +161,7 @@ class ObjectDB:
 
         obj = self.get(hash_info)
         if self.is_protected(obj.path_info):
-            logger.trace(
+            logger.trace(  # type: ignore[attr-defined]
                 "Assuming '%s' is unchanged since it is read-only",
                 obj.path_info,
             )
@@ -133,22 +171,24 @@ class ObjectDB:
             obj.check(self, check_hash=check_hash)
         except ObjectFormatError:
             logger.warning("corrupted cache file '%s'.", obj.path_info)
-            self.fs.remove(obj.path_info)
+            with suppress(FileNotFoundError):
+                self.fs.remove(obj.path_info)
             raise
 
-        # making cache file read-only so we don't need to check it
-        # next time
-        self.protect(obj.path_info)
+        if check_hash:
+            # making cache file read-only so we don't need to check it
+            # next time
+            self.protect(obj.path_info)
 
     def _list_paths(self, prefix=None, progress_callback=None):
         if prefix:
             if len(prefix) > 2:
-                path_info = self.fs.path_info / prefix[:2] / prefix[2:]
+                path_info = self.path_info / prefix[:2] / prefix[2:]
             else:
-                path_info = self.fs.path_info / prefix[:2]
+                path_info = self.path_info / prefix[:2]
             prefix = True
         else:
-            path_info = self.fs.path_info
+            path_info = self.path_info
             prefix = False
         if progress_callback:
             for file_info in self.fs.walk_files(path_info, prefix=prefix):
@@ -315,15 +355,30 @@ class ObjectDB:
     def _remove_unpacked_dir(self, hash_):
         pass
 
-    def gc(self, used, jobs=None):
+    def gc(self, used, jobs=None, cache_odb=None, shallow=True):
+        from ..tree import Tree
+
+        if self.read_only:
+            raise ObjectDBPermissionError("Cannot gc read-only ODB")
+        if not cache_odb:
+            cache_odb = self
+        used_hashes = set()
+        for hash_info in used:
+            used_hashes.add(hash_info.value)
+            if hash_info.isdir and not shallow:
+                tree = Tree.load(cache_odb, hash_info)
+                used_hashes.update(
+                    entry_obj.hash_info.value for _, entry_obj in tree
+                )
+
         removed = False
         # hashes must be sorted to ensure we always remove .dir files first
         for hash_ in sorted(
-            self.all(jobs, str(self.fs.path_info)),
+            self.all(jobs, str(self.path_info)),
             key=self.fs.is_dir_hash,
             reverse=True,
         ):
-            if hash_ in used:
+            if hash_ in used_hashes:
                 continue
             path_info = self.hash_to_path_info(hash_)
             if self.fs.is_dir_hash(hash_):
@@ -339,9 +394,7 @@ class ObjectDB:
         """Return list of the specified hashes which exist in this fs.
         Hashes will be queried individually.
         """
-        logger.debug(
-            "Querying {} hashes via object_exists".format(len(hashes))
-        )
+        logger.debug(f"Querying {len(hashes)} hashes via object_exists")
         with Tqdm(
             desc="Querying "
             + ("cache in " + name if name else "remote cache"),
@@ -399,8 +452,15 @@ class ObjectDB:
         # hashes_exist() (see ssh, local)
         assert self.fs.TRAVERSE_PREFIX_LEN >= 2
 
+        # During the tests, for ensuring that the traverse behavior
+        # is working we turn on this option. It will ensure the
+        # list_hashes_traverse() is called.
+        always_traverse = getattr(self.fs, "_ALWAYS_TRAVERSE", False)
+
         hashes = set(hashes)
-        if len(hashes) == 1 or not self.fs.CAN_TRAVERSE:
+        if (
+            len(hashes) == 1 or not self.fs.CAN_TRAVERSE
+        ) and not always_traverse:
             remote_hashes = self.list_hashes_exists(hashes, jobs, name)
             return remote_hashes
 
@@ -418,7 +478,7 @@ class ObjectDB:
             )
         else:
             traverse_weight = traverse_pages
-        if len(hashes) < traverse_weight:
+        if len(hashes) < traverse_weight and not always_traverse:
             logger.debug(
                 "Large remote ('{}' hashes < '{}' traverse weight), "
                 "using object_exists for remaining hashes".format(
@@ -429,7 +489,7 @@ class ObjectDB:
                 hashes - remote_hashes, jobs, name
             )
 
-        logger.debug("Querying '{}' hashes via traverse".format(len(hashes)))
+        logger.debug(f"Querying '{len(hashes)}' hashes via traverse")
         remote_hashes = set(
             self.list_hashes_traverse(remote_size, remote_hashes, jobs, name)
         )

dvc/objects/db/index.py

@@ -0,0 +1,137 @@
+import logging
+import os
+from abc import ABC, abstractmethod
+from typing import TYPE_CHECKING, Iterable, Optional, Set
+
+from ..errors import ObjectDBError
+
+if TYPE_CHECKING:
+    from dvc.types import StrPath
+
+logger = logging.getLogger(__name__)
+
+
+class ObjectDBIndexBase(ABC):
+    @abstractmethod
+    def __init__(
+        self, tmp_dir: "StrPath", name: str, dir_suffix: Optional[str] = None
+    ):
+        pass
+
+    @abstractmethod
+    def __iter__(self):
+        pass
+
+    @abstractmethod
+    def __contains__(self, hash_):
+        pass
+
+    def hashes(self):
+        return iter(self)
+
+    @abstractmethod
+    def dir_hashes(self):
+        pass
+
+    @abstractmethod
+    def clear(self):
+        pass
+
+    @abstractmethod
+    def update(self, dir_hashes: Iterable[str], file_hashes: Iterable[str]):
+        pass
+
+    @abstractmethod
+    def intersection(self, hashes: Set[str]):
+        pass
+
+
+class ObjectDBIndexNoop(ObjectDBIndexBase):
+    """No-op class for ODBs which are not indexed."""
+
+    def __init__(
+        self, tmp_dir: "StrPath", name: str, dir_suffix: Optional[str] = None
+    ):  # pylint: disable=super-init-not-called
+        pass
+
+    def __iter__(self):
+        return iter([])
+
+    def __contains__(self, hash_):
+        return False
+
+    def dir_hashes(self):
+        return []
+
+    def clear(self):
+        pass
+
+    def update(self, dir_hashes: Iterable[str], file_hashes: Iterable[str]):
+        pass
+
+    def intersection(self, hashes: Set[str]):
+        return []
+
+
+class ObjectDBIndex(ObjectDBIndexBase):
+    """Class for indexing hashes in an ODB."""
+
+    INDEX_SUFFIX = ".idx"
+    INDEX_DIR = "index"
+
+    def __init__(
+        self, tmp_dir: "StrPath", name: str, dir_suffix: Optional[str] = None
+    ):  # pylint: disable=super-init-not-called
+        from diskcache import Index
+
+        from dvc.fs.local import LocalFileSystem
+        from dvc.utils.fs import makedirs
+
+        self.index_dir = os.path.join(tmp_dir, self.INDEX_DIR, name)
+        makedirs(self.index_dir, exist_ok=True)
+        self.fs = LocalFileSystem()
+        self.index = Index(self.index_dir)
+
+        if not dir_suffix:
+            dir_suffix = self.fs.CHECKSUM_DIR_SUFFIX
+        self.dir_suffix = dir_suffix
+
+    def __iter__(self):
+        return iter(self.index)
+
+    def __contains__(self, hash_):
+        return hash_ in self.index
+
+    def dir_hashes(self):
+        """Iterate over .dir hashes stored in the index."""
+        yield from (hash_ for hash_, is_dir in self.index.items() if is_dir)
+
+    def is_dir_hash(self, hash_: str):
+        return hash_.endswith(self.dir_suffix)
+
+    def clear(self):
+        """Clear this index (to force re-indexing later)."""
+        from diskcache import Timeout
+
+        try:
+            self.index.clear()
+        except Timeout as exc:
+            raise ObjectDBError("Failed to clear ODB index") from exc
+
+    def update(self, dir_hashes: Iterable[str], file_hashes: Iterable[str]):
+        """Update this index, adding the specified hashes."""
+        from diskcache import Timeout
+
+        try:
+            with self.index.transact():
+                for hash_ in dir_hashes:
+                    self.index[hash_] = True
+            with self.index.transact():
+                for hash_ in file_hashes:
+                    self.index[hash_] = False
+        except Timeout as exc:
+            raise ObjectDBError("Failed to update ODB index") from exc
+
+    def intersection(self, hashes: Set[str]):
+        """Iterate over values from `hashes` which exist in the index."""
+        yield from hashes.intersection(self.index.keys())

dvc/objects/db/local.py

@@ -22,9 +22,9 @@ class LocalObjectDB(ObjectDB):
     CACHE_MODE = 0o444
     UNPACKED_DIR_SUFFIX = ".unpacked"
 
-    def __init__(self, fs, **config):
-        super().__init__(fs, **config)
-        self.cache_dir = config.get("url")
+    def __init__(self, fs, path_info, **config):
+        super().__init__(fs, path_info, **config)
+        self.cache_dir = path_info.fspath
 
         shared = config.get("shared")
         if shared:
@@ -36,11 +36,11 @@ class LocalObjectDB(ObjectDB):
 
     @property
     def cache_dir(self):
-        return self.fs.path_info.fspath if self.fs.path_info else None
+        return self.path_info.fspath if self.path_info else None
 
     @cache_dir.setter
     def cache_dir(self, value):
-        self.fs.path_info = PathInfo(value) if value else None
+        self.path_info = PathInfo(value) if value else None
 
     @cached_property
     def cache_path(self):
@@ -81,13 +81,13 @@ class LocalObjectDB(ObjectDB):
         return ret
 
     def _list_paths(self, prefix=None, progress_callback=None):
-        assert self.fs.path_info is not None
+        assert self.path_info is not None
         if prefix:
-            path_info = self.fs.path_info / prefix[:2]
+            path_info = self.path_info / prefix[:2]
             if not self.fs.exists(path_info):
                 return
         else:
-            path_info = self.fs.path_info
+            path_info = self.path_info
         # NOTE: use utils.fs walk_files since fs.walk_files will not follow
         # symlinks
         if progress_callback:
@@ -112,7 +112,7 @@ class LocalObjectDB(ObjectDB):
             # would get only the part of file. So, at first, the file should be
             # copied with the temporary name, and then original file should be
             # replaced by new.
-            copyfile(path, tmp, name="Unprotecting '{}'".format(relpath(path)))
+            copyfile(path, tmp, name=f"Unprotecting '{relpath(path)}'")
             remove(path)
             os.rename(tmp, path)
 

dvc/objects/db/oss.py

@@ -0,0 +1,9 @@
+from .base import ObjectDB
+
+
+class OSSObjectDB(ObjectDB):
+    """
+    Temporary extra verification
+    """
+
+    DEFAULT_VERIFY = True

dvc/objects/db/reference.py

@@ -0,0 +1,84 @@
+import io
+import logging
+import os
+from typing import TYPE_CHECKING, Dict
+
+from dvc.scheme import Schemes
+
+from ..errors import ObjectFormatError
+from ..reference import ReferenceHashFile
+from .base import ObjectDB
+
+if TYPE_CHECKING:
+    from dvc.fs.base import BaseFileSystem
+    from dvc.hash_info import HashInfo
+    from dvc.types import AnyPath, DvcPath
+
+logger = logging.getLogger(__name__)
+
+
+class ReferenceObjectDB(ObjectDB):
+    """Reference ODB.
+
+    File objects are stored as ReferenceHashFiles which reference paths outside
+    of the staging ODB fs. Tree objects are stored natively.
+    """
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self._fs_cache: Dict[tuple, "BaseFileSystem"] = {}
+        self._obj_cache: Dict["HashInfo", "ReferenceHashFile"] = {}
+
+    def get(self, hash_info: "HashInfo"):
+        if hash_info.isdir:
+            return super().get(hash_info)
+        try:
+            return self._obj_cache[hash_info]
+        except KeyError:
+            pass
+        path_info = self.hash_to_path(hash_info.value)
+        try:
+            with self.fs.open(path_info, "rb") as fobj:
+                ref_file = ReferenceHashFile.from_bytes(
+                    fobj.read(), fs_cache=self._fs_cache
+                )
+        except OSError:
+            raise FileNotFoundError
+        try:
+            ref_file.check(self, check_hash=False)
+        except ObjectFormatError:
+            self.fs.remove(path_info)
+            raise
+        self._obj_cache[hash_info] = ref_file
+        return ref_file
+
+    def _add_file(
+        self,
+        from_fs: "BaseFileSystem",
+        from_info: "AnyPath",
+        to_info: "DvcPath",
+        hash_info: "HashInfo",
+        move: bool = False,
+    ):
+        self.makedirs(to_info.parent)
+        if hash_info.isdir:
+            return super()._add_file(
+                from_fs, from_info, to_info, hash_info, move
+            )
+        ref_file = ReferenceHashFile(from_info, from_fs, hash_info)
+        self._obj_cache[hash_info] = ref_file
+        ref_fobj = io.BytesIO(ref_file.to_bytes())
+        ref_fobj.seek(0)
+        try:
+            self.fs.upload(ref_fobj, to_info)
+        except OSError as exc:
+            if isinstance(exc, FileExistsError) or (
+                os.name == "nt"
+                and exc.__context__
+                and isinstance(exc.__context__, FileExistsError)
+            ):
+                logger.debug("'%s' file already exists, skipping", to_info)
+            else:
+                raise
+        if from_fs.scheme != Schemes.LOCAL:
+            self._fs_cache[ReferenceHashFile.config_tuple(from_fs)] = from_fs

dvc/objects/db/slow_link_detection.py

@@ -25,15 +25,15 @@ this.message = (
 
 def slow_link_guard(f):
     @wraps(f)
-    def wrapper(remote, *args, **kwargs):
+    def wrapper(odb, *args, **kwargs):
         if this.already_displayed:
-            return f(remote, *args, **kwargs)
+            return f(odb, *args, **kwargs)
 
-        if not remote.slow_link_warning or remote.cache_types:
-            return f(remote, *args, **kwargs)
+        if not odb.slow_link_warning or odb.cache_types:
+            return f(odb, *args, **kwargs)
 
         start = time.time()
-        result = f(remote, *args, **kwargs)
+        result = f(odb, *args, **kwargs)
         delta = time.time() - start
 
         if delta >= this.timeout_seconds:

dvc/objects/db/ssh.py

@@ -1,90 +0,0 @@
-import errno
-import itertools
-import logging
-import posixpath
-from concurrent.futures import ThreadPoolExecutor
-
-from dvc.progress import Tqdm
-from dvc.utils import to_chunks
-
-from .base import ObjectDB
-
-logger = logging.getLogger(__name__)
-
-
-class SSHObjectDB(ObjectDB):
-    def batch_exists(self, path_infos, callback):
-        def _exists(chunk_and_channel):
-            chunk, channel = chunk_and_channel
-            ret = []
-            for path in chunk:
-                try:
-                    channel.stat(path)
-                    ret.append(True)
-                except OSError as exc:
-                    if exc.errno != errno.ENOENT:
-                        raise
-                    ret.append(False)
-                callback(path)
-            return ret
-
-        with self.fs.ssh(path_infos[0]) as ssh:
-            channels = ssh.open_max_sftp_channels()
-            max_workers = len(channels)
-
-            with ThreadPoolExecutor(max_workers=max_workers) as executor:
-                paths = [path_info.path for path_info in path_infos]
-                chunks = to_chunks(paths, num_chunks=max_workers)
-                chunks_and_channels = zip(chunks, channels)
-                outcome = executor.map(_exists, chunks_and_channels)
-                results = list(itertools.chain.from_iterable(outcome))
-
-            return results
-
-    def hashes_exist(self, hashes, jobs=None, name=None):
-        """This is older implementation used in remote/base.py
-        We are reusing it in RemoteSSH, because SSH's batch_exists proved to be
-        faster than current approach (relying on exists(path_info)) applied in
-        remote/base.
-        """
-        if not self.fs.CAN_TRAVERSE:
-            return list(set(hashes) & set(self.all()))
-
-        # possibly prompt for credentials before "Querying" progress output
-        self.fs.ensure_credentials()
-
-        with Tqdm(
-            desc="Querying "
-            + ("cache in " + name if name else "remote cache"),
-            total=len(hashes),
-            unit="file",
-        ) as pbar:
-
-            def exists_with_progress(chunks):
-                return self.batch_exists(chunks, callback=pbar.update_msg)
-
-            with ThreadPoolExecutor(
-                max_workers=jobs or self.fs.jobs
-            ) as executor:
-                path_infos = [self.hash_to_path_info(x) for x in hashes]
-                chunks = to_chunks(path_infos, num_chunks=self.fs.jobs)
-                results = executor.map(exists_with_progress, chunks)
-                in_remote = itertools.chain.from_iterable(results)
-                ret = list(itertools.compress(hashes, in_remote))
-                return ret
-
-    def _list_paths(self, prefix=None, progress_callback=None):
-        if prefix:
-            root = posixpath.join(self.fs.path_info.path, prefix[:2])
-        else:
-            root = self.fs.path_info.path
-        with self.fs.ssh(self.fs.path_info) as ssh:
-            if prefix and not ssh.exists(root):
-                return
-            # If we simply return an iterator then with above closes instantly
-            if progress_callback:
-                for path in ssh.walk_files(root):
-                    progress_callback()
-                    yield path
-            else:
-                yield from ssh.walk_files(root)

dvc/objects/diff.py

@@ -0,0 +1,135 @@
+from dataclasses import dataclass, field
+from typing import TYPE_CHECKING, List, Optional, Tuple
+
+if TYPE_CHECKING:
+    from .file import HashFile
+
+ADD = "add"
+MODIFY = "modify"
+DELETE = "delete"
+UNCHANGED = "unchanged"
+
+
+@dataclass
+class TreeEntry:
+    in_cache: bool
+    key: Tuple[str]
+    obj: Optional["HashFile"] = field(default=None)
+
+    def __bool__(self):
+        return bool(self.obj)
+
+    def __eq__(self, other):
+        if not isinstance(other, TreeEntry):
+            return False
+
+        if self.key != other.key or bool(self.obj) != bool(other.obj):
+            return False
+
+        if not self.obj:
+            return False
+
+        return self.obj.hash_info == other.obj.hash_info
+
+
+@dataclass
+class Change:
+    old: TreeEntry
+    new: TreeEntry
+
+    @property
+    def typ(self):
+        if not self.old and not self.new:
+            return UNCHANGED
+
+        if self.old and not self.new:
+            return DELETE
+
+        if not self.old and self.new:
+            return ADD
+
+        if self.old != self.new:
+            return MODIFY
+
+        return UNCHANGED
+
+    def __bool__(self):
+        return self.typ != UNCHANGED
+
+
+@dataclass
+class DiffResult:
+    added: List[Change] = field(default_factory=list, compare=True)
+    modified: List[Change] = field(default_factory=list, compare=True)
+    deleted: List[Change] = field(default_factory=list, compare=True)
+    unchanged: List[Change] = field(default_factory=list, compare=True)
+
+    def __bool__(self):
+        return bool(self.added or self.modified or self.deleted)
+
+
+ROOT = ("",)
+
+
+def diff(
+    old: Optional["HashFile"], new: Optional["HashFile"], cache
+) -> DiffResult:
+    from .tree import Tree
+
+    if old is None and new is None:
+        return DiffResult()
+
+    def _get_keys(obj):
+        if not obj:
+            return []
+        return [ROOT] + (
+            [key for key, _ in obj] if isinstance(obj, Tree) else []
+        )
+
+    old_keys = set(_get_keys(old))
+    new_keys = set(_get_keys(new))
+
+    def _get_obj(obj, key):
+        if not obj or key == ROOT:
+            return obj
+
+        return obj.get(key)
+
+    def _in_cache(obj, cache):
+        from . import check
+        from .errors import ObjectFormatError
+
+        if not obj:
+            return False
+
+        try:
+            check(cache, obj)
+            return True
+        except (FileNotFoundError, ObjectFormatError):
+            return False
+
+    ret = DiffResult()
+    for key in old_keys | new_keys:
+        old_obj = _get_obj(old, key)
+        new_obj = _get_obj(new, key)
+
+        change = Change(
+            old=TreeEntry(_in_cache(old_obj, cache), key, old_obj),
+            new=TreeEntry(_in_cache(new_obj, cache), key, new_obj),
+        )
+
+        if change.typ == ADD:
+            ret.added.append(change)
+        elif change.typ == MODIFY:
+            ret.modified.append(change)
+        elif change.typ == DELETE:
+            ret.deleted.append(change)
+        else:
+            assert change.typ == UNCHANGED
+            if not change.new.in_cache and not isinstance(
+                change.new.obj, Tree
+            ):
+                ret.modified.append(change)
+            else:
+                ret.unchanged.append(change)
+    return ret

dvc/objects/errors.py

@@ -7,3 +7,11 @@ class ObjectError(DvcException):
 
 class ObjectFormatError(ObjectError):
     pass
+
+
+class ObjectDBError(DvcException):
+    pass
+
+
+class ObjectDBPermissionError(ObjectDBError):
+    pass

dvc/objects/file.py

@@ -1,23 +1,36 @@
 import errno
 import logging
 import os
+from typing import TYPE_CHECKING, Optional
 
 from .errors import ObjectFormatError
 
+if TYPE_CHECKING:
+    from dvc.fs.base import BaseFileSystem
+    from dvc.hash_info import HashInfo
+    from dvc.types import AnyPath
+
+    from .db.base import ObjectDB
+
 logger = logging.getLogger(__name__)
 
 
 class HashFile:
-    def __init__(self, path_info, fs, hash_info):
+    def __init__(
+        self,
+        path_info: Optional["AnyPath"],
+        fs: Optional["BaseFileSystem"],
+        hash_info: "HashInfo",
+        name: Optional[str] = None,
+    ):
         self.path_info = path_info
         self.fs = fs
         self.hash_info = hash_info
+        self.name = name
 
     @property
     def size(self):
-        if not (self.path_info and self.fs):
-            return None
-        return self.fs.getsize(self.path_info)
+        return self.hash_info.size
 
     def __len__(self):
         return 1
@@ -37,10 +50,18 @@ class HashFile:
             and self.hash_info == other.hash_info
         )
 
-    def check(self, odb, check_hash=True):
-        from .stage import get_file_hash
+    def __hash__(self):
+        return hash(
+            (
+                self.hash_info,
+                self.path_info,
+                self.fs.scheme if self.fs else None,
+            )
+        )
 
+    def check(self, odb: "ObjectDB", check_hash: bool = True):
         if not check_hash:
+            assert self.fs
             if not self.fs.exists(self.path_info):
                 raise FileNotFoundError(
                     errno.ENOENT, os.strerror(errno.ENOENT), self.path_info
@@ -48,6 +69,11 @@ class HashFile:
             else:
                 return None
 
+        self._check_hash(odb)
+
+    def _check_hash(self, odb):
+        from .stage import get_file_hash
+
         actual = get_file_hash(
             self.path_info, self.fs, self.hash_info.name, odb.state
         )

dvc/objects/reference.py

@@ -0,0 +1,122 @@
+import errno
+import logging
+import os
+import pickle
+from typing import TYPE_CHECKING, Optional
+
+from .errors import ObjectFormatError
+from .file import HashFile
+
+if TYPE_CHECKING:
+    from dvc.fs.base import BaseFileSystem
+    from dvc.hash_info import HashInfo
+    from dvc.types import AnyPath
+
+    from .db.base import ObjectDB
+
+logger = logging.getLogger(__name__)
+
+
+class ReferenceHashFile(HashFile):
+    PARAM_PATH = "path"
+    PARAM_HASH = "hash"
+    PARAM_CHECKSUM = "checksum"
+    PARAM_FS_CONFIG = "fs_config"
+
+    def __init__(
+        self,
+        path_info: "AnyPath",
+        fs: "BaseFileSystem",
+        hash_info: "HashInfo",
+        checksum: Optional[str] = None,
+        **kwargs,
+    ):
+        super().__init__(path_info, fs, hash_info, **kwargs)
+        self.checksum = checksum or fs.checksum(path_info)
+
+    def __str__(self):
+        return f"ref object {self.hash_info} -> {self.path_info}"
+
+    def check(self, odb: "ObjectDB", check_hash: bool = True):
+        assert self.fs
+        if not self.fs.exists(self.path_info):
+            raise FileNotFoundError(
+                errno.ENOENT, os.strerror(errno.ENOENT), self.path_info
+            )
+        if self.checksum != self._get_checksum():
+            raise ObjectFormatError(f"{self} is changed")
+        if check_hash:
+            self._check_hash(odb)
+
+    def _get_checksum(self) -> str:
+        assert self.fs
+        return self.fs.checksum(self.path_info)
+
+    def to_bytes(self):
+        from dvc.fs.repo import RepoFileSystem
+        from dvc.path_info import PathInfo
+
+        # NOTE: dumping reference FS's this way is insecure, as the
+        # fully parsed remote FS config will include credentials
+        #
+        # ReferenceHashFiles should currently only be serialized in
+        # memory and not to disk
+        path_info = self.path_info
+        if isinstance(self.fs, RepoFileSystem):
+            path_info = PathInfo(path_info).relative_to(self.fs.root_dir)
+
+        dict_ = {
+            self.PARAM_PATH: path_info,
+            self.PARAM_HASH: self.hash_info,
+            self.PARAM_CHECKSUM: self.checksum,
+            self.PARAM_FS_CONFIG: self.config_tuple(self.fs),
+        }
+        try:
+            return pickle.dumps(dict_)
+        except pickle.PickleError as exc:
+            raise ObjectFormatError(f"Could not pickle {self}") from exc
+
+    @classmethod
+    def from_bytes(cls, data: bytes, fs_cache: Optional[dict] = None):
+        from dvc.fs import get_fs_cls
+        from dvc.fs.repo import RepoFileSystem
+
+        try:
+            dict_ = pickle.loads(data)
+        except pickle.PickleError as exc:
+            raise ObjectFormatError("ReferenceHashFile is corrupted") from exc
+
+        try:
+            path_info = dict_[cls.PARAM_PATH]
+            hash_info = dict_[cls.PARAM_HASH]
+        except KeyError as exc:
+            raise ObjectFormatError("ReferenceHashFile is corrupted") from exc
+
+        scheme, config_pairs = dict_.get(cls.PARAM_FS_CONFIG)
+        fs = fs_cache.get((scheme, config_pairs)) if fs_cache else None
+        if not fs:
+            config = dict(config_pairs)
+            if RepoFileSystem.PARAM_REPO_URL in config:
+                fs = RepoFileSystem(**config)
+                path_info = fs.root_dir / path_info
+            else:
+                fs_cls = get_fs_cls(config, scheme=path_info.scheme)
+                fs = fs_cls(**config)
+        return ReferenceHashFile(
+            path_info,
+            fs,
+            hash_info,
+            checksum=dict_.get(cls.PARAM_CHECKSUM),
+        )
+
+    @staticmethod
+    def config_tuple(fs: "BaseFileSystem"):
+        return (
+            fs.scheme,
+            tuple(
+                (key, value)
+                for key, value in sorted(
+                    fs.config.items(), key=lambda item: item[0]
+                )
+            ),
+        )

dvc/objects/stage.py

@@ -1,47 +1,60 @@
-import errno
+import hashlib
+import logging
 import os
+import pathlib
 from concurrent.futures import ThreadPoolExecutor
 from functools import partial
+from typing import TYPE_CHECKING, Dict, Tuple
 
 from dvc.exceptions import DvcIgnoreInCollectedDirError
 from dvc.hash_info import HashInfo
 from dvc.ignore import DvcIgnore
-from dvc.objects.file import HashFile
 from dvc.progress import Tqdm
 from dvc.utils import file_md5
 
+from .db.reference import ReferenceObjectDB
+from .file import HashFile
 
-def _upload_file(path_info, fs, odb):
+if TYPE_CHECKING:
+    from dvc.fs.base import BaseFileSystem
+    from dvc.types import AnyPath, DvcPath
+
+    from .db.base import ObjectDB
+
+logger = logging.getLogger(__name__)
+
+
+_STAGING_MEMFS_PATH = "dvc-staging"
+
+
+def _upload_file(path_info, fs, odb, upload_odb):
     from dvc.utils import tmp_fname
     from dvc.utils.stream import HashedStreamReader
 
-    tmp_info = odb.fs.path_info / tmp_fname()
+    tmp_info = upload_odb.path_info / tmp_fname()
     with fs.open(path_info, mode="rb", chunk_size=fs.CHUNK_SIZE) as stream:
         stream = HashedStreamReader(stream)
-        odb.fs.upload_fobj(
-            stream, tmp_info, desc=path_info.name, total=fs.getsize(path_info)
-        )
+        size = fs.getsize(path_info)
+        upload_odb.fs.upload(stream, tmp_info, desc=path_info.name, total=size)
 
-    obj = HashFile(tmp_info, odb.fs, stream.hash_info)
-    return path_info, obj
+    odb.add(tmp_info, upload_odb.fs, stream.hash_info)
+    return path_info, odb.get(stream.hash_info)
 
 
 def _get_file_hash(path_info, fs, name):
     info = fs.info(path_info)
     if name in info:
         assert not info[name].endswith(".dir")
-        return HashInfo(name, info[name], size=info["size"])
+        hash_value = info[name]
+    elif hasattr(fs, name):
+        func = getattr(fs, name)
+        hash_value = func(path_info)
+    elif name == "md5":
+        hash_value = file_md5(path_info, fs)
+    else:
+        raise NotImplementedError
 
-    func = getattr(fs, name, None)
-    if func:
-        return func(path_info)
-
-    if name == "md5":
-        return HashInfo(
-            name, file_md5(path_info, fs), size=fs.getsize(path_info)
-        )
-
-    raise NotImplementedError
+    return HashInfo(name, hash_value, size=info["size"])
 
 
 def get_file_hash(path_info, fs, name, state=None):
@@ -52,11 +65,6 @@ def get_file_hash(path_info, fs, name, state=None):
         if hash_info:
             return hash_info
 
-    if not fs.exists(path_info):
-        raise FileNotFoundError(
-            errno.ENOENT, os.strerror(errno.ENOENT), path_info
-        )
-
     hash_info = _get_file_hash(path_info, fs, name)
 
     if state:
@@ -66,19 +74,31 @@ def get_file_hash(path_info, fs, name, state=None):
     return hash_info
 
 
-def _get_file_obj(path_info, fs, name, odb=None, state=None, upload=False):
-    if upload:
+def _get_file_obj(
+    path_info, fs, name, odb=None, upload_odb=None, dry_run=False
+):
+    state = odb.state if odb else None
+    hash_info = get_file_hash(path_info, fs, name, state=state)
+    if upload_odb and not dry_run:
         assert odb and name == "md5"
-        return _upload_file(path_info, fs, odb)
+        return _upload_file(path_info, fs, odb, upload_odb)
 
-    obj = HashFile(
-        path_info, fs, get_file_hash(path_info, fs, name, state=state)
-    )
+    if dry_run:
+        obj = HashFile(path_info, fs, hash_info)
+    else:
+        odb.add(path_info, fs, hash_info, move=False)
+        obj = odb.get(hash_info)
     return path_info, obj
 
 
 def _build_objects(
-    path_info, fs, name, odb, state, upload, dvcignore=None, **kwargs
+    path_info,
+    fs,
+    name,
+    dvcignore=None,
+    jobs=None,
+    no_progress_bar=False,
+    **kwargs,
 ):
     if dvcignore:
         walk_iterator = dvcignore.walk_files(fs, path_info)
@@ -87,45 +107,31 @@ def _build_objects(
     with Tqdm(
         unit="md5",
         desc="Computing file/dir hashes (only done once)",
-        disable=kwargs.pop("no_progress_bar", False),
+        disable=no_progress_bar,
     ) as pbar:
         worker = pbar.wrap_fn(
             partial(
                 _get_file_obj,
                 fs=fs,
                 name=name,
-                odb=odb,
-                state=state,
-                upload=upload,
+                **kwargs,
             )
         )
         with ThreadPoolExecutor(
-            max_workers=kwargs.pop("jobs", fs.hash_jobs)
+            max_workers=jobs if jobs is not None else fs.hash_jobs
         ) as executor:
             yield from executor.map(worker, walk_iterator)
 
 
-def _iter_objects(path_info, fs, name, odb, state, upload, **kwargs):
-    if not upload and name in fs.DETAIL_FIELDS:
-        for details in fs.find(path_info, detail=True):
-            file_info = path_info.replace(path=details["name"])
-            hash_info = HashInfo(name, details[name], size=details.get("size"))
-            yield file_info, HashFile(file_info, fs, hash_info)
-
-        return None
-
-    yield from _build_objects(
-        path_info, fs, name, odb, state, upload, **kwargs
-    )
+def _iter_objects(path_info, fs, name, **kwargs):
+    yield from _build_objects(path_info, fs, name, **kwargs)
 
 
-def _build_tree(path_info, fs, name, odb, state, upload, **kwargs):
+def _build_tree(path_info, fs, name, **kwargs):
     from .tree import Tree
 
     tree = Tree(None, None, None)
-    for file_info, obj in _iter_objects(
-        path_info, fs, name, odb, state, upload, **kwargs
-    ):
+    for file_info, obj in _iter_objects(path_info, fs, name, **kwargs):
         if DvcIgnore.DVCIGNORE_FILE == file_info.name:
             raise DvcIgnoreInCollectedDirError(file_info.parent)
 
@@ -138,89 +144,184 @@ def _build_tree(path_info, fs, name, odb, state, upload, **kwargs):
         # Yes, this is a BUG, as long as we permit "/" in
         # filenames on Windows and "\" on Unix
         tree.add(file_info.relative_to(path_info).parts, obj)
-
-    tree.digest()
-
     return tree
 
 
-def _get_tree_obj(path_info, fs, name, odb, state, upload, **kwargs):
+def _get_tree_obj(path_info, fs, fs_info, name, odb=None, **kwargs):
     from .tree import Tree
 
-    value = fs.info(path_info).get(name)
-    if value:
+    value = fs_info.get(name)
+    if odb and value:
         hash_info = HashInfo(name, value)
         try:
-            return Tree.load(odb, hash_info)
+            tree = Tree.load(odb, hash_info)
+            # NOTE: loaded entries are naive objects with hash_infos but no
+            # path_info. For staging trees, obj.path_info should be relative
+            # to the staging src `path_info` and src fs
+            for key, entry in tree:
+                entry.fs = fs
+                entry.path_info = path_info.joinpath(*key)
+            return tree
         except FileNotFoundError:
             pass
 
-    tree = _build_tree(path_info, fs, name, odb, state, upload, **kwargs)
-
-    odb.add(tree.path_info, tree.fs, tree.hash_info)
-    if name != "md5":
-        # NOTE: used only for external outputs. Initial reasoning was to be
-        # able to validate .dir files right in the workspace (e.g. check s3
-        # etag), but could be dropped for manual validation with regular md5,
-        # that would be universal for all clouds.
-        raw = odb.get(tree.hash_info)
-        hash_info = get_file_hash(raw.path_info, raw.fs, name, state)
-        tree.hash_info.name = hash_info.name
-        tree.hash_info.value = hash_info.value
-        if not tree.hash_info.value.endswith(".dir"):
-            tree.hash_info.value += ".dir"
-        odb.add(tree.path_info, tree.fs, tree.hash_info)
-
+    tree = _build_tree(path_info, fs, name, odb=odb, **kwargs)
+    state = odb.state if odb and odb.state else None
+    hash_info = None
+    if state:
+        hash_info = state.get(  # pylint: disable=assignment-from-none
+            path_info, fs
+        )
+    tree.digest(hash_info=hash_info)
+    odb.add(tree.path_info, tree.fs, tree.hash_info, move=True)
+    raw = odb.get(tree.hash_info)
+    # cleanup unneeded memfs tmpfile and return tree based on the
+    # ODB fs/path
+    if odb.fs != tree.fs:
+        tree.fs.remove(tree.path_info)
+    tree.fs = raw.fs
+    tree.path_info = raw.path_info
     return tree
 
 
-def stage(odb, path_info, fs, name, upload=False, **kwargs):
-    assert path_info and (
-        isinstance(path_info, str) or path_info.scheme == fs.scheme
-    )
+_url_cache: Dict[str, str] = {}
 
-    if not fs.exists(path_info):
-        raise FileNotFoundError(
-            errno.ENOENT, os.strerror(errno.ENOENT), path_info
-        )
+
+def _make_staging_url(path_info: "AnyPath"):
+    from dvc.path_info import CloudURLInfo
+    from dvc.scheme import Schemes
+
+    url = CloudURLInfo(f"{Schemes.MEMORY}://{_STAGING_MEMFS_PATH}")
+    if path_info:
+        if isinstance(path_info, (str, pathlib.PurePath)):
+            path = os.path.abspath(path_info)
+        else:
+            path = str(path_info)
+        if path not in _url_cache:
+            _url_cache[path] = hashlib.sha256(path.encode("utf-8")).hexdigest()
+        url /= _url_cache[path]
+    return url
+
+
+def _get_staging(odb: "ObjectDB") -> "ObjectDB":
+    """Return an ODB that can be used for staging objects.
+
+    Staging will be a reference ODB stored in the the global memfs.
+    """
+
+    from dvc.fs.memory import MemoryFileSystem
+
+    fs = MemoryFileSystem()
+    path_info = _make_staging_url(odb.path_info)
+    state = odb.state
+    return ReferenceObjectDB(fs, path_info, state=state)
+
+
+def _load_from_state(odb, staging, path_info, fs, name):
+    from . import check, load
+    from .errors import ObjectFormatError
+    from .tree import Tree
 
     state = odb.state
-    # pylint: disable=assignment-from-none
     hash_info = state.get(path_info, fs)
-
-    # If we have dir hash in state db, but dir cache file is lost,
-    # then we need to recollect the dir via .get_dir_hash() call below,
-    # see https://github.com/iterative/dvc/issues/2219 for context
-    if (
-        hash_info
-        and hash_info.isdir
-        and not odb.fs.exists(odb.hash_to_path_info(hash_info.value))
-    ):
-        hash_info = None
-
     if hash_info:
-        from . import load
-        from .tree import Tree
+        for odb_ in (odb, staging):
+            if odb_.exists(hash_info):
+                try:
+                    obj = load(odb_, hash_info)
+                    check(odb_, obj, check_hash=False)
+                    if isinstance(obj, Tree):
+                        obj.hash_info.nfiles = len(obj)
+                        for key, entry in obj:
+                            entry.fs = fs
+                            entry.path_info = path_info.joinpath(*key)
+                    else:
+                        obj.fs = fs
+                        obj.path_info = path_info
+                    assert obj.hash_info.name == name
+                    obj.hash_info.size = hash_info.size
+                    return odb_, obj
+                except (ObjectFormatError, FileNotFoundError):
+                    pass
+    raise FileNotFoundError
 
-        obj = load(odb, hash_info)
-        if isinstance(obj, Tree):
-            obj.hash_info.nfiles = len(obj)
-            for key, entry in obj:
-                entry.fs = fs
-                entry.path_info = path_info.joinpath(*key)
-        else:
-            obj.fs = fs
-            obj.path_info = path_info
-        assert obj.hash_info.name == name
-        obj.hash_info.size = hash_info.size
-        return obj
 
-    if fs.isdir(path_info):
-        obj = _get_tree_obj(path_info, fs, name, odb, state, upload, **kwargs)
+def _stage_external_tree_info(odb, tree, name):
+    # NOTE: used only for external outputs. Initial reasoning was to be
+    # able to validate .dir files right in the workspace (e.g. check s3
+    # etag), but could be dropped for manual validation with regular md5,
+    # that would be universal for all clouds.
+    assert odb and name != "md5"
+
+    odb.add(tree.path_info, tree.fs, tree.hash_info)
+    raw = odb.get(tree.hash_info)
+    hash_info = get_file_hash(raw.path_info, raw.fs, name, state=odb.state)
+    tree.path_info = raw.path_info
+    tree.fs = raw.fs
+    tree.hash_info.name = hash_info.name
+    tree.hash_info.value = hash_info.value
+    if not tree.hash_info.value.endswith(".dir"):
+        tree.hash_info.value += ".dir"
+    return tree
+
+
+def stage(
+    odb: "ObjectDB",
+    path_info: "DvcPath",
+    fs: "BaseFileSystem",
+    name: str,
+    upload: bool = False,
+    dry_run: bool = False,
+    **kwargs,
+) -> Tuple["ObjectDB", "HashFile"]:
+    """Stage (prepare) objects from the given path for addition to an ODB.
+
+    Returns at tuple of (staging_odb, object) where addition to the ODB can
+    be completed by transferring the object from staging to the dest ODB.
+
+    If dry_run is True, object hashes will be computed and returned, but file
+    objects themselves will not be added to the staging ODB (i.e. the resulting
+    file objects cannot transferred from staging to another ODB).
+
+    If upload is True, files will be uploaded to a temporary path on the dest
+    ODB filesystem, and staged objects will reference the uploaded path rather
+    than the original source path.
+    """
+    assert path_info and path_info.scheme == fs.scheme
+
+    details = fs.info(path_info)
+    staging = _get_staging(odb)
+    if odb:
+        try:
+            return _load_from_state(odb, staging, path_info, fs, name)
+        except FileNotFoundError:
+            pass
+
+    if details["type"] == "directory":
+        obj = _get_tree_obj(
+            path_info,
+            fs,
+            details,
+            name,
+            odb=staging,
+            upload_odb=odb if upload else None,
+            dry_run=dry_run,
+            **kwargs,
+        )
+        logger.debug("staged tree '%s'", obj)
+        if name != "md5":
+            obj = _stage_external_tree_info(odb, obj, name)
     else:
-        _, obj = _get_file_obj(path_info, fs, name, odb, state, upload)
+        _, obj = _get_file_obj(
+            path_info,
+            fs,
+            name,
+            odb=staging,
+            upload_odb=odb if upload else None,
+            dry_run=dry_run,
+        )
 
-    if obj.hash_info and fs.exists(path_info):
-        state.save(path_info, fs, obj.hash_info)
+    if odb and odb.state and obj.hash_info:
+        odb.state.save(path_info, fs, obj.hash_info)
 
-    return obj
+    return staging, obj

dvc/objects/status.py

@@ -0,0 +1,187 @@
+import logging
+from typing import TYPE_CHECKING, Dict, Iterable, NamedTuple, Optional, Set
+
+from dvc.hash_info import HashInfo
+from dvc.scheme import Schemes
+
+from .tree import Tree
+
+if TYPE_CHECKING:
+    from .db.base import ObjectDB
+    from .db.index import ObjectDBIndexBase
+    from .file import HashFile
+
+logger = logging.getLogger(__name__)
+
+
+class StatusResult(NamedTuple):
+    exists: Set["HashInfo"]
+    missing: Set["HashInfo"]
+
+
+class CompareStatusResult(NamedTuple):
+    ok: Set["HashInfo"]
+    missing: Set["HashInfo"]
+    new: Set["HashInfo"]
+    deleted: Set["HashInfo"]
+
+
+def _indexed_dir_hashes(odb, index, dir_objs, name, cache_odb):
+    # Validate our index by verifying all indexed .dir hashes
+    # still exist on the remote
+    dir_hashes = set(dir_objs.keys())
+    indexed_dirs = set(index.dir_hashes())
+    indexed_dir_exists = set()
+    if indexed_dirs:
+        indexed_dir_exists.update(odb.list_hashes_exists(indexed_dirs))
+        missing_dirs = indexed_dirs.difference(indexed_dir_exists)
+        if missing_dirs:
+            logger.debug(
+                "Remote cache missing indexed .dir hashes '%s', "
+                "clearing remote index",
+                ", ".join(missing_dirs),
+            )
+            index.clear()
+
+    # Check if non-indexed (new) dir hashes exist on remote
+    dir_exists = dir_hashes.intersection(indexed_dir_exists)
+    dir_exists.update(odb.list_hashes_exists(dir_hashes - dir_exists))
+
+    # If .dir hash exists in the ODB, assume directory contents
+    # also exists
+    for dir_hash in dir_exists:
+        tree = dir_objs.get(dir_hash)
+        if not tree:
+            try:
+                tree = Tree.load(cache_odb, HashInfo(name, dir_hash))
+            except FileNotFoundError:
+                continue
+        file_hashes = [entry.hash_info.value for _, entry in tree]
+        if dir_hash not in index:
+            logger.debug(
+                "Indexing new .dir '%s' with '%s' nested files",
+                dir_hash,
+                len(file_hashes),
+            )
+            index.update([dir_hash], file_hashes)
+        yield from file_hashes
+        yield tree.hash_info.value
+
+
+def status(
+    odb: "ObjectDB",
+    obj_ids: Iterable["HashInfo"],
+    name: Optional[str] = None,
+    index: Optional["ObjectDBIndexBase"] = None,
+    cache_odb: Optional["ObjectDB"] = None,
+    shallow: bool = True,
+    **kwargs,
+) -> "StatusResult":
+    """Return status of whether or not the specified objects exist odb.
+
+    If cache_odb is set, trees will be loaded from cache_odb instead of odb
+    when needed.
+
+    Status is returned as a tuple of:
+        exists: objs that exist in odb
+        missing: objs that do not exist in ODB
+    """
+    logger.debug("Preparing to collect status from '%s'", odb.path_info)
+    if not name:
+        name = odb.fs.PARAM_CHECKSUM
+
+    if cache_odb is None:
+        cache_odb = odb
+
+    hash_infos: Dict[str, "HashInfo"] = {}
+    dir_objs: Dict[str, Optional["HashFile"]] = {}
+    for hash_info in obj_ids:
+        assert hash_info.value
+        if hash_info.isdir:
+            if shallow:
+                tree = None
+            else:
+                tree = Tree.load(cache_odb, hash_info)
+                for _, entry in tree:
+                    assert entry.hash_info and entry.hash_info.value
+                    hash_infos[entry.hash_info.value] = entry.hash_info
+            if index:
+                dir_objs[hash_info.value] = tree
+        hash_infos[hash_info.value] = hash_info
+
+    if odb.fs.scheme == Schemes.MEMORY:
+        # assume memfs staged objects already exist
+        return StatusResult(set(hash_infos.values()), set())
+
+    hashes: Set[str] = set(hash_infos.keys())
+    exists: Set[str] = set()
+
+    logger.debug("Collecting status from '%s'", odb.path_info)
+    if index and hashes:
+        if dir_objs:
+            exists = hashes.intersection(
+                _indexed_dir_hashes(odb, index, dir_objs, name, cache_odb)
+            )
+            hashes.difference_update(exists)
+        if hashes:
+            exists.update(index.intersection(hashes))
+            hashes.difference_update(exists)
+
+    if hashes:
+        exists.update(
+            odb.hashes_exist(hashes, name=str(odb.path_info), **kwargs)
+        )
+    return StatusResult(
+        {hash_infos[hash_] for hash_ in exists},
+        {hash_infos[hash_] for hash_ in (hashes - exists)},
+    )
+
+
+def compare_status(
+    src: "ObjectDB",
+    dest: "ObjectDB",
+    obj_ids: Iterable["HashInfo"],
+    log_missing: bool = True,
+    check_deleted: bool = True,
+    src_index: Optional["ObjectDBIndexBase"] = None,
+    dest_index: Optional["ObjectDBIndexBase"] = None,
+    **kwargs,
+) -> "CompareStatusResult":
+    """Compare status for the specified objects between two ODBs.
+
+    Status is returned as a tuple of:
+        ok: hashes that exist in both src and dest
+        missing: hashes that do not exist in neither src nor dest
+        new: hashes that only exist in src
+        deleted: hashes that only exist in dest
+    """
+    if "cache_odb" not in kwargs:
+        kwargs["cache_odb"] = src
+    dest_exists, dest_missing = status(
+        dest, obj_ids, index=dest_index, **kwargs
+    )
+    # for transfer operations we can skip src status check when all objects
+    # already exist in dest
+    if dest_missing or check_deleted:
+        src_exists, src_missing = status(
+            src, obj_ids, index=src_index, **kwargs
+        )
+    else:
+        src_exists = dest_exists
+        src_missing = set()
+    result = CompareStatusResult(
+        src_exists & dest_exists,
+        src_missing & dest_missing,
+        src_exists - dest_exists,
+        dest_exists - src_exists,
+    )
+    if log_missing and result.missing:
+        missing_desc = "\n".join(
+            f"name: {hash_info.obj_name}, {hash_info}"
+            for hash_info in result.missing
+        )
+        logger.warning(
+            "Some of the cache files do not exist neither locally "
+            f"nor on remote. Missing cache files:\n{missing_desc}"
+        )
+    return result

dvc/objects/transfer.py

@@ -0,0 +1,172 @@
+import errno
+import logging
+from functools import partial, wraps
+from typing import TYPE_CHECKING, Any, Callable, Iterable, Optional
+
+from funcy import split
+
+from dvc.progress import Tqdm
+from dvc.utils.threadpool import ThreadPoolExecutor
+
+if TYPE_CHECKING:
+    from dvc.hash_info import HashInfo
+
+    from .db.base import ObjectDB
+    from .db.index import ObjectDBIndexBase
+    from .tree import Tree
+
+logger = logging.getLogger(__name__)
+
+
+def _log_exceptions(func):
+    @wraps(func)
+    def wrapper(path_info, *args, **kwargs):
+        try:
+            func(path_info, *args, **kwargs)
+            return 0
+        except Exception as exc:  # pylint: disable=broad-except
+            # NOTE: this means we ran out of file descriptors and there is no
+            # reason to try to proceed, as we will hit this error anyways.
+            # pylint: disable=no-member
+            if isinstance(exc, OSError) and exc.errno == errno.EMFILE:
+                raise
+
+            logger.exception("failed to transfer '%s'", path_info)
+            return 1
+
+    return wrapper
+
+
+def find_tree_by_obj_id(
+    odbs: Iterable[Optional["ObjectDB"]], obj_id: "HashInfo"
+) -> Optional["Tree"]:
+    from .errors import ObjectFormatError
+    from .tree import Tree
+
+    for odb in odbs:
+        if odb is not None:
+            try:
+                return Tree.load(odb, obj_id)
+            except (FileNotFoundError, ObjectFormatError):
+                pass
+    return None
+
+
+def _do_transfer(
+    src: "ObjectDB",
+    dest: "ObjectDB",
+    obj_ids: Iterable["HashInfo"],
+    missing_ids: Iterable["HashInfo"],
+    processor: Callable,
+    src_index: Optional["ObjectDBIndexBase"] = None,
+    dest_index: Optional["ObjectDBIndexBase"] = None,
+    cache_odb: Optional["ObjectDB"] = None,
+    **kwargs: Any,
+):
+    from dvc.exceptions import FileTransferError
+
+    dir_ids, file_ids = split(lambda hash_info: hash_info.isdir, obj_ids)
+    total_fails = 0
+    succeeded_dir_objs = []
+    all_file_ids = set(file_ids)
+
+    for dir_hash in dir_ids:
+        dir_obj = find_tree_by_obj_id([cache_odb, src], dir_hash)
+        assert dir_obj
+
+        entry_ids = {entry.hash_info for _, entry in dir_obj}
+        bound_file_ids = all_file_ids & entry_ids
+        all_file_ids -= entry_ids
+
+        dir_fails = sum(processor(bound_file_ids))
+        if dir_fails:
+            logger.debug(
+                "failed to upload full contents of '%s', "
+                "aborting .dir file upload",
+                dir_obj.name,
+            )
+            logger.error(
+                "failed to upload '%s' to '%s'",
+                src.get(dir_obj.hash_info).path_info,
+                dest.get(dir_obj.hash_info).path_info,
+            )
+            total_fails += dir_fails + 1
+        elif entry_ids.intersection(missing_ids):
+            # if for some reason a file contained in this dir is
+            # missing both locally and in the remote, we want to
+            # push whatever file content we have, but should not
+            # push .dir file
+            logger.debug(
+                "directory '%s' contains missing files,"
+                "skipping .dir file upload",
+                dir_obj.name,
+            )
+        else:
+            is_dir_failed = sum(processor([dir_obj.hash_info]))
+            total_fails += is_dir_failed
+            if not is_dir_failed:
+                succeeded_dir_objs.append(dir_obj)
+
+    # insert the rest
+    total_fails += sum(processor(all_file_ids))
+    if total_fails:
+        if src_index:
+            src_index.clear()
+        raise FileTransferError(total_fails)
+
+    # index successfully pushed dirs
+    if dest_index:
+        for dir_obj in succeeded_dir_objs:
+            file_hashes = {entry.hash_info.value for _, entry in dir_obj}
+            logger.debug(
+                "Indexing pushed dir '%s' with '%s' nested files",
+                dir_obj.hash_info,
+                len(file_hashes),
+            )
+            assert dir_obj.hash_info and dir_obj.hash_info.value
+            dest_index.update([dir_obj.hash_info.value], file_hashes)
+
+
+def transfer(
+    src: "ObjectDB",
+    dest: "ObjectDB",
+    obj_ids: Iterable["HashInfo"],
+    jobs: Optional[int] = None,
+    verify: bool = False,
+    move: bool = False,
+    **kwargs,
+) -> int:
+    """Transfer (copy) the specified objects from one ODB to another.
+
+    Returns the number of successfully transferred objects
+    """
+    from .status import compare_status
+
+    logger.debug(
+        "Preparing to transfer data from '%s' to '%s'",
+        src.path_info,
+        dest.path_info,
+    )
+    if src == dest:
+        return 0
+
+    status = compare_status(src, dest, obj_ids, check_deleted=False, **kwargs)
+    if not status.new:
+        return 0
+
+    def func(hash_info: "HashInfo") -> None:
+        obj = src.get(hash_info)
+        return dest.add(
+            obj.path_info, obj.fs, obj.hash_info, verify=verify, move=move
+        )
+
+    total = len(status.new)
+    jobs = jobs or dest.fs.jobs
+    with Tqdm(total=total, unit="file", desc="Transferring") as pbar:
+        with ThreadPoolExecutor(max_workers=jobs) as executor:
+            wrapped_func = pbar.wrap_fn(_log_exceptions(func))
+            processor = partial(executor.imap_unordered, wrapped_func)
+            _do_transfer(
+                src, dest, status.new, status.missing, processor, **kwargs
+            )
+    return total

dvc/objects/tree.py

@@ -1,6 +1,7 @@
 import json
 import logging
 import posixpath
+from typing import TYPE_CHECKING, Dict, Optional, Tuple
 
 from funcy import cached_property
 
@@ -8,6 +9,9 @@ from .errors import ObjectFormatError
 from .file import HashFile
 from .stage import get_file_hash
 
+if TYPE_CHECKING:
+    from dvc.hash_info import HashInfo
+
 logger = logging.getLogger(__name__)
 
 
@@ -16,7 +20,7 @@ class Tree(HashFile):
 
     def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)
-        self._dict = {}
+        self._dict: Dict[Tuple[str], "HashFile"] = {}
 
     @cached_property
     def trie(self):
@@ -24,31 +28,31 @@ class Tree(HashFile):
 
         return Trie(self._dict)
 
-    @property
-    def size(self):
-        try:
-            return sum(obj.size for _, obj in self)
-        except TypeError:
-            return None
-
     def add(self, key, obj):
         self.__dict__.pop("trie", None)
         self._dict[key] = obj
 
-    def digest(self):
+    def digest(self, hash_info: Optional["HashInfo"] = None):
         from dvc.fs.memory import MemoryFileSystem
-        from dvc.path_info import PathInfo
+        from dvc.path_info import CloudURLInfo
         from dvc.utils import tmp_fname
 
         memfs = MemoryFileSystem()
-        path_info = PathInfo(tmp_fname(""))
+        path_info = CloudURLInfo("memory://{}".format(tmp_fname("")))
         with memfs.open(path_info, "wb") as fobj:
             fobj.write(self.as_bytes())
         self.fs = memfs
         self.path_info = path_info
-        self.hash_info = get_file_hash(path_info, memfs, "md5")
-        self.hash_info.value += ".dir"
-        self.hash_info.size = self.size
+        if hash_info:
+            self.hash_info = hash_info
+        else:
+            self.hash_info = get_file_hash(path_info, memfs, "md5")
+            assert self.hash_info.value
+            self.hash_info.value += ".dir"
+        try:
+            self.hash_info.size = sum(obj.size for _, obj in self)
+        except TypeError:
+            self.hash_info.size = None
         self.hash_info.nfiles = len(self)
 
     def __len__(self):
@@ -96,7 +100,6 @@ class Tree(HashFile):
 
     @classmethod
     def load(cls, odb, hash_info):
-
         obj = odb.get(hash_info)
 
         try:
@@ -115,24 +118,46 @@ class Tree(HashFile):
         tree = cls.from_list(raw)
         tree.path_info = obj.path_info
         tree.fs = obj.fs
+        for _, entry_obj in tree:
+            entry_obj.fs = obj.fs
         tree.hash_info = hash_info
 
         return tree
 
-    def filter(self, odb, prefix):
+    def filter(self, prefix: Tuple[str]) -> Optional["Tree"]:
+        """Return a filtered copy of this tree that only contains entries
+        inside prefix.
+
+        The returned tree will contain the original tree's hash_info and
+        path_info.
+
+        Returns an empty tree if no object exists at the specified prefix.
+        """
+        tree = Tree(self.path_info, self.fs, self.hash_info)
+        try:
+            for key, obj in self.trie.items(prefix):
+                tree.add(key, obj)
+        except KeyError:
+            pass
+        return tree
+
+    def get(self, prefix: Tuple[str]) -> Optional[HashFile]:
+        """Return object at the specified prefix in this tree.
+
+        Returns None if no object exists at the specified prefix.
+        """
         obj = self._dict.get(prefix)
         if obj:
             return obj
 
-        depth = len(prefix)
         tree = Tree(None, None, None)
+        depth = len(prefix)
         try:
             for key, obj in self.trie.items(prefix):
                 tree.add(key[depth:], obj)
         except KeyError:
             return None
         tree.digest()
-        odb.add(tree.path_info, tree.fs, tree.hash_info)
         return tree
 
 

dvc/output.py

@@ -2,14 +2,13 @@ import logging
 import os
 from collections import defaultdict
 from copy import copy
-from typing import Type
+from typing import TYPE_CHECKING, Dict, Optional, Set, Type
 from urllib.parse import urlparse
 
 from funcy import collecting, project
 from voluptuous import And, Any, Coerce, Length, Lower, Required, SetTo
 
 from dvc import objects, prompt
-from dvc.checkout import checkout
 from dvc.exceptions import (
     CheckoutError,
     CollectCacheError,
@@ -17,6 +16,7 @@ from dvc.exceptions import (
     MergeError,
     RemoteCacheRequiredError,
 )
+from dvc.objects.checkout import checkout
 
 from .fs import get_cloud_fs
 from .fs.hdfs import HDFSFileSystem
@@ -24,14 +24,17 @@ from .fs.local import LocalFileSystem
 from .fs.s3 import S3FileSystem
 from .hash_info import HashInfo
 from .istextfile import istextfile
-from .objects import save as osave
-from .objects.db import NamedCache
+from .objects import Tree
 from .objects.errors import ObjectFormatError
 from .objects.stage import stage as ostage
+from .objects.transfer import transfer as otransfer
 from .scheme import Schemes
 from .utils import relpath
 from .utils.fs import path_isin
 
+if TYPE_CHECKING:
+    from .objects.db.base import ObjectDB
+
 logger = logging.getLogger(__name__)
 
 
@@ -41,18 +44,24 @@ CHECKSUM_SCHEMA = Any(
     And(Any(str, And(int, Coerce(str))), Length(min=3), Lower),
 )
 
+CASE_SENSITIVE_CHECKSUM_SCHEMA = Any(
+    None,
+    And(str, Length(max=0), SetTo(None)),
+    And(Any(str, And(int, Coerce(str))), Length(min=3)),
+)
+
 # NOTE: currently there are only 3 possible checksum names:
 #
 #    1) md5 (LOCAL, SSH);
-#    2) etag (S3);
+#    2) etag (S3, GS, OSS, AZURE, HTTP);
 #    3) checksum (HDFS);
 #
 # so when a few types of outputs share the same name, we only need
 # specify it once.
 CHECKSUMS_SCHEMA = {
     LocalFileSystem.PARAM_CHECKSUM: CHECKSUM_SCHEMA,
-    S3FileSystem.PARAM_CHECKSUM: CHECKSUM_SCHEMA,
     HDFSFileSystem.PARAM_CHECKSUM: CHECKSUM_SCHEMA,
+    S3FileSystem.PARAM_CHECKSUM: CASE_SENSITIVE_CHECKSUM_SCHEMA,
 }
 
 
@@ -72,6 +81,7 @@ def loadd_from(stage, d_list):
         desc = d.pop(Output.PARAM_DESC, False)
         isexec = d.pop(Output.PARAM_ISEXEC, False)
         live = d.pop(Output.PARAM_LIVE, False)
+        remote = d.pop(Output.PARAM_REMOTE, None)
         ret.append(
             _get(
                 stage,
@@ -85,6 +95,7 @@ def loadd_from(stage, d_list):
                 desc=desc,
                 isexec=isexec,
                 live=live,
+                remote=remote,
             )
         )
     return ret
@@ -100,6 +111,7 @@ def loads_from(
     checkpoint=False,
     isexec=False,
     live=False,
+    remote=None,
 ):
     return [
         _get(
@@ -113,6 +125,7 @@ def loads_from(
             checkpoint=checkpoint,
             isexec=isexec,
             live=live,
+            remote=remote,
         )
         for s in s_list
     ]
@@ -153,7 +166,6 @@ def load_from_pipeline(stage, data, typ="outs"):
     metric = typ == stage.PARAM_METRICS
     plot = typ == stage.PARAM_PLOTS
     live = typ == stage.PARAM_LIVE
-
     if live:
         # `live` is single object
         data = [data]
@@ -176,6 +188,7 @@ def load_from_pipeline(stage, data, typ="outs"):
                 Output.PARAM_CACHE,
                 Output.PARAM_PERSIST,
                 Output.PARAM_CHECKPOINT,
+                Output.PARAM_REMOTE,
             ],
         )
 
@@ -246,6 +259,7 @@ class Output:
     PARAM_LIVE = "live"
     PARAM_LIVE_SUMMARY = "summary"
     PARAM_LIVE_HTML = "html"
+    PARAM_REMOTE = "remote"
 
     METRIC_SCHEMA = Any(
         None,
@@ -261,8 +275,6 @@ class Output:
     IsStageFileError = OutputIsStageFileError  # type: Type[DvcException]
     IsIgnoredError = OutputIsIgnoredError  # type: Type[DvcException]
 
-    sep = "/"
-
     def __init__(
         self,
         stage,
@@ -276,12 +288,12 @@ class Output:
         live=False,
         desc=None,
         isexec=False,
+        remote=None,
     ):
         self.repo = stage.repo if stage else None
 
-        fs_cls, fs_config = get_cloud_fs(self.repo, url=path)
+        fs_cls, fs_config, path_info = get_cloud_fs(self.repo, url=path)
         self.fs = fs_cls(**fs_config)
-        path_info = self.fs.path_info
 
         if (
             self.fs.scheme == "local"
@@ -320,6 +332,8 @@ class Output:
         self.obj = None
         self.isexec = False if self.IS_DEPENDENCY else isexec
 
+        self.remote = remote
+
     def _parse_path(self, fs, path_info):
         if fs.scheme != "local":
             return path_info
@@ -395,21 +409,21 @@ class Output:
         return self.odb.hash_to_path_info(self.hash_info.value).url
 
     def get_hash(self):
-        if not self.use_cache:
-            return ostage(
-                self.repo.odb.local,
-                self.path_info,
-                self.fs,
-                self.fs.PARAM_CHECKSUM,
-                dvcignore=self.dvcignore,
-            ).hash_info
-        return ostage(
-            self.odb,
+        if self.use_cache:
+            odb = self.odb
+            name = self.odb.fs.PARAM_CHECKSUM
+        else:
+            odb = self.repo.odb.local
+            name = self.fs.PARAM_CHECKSUM
+        _, obj = ostage(
+            odb,
             self.path_info,
             self.fs,
-            self.odb.fs.PARAM_CHECKSUM,
+            name,
             dvcignore=self.dvcignore,
-        ).hash_info
+            dry_run=not self.use_cache,
+        )
+        return obj.hash_info
 
     @property
     def is_dir_checksum(self):
@@ -536,7 +550,7 @@ class Output:
             logger.debug("Output '%s' didn't change. Skipping saving.", self)
             return
 
-        self.obj = ostage(
+        _, self.obj = ostage(
             self.odb,
             self.path_info,
             self.fs,
@@ -557,14 +571,28 @@ class Output:
         assert self.hash_info
 
         if self.use_cache:
-            obj = ostage(
-                self.odb,
-                filter_info or self.path_info,
-                self.fs,
-                self.odb.fs.PARAM_CHECKSUM,
-                dvcignore=self.dvcignore,
+            granular = (
+                self.is_dir_checksum
+                and filter_info
+                and filter_info != self.path_info
             )
-            objects.save(self.odb, obj)
+            if granular:
+                obj = self._commit_granular_dir(filter_info)
+            else:
+                staging, obj = ostage(
+                    self.odb,
+                    filter_info or self.path_info,
+                    self.fs,
+                    self.odb.fs.PARAM_CHECKSUM,
+                    dvcignore=self.dvcignore,
+                )
+                otransfer(
+                    staging,
+                    self.odb,
+                    {obj.hash_info},
+                    shallow=False,
+                    move=True,
+                )
             checkout(
                 filter_info or self.path_info,
                 self.fs,
@@ -576,6 +604,26 @@ class Output:
             )
             self.set_exec()
 
+    def _commit_granular_dir(self, filter_info):
+        prefix = filter_info.relative_to(self.path_info).parts
+        staging, save_obj = ostage(
+            self.odb,
+            self.path_info,
+            self.fs,
+            self.odb.fs.PARAM_CHECKSUM,
+            dvcignore=self.dvcignore,
+        )
+        save_obj = save_obj.filter(prefix)
+        checkout_obj = save_obj.get(prefix)
+        otransfer(
+            staging,
+            self.odb,
+            {save_obj.hash_info} | {entry.hash_info for _, entry in save_obj},
+            shallow=True,
+            move=True,
+        )
+        return checkout_obj
+
     def dumpd(self):
         ret = copy(self.hash_info.to_dict())
 
@@ -648,7 +696,7 @@ class Output:
     def download(self, to, jobs=None):
         self.fs.download(self.path_info, to.path_info, jobs=jobs)
 
-    def get_obj(self, filter_info=None):
+    def get_obj(self, filter_info=None, **kwargs):
         if self.obj:
             obj = self.obj
         elif self.hash_info:
@@ -661,7 +709,7 @@ class Output:
 
         if filter_info and filter_info != self.path_info:
             prefix = filter_info.relative_to(self.path_info).parts
-            obj = obj.filter(self.odb, prefix)
+            obj = obj.get(prefix)
 
         return obj
 
@@ -741,9 +789,8 @@ class Output:
         if odb is None:
             odb = self.odb
 
-        cls, config = get_cloud_fs(self.repo, url=source)
+        cls, config, from_info = get_cloud_fs(self.repo, url=source)
         from_fs = cls(**config)
-        from_info = from_fs.path_info
 
         # When running import-url --to-remote / add --to-remote/-o ... we
         # assume that it is unlikely that the odb will contain majority of the
@@ -756,7 +803,7 @@ class Output:
 
         upload = not (update and from_fs.isdir(from_info))
         jobs = jobs or min((from_fs.jobs, odb.fs.jobs))
-        obj = ostage(
+        staging, obj = ostage(
             odb,
             from_info,
             from_fs,
@@ -765,7 +812,14 @@ class Output:
             jobs=jobs,
             no_progress_bar=no_progress_bar,
         )
-        osave(odb, obj, jobs=jobs, move=upload)
+        otransfer(
+            staging,
+            odb,
+            {obj.hash_info},
+            jobs=jobs,
+            move=upload,
+            shallow=False,
+        )
 
         self.hash_info = obj.hash_info
         return obj
@@ -788,18 +842,19 @@ class Output:
             self.odb.unprotect(self.path_info)
 
     def get_dir_cache(self, **kwargs):
-
         if not self.is_dir_checksum:
             raise DvcException("cannot get dir cache for file checksum")
 
+        obj = self.odb.get(self.hash_info)
         try:
-            objects.check(self.odb, self.odb.get(self.hash_info))
-        except (FileNotFoundError, ObjectFormatError):
-            self.repo.cloud.pull(
-                NamedCache.make("local", self.hash_info.value, str(self)),
-                show_checksums=False,
-                **kwargs,
-            )
+            objects.check(self.odb, obj)
+        except FileNotFoundError:
+            if self.remote:
+                kwargs["remote"] = self.remote
+            self.repo.cloud.pull([obj.hash_info], **kwargs)
+
+        if self.obj:
+            return self.obj
 
         try:
             self.obj = objects.load(self.odb, self.hash_info)
@@ -808,29 +863,10 @@ class Output:
 
         return self.obj
 
-    def collect_used_dir_cache(
+    def _collect_used_dir_cache(
         self, remote=None, force=False, jobs=None, filter_info=None
-    ):
-        """Get a list of `info`s related to the given directory.
-
-        - Pull the directory entry from the remote cache if it was changed.
-
-        Example:
-
-            Given the following commands:
-
-            $ echo "foo" > directory/foo
-            $ echo "bar" > directory/bar
-            $ dvc add directory
-
-            It will return a NamedCache like:
-
-            nc = NamedCache()
-            nc.add(self.scheme, 'c157a79031e1', 'directory/foo')
-            nc.add(self.scheme, 'd3b07384d113', 'directory/bar')
-        """
-
-        cache = NamedCache()
+    ) -> Optional["Tree"]:
+        """Fetch dir cache and return used object IDs for this out."""
 
         try:
             self.get_dir_cache(jobs=jobs, remote=remote)
@@ -839,7 +875,7 @@ class Output:
 
         try:
             objects.check(self.odb, self.odb.get(self.hash_info))
-        except (FileNotFoundError, ObjectFormatError):
+        except FileNotFoundError:
             msg = (
                 "Missing cache for directory '{}'. "
                 "Cache for files inside will be lost. "
@@ -850,38 +886,24 @@ class Output:
                     "unable to fully collect used cache"
                     " without cache for directory '{}'".format(self)
                 )
-            return cache
+            return None
 
-        path = str(self.path_info)
-        filter_path = str(filter_info) if filter_info else None
-        for entry_key, entry_obj in self.obj:
-            entry_path = os.path.join(path, *entry_key)
-            if (
-                not filter_path
-                or entry_path == filter_path
-                or entry_path.startswith(filter_path + os.sep)
-            ):
-                cache.add(self.scheme, entry_obj.hash_info.value, entry_path)
+        obj = self.get_obj()
+        if filter_info and filter_info != self.path_info:
+            prefix = filter_info.relative_to(self.path_info).parts
+            obj = obj.filter(prefix)
+        return obj
 
-        return cache
-
-    def get_used_cache(self, **kwargs):
-        """Get a dumpd of the given `out`, with an entry including the branch.
-
-        The `used_cache` of an output is no more than its `info`.
-
-        In case that the given output is a directory, it will also
-        include the `info` of its files.
-        """
+    def get_used_objs(
+        self, **kwargs
+    ) -> Dict[Optional["ObjectDB"], Set["HashInfo"]]:
+        """Return filtered set of used object IDs for this out."""
 
         if not self.use_cache:
-            return NamedCache()
+            return {}
 
         if self.stage.is_repo_import:
-            cache = NamedCache()
-            (dep,) = self.stage.deps
-            cache.external[dep.repo_pair].add(dep.def_path)
-            return cache
+            return self.get_used_external(**kwargs)
 
         if not self.hash_info:
             msg = (
@@ -900,18 +922,43 @@ class Output:
                     )
                 )
             logger.warning(msg)
-            return NamedCache()
+            return {}
 
-        ret = NamedCache.make(self.scheme, self.hash_info.value, str(self))
+        if self.is_dir_checksum:
+            obj = self._collect_used_dir_cache(**kwargs)
+        else:
+            obj = self.get_obj(filter_info=kwargs.get("filter_info"))
+            if not obj:
+                obj = self.odb.get(self.hash_info)
 
-        if not self.is_dir_checksum:
-            return ret
+        if not obj:
+            return {}
 
-        ret.add_child_cache(
-            self.hash_info.value, self.collect_used_dir_cache(**kwargs)
-        )
+        if self.remote:
+            remote = self.repo.cloud.get_remote_odb(name=self.remote)
+        else:
+            remote = None
 
-        return ret
+        return {remote: self._named_obj_ids(obj)}
+
+    def _named_obj_ids(self, obj):
+        name = str(self)
+        obj.hash_info.obj_name = name
+        oids = {obj.hash_info}
+        if isinstance(obj, Tree):
+            for key, entry_obj in obj:
+                entry_obj.hash_info.obj_name = self.fs.sep.join([name, *key])
+                oids.add(entry_obj.hash_info)
+        return oids
+
+    def get_used_external(
+        self, **kwargs
+    ) -> Dict[Optional["ObjectDB"], Set["HashInfo"]]:
+        if not self.use_cache or not self.stage.is_repo_import:
+            return {}
+
+        (dep,) = self.stage.deps
+        return dep.get_used_objs(**kwargs)
 
     def _validate_output_path(self, path, stage=None):
         from dvc.dvcfile import is_valid_filename
@@ -974,6 +1021,18 @@ class Output:
     def fspath(self):
         return self.path_info.fspath
 
+    @property
+    def is_decorated(self) -> bool:
+        return self.is_metric or self.is_plot
+
+    @property
+    def is_metric(self) -> bool:
+        return bool(self.metric) or bool(self.live)
+
+    @property
+    def is_plot(self) -> bool:
+        return bool(self.plot)
+
 
 ARTIFACT_SCHEMA = {
     **CHECKSUMS_SCHEMA,
@@ -991,4 +1050,5 @@ SCHEMA = {
     Output.PARAM_CACHE: bool,
     Output.PARAM_METRIC: Output.METRIC_SCHEMA,
     Output.PARAM_DESC: str,
+    Output.PARAM_REMOTE: str,
 }

dvc/path_info.py

@@ -52,7 +52,7 @@ class PathInfo(pathlib.PurePath, _BasePath):
         return relpath(path)
 
     def __repr__(self):
-        return "{}: '{}'".format(type(self).__name__, self)
+        return f"{type(self).__name__}: '{self}'"
 
     # This permits passing it to file utils directly in Python 3.6+
     def __fspath__(self):
@@ -64,6 +64,8 @@ class PathInfo(pathlib.PurePath, _BasePath):
 
     url = fspath
 
+    path = fspath
+
     def relpath(self, other):
         return self.__class__(relpath(self, other))
 
@@ -174,7 +176,7 @@ class URLInfo(_BasePath):
         return self.url
 
     def __repr__(self):
-        return "{}: '{}'".format(type(self).__name__, self)
+        return f"{type(self).__name__}: '{self}'"
 
     def __eq__(self, other):
         if isinstance(other, (str, bytes)):

dvc/progress.py

@@ -1,11 +1,12 @@
 """Manages progress bars for DVC repo."""
-
 import logging
 import sys
 from threading import RLock
 
+import fsspec
 from tqdm import tqdm
 
+from dvc.env import DVC_IGNORE_ISATTY
 from dvc.utils import env2bool
 
 logger = logging.getLogger(__name__)
@@ -50,7 +51,7 @@ class Tqdm(tqdm):
         file=None,
         total=None,
         postfix=None,
-        **kwargs
+        **kwargs,
     ):
         """
         bytes   : shortcut for
@@ -77,7 +78,7 @@ class Tqdm(tqdm):
         # auto-disable based on TTY
         if (
             not disable
-            and not env2bool("DVC_IGNORE_ISATTY")
+            and not env2bool(DVC_IGNORE_ISATTY)
             and hasattr(file, "isatty")
         ):
             disable = not file.isatty()
@@ -89,7 +90,7 @@ class Tqdm(tqdm):
             bar_format="!",
             lock_args=(False,),
             total=total,
-            **kwargs
+            **kwargs,
         )
         self.postfix = postfix or {"info": ""}
         if bar_format is None:
@@ -105,13 +106,16 @@ class Tqdm(tqdm):
             self.bar_format = bar_format
         self.refresh()
 
-    def update_msg(self, msg, n=1):
+    def update_msg(self, msg: str, n: int = 1) -> None:
         """
         Sets `msg` as a postfix and calls `update(n)`.
         """
-        self.postfix["info"] = " %s |" % msg
+        self.set_msg(msg)
         self.update(n)
 
+    def set_msg(self, msg: str) -> None:
+        self.postfix["info"] = f" {msg} |"
+
     def update_to(self, current, total=None):
         if total:
             self.total = total
@@ -132,6 +136,9 @@ class Tqdm(tqdm):
 
         return wrapped
 
+    def as_callback(self):
+        return FsspecCallback(self)
+
     def close(self):
         self.postfix["info"] = ""
         # remove ETA (either unknown or zero); remove completed bar
@@ -157,3 +164,49 @@ class Tqdm(tqdm):
             d["ncols_desc"] = d["ncols_info"] = 1
             d["prefix"] = ""
         return d
+
+
+class FsspecCallback(fsspec.Callback):
+    def __init__(self, progress_bar):
+        self.progress_bar = progress_bar
+        super().__init__()
+
+    def set_size(self, size):
+        if size is not None:
+            self.progress_bar.total = size
+            self.progress_bar.refresh()
+            super().set_size(size)
+
+    def relative_update(self, inc=1):
+        self.progress_bar.update(inc)
+        super().relative_update(inc)
+
+    def absolute_update(self, value):
+        self.progress_bar.update_to(value)
+        super().absolute_update(value)
+
+    @staticmethod
+    def wrap_fn(cb, fn):
+        def wrapped(*args, **kwargs):
+            res = fn(*args, **kwargs)
+            cb.relative_update()
+            return res
+
+        return wrapped
+
+
+def tdqm_or_callback_wrapped(
+    fobj, method, total, callback=None, **pbar_kwargs
+):
+    if callback:
+        from funcy import nullcontext
+        from tqdm.utils import CallbackIOWrapper
+
+        callback.set_size(total)
+        wrapper = CallbackIOWrapper(callback.relative_update, fobj, method)
+        return nullcontext(wrapper)
+
+    return Tqdm.wrapattr(fobj, method, total=total, bytes=True, **pbar_kwargs)
+
+
+DEFAULT_CALLBACK = fsspec.callbacks.NoOpCallback()

dvc/remote/__init__.py

@@ -1,11 +0,0 @@
-from ..fs import get_cloud_fs
-from .base import Remote
-from .local import LocalRemote
-
-
-def get_remote(repo, **kwargs):
-    cls, config = get_cloud_fs(repo, **kwargs)
-    fs = cls(**config)
-    if fs.scheme == "local":
-        return LocalRemote(fs, repo.tmp_dir, **config)
-    return Remote(fs, repo.tmp_dir, **config)

dvc/remote/base.py

@@ -1,522 +0,0 @@
-import errno
-import hashlib
-import itertools
-import logging
-from concurrent import futures
-from concurrent.futures import ThreadPoolExecutor
-from functools import partial, wraps
-
-from dvc.exceptions import DownloadError, UploadError
-from dvc.hash_info import HashInfo
-
-from ..progress import Tqdm
-from .index import RemoteIndex, RemoteIndexNoop
-
-logger = logging.getLogger(__name__)
-
-STATUS_OK = 1
-STATUS_MISSING = 2
-STATUS_NEW = 3
-STATUS_DELETED = 4
-
-STATUS_MAP = {
-    # (local_exists, remote_exists)
-    (True, True): STATUS_OK,
-    (False, False): STATUS_MISSING,
-    (True, False): STATUS_NEW,
-    (False, True): STATUS_DELETED,
-}
-
-
-def _log_exceptions(func, operation):
-    @wraps(func)
-    def wrapper(from_info, to_info, *args, **kwargs):
-        try:
-            func(from_info, to_info, *args, **kwargs)
-            return 0
-        except Exception as exc:  # pylint: disable=broad-except
-            # NOTE: this means we ran out of file descriptors and there is no
-            # reason to try to proceed, as we will hit this error anyways.
-            # pylint: disable=no-member
-            if isinstance(exc, OSError) and exc.errno == errno.EMFILE:
-                raise
-
-            logger.exception(
-                "failed to %s '%s' to '%s'", operation, from_info, to_info
-            )
-            return 1
-
-    return wrapper
-
-
-def index_locked(f):
-    @wraps(f)
-    def wrapper(obj, *args, **kwargs):
-        with obj.index:
-            return f(obj, *args, **kwargs)
-
-    return wrapper
-
-
-class Remote:
-    """Cloud remote class.
-
-    Provides methods for indexing and garbage collecting fss which contain
-    DVC remotes.
-    """
-
-    INDEX_CLS = RemoteIndex
-
-    def __init__(self, fs, tmp_dir, **config):
-        from dvc.objects.db import get_odb
-
-        self.fs = fs
-        self.odb = get_odb(self.fs, **config)
-
-        url = config.get("url")
-        if url:
-            index_name = hashlib.sha256(url.encode("utf-8")).hexdigest()
-            self.index = self.INDEX_CLS(
-                tmp_dir, index_name, dir_suffix=self.fs.CHECKSUM_DIR_SUFFIX
-            )
-        else:
-            self.index = RemoteIndexNoop()
-
-    def __repr__(self):
-        return "{class_name}: '{path_info}'".format(
-            class_name=type(self).__name__,
-            path_info=self.fs.path_info or "No path",
-        )
-
-    @index_locked
-    def gc(self, *args, **kwargs):
-        removed = self.odb.gc(*args, **kwargs)
-
-        if removed:
-            self.index.clear()
-
-        return removed
-
-    @index_locked
-    def status(
-        self,
-        cache,
-        named_cache,
-        jobs=None,
-        show_checksums=False,
-        download=False,
-        log_missing=True,
-    ):
-        # Return flattened dict containing all status info
-        dir_status, file_status, _ = self._status(
-            cache,
-            named_cache,
-            jobs=jobs,
-            show_checksums=show_checksums,
-            download=download,
-            log_missing=log_missing,
-        )
-        return dict(dir_status, **file_status)
-
-    def hashes_exist(self, hashes, **kwargs):
-        hashes = set(hashes)
-        indexed_hashes = set(self.index.intersection(hashes))
-        hashes -= indexed_hashes
-        indexed_hashes = list(indexed_hashes)
-        logger.debug("Matched '{}' indexed hashes".format(len(indexed_hashes)))
-        if not hashes:
-            return indexed_hashes
-
-        return indexed_hashes + self.odb.hashes_exist(list(hashes), **kwargs)
-
-    def _status(
-        self,
-        cache,
-        named_cache,
-        jobs=None,
-        show_checksums=False,
-        download=False,
-        log_missing=True,
-    ):
-        """Return a tuple of (dir_status_info, file_status_info, dir_contents).
-
-        dir_status_info contains status for .dir files, file_status_info
-        contains status for all other files, and dir_contents is a dict of
-        {dir_hash: set(file_hash, ...)} which can be used to map
-        a .dir file to its file contents.
-        """
-        logger.debug(f"Preparing to collect status from {self.fs.path_info}")
-        md5s = set(named_cache.scheme_keys(cache.fs.scheme))
-
-        logger.debug("Collecting information from local cache...")
-        local_exists = frozenset(
-            cache.hashes_exist(md5s, jobs=jobs, name=cache.cache_dir)
-        )
-
-        # This is a performance optimization. We can safely assume that,
-        # if the resources that we want to fetch are already cached,
-        # there's no need to check the remote storage for the existence of
-        # those files.
-        if download and local_exists == md5s:
-            remote_exists = local_exists
-        else:
-            logger.debug("Collecting information from remote cache...")
-            remote_exists = set()
-            dir_md5s = set(named_cache.dir_keys(cache.fs.scheme))
-            if dir_md5s:
-                remote_exists.update(
-                    self._indexed_dir_hashes(cache, named_cache, dir_md5s)
-                )
-                md5s.difference_update(remote_exists)
-            if md5s:
-                remote_exists.update(
-                    self.hashes_exist(
-                        md5s, jobs=jobs, name=str(self.fs.path_info)
-                    )
-                )
-        return self._make_status(
-            cache,
-            named_cache,
-            show_checksums,
-            local_exists,
-            remote_exists,
-            log_missing,
-        )
-
-    def _make_status(
-        self,
-        cache,
-        named_cache,
-        show_checksums,
-        local_exists,
-        remote_exists,
-        log_missing,
-    ):
-        def make_names(hash_, names):
-            return {"name": hash_ if show_checksums else " ".join(names)}
-
-        dir_status = {}
-        file_status = {}
-        dir_contents = {}
-        for hash_, item in named_cache[cache.fs.scheme].items():
-            if item.children:
-                dir_status[hash_] = make_names(hash_, item.names)
-                dir_contents[hash_] = set()
-                for child_hash, child in item.children.items():
-                    file_status[child_hash] = make_names(
-                        child_hash, child.names
-                    )
-                    dir_contents[hash_].add(child_hash)
-            else:
-                file_status[hash_] = make_names(hash_, item.names)
-
-        self._fill_statuses(dir_status, local_exists, remote_exists)
-        self._fill_statuses(file_status, local_exists, remote_exists)
-
-        if log_missing:
-            self._log_missing_caches(dict(dir_status, **file_status))
-
-        return dir_status, file_status, dir_contents
-
-    def _indexed_dir_hashes(self, cache, named_cache, dir_md5s):
-        # Validate our index by verifying all indexed .dir hashes
-        # still exist on the remote
-        indexed_dirs = set(self.index.dir_hashes())
-        indexed_dir_exists = set()
-        if indexed_dirs:
-            indexed_dir_exists.update(
-                self.odb.list_hashes_exists(indexed_dirs)
-            )
-            missing_dirs = indexed_dirs.difference(indexed_dir_exists)
-            if missing_dirs:
-                logger.debug(
-                    "Remote cache missing indexed .dir hashes '{}', "
-                    "clearing remote index".format(", ".join(missing_dirs))
-                )
-                self.index.clear()
-
-        # Check if non-indexed (new) dir hashes exist on remote
-        dir_exists = dir_md5s.intersection(indexed_dir_exists)
-        dir_exists.update(self.odb.list_hashes_exists(dir_md5s - dir_exists))
-
-        # If .dir hash exists on the remote, assume directory contents
-        # still exists on the remote
-        for dir_hash in dir_exists:
-            file_hashes = list(
-                named_cache.child_keys(cache.fs.scheme, dir_hash)
-            )
-            if dir_hash not in self.index:
-                logger.debug(
-                    "Indexing new .dir '{}' with '{}' nested files".format(
-                        dir_hash, len(file_hashes)
-                    )
-                )
-                self.index.update([dir_hash], file_hashes)
-            yield dir_hash
-            yield from file_hashes
-
-    @staticmethod
-    def _fill_statuses(hash_info_dir, local_exists, remote_exists):
-        # Using sets because they are way faster for lookups
-        local = set(local_exists)
-        remote = set(remote_exists)
-
-        for md5, info in hash_info_dir.items():
-            status = STATUS_MAP[(md5 in local, md5 in remote)]
-            info["status"] = status
-
-    def _get_plans(self, cache_obj, download, status_info, status):
-        cache = []
-        path_infos = []
-        names = []
-        hashes = []
-        missing = []
-        for md5, info in Tqdm(
-            status_info.items(), desc="Analysing status", unit="file"
-        ):
-            if info["status"] == status:
-                cache.append(cache_obj.hash_to_path_info(md5))
-                path_infos.append(self.odb.hash_to_path_info(md5))
-                names.append(info["name"])
-                hashes.append(md5)
-            elif info["status"] == STATUS_MISSING:
-                missing.append(md5)
-
-        if download:
-            to_infos = cache
-            from_infos = path_infos
-        else:
-            to_infos = path_infos
-            from_infos = cache
-
-        return (from_infos, to_infos, names, hashes), missing
-
-    def _process(
-        self,
-        cache,
-        named_cache,
-        jobs=None,
-        show_checksums=False,
-        download=False,
-    ):
-        logger.debug(
-            "Preparing to {} '{}'".format(
-                "download data from" if download else "upload data to",
-                self.fs.path_info,
-            )
-        )
-
-        if download:
-            func = _log_exceptions(self.fs.download_file, "download")
-            status = STATUS_DELETED
-            desc = "Downloading"
-        else:
-            func = _log_exceptions(self.fs.upload, "upload")
-            status = STATUS_NEW
-            desc = "Uploading"
-
-        if jobs is None:
-            jobs = self.fs.jobs
-
-        dir_status, file_status, dir_contents = self._status(
-            cache,
-            named_cache,
-            jobs=jobs,
-            show_checksums=show_checksums,
-            download=download,
-        )
-
-        dir_plans, _ = self._get_plans(cache, download, dir_status, status)
-        file_plans, missing_files = self._get_plans(
-            cache, download, file_status, status
-        )
-
-        total = len(dir_plans[0]) + len(file_plans[0])
-        if total == 0:
-            return 0
-
-        with Tqdm(total=total, unit="file", desc=desc) as pbar:
-            func = pbar.wrap_fn(func)
-            self._process_plans(
-                download,
-                dir_plans,
-                file_plans,
-                dir_contents,
-                missing_files,
-                jobs,
-                func,
-            )
-
-        return total
-
-    def _process_plans(
-        self,
-        download,
-        dir_plans,
-        file_plans,
-        dir_contents,
-        missing_files,
-        jobs,
-        func,
-    ):
-        with ThreadPoolExecutor(max_workers=jobs) as executor:
-            processor = partial(self._create_tasks, executor, jobs, func)
-            processor.transfer_func = func
-            if download:
-                self._download_plans(dir_plans, file_plans, processor)
-            else:
-                self._upload_plans(
-                    dir_plans,
-                    file_plans,
-                    dir_contents,
-                    missing_files,
-                    processor,
-                )
-
-    def _create_tasks(self, executor, jobs, func, file_plans):
-        fails = 0
-        file_plan_iterator = iter(file_plans)
-
-        def create_taskset(amount):
-            return {
-                executor.submit(func, from_info, to_info, name)
-                for from_info, to_info, name, _ in itertools.islice(
-                    file_plan_iterator, amount
-                )
-            }
-
-        tasks = create_taskset(jobs * 5)
-        while tasks:
-            done, tasks = futures.wait(
-                tasks, return_when=futures.FIRST_COMPLETED
-            )
-            fails += sum(task.result() for task in done)
-            tasks.update(create_taskset(len(done)))
-        return fails
-
-    def _download_plans(self, dir_plans, file_plans, processor):
-        plans = [*zip(*dir_plans), *zip(*file_plans)]
-        fails = processor(plans)
-        if fails:
-            self.index.clear()
-            raise DownloadError(fails)
-
-    def _upload_plans(
-        self, dir_plans, file_plans, dir_contents, missing_files, processor
-    ):
-        total_fails = 0
-        succeeded_dir_hashes = []
-        all_file_plans = list(zip(*file_plans))
-        for dir_from_info, dir_to_info, dir_name, dir_hash in zip(*dir_plans):
-            bound_file_plans = []
-            directory_hashes = dir_contents[dir_hash]
-
-            for file_plan in all_file_plans.copy():
-                if file_plan[-1] in directory_hashes:
-                    bound_file_plans.append(file_plan)
-                    all_file_plans.remove(file_plan)
-
-            dir_fails = processor(bound_file_plans)
-            if dir_fails:
-                logger.debug(
-                    "failed to upload full contents of '{}', "
-                    "aborting .dir file upload".format(dir_name)
-                )
-                logger.error(
-                    f"failed to upload '{dir_from_info}'"
-                    f" to '{dir_to_info}'"
-                )
-                total_fails += dir_fails + 1
-            elif directory_hashes.intersection(missing_files):
-                # if for some reason a file contained in this dir is
-                # missing both locally and in the remote, we want to
-                # push whatever file content we have, but should not
-                # push .dir file
-                logger.debug(
-                    "directory '%s' contains missing files,"
-                    "skipping .dir file upload",
-                    dir_name,
-                )
-            else:
-                is_dir_failed = processor.transfer_func(
-                    dir_from_info, dir_to_info, dir_name
-                )
-                total_fails += is_dir_failed
-                if not is_dir_failed:
-                    succeeded_dir_hashes.append(dir_hash)
-
-        # insert the rest
-        total_fails += processor(all_file_plans)
-        if total_fails:
-            raise UploadError(total_fails)
-
-        # index successfully pushed dirs
-        for dir_hash in succeeded_dir_hashes:
-            file_hashes = dir_contents[dir_hash]
-            logger.debug(
-                "Indexing pushed dir '{}' with "
-                "'{}' nested files".format(dir_hash, len(file_hashes))
-            )
-            self.index.update([dir_hash], file_hashes)
-
-    @index_locked
-    def push(self, cache, named_cache, jobs=None, show_checksums=False):
-        ret = self._process(
-            cache,
-            named_cache,
-            jobs=jobs,
-            show_checksums=show_checksums,
-            download=False,
-        )
-
-        if self.fs.scheme == "local":
-            for checksum in named_cache.scheme_keys("local"):
-                cache_file = self.odb.hash_to_path_info(checksum)
-                if self.fs.exists(cache_file):
-                    hash_info = HashInfo(self.fs.PARAM_CHECKSUM, checksum)
-                    self.odb.state.save(cache_file, self.fs, hash_info)
-                    self.odb.protect(cache_file)
-
-        return ret
-
-    @index_locked
-    def pull(self, cache, named_cache, jobs=None, show_checksums=False):
-        ret = self._process(
-            cache,
-            named_cache,
-            jobs=jobs,
-            show_checksums=show_checksums,
-            download=True,
-        )
-
-        if not self.odb.verify:
-            for checksum in named_cache.scheme_keys("local"):
-                cache_file = cache.hash_to_path_info(checksum)
-                if cache.fs.exists(cache_file):
-                    # We can safely save here, as existing corrupted files
-                    # will be removed upon status, while files corrupted
-                    # during download will not be moved from tmp_file
-                    # (see `BaseFileSystem.download()`)
-                    hash_info = HashInfo(cache.fs.PARAM_CHECKSUM, checksum)
-                    cache.state.save(cache_file, cache.fs, hash_info)
-                    cache.protect(cache_file)
-
-        return ret
-
-    @staticmethod
-    def _log_missing_caches(hash_info_dict):
-        missing_caches = [
-            (md5, info)
-            for md5, info in hash_info_dict.items()
-            if info["status"] == STATUS_MISSING
-        ]
-        if missing_caches:
-            missing_desc = "\n".join(
-                "name: {}, md5: {}".format(info["name"], md5)
-                for md5, info in missing_caches
-            )
-            msg = (
-                "Some of the cache files do not exist neither locally "
-                "nor on remote. Missing cache files:\n{}".format(missing_desc)
-            )
-            logger.warning(msg)