dvc: bump to 2.7.4

* tests: additional callbacks test for remaining filesystems

* requirements: bump pydrive2 to 1.9.4

Co-authored-by: Ruslan Kuprieiev <[email protected]>

.github/workflows/packages.yaml

@@ -5,6 +5,7 @@ on:
     - master
   release:
     types: [released, prereleased]
+  workflow_dispatch:
 jobs:
   deb:
     runs-on: ubuntu-18.04

.github/workflows/tests.yaml

@@ -13,6 +13,7 @@ env:
 
 jobs:
   lint:
+    timeout-minutes: 10
     runs-on: ubuntu-latest
     steps:
     - uses: actions/[email protected]
@@ -32,6 +33,7 @@ jobs:
       run: python setup.py checkdocs
     - uses: pre-commit/[email protected]
   tests:
+    timeout-minutes: 45
     runs-on: ${{ matrix.os }}
     strategy:
       fail-fast: false
@@ -97,6 +99,7 @@ jobs:
       run: |
         echo "extra_test_args=--disable-gdrive" >> $GITHUB_ENV
     - name: run tests
+      timeout-minutes: 30
       env:
         GDRIVE_CREDENTIALS_DATA: ${{ secrets.GDRIVE_CREDENTIALS_DATA }}
         AWS_ACCESS_KEY_ID: ${{ secrets.AWS_ACCESS_KEY_ID }}
@@ -109,7 +112,7 @@ jobs:
         --cov-report=xml --cov-report=term
         --all ${{ env.extra_test_args }}
     - name: upload coverage report
-      uses: codecov/codecov-action@v2.0.3
+      uses: codecov/codecov-action@v2.1.0
       with:
         file: ./coverage.xml
         fail_ci_if_error: false

MANIFEST.in

@@ -1,3 +1,3 @@
 include fastentrypoints.py
 include LICENSE
-include test_requirements.txt
+recursive-include requirements *.txt

README.rst

@@ -222,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
 ============
@@ -299,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/command/config.py

@@ -66,7 +66,8 @@ 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(
@@ -81,9 +82,7 @@ class CmdConfig(CmdBaseNoRepo):
     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)
@@ -136,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/experiments.py

@@ -1,5 +1,6 @@
 import argparse
 import logging
+import os
 from collections import Counter, OrderedDict, defaultdict
 from datetime import date, datetime
 from fnmatch import fnmatch
@@ -141,6 +142,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
 
@@ -161,8 +164,8 @@ def _collect_rows(
         elif exp.get("queued"):
             state = "Queued"
         else:
-            state = FILL_VALUE
-        executor = exp.get("executor", FILL_VALUE)
+            state = fill_value
+        executor = exp.get("executor", fill_value)
         is_baseline = rev == "baseline"
 
         if is_baseline:
@@ -202,12 +205,12 @@ def _collect_rows(
             exp_name,
             name_rev,
             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
+        fill_value = FILL_VALUE_ERRORED if results.get("error") else fill_value
         _extend_row(
             row,
             metric_names,
@@ -274,14 +277,18 @@ 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, fill_value=FILL_VALUE):
@@ -320,6 +327,7 @@ def _parse_filter_list(param_list):
 
 def experiments_table(
     all_experiments,
+    headers,
     metric_headers,
     metric_names,
     param_headers,
@@ -327,22 +335,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",
-        "typ",
-        "Created",
-        "parent",
-        "State",
-        "Executor",
-    ]
     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(
@@ -353,6 +354,8 @@ def experiments_table(
             sort_by=sort_by,
             sort_order=sort_order,
             precision=precision,
+            fill_value=fill_value,
+            iso=iso,
         )
         td.extend(rows)
 
@@ -385,8 +388,10 @@ def baseline_styler(typ):
 
 
 def show_experiments(
-    all_experiments, pager=True, no_timestamp=False, **kwargs
+    all_experiments, pager=True, no_timestamp=False, show_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", []))
@@ -399,11 +404,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,
@@ -411,6 +431,8 @@ def show_experiments(
         kwargs.get("sort_by"),
         kwargs.get("sort_order"),
         kwargs.get("precision"),
+        kwargs.get("fill_value"),
+        kwargs.get("iso"),
     )
 
     if no_timestamp:
@@ -422,9 +444,12 @@ def show_experiments(
 
     row_styles = lmap(baseline_styler, td.column("typ"))
 
-    merge_headers = ["Experiment", "rev", "typ", "parent"]
-    td.column("Experiment")[:] = map(prepare_exp_id, td.as_dict(merge_headers))
-    td.drop(*merge_headers[1:])
+    if not show_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 = {
@@ -453,13 +478,11 @@ def show_experiments(
         rich_table=True,
         header_styles=styles,
         row_styles=row_styles,
+        show_csv=show_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
@@ -493,6 +516,14 @@ class CmdExperimentsShow(CmdBase):
 
             ui.write(json.dumps(all_experiments, default=_format_json))
         else:
+            precision = (
+                self.args.precision or None
+                if self.args.show_csv
+                else DEFAULT_PRECISION
+            )
+            fill_value = "" if self.args.show_csv else FILL_VALUE
+            iso = True if self.args.show_csv else False
+
             show_experiments(
                 all_experiments,
                 include_metrics=self.args.include_metrics,
@@ -502,8 +533,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,
+                show_csv=self.args.show_csv,
             )
         return 0
 
@@ -756,6 +790,62 @@ class CmdExperimentsRemove(CmdBase):
         return 0
 
 
+class CmdExperimentsInit(CmdBase):
+    CODE = "src"
+    DATA = "data"
+    MODELS = "models"
+    DEFAULT_METRICS = "metrics.json"
+    DEFAULT_PARAMS = "params.yaml"
+    PLOTS = "plots"
+    DVCLIVE = "dvclive"
+    DEFAULT_NAME = "default"
+
+    def run(self):
+        from dvc.command.stage import parse_cmd
+
+        cmd = parse_cmd(self.args.cmd)
+        if not cmd:
+            raise InvalidArgumentError("command is not specified")
+        if self.args.interactive:
+            raise NotImplementedError(
+                "'-i/--interactive' is not implemented yet."
+            )
+        if self.args.explicit:
+            raise NotImplementedError("'--explicit' is not implemented yet.")
+        if self.args.template:
+            raise NotImplementedError("template is not supported yet.")
+
+        from dvc.utils.serialize import LOADERS
+
+        code = self.args.code or self.CODE
+        data = self.args.data or self.DATA
+        models = self.args.models or self.MODELS
+        metrics = self.args.metrics or self.DEFAULT_METRICS
+        params_path = self.args.params or self.DEFAULT_PARAMS
+        plots = self.args.plots or self.PLOTS
+        dvclive = self.args.live or self.DVCLIVE
+
+        _, ext = os.path.splitext(params_path)
+        params = list(LOADERS[ext](params_path))
+
+        name = self.args.name or self.DEFAULT_NAME
+        stage = self.repo.stage.add(
+            name=name,
+            cmd=cmd,
+            deps=[code, data],
+            outs=[models],
+            params=[{params_path: params}],
+            metrics_no_cache=[metrics],
+            plots_no_cache=[plots],
+            live=dvclive,
+            force=True,
+        )
+
+        if self.args.run:
+            return self.repo.experiments.run(targets=[stage.addressing])
+        return 0
+
+
 def add_parser(subparsers, parent_parser):
     EXPERIMENTS_HELP = "Commands to run and compare experiments."
 
@@ -883,6 +973,12 @@ def add_parser(subparsers, parent_parser):
         default=False,
         help="Print output in JSON format instead of a human-readable table.",
     )
+    experiments_show_parser.add_argument(
+        "--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,
@@ -1112,9 +1208,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>]",
     )
@@ -1264,6 +1360,68 @@ 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=argparse.RawDescriptionHelpFormatter,
+    )
+    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(
+        "--template", help="Stage template to use to fill with provided values"
+    )
+    experiments_init_parser.add_argument(
+        "--explicit", 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",
+        help="Path to the source file or directory "
+        "which your experiments depend",
+    )
+    experiments_init_parser.add_argument(
+        "--data",
+        help="Path to the data file or directory "
+        "which your experiments depend",
+    )
+    experiments_init_parser.add_argument(
+        "--models",
+        help="Path to the model file or directory for your experiments",
+    )
+    experiments_init_parser.add_argument(
+        "--params", help="Path to the parameters file for your experiments"
+    )
+    experiments_init_parser.add_argument(
+        "--metrics", help="Path to the metrics file for your experiments"
+    )
+    experiments_init_parser.add_argument(
+        "--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"
+    )
+    experiments_init_parser.set_defaults(func=CmdExperimentsInit)
+
 
 def _add_run_common(parser):
     """Add common args for 'exp run' and 'exp resume'."""

dvc/command/machine.py

@@ -69,6 +69,22 @@ class CmdMachineRemove(CmdMachineConfig):
         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
@@ -219,6 +235,27 @@ def add_parser(subparsers, parent_parser):
     )
     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",

dvc/compare.py

@@ -168,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("show_csv", False):
+            ui.write(self.to_csv(), end="")
+        else:
+            ui.table(self, headers=self.keys(), **kwargs)
 
     def as_dict(
         self, cols: Iterable[str] = None

dvc/config.py

@@ -76,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"
@@ -263,6 +265,7 @@ class Config(dict):
                     "key_path": func,
                 }
             },
+            "machine": {str: {"startup_script": func}},
         }
         return Schema(dirs_schema, extra=ALLOW_EXTRA)(conf)
 
@@ -285,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)

dvc/config_schema.py

@@ -229,6 +229,18 @@ SCHEMA = {
     "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

dvc/fs/azure.py

@@ -11,7 +11,7 @@ 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 = (
@@ -39,7 +39,7 @@ def _az_config():
 
 
 # pylint:disable=abstract-method
-class AzureFileSystem(ObjectFSWrapper):
+class AzureFileSystem(CallbackMixin, ObjectFSWrapper):
     scheme = Schemes.AZURE
     PATH_CLS = CloudURLInfo
     PARAM_CHECKSUM = "etag"

dvc/fs/base.py

@@ -1,12 +1,18 @@
+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 funcy import cached_property
+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
 
@@ -217,43 +223,64 @@ 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)
+    @cached_property
+    def _local_fs(self):
+        from dvc.fs import LocalFileSystem
+
+        return LocalFileSystem()
+
+    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(self._local_fs, from_info)
+            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, size=None, **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,
-            total=size,
-            **pbar_args,
-        ) as wrapped:
-            self._upload_fobj(  # pylint: disable=no-member
-                wrapped, to_info, size=size
+            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(
@@ -261,84 +288,105 @@ class BaseFileSystem:
         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(self, from_info)
+
+        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
 
@@ -256,10 +257,12 @@ class DvcFileSystem(BaseFileSystem):  # pylint:disable=abstract-method
 
         return ret
 
-    def _download(self, from_info, to_file, **kwargs):
+    def get_file(
+        self, from_info, to_file, callback=DEFAULT_CALLBACK, **kwargs
+    ):
         fs, path = self._get_fs_path(from_info)
-        fs._download(  # pylint: disable=protected-access
-            path, to_file, **kwargs
+        fs.get_file(  # pylint: disable=protected-access
+            path, to_file, callback=callback, **kwargs
         )
 
     def checksum(self, path_info):

dvc/fs/fsspec_wrapper.py

@@ -3,8 +3,9 @@ import shutil
 from functools import lru_cache
 
 from funcy import cached_property
+from tqdm.utils import CallbackIOWrapper
 
-from dvc.progress import Tqdm
+from dvc.progress import DEFAULT_CALLBACK
 
 from .base import BaseFileSystem
 from .local import LocalFileSystem
@@ -130,43 +131,26 @@ class FSSpecWrapper(BaseFileSystem):
             self._with_bucket(path_info), exist_ok=kwargs.pop("exist_ok", True)
         )
 
-    def _upload_fobj(self, fobj, to_info, size=None):
+    def put_file(
+        self, from_file, to_info, callback=DEFAULT_CALLBACK, **kwargs
+    ):
+        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 get_file(
+        self, from_info, to_info, callback=DEFAULT_CALLBACK, **kwargs
+    ):
+        self.fs.get_file(
+            self._with_bucket(from_info), to_info, callback=callback, **kwargs
+        )
+
+    def upload_fobj(self, fobj, to_info, **kwargs):
         self.makedirs(to_info.parent)
         with self.open(to_info, "wb") as fdest:
             shutil.copyfileobj(fobj, fdest, length=fdest.blocksize)
 
-    def _upload(
-        self, from_file, to_info, name=None, no_progress_bar=False, **kwargs
-    ):
-        self.makedirs(to_info.parent)
-        size = os.path.getsize(from_file)
-        with open(from_file, "rb") as fobj:
-            self.upload_fobj(
-                fobj,
-                to_info,
-                size=size,
-                desc=name,
-                no_progress_bar=no_progress_bar,
-            )
-        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)
-
 
 # pylint: disable=abstract-method
 class ObjectFSWrapper(FSSpecWrapper):
@@ -233,42 +217,62 @@ class ObjectFSWrapper(FSSpecWrapper):
         yield from self._strip_buckets(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
+
+
 _LOCAL_FS = LocalFileSystem()
 
 
 class CallbackMixin:
-    """Use the native ``get_file()``/``put_file()`` APIs
-    if the target filesystem supports callbacks."""
+    """Provides callback support for the filesystem that don't support yet."""
 
-    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,
     ):
-        with Tqdm(
-            desc=name,
-            disable=no_progress_bar,
-            bytes=True,
-            total=-1,
-            **pbar_args,
-        ) as pbar:
-            self.fs.put_file(
-                os.fspath(from_file),
-                self._with_bucket(to_info),
-                callback=pbar.as_callback(_LOCAL_FS, from_file),
-            )
-        self.fs.invalidate_cache(self._with_bucket(to_info.parent))
+        """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 _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,
     ):
-        with Tqdm(
-            desc=name,
-            disable=no_progress_bar,
-            bytes=True,
-            total=-1,
-            **pbar_args,
-        ) as pbar:
-            self.fs.get_file(
-                self._with_bucket(from_info),
-                os.fspath(to_file),
-                callback=pbar.as_callback(self, from_info),
-            )
+        # 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

@@ -12,7 +12,7 @@ from dvc.path_info import CloudURLInfo
 from dvc.scheme import Schemes
 from dvc.utils import format_link, tmp_fname
 
-from .fsspec_wrapper import CallbackMixin, FSSpecWrapper
+from .fsspec_wrapper import FSSpecWrapper
 
 logger = logging.getLogger(__name__)
 FOLDER_MIME_TYPE = "application/vnd.google-apps.folder"
@@ -79,9 +79,7 @@ class GDriveURLInfo(CloudURLInfo):
         self._spath = re.sub("/{2,}", "/", self._spath.rstrip("/"))
 
 
-class GDriveFileSystem(
-    CallbackMixin, FSSpecWrapper
-):  # pylint:disable=abstract-method
+class GDriveFileSystem(FSSpecWrapper):  # pylint:disable=abstract-method
     scheme = Schemes.GDRIVE
     PATH_CLS = GDriveURLInfo
     PARAM_CHECKSUM = "checksum"
@@ -298,7 +296,16 @@ class GDriveFileSystem(
 
         return super()._with_bucket(path)
 
-    def _upload_fobj(self, fobj, to_info, size: int = None):
+    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
+        return path or bucket
+
+    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, size=size)
+        return self.fs.upload_fobj(fobj, rpath, **kwargs)

dvc/fs/git.py

@@ -1,8 +1,11 @@
 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
 
 
@@ -116,16 +119,18 @@ class GitFileSystem(BaseFileSystem):  # pylint:disable=abstract-method
                 # NOTE: os.path.join is ~5.5 times slower
                 yield f"{root}{os.sep}{file}"
 
-    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
 
-        from dvc.progress import Tqdm
+        total = self.getsize(from_info)
+        if total:
+            callback.set_size(total)
 
-        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)
+        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,11 +6,11 @@ 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"}

dvc/fs/hdfs.py

@@ -8,8 +8,10 @@ import subprocess
 from collections import deque
 from contextlib import closing, contextmanager
 
+from tqdm.utils import CallbackIOWrapper
+
 from dvc.hash_info import HashInfo
-from dvc.progress import Tqdm
+from dvc.progress import DEFAULT_CALLBACK
 from dvc.scheme import Schemes
 from dvc.utils import fix_env, tmp_fname
 
@@ -244,42 +246,37 @@ class HDFSFileSystem(BaseFileSystem):
             size=self.getsize(path_info),
         )
 
-    def _upload_fobj(self, fobj, to_info, **kwargs):
+    def upload_fobj(self, fobj, to_info, **kwargs):
         with self.hdfs(to_info) as hdfs:
             with hdfs.open_output_stream(to_info.path) as fdest:
                 shutil.copyfileobj(fobj, fdest, self.BLOCK_SIZE)
 
-    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
     ):
         with self.hdfs(to_info) as hdfs:
+            hdfs.create_dir(to_info.parent.path)
+
             tmp_file = tmp_fname(to_info.path)
-            total = os.path.getsize(from_file)
+            total: int = os.path.getsize(from_file)
+            callback.set_size(total)
+
             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:
-                        shutil.copyfileobj(wrapped, sobj, self.BLOCK_SIZE)
+                wrapped = CallbackIOWrapper(callback.relative_update, fobj)
+                with hdfs.open_output_stream(tmp_file) as sobj:
+                    shutil.copyfileobj(wrapped, sobj, self.BLOCK_SIZE)
             hdfs.move(tmp_file, to_info.path)
 
-    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
     ):
         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:
-                        shutil.copyfileobj(sobj, wrapped, self.BLOCK_SIZE)
+            if total:
+                callback.set_size(total)
+
+            with hdfs.open_input_stream(from_info.path) as sobj:
+                with open(to_file, "wb+") as fobj:
+                    wrapped = CallbackIOWrapper(callback.relative_update, sobj)
+                    shutil.copyfileobj(wrapped, fobj, self.BLOCK_SIZE)

dvc/fs/http.py

@@ -1,20 +1,12 @@
-import logging
-import os.path
 import threading
-from typing import Optional
-from urllib.parse import urlparse
 
-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())
@@ -26,179 +18,111 @@ 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
-    REQUIRES = {"requests": "requests"}
 
     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
 
-        self.user = config.get("user", 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, url):
-        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(urlparse(url).hostname, 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")
+
+            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'"
+                    )
+
+                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."
+                )
+
+        if "ssl_verify" in config:
+            with fsspec_loop():
+                client_kwargs["connector"] = aiohttp.TCPConnector(
+                    ssl=make_context(config["ssl_verify"])
+                )
+
+        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,
+        )
+
+        # 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 RetryClient(**kwargs)
 
-    @wrap_prop(threading.Lock())
     @cached_property
-    def _session(self):
-        import requests
-        from requests.adapters import HTTPAdapter
-        from urllib3.util.retry import Retry
-
-        session = requests.Session()
-
-        session.verify = self.ssl_verify
-
-        retries = Retry(
-            total=self.SESSION_RETRIES,
-            backoff_factor=self.SESSION_BACKOFF_FACTOR,
+    def fs(self):
+        from fsspec.implementations.http import (
+            HTTPFileSystem as _HTTPFileSystem,
         )
 
-        session.mount("http://", HTTPAdapter(max_retries=retries))
-        session.mount("https://", HTTPAdapter(max_retries=retries))
+        return _HTTPFileSystem(**self.fs_args)
 
-        return session
-
-    def request(self, method, url, **kwargs):
-        import requests
-
-        kwargs.setdefault("allow_redirects", True)
-        kwargs.setdefault("timeout", self.REQUEST_TIMEOUT)
-
-        try:
-            res = self._session.request(
-                method,
-                url,
-                auth=self._auth_method(url),
-                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, "type": "file"}
-
-    def _upload_fobj(self, fobj, to_info, **kwargs):
-        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,
-                size=None if no_progress_bar else os.path.getsize(from_file),
-                no_progress_bar=no_progress_bar,
-                desc=name or to_info.url,
-            )
-
-    def open(self, path_info, mode: str = "r", encoding: str = None, **kwargs):
-        from dvc.utils.http import open_url
-
-        return open_url(
-            path_info.url,
-            mode=mode,
-            encoding=encoding,
-            auth=self._auth_method(path_info),
-            **kwargs,
-        )
-
-    @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

@@ -7,6 +7,7 @@ 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__)
@@ -108,7 +109,7 @@ class LocalFileSystem(BaseFileSystem):
             self.remove(tmp_info)
             raise
 
-    def _upload_fobj(self, fobj, to_info, **kwargs):
+    def upload_fobj(self, fobj, to_info, **kwargs):
         self.makedirs(to_info.parent)
         tmp_info = to_info.parent / tmp_fname("")
         try:
@@ -158,21 +159,15 @@ class LocalFileSystem(BaseFileSystem):
     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/oss.py

@@ -7,13 +7,13 @@ from funcy import cached_property, wrap_prop
 from dvc.path_info import CloudURLInfo
 from dvc.scheme import Schemes
 
-from .fsspec_wrapper import CallbackMixin, ObjectFSWrapper
+from .fsspec_wrapper import ObjectFSWrapper
 
 logger = logging.getLogger(__name__)
 
 
 # pylint:disable=abstract-method
-class OSSFileSystem(CallbackMixin, ObjectFSWrapper):
+class OSSFileSystem(ObjectFSWrapper):
     scheme = Schemes.OSS
     PATH_CLS = CloudURLInfo
     REQUIRES = {"ossfs": "ossfs"}

dvc/fs/repo.py

@@ -9,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
 
@@ -448,19 +449,21 @@ class RepoFileSystem(BaseFileSystem):  # pylint:disable=abstract-method
             for fname in files:
                 yield PathInfo(root) / fname
 
-    def _download(self, from_info, to_file, **kwargs):
+    def get_file(
+        self, from_info, to_file, callback=DEFAULT_CALLBACK, **kwargs
+    ):
         fs, dvc_fs = self._get_fs_pair(from_info)
         try:
-            fs._download(  # pylint: disable=protected-access
-                from_info, to_file, **kwargs
+            fs.get_file(  # pylint: disable=protected-access
+                from_info, to_file, callback=callback, **kwargs
             )
             return
         except FileNotFoundError:
             if not dvc_fs:
                 raise
 
-        dvc_fs._download(  # pylint: disable=protected-access
-            from_info, to_file, **kwargs
+        dvc_fs.get_file(  # pylint: disable=protected-access
+            from_info, to_file, callback=callback, **kwargs
         )
 
     def metadata(self, path):

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
@@ -204,36 +204,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

@@ -8,7 +8,8 @@ from dvc import prompt
 from dvc.scheme import Schemes
 from dvc.utils.fs import as_atomic
 
-from .fsspec_wrapper import CallbackMixin, FSSpecWrapper
+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"))
@@ -26,7 +27,7 @@ def ask_password(host, user, port):
 
 
 # pylint:disable=abstract-method
-class SSHFileSystem(CallbackMixin, FSSpecWrapper):
+class SSHFileSystem(FSSpecWrapper):
     scheme = Schemes.SSH
     REQUIRES = {"sshfs": "sshfs"}
 
@@ -66,7 +67,13 @@ class SSHFileSystem(CallbackMixin, FSSpecWrapper):
             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"):
@@ -99,11 +106,6 @@ class SSHFileSystem(CallbackMixin, FSSpecWrapper):
         login_info["agent_forwarding"] = config.get("agent_forwarding", True)
         login_info["proxy_command"] = user_ssh_config.get("ProxyCommand")
 
-        if config.get("ask_password") and login_info["password"] is None:
-            login_info["password"] = ask_password(
-                login_info["host"], login_info["username"], login_info["port"]
-            )
-
         # We are going to automatically add stuff to known_hosts
         # something like paramiko's AutoAddPolicy()
         login_info["known_hosts"] = None
@@ -119,10 +121,12 @@ class SSHFileSystem(CallbackMixin, FSSpecWrapper):
     # Ensure that if an interrupt happens during the transfer, we don't
     # pollute the cache.
 
-    def _upload_fobj(self, fobj, to_info, *args, **kwargs):
+    def upload_fobj(self, fobj, to_info, **kwargs):
         with as_atomic(self, to_info) as tmp_file:
-            super()._upload_fobj(fobj, tmp_file, *args, **kwargs)
+            super().upload_fobj(fobj, tmp_file, **kwargs)
 
-    def _upload(self, from_file, to_info, *args, **kwargs):
+    def put_file(
+        self, from_file, to_info, callback=DEFAULT_CALLBACK, **kwargs
+    ):
         with as_atomic(self, to_info) as tmp_file:
-            super()._upload(from_file, tmp_file, *args, **kwargs)
+            super().put_file(from_file, tmp_file, callback=callback, **kwargs)

dvc/fs/utils.py

@@ -33,7 +33,8 @@ def transfer(
             return from_fs.download_file(from_info, to_info)
 
         with from_fs.open(from_info, mode="rb") as fobj:
-            return to_fs.upload_fobj(fobj, to_info)
+            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).

dvc/fs/webdav.py

@@ -1,5 +1,4 @@
 import logging
-import os
 import threading
 from functools import lru_cache
 
@@ -71,15 +70,13 @@ class WebDAVFileSystem(FSSpecWrapper):  # pylint:disable=abstract-method
 
         return WebdavFileSystem(**self.fs_args)
 
-    def _upload_fobj(self, fobj, to_info, size: int = None):
+    def upload_fobj(self, fobj, to_info, **kwargs):
         rpath = self.translate_path_info(to_info)
-        self.makedirs(os.path.dirname(rpath))
+        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.client.upload_fileobj(
-            fobj, rpath, overwrite=True, size=size
-        )
+        return self.fs.upload_fileobj(fobj, rpath, overwrite=True, size=size)
 
     @lru_cache(512)
     def translate_path_info(self, path):

dvc/fs/webhdfs.py

@@ -9,7 +9,7 @@ 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.progress import DEFAULT_CALLBACK
 from dvc.scheme import Schemes
 
 from .base import BaseFileSystem
@@ -29,6 +29,15 @@ def update_pbar(pbar, total):
     return update
 
 
+def update_callback(callback, total):
+    def update(_, bytes_transfered):
+        if bytes_transfered == -1:
+            return callback.absolute_update(total)
+        return callback.relative_update(bytes_transfered)
+
+    return update
+
+
 class WebHDFSFileSystem(BaseFileSystem):  # pylint:disable=abstract-method
     scheme = Schemes.WEBHDFS
     PATH_CLS = CloudURLInfo
@@ -141,31 +150,31 @@ class WebHDFSFileSystem(BaseFileSystem):  # pylint:disable=abstract-method
         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, **kwargs):
+    def upload_fobj(self, fobj, to_info, **kwargs):
         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
+    def put_file(
+        self, from_file, to_info, callback=DEFAULT_CALLBACK, **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),
-            )
+        callback.set_size(total)
 
-    def _download(
-        self, from_info, to_file, name=None, no_progress_bar=False, **_kwargs
+        self.hdfs_client.makedirs(to_info.parent.path)
+        return self.hdfs_client.upload(
+            to_info.path,
+            from_file,
+            overwrite=True,
+            progress=update_callback(callback, total),
+        )
+
+    def get_file(
+        self, from_info, to_file, callback=DEFAULT_CALLBACK, **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)
-            )
+        if total:
+            callback.set_size(total)
+
+        self.hdfs_client.download(
+            from_info.path, to_file, progress=update_callback(callback, total)
+        )

dvc/machine/__init__.py

@@ -25,6 +25,18 @@ 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
@@ -168,6 +180,12 @@ class MachineManager:
     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]):

dvc/machine/backend/base.py

@@ -1,15 +1,38 @@
-from abc import abstractmethod
+from abc import ABC, abstractmethod
 from contextlib import contextmanager
 from typing import TYPE_CHECKING, Iterator, Optional
 
-from tpi import base
-
 if TYPE_CHECKING:
     from dvc.fs.ssh import SSHFileSystem
     from dvc.repo.experiments.executor.base import BaseExecutor
+    from dvc.types import StrPath
 
 
-class BaseMachineBackend(base.BaseMachineBackend):
+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

dvc/machine/backend/terraform.py

@@ -5,11 +5,17 @@ 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):
+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":

dvc/objects/db/base.py

@@ -97,7 +97,6 @@ class ObjectDB:
         hash_info: "HashInfo",
         move: bool = True,
         verify: Optional[bool] = None,
-        **kwargs,
     ):
         if self.read_only:
             raise ObjectDBPermissionError("Cannot add to read-only ODB")
@@ -121,10 +120,6 @@ class ObjectDB:
         except (ObjectFormatError, FileNotFoundError):
             pass
 
-        callback = kwargs.get("download_callback")
-        if callback:
-            callback(1)
-
     def hash_to_path_info(self, hash_) -> "DvcPath":
         return self.path_info / hash_[0:2] / hash_[2:]
 

dvc/objects/db/reference.py

@@ -70,7 +70,7 @@ class ReferenceObjectDB(ObjectDB):
         ref_fobj = io.BytesIO(ref_file.to_bytes())
         ref_fobj.seek(0)
         try:
-            self.fs.upload_fobj(ref_fobj, to_info)
+            self.fs.upload(ref_fobj, to_info)
         except OSError as exc:
             if isinstance(exc, FileExistsError) or (
                 os.name == "nt"

dvc/objects/stage.py

@@ -34,9 +34,8 @@ def _upload_file(path_info, fs, odb, upload_odb):
     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)
-        upload_odb.fs.upload_fobj(
-            stream, tmp_info, desc=path_info.name, size=fs.getsize(path_info)
-        )
+        size = fs.getsize(path_info)
+        upload_odb.fs.upload(stream, tmp_info, desc=path_info.name, total=size)
 
     odb.add(tmp_info, upload_odb.fs, stream.hash_info)
     return path_info, odb.get(stream.hash_info)

dvc/objects/transfer.py

@@ -1,20 +1,19 @@
 import errno
-import itertools
 import logging
-from concurrent import futures
-from concurrent.futures import ThreadPoolExecutor
 from functools import partial, wraps
-from typing import TYPE_CHECKING, Callable, Iterable, Optional
+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__)
 
@@ -38,109 +37,48 @@ def _log_exceptions(func):
     return wrapper
 
 
-def _transfer(
-    src, dest, dir_ids, file_ids, missing_ids, jobs, verify, move, **kwargs
-):
-    func = _log_exceptions(dest.add)
-    total = len(dir_ids) + len(file_ids)
-    if total == 0:
-        return 0
-    with Tqdm(total=total, unit="file", desc="Transferring") as pbar:
-        func = pbar.wrap_fn(func)
-        with ThreadPoolExecutor(max_workers=jobs) as executor:
-            processor = partial(
-                _create_tasks,
-                executor,
-                jobs,
-                func,
-                src,
-                verify,
-                move,
-            )
-            processor.add_func = func
-            _do_transfer(
-                src,
-                dest,
-                dir_ids,
-                file_ids,
-                missing_ids,
-                processor,
-                verify=verify,
-                move=move,
-                **kwargs,
-            )
-    return total
+def find_tree_by_obj_id(
+    odbs: Iterable[Optional["ObjectDB"]], obj_id: "HashInfo"
+) -> Optional["Tree"]:
+    from .errors import ObjectFormatError
+    from .tree import Tree
 
-
-def _create_tasks(executor, jobs, func, src, verify, move, obj_ids):
-    fails = 0
-    hash_iter = iter(obj_ids)
-
-    def submit(hash_info):
-        obj = src.get(hash_info)
-        return executor.submit(
-            func,
-            obj.path_info,
-            obj.fs,
-            obj.hash_info,
-            verify=verify,
-            move=move,
-        )
-
-    def create_taskset(amount):
-        return {
-            submit(hash_info)
-            for hash_info in itertools.islice(hash_iter, 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
+    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",
-    dir_ids: Iterable["HashInfo"],
-    file_ids: Iterable["HashInfo"],
+    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,
+    **kwargs: Any,
 ):
     from dvc.exceptions import FileTransferError
-    from dvc.objects.errors import ObjectFormatError
 
+    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:
-        from .tree import Tree
-
-        bound_file_ids = set()
-        dir_obj: Optional["Tree"] = None
-        for odb in (cache_odb, src):
-            if odb is not None:
-                try:
-                    dir_obj = Tree.load(odb, dir_hash)
-                    break
-                except (FileNotFoundError, ObjectFormatError):
-                    pass
+        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
 
-        for file_hash in all_file_ids.copy():
-            if file_hash in entry_ids:
-                bound_file_ids.add(file_hash)
-                all_file_ids.remove(file_hash)
-
-        dir_fails = processor(bound_file_ids)
+        dir_fails = sum(processor(bound_file_ids))
         if dir_fails:
             logger.debug(
                 "failed to upload full contents of '%s', "
@@ -164,19 +102,13 @@ def _do_transfer(
                 dir_obj.name,
             )
         else:
-            raw_obj = src.get(dir_obj.hash_info)
-            is_dir_failed = processor.add_func(  # type: ignore[attr-defined]
-                raw_obj.path_info,
-                raw_obj.fs,
-                raw_obj.hash_info,
-                **kwargs,
-            )
+            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 += processor(all_file_ids)
+    total_fails += sum(processor(all_file_ids))
     if total_fails:
         if src_index:
             src_index.clear()
@@ -222,18 +154,19 @@ def transfer(
     if not status.new:
         return 0
 
-    dir_ids, file_ids = split(lambda hash_info: hash_info.isdir, status.new)
-    if jobs is None:
-        jobs = dest.fs.jobs
+    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
+        )
 
-    return _transfer(
-        src,
-        dest,
-        set(dir_ids),
-        set(file_ids),
-        status.missing,
-        jobs,
-        verify,
-        move,
-        **kwargs,
-    )
+    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/output.py

@@ -849,8 +849,9 @@ class Output:
         try:
             objects.check(self.odb, obj)
         except FileNotFoundError:
-            remote = self.repo.cloud.get_remote_odb(self.remote)
-            self.repo.cloud.pull([obj.hash_info], odb=remote, **kwargs)
+            if self.remote:
+                kwargs["remote"] = self.remote
+            self.repo.cloud.pull([obj.hash_info], **kwargs)
 
         if self.obj:
             return self.obj

dvc/progress.py

@@ -1,5 +1,4 @@
 """Manages progress bars for DVC repo."""
-
 import logging
 import sys
 from threading import RLock
@@ -182,9 +181,38 @@ class FsspecCallback(fsspec.Callback):
             size = self.fs.info(self.path_info)["size"]
         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/render/utils.py

@@ -1,48 +1,28 @@
 import os.path
-from typing import Dict, List, Set
+from typing import Dict, List
+
+import dpath
 
 
-def get_files(data: Dict) -> Set:
+def get_files(data: Dict) -> List:
     files = set()
     for rev in data.keys():
         for file in data[rev].get("data", {}).keys():
             files.add(file)
-    return files
+    sorted_files = sorted(files)
+    return sorted_files
 
 
 def group_by_filename(plots_data: Dict) -> List[Dict]:
-    # TODO use dpath.util.search once
-    #  https://github.com/dpath-maintainers/dpath-python/issues/147 is released
-    #  now cannot search when errors are present in data
     files = get_files(plots_data)
     grouped = []
-
     for file in files:
-        tmp: Dict = {}
-        for revision, revision_data in plots_data.items():
-            if file in revision_data.get("data", {}):
-                if "data" not in tmp:
-                    tmp[revision] = {"data": {}}
-                tmp[revision]["data"].update(
-                    {file: revision_data["data"][file]}
-                )
-        grouped.append(tmp)
-
+        grouped.append(dpath.util.search(plots_data, ["*", "*", file]))
     return grouped
 
 
 def find_vega(repo, plots_data, target):
-    # TODO same as group_by_filename
-    grouped = group_by_filename(plots_data)
-    found = None
-    for plot_group in grouped:
-        files = get_files(plot_group)
-        assert len(files) == 1
-        file = files.pop()
-        if file == target:
-            found = plot_group
-            break
-
+    found = dpath.util.search(plots_data, ["*", "*", target])
     from dvc.render.vega import VegaRenderer
 
     if found and VegaRenderer.matches(found):

dvc/repo/diff.py

@@ -4,7 +4,6 @@ from collections import defaultdict
 from typing import Dict, List
 
 from dvc.exceptions import PathMissingError
-from dvc.objects.stage import get_file_hash
 from dvc.repo import locked
 from dvc.repo.experiments.utils import fix_exp_head
 
@@ -45,7 +44,7 @@ def diff(self, a_rev="HEAD", b_rev=None, targets=None):
                 repo_fs, targets
             )
 
-        results[rev] = _paths_checksums(self, repo_fs, targets_path_infos)
+        results[rev] = _paths_checksums(self, targets_path_infos)
 
     if targets is not None:
         # check for overlapping missing targets between a_rev and b_rev
@@ -98,7 +97,7 @@ def diff(self, a_rev="HEAD", b_rev=None, targets=None):
     return ret if any(ret.values()) else {}
 
 
-def _paths_checksums(repo, repo_fs, targets):
+def _paths_checksums(repo, targets):
     """
     A dictionary of checksums addressed by relpaths collected from
     the current fs outputs.
@@ -110,10 +109,10 @@ def _paths_checksums(repo, repo_fs, targets):
         file:      "data"
     """
 
-    return dict(_output_paths(repo, repo_fs, targets))
+    return dict(_output_paths(repo, targets))
 
 
-def _output_paths(repo, repo_fs, targets):
+def _output_paths(repo, targets):
     from dvc.fs.local import LocalFileSystem
     from dvc.objects.stage import stage as ostage
 
@@ -131,45 +130,47 @@ def _output_paths(repo, repo_fs, targets):
             else os.path.join(str(output), "")
         )
 
-    def _to_checksum(output):
-        if on_working_fs:
-            return ostage(
-                repo.odb.local,
-                output.path_info,
-                repo.odb.local.fs,
-                "md5",
-                dry_run=True,
-            )[1].hash_info.value
-        return output.hash_info.value
-
     for output in repo.index.outs:
         if _exists(output):
             yield_output = targets is None or any(
                 output.path_info.isin_or_eq(target) for target in targets
             )
 
+            if on_working_fs:
+                _, obj = ostage(
+                    repo.odb.local,
+                    output.path_info,
+                    repo.odb.local.fs,
+                    "md5",
+                    dry_run=True,
+                    dvcignore=output.dvcignore,
+                )
+                hash_info = obj.hash_info
+            else:
+                hash_info = output.hash_info
+                obj = output.get_obj()
+
             if yield_output:
-                yield _to_path(output), _to_checksum(output)
+                yield _to_path(output), hash_info.value
+
+            if not obj:
+                continue
 
             if output.is_dir_checksum and (
                 yield_output
                 or any(target.isin(output.path_info) for target in targets)
             ):
-                yield from _dir_output_paths(repo_fs, output, targets)
+                yield from _dir_output_paths(output.path_info, obj, targets)
 
 
-def _dir_output_paths(repo_fs, output, targets=None):
-    from dvc.config import NoRemoteError
-
-    try:
-        for fname in repo_fs.walk_files(output.path_info):
-            if targets is None or any(
-                fname.isin_or_eq(target) for target in targets
-            ):
-                # pylint: disable=no-member
-                yield str(fname), get_file_hash(fname, repo_fs, "md5").value
-    except NoRemoteError:
-        logger.warning("dir cache entry for '%s' is missing", output)
+def _dir_output_paths(path_info, obj, targets=None):
+    for key, entry_obj in obj:
+        fname = path_info.joinpath(*key)
+        if targets is None or any(
+            fname.isin_or_eq(target) for target in targets
+        ):
+            # pylint: disable=no-member
+            yield str(fname), entry_obj.hash_info.value
 
 
 def _filter_missing(repo_fs, paths):

dvc/scm/base.py

@@ -47,6 +47,15 @@ class InvalidRemoteSCMRepo(SCMError):
         super().__init__(msg)
 
 
+class GitAuthError(SCMError):
+    def __init__(self, url: str):
+        super().__init__(
+            f"HTTP Git authentication is not supported: '{url}'"
+            "\nSee https://dvc.org/doc//user-guide/"
+            "troubleshooting#git-auth"
+        )
+
+
 class Base:
     """Base class for source control management driver implementations."""
 

dvc/scm/git/backend/dulwich.py

@@ -20,7 +20,7 @@ from funcy import cached_property
 
 from dvc.path_info import PathInfo
 from dvc.progress import Tqdm
-from dvc.scm.base import InvalidRemoteSCMRepo, SCMError
+from dvc.scm.base import GitAuthError, InvalidRemoteSCMRepo, SCMError
 from dvc.utils import relpath
 
 from ..objects import GitObject
@@ -355,7 +355,7 @@ class DulwichBackend(BaseGitBackend):  # pylint:disable=abstract-method
                 yield os.fsdecode(key)
 
     def iter_remote_refs(self, url: str, base: Optional[str] = None):
-        from dulwich.client import get_transport_and_path
+        from dulwich.client import HTTPUnauthorized, get_transport_and_path
         from dulwich.errors import NotGitRepository
         from dulwich.porcelain import get_remote_repo
 
@@ -376,6 +376,8 @@ class DulwichBackend(BaseGitBackend):  # pylint:disable=abstract-method
                 yield from (os.fsdecode(ref) for ref in client.get_refs(path))
         except NotGitRepository as exc:
             raise InvalidRemoteSCMRepo(url) from exc
+        except HTTPUnauthorized:
+            raise GitAuthError(url)
 
     def get_refs_containing(self, rev: str, pattern: Optional[str] = None):
         raise NotImplementedError
@@ -388,7 +390,7 @@ class DulwichBackend(BaseGitBackend):  # pylint:disable=abstract-method
         force: bool = False,
         on_diverged: Optional[Callable[[str, str], bool]] = None,
     ):
-        from dulwich.client import get_transport_and_path
+        from dulwich.client import HTTPUnauthorized, get_transport_and_path
         from dulwich.errors import NotGitRepository, SendPackError
         from dulwich.porcelain import (
             DivergedBranches,
@@ -447,6 +449,8 @@ class DulwichBackend(BaseGitBackend):  # pylint:disable=abstract-method
                 )
         except (NotGitRepository, SendPackError) as exc:
             raise SCMError("Git failed to push '{src}' to '{url}'") from exc
+        except HTTPUnauthorized:
+            raise GitAuthError(url)
 
     def _push_dest_refs(
         self, src: Optional[str], dest: str

dvc/state.py

@@ -53,7 +53,6 @@ class State(StateBase):  # pylint: disable=too-many-instance-attributes
         self.tmp_dir = tmp_dir
         self.root_dir = root_dir
         self.dvcignore = dvcignore
-        self.fs = LocalFileSystem()
 
         if not tmp_dir:
             return
@@ -85,7 +84,7 @@ class State(StateBase):  # pylint: disable=too-many-instance-attributes
         assert isinstance(hash_info, HashInfo)
         assert os.path.exists(path_info)
 
-        mtime, size = get_mtime_and_size(path_info, self.fs, self.dvcignore)
+        mtime, size = get_mtime_and_size(path_info, fs, self.dvcignore)
         inode = get_inode(path_info)
 
         logger.debug(
@@ -121,7 +120,7 @@ class State(StateBase):  # pylint: disable=too-many-instance-attributes
         if not os.path.exists(path):
             return None
 
-        mtime, size = get_mtime_and_size(path, self.fs, self.dvcignore)
+        mtime, size = get_mtime_and_size(path, fs, self.dvcignore)
         inode = get_inode(path)
 
         value = self.md5s.get(inode)
@@ -143,10 +142,10 @@ class State(StateBase):  # pylint: disable=too-many-instance-attributes
 
         assert isinstance(path_info, str) or path_info.scheme == "local"
 
-        if not self.fs.exists(path_info):
+        if not fs.exists(path_info):
             return
 
-        mtime, _ = get_mtime_and_size(path_info, self.fs, self.dvcignore)
+        mtime, _ = get_mtime_and_size(path_info, fs, self.dvcignore)
         inode = get_inode(path_info)
         relative_path = relpath(path_info, self.root_dir)
 
@@ -168,11 +167,11 @@ class State(StateBase):  # pylint: disable=too-many-instance-attributes
             for relative_path in ref:
                 path = os.path.join(self.root_dir, relative_path)
 
-                if path in used or not self.fs.exists(path):
+                if path in used or not fs.exists(path):
                     continue
 
                 inode = get_inode(path)
-                mtime, _ = get_mtime_and_size(path, self.fs, self.dvcignore)
+                mtime, _ = get_mtime_and_size(path, fs, self.dvcignore)
 
                 if ref[relative_path] == (inode, mtime):
                     logger.debug("Removing '%s' as unused link.", path)

dvc/utils/fs.py

@@ -193,33 +193,39 @@ def makedirs(path, exist_ok=False, mode=None):
         logger.trace("failed to chmod '%o' '%s'", mode, path, exc_info=True)
 
 
-def copyfile(src, dest, no_progress_bar=False, name=None):
+def copyfile(src, dest, callback=None, no_progress_bar=False, name=None):
     """Copy file with progress bar"""
-    from dvc.progress import Tqdm
-
     name = name if name else os.path.basename(dest)
     total = os.stat(src).st_size
 
     if os.path.isdir(dest):
         dest = os.path.join(dest, os.path.basename(src))
 
+    if callback:
+        callback.set_size(total)
+
     try:
         System.reflink(src, dest)
     except DvcException:
+        from dvc.progress import tdqm_or_callback_wrapped
+
         with open(src, "rb") as fsrc, open(dest, "wb+") as fdest:
-            with Tqdm.wrapattr(
+            with tdqm_or_callback_wrapped(
                 fdest,
                 "write",
-                desc=name,
+                total,
+                callback=callback,
                 disable=no_progress_bar,
-                total=total,
-                bytes=True,
-            ) as fdest_wrapped:
+                desc=name,
+            ) as wrapped:
                 while True:
                     buf = fsrc.read(LOCAL_CHUNK_SIZE)
                     if not buf:
                         break
-                    fdest_wrapped.write(buf)
+                    wrapped.write(buf)
+
+    if callback:
+        callback.absolute_update(total)
 
 
 def copy_fobj_to_file(fsrc, dest):

dvc/utils/serialize/__init__.py

@@ -14,6 +14,13 @@ LOADERS.update(
     {".toml": load_toml, ".json": load_json, ".py": load_py}  # noqa: F405
 )
 
+DUMPERS: DefaultDict[str, DumperFn] = defaultdict(  # noqa: F405
+    lambda: dump_yaml  # noqa: F405
+)
+DUMPERS.update(
+    {".toml": dump_toml, ".json": dump_json, ".py": dump_py}  # noqa: F405
+)
+
 MODIFIERS: DefaultDict[str, ModifierFn] = defaultdict(  # noqa: F405
     lambda: modify_yaml  # noqa: F405
 )

dvc/utils/serialize/_common.py

@@ -63,10 +63,16 @@ def _load_data(path: "AnyPath", parser: ParserFn, fs: "BaseFileSystem" = None):
             return parser(fd.read(), path)
 
 
-def _dump_data(path, data: Any, dumper: DumperFn, fs: "BaseFileSystem" = None):
+def _dump_data(
+    path,
+    data: Any,
+    dumper: DumperFn,
+    fs: "BaseFileSystem" = None,
+    **dumper_args,
+):
     open_fn = fs.open if fs else open
     with open_fn(path, "w+", encoding="utf-8") as fd:  # type: ignore
-        dumper(data, fd)
+        dumper(data, fd, **dumper_args)
 
 
 @contextmanager

dvc/utils/serialize/_json.py

@@ -19,8 +19,8 @@ def parse_json(text, path, **kwargs):
         return json.loads(text, **kwargs) or {}
 
 
-def dump_json(path, data, fs=None):
-    return _dump_data(path, data, dumper=json.dump, fs=fs)
+def dump_json(path, data, fs=None, **kwargs):
+    return _dump_data(path, data, dumper=json.dump, fs=fs, **kwargs)
 
 
 @contextmanager

dvc/utils/serialize/_toml.py

@@ -40,8 +40,8 @@ def _dump(data, stream):
     return toml.dump(data, stream, encoder=toml.TomlPreserveCommentEncoder())
 
 
-def dump_toml(path, data, fs=None):
-    return _dump_data(path, data, dumper=_dump, fs=fs)
+def dump_toml(path, data, fs=None, **kwargs):
+    return _dump_data(path, data, dumper=_dump, fs=fs, **kwargs)
 
 
 @contextmanager

dvc/utils/serialize/_yaml.py

@@ -58,8 +58,8 @@ def _dump(data, stream):
     return yaml.dump(data, stream)
 
 
-def dump_yaml(path, data, fs=None):
-    return _dump_data(path, data, dumper=_dump, fs=fs)
+def dump_yaml(path, data, fs=None, **kwargs):
+    return _dump_data(path, data, dumper=_dump, fs=fs, **kwargs)
 
 
 def loads_yaml(s, typ="safe"):

dvc/utils/threadpool.py

@@ -0,0 +1,34 @@
+from concurrent import futures
+from itertools import islice
+from typing import Any, Callable, Iterable, Iterator, Set, TypeVar
+
+_T = TypeVar("_T")
+
+
+class ThreadPoolExecutor(futures.ThreadPoolExecutor):
+    _max_workers: int
+
+    @property
+    def max_workers(self) -> int:
+        return self._max_workers
+
+    def imap_unordered(
+        self, fn: Callable[..., _T], *iterables: Iterable[Any]
+    ) -> Iterator[_T]:
+        """Lazier version of map that does not preserve ordering of results.
+
+        It does not create all the futures at once to reduce memory usage.
+        """
+
+        def create_taskset(n: int) -> Set[futures.Future]:
+            return {self.submit(fn, *args) for args in islice(it, n)}
+
+        it = zip(*iterables)
+        tasks = create_taskset(self.max_workers * 5)
+        while tasks:
+            done, tasks = futures.wait(
+                tasks, return_when=futures.FIRST_COMPLETED
+            )
+            for fut in done:
+                yield fut.result()
+            tasks.update(create_taskset(len(done)))

dvc/version.py

@@ -6,7 +6,7 @@
 import os
 import subprocess
 
-_BASE_VERSION = "2.7.0"
+_BASE_VERSION = "2.7.4"
 
 
 def _generate_version(base_version):

requirements/azure.txt

@@ -0,0 +1,3 @@
+adlfs==2021.9.1
+azure-identity>=1.4.0
+knack

requirements/default.txt

@@ -0,0 +1,46 @@
+# See https://github.com/pyinstaller/pyinstaller/issues/1945
+ply>=3.9
+colorama>=0.3.9
+configobj>=5.0.6
+gitpython>3
+dulwich>=0.20.23
+pygit2>=1.5.0
+setuptools>=34.0.0
+nanotime>=0.5.2
+pyasn1>=0.4.1
+voluptuous>=0.11.7
+requests>=2.22.0
+# See https://github.com/bdcht/grandalf/issues/26
+grandalf==0.6
+distro>=1.3.0
+appdirs>=1.4.3
+ruamel.yaml>=0.17.11
+toml>=0.10.1
+funcy>=1.14
+pathspec>=0.6.0,<0.9.0
+shortuuid>=0.5.0
+tqdm>=4.45.0,<5
+packaging>=19.0
+zc.lockfile>=1.2.1
+flufl.lock>=3.2,<4
+win-unicode-console>=0.5; sys_platform == 'win32'
+pywin32>=225; sys_platform == 'win32' and python_version < '3.10'
+networkx>=2.5
+psutil>=5.8.0
+pydot>=1.2.4
+speedcopy>=2.0.1; python_version < '3.8' and sys_platform == 'win32'
+dataclasses==0.7; python_version < '3.7'
+importlib-metadata>=1.4; python_version < '3.8'
+flatten_dict>=0.4.1,<1
+tabulate>=0.8.7
+pygtrie>=2.3.2
+dpath>=2.0.2,<3
+shtab>=1.3.4,<2
+rich>=10.0.0
+dictdiffer>=0.8.1
+python-benedict>=0.21.1
+pyparsing==2.4.7
+typing_extensions>=3.10.0.2
+fsspec[http]>=2021.8.1
+aiohttp-retry==2.4.5
+diskcache>=5.2.1

requirements/gdrive.txt

@@ -0,0 +1 @@
+pydrive2[fsspec]>=1.9.4

requirements/gs.txt

@@ -0,0 +1 @@
+gcsfs==2021.8.1

requirements/hdfs.txt

@@ -0,0 +1 @@
+pyarrow>=2.0.0; python_version < '3.10'

requirements/oss.txt

@@ -0,0 +1 @@
+ossfs==2021.8.0

requirements/s3.txt

@@ -0,0 +1,2 @@
+s3fs==2021.8.1
+aiobotocore[boto3]>1.0.1

requirements/ssh.txt

@@ -0,0 +1 @@
+sshfs>=2021.8.1

requirements/ssh_gssapi.txt

@@ -0,0 +1 @@
+sshfs[gssapi]>=2021.8.1

requirements/terraform.txt

@@ -0,0 +1 @@
+tpi[ssh]>=0.0.0

requirements/tests.txt

@@ -6,21 +6,19 @@ pytest-cov==2.12.1
 pytest-xdist==2.3.0
 pytest-mock==3.6.1
 pytest-lazy-fixture==0.6.3
-pytest-timeout==1.4.2
 pytest-docker==0.10.3
 
 flaky==3.7.0
 mock==4.0.3
 rangehttpserver==1.2.0
-mock-ssh-server==0.9.0
-beautifulsoup4==4.9.3
+mock-ssh-server==0.9.1
 wget==3.2
 filelock==3.0.12
 wsgidav==3.1.1
 crc32c==2.2.post0
 xmltodict==0.12.0
 google-compute-engine==2.8.13
-google-cloud-storage==1.42.0
+google-cloud-storage==1.42.1
 urllib3==1.26.6
 dvclive>=0.2.1
 

requirements/webdav.txt

@@ -0,0 +1 @@
+webdav4>=0.9.1

requirements/webhdfs.txt

@@ -0,0 +1 @@
+hdfs==2.6.0

scripts/pyinstaller/hooks/hook-dvc.py

@@ -14,6 +14,8 @@ datas += copy_metadata("boto3")
 datas += copy_metadata("ossfs")
 datas += copy_metadata("sshfs")
 datas += copy_metadata("webdav4")
+datas += copy_metadata("aiohttp")
+datas += copy_metadata("aiohttp_retry")
 
 # https://github.com/pypa/setuptools/issues/1963
 hiddenimports = ["pkg_resources.py2_warn"]

setup.cfg

@@ -17,8 +17,6 @@ known_first_party=dvc,tests
 line_length=79
 
 [tool:pytest]
-timeout = 600
-timeout_method = thread
 log_level = debug
 addopts = -ra
 markers =

setup.py

@@ -46,79 +46,25 @@ class build_py(_build_py):
         _build_py.run(self)
 
 
-install_requires = [
-    "ply>=3.9",  # See https://github.com/pyinstaller/pyinstaller/issues/1945
-    "colorama>=0.3.9",
-    "configobj>=5.0.6",
-    "gitpython>3",
-    "dulwich>=0.20.23",
-    "pygit2>=1.5.0",
-    "setuptools>=34.0.0",
-    "nanotime>=0.5.2",
-    "pyasn1>=0.4.1",
-    "voluptuous>=0.11.7",
-    "requests>=2.22.0",
-    "grandalf==0.6",
-    "distro>=1.3.0",
-    "appdirs>=1.4.3",
-    "ruamel.yaml>=0.17.11",
-    "toml>=0.10.1",
-    "funcy>=1.14",
-    "pathspec>=0.6.0,<0.9.0",
-    "shortuuid>=0.5.0",
-    "tqdm>=4.45.0,<5",
-    "packaging>=19.0",
-    "zc.lockfile>=1.2.1",
-    "flufl.lock>=3.2,<4",
-    "win-unicode-console>=0.5; sys_platform == 'win32'",
-    "pywin32>=225; sys_platform == 'win32' and python_version < '3.10'",
-    "networkx>=2.5",
-    "psutil>=5.8.0",
-    "pydot>=1.2.4",
-    "speedcopy>=2.0.1; python_version < '3.8' and sys_platform == 'win32'",
-    "dataclasses==0.7; python_version < '3.7'",
-    "importlib-metadata>=1.4; python_version < '3.8'",
-    "flatten_dict>=0.4.1,<1",
-    "tabulate>=0.8.7",
-    "pygtrie>=2.3.2",
-    "dpath>=2.0.1,<3",
-    "shtab>=1.3.4,<2",
-    "rich>=10.0.0",
-    "dictdiffer>=0.8.1",
-    "python-benedict>=0.21.1",
-    "pyparsing==2.4.7",
-    "typing_extensions>=3.7.4; python_version < '3.10'",
-    # until https://github.com/python/typing/issues/865 is fixed for python3.10
-    "typing_extensions==3.10.0.0; python_version >= '3.10'",
-    "fsspec>=2021.8.1",
-    "diskcache>=5.2.1",
-]
-
-
 # Extra dependencies for remote integrations
+requirements = {
+    path.stem: path.read_text().strip().splitlines()
+    for path in Path("requirements").glob("*.txt")
+}
 
-gs = ["gcsfs==2021.8.1"]
-gdrive = ["pydrive2[fsspec]>=1.9.2"]
-s3 = ["s3fs==2021.8.1", "aiobotocore[boto3]>1.0.1"]
-azure = ["adlfs==2021.8.2", "azure-identity>=1.4.0", "knack"]
-oss = ["ossfs==2021.8.0"]
-ssh = ["sshfs>=2021.8.1"]
-
-hdfs = ["pyarrow>=2.0.0; python_version < '3.10'"]
-webhdfs = ["hdfs==2.5.8"]
-webdav = ["webdav4>=0.9.0"]
 # gssapi should not be included in all_remotes, because it doesn't have wheels
 # for linux and mac, so it will fail to compile if user doesn't have all the
 # requirements, including kerberos itself. Once all the wheels are available,
 # we can start shipping it by default.
-ssh_gssapi = ["sshfs[gssapi]>=2021.8.1"]
-all_remotes = gs + s3 + azure + ssh + oss + gdrive + hdfs + webhdfs + webdav
 
-terraform = ["tpi[ssh]>=0.0.0"]
-
-tests_requirements = (
-    Path("test_requirements.txt").read_text().strip().splitlines()
-) + terraform
+install_requires = requirements.pop("default")
+requirements["all"] = [
+    requirements
+    for key, requirements in requirements.items()
+    if key not in ("tests", "ssh_gssapi", "terraform")
+]
+requirements["tests"] += requirements["terraform"]
+requirements["dev"] = requirements["all"] + requirements["tests"]
 
 setup(
     name="dvc",
@@ -132,21 +78,7 @@ setup(
     download_url="https://github.com/iterative/dvc",
     license="Apache License 2.0",
     install_requires=install_requires,
-    extras_require={
-        "all": all_remotes,
-        "gs": gs,
-        "gdrive": gdrive,
-        "s3": s3,
-        "azure": azure,
-        "oss": oss,
-        "ssh": ssh,
-        "ssh_gssapi": ssh_gssapi,
-        "hdfs": hdfs,
-        "webhdfs": webhdfs,
-        "webdav": webdav,
-        "terraform": terraform,
-        "tests": tests_requirements,
-    },
+    extras_require=requirements,
     keywords="data-science data-version-control machine-learning git"
     " developer-tools reproducibility collaboration ai",
     python_requires=">=3.6",

tests/conftest.py

@@ -5,6 +5,7 @@ import pytest
 
 from .dir_helpers import *  # noqa, pylint: disable=wildcard-import
 from .remotes import *  # noqa, pylint: disable=wildcard-import
+from .utils.scriptify import scriptify
 
 # Prevent updater and analytics from running their processes
 os.environ["DVC_TEST"] = "true"
@@ -164,3 +165,6 @@ def custom_template(tmp_dir, dvc):
     template = tmp_dir / "custom_template.json"
     shutil.copy(tmp_dir / ".dvc" / "plots" / "default.json", template)
     return template
+
+
+scriptify_fixture = pytest.fixture(lambda: scriptify, name="scriptify")

tests/dir_helpers.py

@@ -49,12 +49,14 @@ import os
 import pathlib
 import sys
 from contextlib import contextmanager
+from functools import partialmethod
 from textwrap import dedent
 
 import pytest
 from funcy import lmap, retry
 
 from dvc.logger import disable_other_loggers
+from dvc.utils import serialize
 from dvc.utils.fs import makedirs
 
 __all__ = [
@@ -250,6 +252,22 @@ class TmpDir(pathlib.Path):
     def hash_to_path_info(self, hash_):
         return self / hash_[0:2] / hash_[2:]
 
+    def dump(self, *args, **kwargs):
+        return serialize.DUMPERS[self.suffix](self, *args, **kwargs)
+
+    def parse(self, *args, **kwargs):
+        return serialize.LOADERS[self.suffix](self, *args, **kwargs)
+
+    def modify(self, *args, **kwargs):
+        return serialize.MODIFIERS[self.suffix](self, *args, **kwargs)
+
+    load_yaml = partialmethod(serialize.load_yaml)
+    dump_yaml = partialmethod(serialize.dump_yaml)
+    load_json = partialmethod(serialize.load_json)
+    dump_json = partialmethod(serialize.dump_json)
+    load_toml = partialmethod(serialize.load_toml)
+    dump_toml = partialmethod(serialize.dump_toml)
+
 
 def _coerce_filenames(filenames):
     if isinstance(filenames, (str, bytes, pathlib.PurePath)):

tests/func/experiments/conftest.py

@@ -88,3 +88,17 @@ def checkpoint_stage(tmp_dir, scm, dvc, mocker):
     scm.commit("init")
     stage.iterations = DEFAULT_ITERATIONS
     return stage
+
+
+@pytest.fixture
+def http_auth_patch(mocker):
+    from dulwich.client import HTTPUnauthorized
+
+    url = "https://0.0.0.0"
+    client = mocker.MagicMock()
+    client.get_refs.side_effect = HTTPUnauthorized("", url)
+    client.send_pack.side_effect = HTTPUnauthorized("", url)
+
+    patch = mocker.patch("dulwich.client.get_transport_and_path")
+    patch.return_value = (client, url)
+    return url

tests/func/experiments/test_experiments.py

@@ -8,7 +8,7 @@ from funcy import first
 
 from dvc.dvcfile import PIPELINE_FILE
 from dvc.repo.experiments.utils import exp_refs_by_rev
-from dvc.utils.serialize import PythonFileCorruptedError, load_yaml
+from dvc.utils.serialize import PythonFileCorruptedError
 from tests.func.test_repro_multistage import COPY_SCRIPT
 
 
@@ -660,9 +660,9 @@ def test_modified_data_dep(tmp_dir, scm, dvc, workspace, params, target):
 
 
 def test_exp_run_recursive(tmp_dir, scm, dvc, run_copy_metrics):
-    tmp_dir.dvc_gen("metric_t.json", "foo: 1")
+    tmp_dir.dvc_gen("metric_t.json", '{"foo": 1}')
     run_copy_metrics(
         "metric_t.json", "metric.json", metrics=["metric.json"], no_exec=True
     )
     assert dvc.experiments.run(".", recursive=True)
-    assert load_yaml(tmp_dir / "metric.json") == {"foo": 1}
+    assert (tmp_dir / "metric.json").parse() == {"foo": 1}

tests/func/experiments/test_init.py

@@ -0,0 +1,34 @@
+import os
+
+from dvc.command.experiments import CmdExperimentsInit
+from dvc.main import main
+from dvc.utils.serialize import load_yaml
+
+
+def test_init(tmp_dir, dvc):
+    tmp_dir.gen(
+        {
+            CmdExperimentsInit.CODE: {"copy.py": ""},
+            "data": "data",
+            "params.yaml": '{"foo": 1}',
+            "dvclive": {},
+            "plots": {},
+        }
+    )
+    code_path = os.path.join(CmdExperimentsInit.CODE, "copy.py")
+    script = f"python {code_path}"
+
+    assert main(["exp", "init", script]) == 0
+    assert load_yaml(tmp_dir / "dvc.yaml") == {
+        "stages": {
+            "default": {
+                "cmd": script,
+                "deps": ["data", "src"],
+                "live": {"dvclive": {"html": True, "summary": True}},
+                "metrics": [{"metrics.json": {"cache": False}}],
+                "outs": ["models"],
+                "params": ["foo"],
+                "plots": [{"plots": {"cache": False}}],
+            }
+        }
+    }

tests/func/experiments/test_remote.py

@@ -252,3 +252,37 @@ def test_push_pull_cache(
         path = os.path.join(dvc.odb.local.cache_dir, hash_[:2], hash_[2:])
         assert os.path.exists(path)
         assert open(path).read() == str(x)
+
+
+def test_auth_error_list(tmp_dir, scm, dvc, http_auth_patch):
+    from dvc.scm.base import GitAuthError
+
+    with pytest.raises(
+        GitAuthError,
+        match=f"HTTP Git authentication is not supported: '{http_auth_patch}'",
+    ):
+        dvc.experiments.ls(git_remote=http_auth_patch)
+
+
+def test_auth_error_pull(tmp_dir, scm, dvc, http_auth_patch):
+    from dvc.scm.base import GitAuthError
+
+    with pytest.raises(
+        GitAuthError,
+        match=f"HTTP Git authentication is not supported: '{http_auth_patch}'",
+    ):
+        dvc.experiments.pull(http_auth_patch, "foo")
+
+
+def test_auth_error_push(tmp_dir, scm, dvc, exp_stage, http_auth_patch):
+    from dvc.scm.base import GitAuthError
+
+    results = dvc.experiments.run(exp_stage.addressing, params=["foo=2"])
+    exp = first(results)
+    ref_info = first(exp_refs_by_rev(scm, exp))
+
+    with pytest.raises(
+        GitAuthError,
+        match=f"HTTP Git authentication is not supported: '{http_auth_patch}'",
+    ):
+        dvc.experiments.push(http_auth_patch, ref_info.name)

tests/func/experiments/test_show.py

@@ -9,8 +9,9 @@ from dvc.exceptions import InvalidArgumentError
 from dvc.main import main
 from dvc.repo.experiments.base import EXPS_STASH, ExpRefInfo
 from dvc.repo.experiments.executor.base import BaseExecutor, ExecutorInfo
+from dvc.repo.experiments.utils import exp_refs_by_rev
 from dvc.utils.fs import makedirs
-from dvc.utils.serialize import YAMLFileCorruptedError, dump_yaml
+from dvc.utils.serialize import YAMLFileCorruptedError
 from tests.func.test_repro_multistage import COPY_SCRIPT
 
 
@@ -269,6 +270,10 @@ def test_show_filter(
     included,
     excluded,
 ):
+    from contextlib import contextmanager
+
+    from dvc.ui import ui
+
     capsys.readouterr()
     div = "│" if os.name == "nt" else "┃"
 
@@ -281,7 +286,7 @@ def test_show_filter(
         "train/bar": 1,
         "nested": {"foo": 1, "bar": 1},
     }
-    dump_yaml(params_file, params_data)
+    (tmp_dir / params_file).dump(params_data)
 
     dvc.run(
         cmd="python copy.py params.yaml metrics.yaml",
@@ -312,13 +317,30 @@ def test_show_filter(
     if e_params is not None:
         command.append(f"--exclude-params={e_params}")
 
-    assert main(command) == 0
+    @contextmanager
+    def console_with(console, width):
+        console_options = console.options
+        original = console_options.max_width
+        con_width = console._width
+
+        try:
+            console_options.max_width = width
+            console._width = width
+            yield
+        finally:
+            console_options.max_width = original
+            console._width = con_width
+
+    with console_with(ui.rich_console, 255):
+        assert main(command) == 0
     cap = capsys.readouterr()
 
     for i in included:
-        assert f"{div} {i} {div}" in cap.out
+        assert f"{div} params.yaml:{i} {div}" in cap.out
+        assert f"{div} metrics.yaml:{i} {div}" in cap.out
     for e in excluded:
-        assert f"{div} {e} {div}" not in cap.out
+        assert f"{div} params.yaml:{e} {div}" not in cap.out
+        assert f"{div} metrics.yaml:{e} {div}" not in cap.out
 
 
 def test_show_multiple_commits(tmp_dir, scm, dvc, exp_stage):
@@ -364,7 +386,7 @@ def test_show_running_workspace(tmp_dir, scm, dvc, exp_stage, capsys):
     makedirs(pid_dir, True)
     info = ExecutorInfo(None, None, None, BaseExecutor.DEFAULT_LOCATION)
     pidfile = os.path.join(pid_dir, f"workspace{BaseExecutor.PIDFILE_EXT}")
-    dump_yaml(pidfile, info.to_dict())
+    (tmp_dir / pidfile).dump(info.to_dict())
 
     assert dvc.experiments.show()["workspace"] == {
         "baseline": {
@@ -395,7 +417,7 @@ def test_show_running_executor(tmp_dir, scm, dvc, exp_stage):
     makedirs(pid_dir, True)
     info = ExecutorInfo(None, None, None, BaseExecutor.DEFAULT_LOCATION)
     pidfile = os.path.join(pid_dir, f"{exp_rev}{BaseExecutor.PIDFILE_EXT}")
-    dump_yaml(pidfile, info.to_dict())
+    (tmp_dir / pidfile).dump(info.to_dict())
 
     results = dvc.experiments.show()
     exp_data = get_in(results, [baseline_rev, exp_rev, "data"])
@@ -412,7 +434,6 @@ def test_show_running_checkpoint(
 ):
     from dvc.repo.experiments.base import EXEC_BRANCH
     from dvc.repo.experiments.executor.local import TempDirExecutor
-    from dvc.repo.experiments.utils import exp_refs_by_rev
 
     baseline_rev = scm.get_rev()
     dvc.experiments.run(
@@ -434,7 +455,7 @@ def test_show_running_checkpoint(
     info = ExecutorInfo(123, "foo.git", baseline_rev, executor)
     rev = "workspace" if workspace else stash_rev
     pidfile = os.path.join(pid_dir, f"{rev}{BaseExecutor.PIDFILE_EXT}")
-    dump_yaml(pidfile, info.to_dict())
+    (tmp_dir / pidfile).dump(info.to_dict())
 
     mocker.patch.object(
         BaseExecutor, "fetch_exps", return_value=[str(exp_ref)]
@@ -471,3 +492,49 @@ def test_show_with_broken_repo(tmp_dir, scm, dvc, exp_stage, caplog):
 
     paths = ["workspace", "baseline", "error"]
     assert isinstance(get_in(result, paths), YAMLFileCorruptedError)
+
+
+def test_show_csv(tmp_dir, scm, dvc, exp_stage, capsys):
+    import time
+
+    baseline_rev = scm.get_rev()
+
+    def _get_rev_isotimestamp(rev):
+        return datetime.fromtimestamp(
+            scm.gitpython.repo.rev_parse(rev).committed_date
+        ).isoformat()
+
+    result1 = dvc.experiments.run(exp_stage.addressing, params=["foo=2"])
+    rev1 = first(result1)
+    ref_info1 = first(exp_refs_by_rev(scm, rev1))
+    time.sleep(1)
+    result2 = dvc.experiments.run(exp_stage.addressing, params=["foo=3"])
+    rev2 = first(result2)
+    ref_info2 = first(exp_refs_by_rev(scm, rev2))
+
+    capsys.readouterr()
+    assert main(["exp", "show", "--show-csv"]) == 0
+    cap = capsys.readouterr()
+    assert (
+        "Experiment,rev,typ,Created,parent,metrics.yaml:foo,params.yaml:foo"
+        in cap.out
+    )
+    assert ",workspace,baseline,,,3,3" in cap.out
+    assert (
+        "master,{},baseline,{},,1,1".format(
+            baseline_rev[:7], _get_rev_isotimestamp(baseline_rev)
+        )
+        in cap.out
+    )
+    assert (
+        "{},{},branch_base,{},,2,2".format(
+            ref_info1.name, rev1[:7], _get_rev_isotimestamp(rev1)
+        )
+        in cap.out
+    )
+    assert (
+        "{},{},branch_commit,{},,3,3".format(
+            ref_info2.name, rev2[:7], _get_rev_isotimestamp(rev2)
+        )
+        in cap.out
+    )

tests/func/machine/test_machine_config.py

@@ -0,0 +1,123 @@
+import os
+import textwrap
+
+import pytest
+
+from dvc.main import main
+
+CONFIG_TEXT = textwrap.dedent(
+    """\
+        [feature]
+            machine = true
+        ['machine \"foo\"']
+            cloud = aws
+    """
+)
+
+
+@pytest.mark.parametrize(
+    "slot,value",
+    [
+        ("region", "us-west"),
+        ("image", "iterative-cml"),
+        ("name", "iterative_test"),
+        ("spot", "True"),
+        ("spot_price", "1.2345"),
+        ("spot_price", "12345"),
+        ("instance_hdd_size", "10"),
+        ("instance_type", "l"),
+        ("instance_gpu", "tesla"),
+        ("ssh_private", "secret"),
+    ],
+)
+def test_machine_modify_susccess(tmp_dir, dvc, slot, value):
+    (tmp_dir / ".dvc" / "config").write_text(CONFIG_TEXT)
+    assert main(["machine", "modify", "foo", slot, value]) == 0
+    assert (
+        tmp_dir / ".dvc" / "config"
+    ).read_text() == CONFIG_TEXT + f"    {slot} = {value}\n"
+    assert main(["machine", "modify", "--unset", "foo", slot]) == 0
+    assert (tmp_dir / ".dvc" / "config").read_text() == CONFIG_TEXT
+
+
+def test_machine_modify_startup_script(tmp_dir, dvc):
+    slot, value = "startup_script", "start.sh"
+    (tmp_dir / ".dvc" / "config").write_text(CONFIG_TEXT)
+    assert main(["machine", "modify", "foo", slot, value]) == 0
+    assert (
+        tmp_dir / ".dvc" / "config"
+    ).read_text() == CONFIG_TEXT + f"    {slot} = ../{value}\n"
+    assert main(["machine", "modify", "--unset", "foo", slot]) == 0
+    assert (tmp_dir / ".dvc" / "config").read_text() == CONFIG_TEXT
+
+
+@pytest.mark.parametrize(
+    "slot,value,msg",
+    [
+        (
+            "region",
+            "other-west",
+            "expected one of us-west, us-east, eu-west, eu-north",
+        ),
+        ("spot_price", "NUM", "expected float"),
+        ("instance_hdd_size", "BIG", "expected int"),
+    ],
+)
+def test_machine_modify_fail(tmp_dir, dvc, caplog, slot, value, msg):
+    (tmp_dir / ".dvc" / "config").write_text(CONFIG_TEXT)
+
+    assert main(["machine", "modify", "foo", slot, value]) == 251
+    assert (tmp_dir / ".dvc" / "config").read_text() == CONFIG_TEXT
+    assert msg in caplog.text
+
+
+FULL_CONFIG_TEXT = textwrap.dedent(
+    """\
+        [feature]
+            machine = true
+        ['machine \"bar\"']
+            cloud = azure
+        ['machine \"foo\"']
+            cloud = aws
+            region = us-west
+            image = iterative-cml
+            name = iterative_test
+            spot = True
+            spot_price = 1.2345
+            instance_hdd_size = 10
+            instance_type = l
+            instance_gpu = tesla
+            ssh_private = secret
+            startup_script = {}
+    """.format(
+        os.path.join("..", "start.sh")
+    )
+)
+
+
+def test_machine_list(tmp_dir, dvc, capsys):
+    (tmp_dir / ".dvc" / "config").write_text(FULL_CONFIG_TEXT)
+
+    assert main(["machine", "list"]) == 0
+    cap = capsys.readouterr()
+    assert "cloud=azure" in cap.out
+
+    assert main(["machine", "list", "foo"]) == 0
+    cap = capsys.readouterr()
+    assert "cloud=azure" not in cap.out
+    assert "cloud=aws" in cap.out
+    assert "region=us-west" in cap.out
+    assert "image=iterative-cml" in cap.out
+    assert "name=iterative_test" in cap.out
+    assert "spot=True" in cap.out
+    assert "spot_price=1.2345" in cap.out
+    assert "instance_hdd_size=10" in cap.out
+    assert "instance_type=l" in cap.out
+    assert "instance_gpu=tesla" in cap.out
+    assert "ssh_private=secret" in cap.out
+    assert (
+        "startup_script={}".format(
+            os.path.join(tmp_dir, ".dvc", "..", "start.sh")
+        )
+        in cap.out
+    )

tests/func/metrics/test_diff.py

@@ -1,7 +1,6 @@
 import json
 
 from dvc.main import main
-from dvc.utils.serialize import dump_yaml
 
 
 def test_metrics_diff_simple(tmp_dir, scm, dvc, run_copy_metrics):
@@ -22,7 +21,7 @@ def test_metrics_diff_simple(tmp_dir, scm, dvc, run_copy_metrics):
 def test_metrics_diff_yaml(tmp_dir, scm, dvc, run_copy_metrics):
     def _gen(val):
         metrics = {"a": {"b": {"c": val, "d": 1, "e": str(val)}}}
-        dump_yaml("m_temp.yaml", metrics)
+        (tmp_dir / "m_temp.yaml").dump(metrics)
         run_copy_metrics(
             "m_temp.yaml", "m.yaml", metrics=["m.yaml"], commit=str(val)
         )
@@ -39,7 +38,7 @@ def test_metrics_diff_yaml(tmp_dir, scm, dvc, run_copy_metrics):
 def test_metrics_diff_json(tmp_dir, scm, dvc, run_copy_metrics):
     def _gen(val):
         metrics = {"a": {"b": {"c": val, "d": 1, "e": str(val)}}}
-        tmp_dir.gen({"m_temp.json": json.dumps(metrics)})
+        (tmp_dir / "m_temp.json").dump(metrics)
         run_copy_metrics(
             "m_temp.json", "m.json", metrics=["m.json"], commit=str(val)
         )
@@ -55,7 +54,7 @@ def test_metrics_diff_json(tmp_dir, scm, dvc, run_copy_metrics):
 def test_metrics_diff_json_unchanged(tmp_dir, scm, dvc, run_copy_metrics):
     def _gen(val):
         metrics = {"a": {"b": {"c": val, "d": 1, "e": str(val)}}}
-        tmp_dir.gen({"m_temp.json": json.dumps(metrics)})
+        (tmp_dir / "m_temp.json").dump(metrics)
         run_copy_metrics(
             "m_temp.json", "m.json", metrics=["m.json"], commit=str(val)
         )
@@ -69,7 +68,7 @@ def test_metrics_diff_json_unchanged(tmp_dir, scm, dvc, run_copy_metrics):
 
 def test_metrics_diff_broken_json(tmp_dir, scm, dvc, run_copy_metrics):
     metrics = {"a": {"b": {"c": 1, "d": 1, "e": "3"}}}
-    tmp_dir.gen({"m_temp.json": json.dumps(metrics)})
+    (tmp_dir / "m_temp.json").dump(metrics)
     run_copy_metrics(
         "m_temp.json",
         "m.json",
@@ -94,7 +93,7 @@ def test_metrics_diff_no_metrics(tmp_dir, scm, dvc):
 
 def test_metrics_diff_new_metric(tmp_dir, scm, dvc, run_copy_metrics):
     metrics = {"a": {"b": {"c": 1, "d": 1, "e": "3"}}}
-    tmp_dir.gen({"m_temp.json": json.dumps(metrics)})
+    (tmp_dir / "m_temp.json").dump(metrics)
     run_copy_metrics("m_temp.json", "m.json", metrics_no_cache=["m.json"])
 
     assert dvc.metrics.diff() == {
@@ -107,7 +106,7 @@ def test_metrics_diff_new_metric(tmp_dir, scm, dvc, run_copy_metrics):
 
 def test_metrics_diff_deleted_metric(tmp_dir, scm, dvc, run_copy_metrics):
     metrics = {"a": {"b": {"c": 1, "d": 1, "e": "3"}}}
-    tmp_dir.gen({"m_temp.json": json.dumps(metrics)})
+    (tmp_dir / "m_temp.json").dump(metrics)
     run_copy_metrics(
         "m_temp.json",
         "m.json",

tests/func/metrics/test_show.py

@@ -6,10 +6,9 @@ from funcy import get_in
 
 from dvc.dvcfile import PIPELINE_FILE
 from dvc.exceptions import OverlappingOutputPathsError
-from dvc.path_info import PathInfo
 from dvc.repo import Repo
 from dvc.utils.fs import remove
-from dvc.utils.serialize import YAMLFileCorruptedError, dump_yaml, modify_yaml
+from dvc.utils.serialize import YAMLFileCorruptedError
 
 
 def test_show_simple(tmp_dir, dvc, run_copy_metrics):
@@ -227,10 +226,10 @@ def test_show_no_metrics_files(tmp_dir, dvc, caplog):
 def test_metrics_show_overlap(
     tmp_dir, dvc, run_copy_metrics, clear_before_run
 ):
-    data_dir = PathInfo("data")
-    (tmp_dir / data_dir).mkdir()
+    data_dir = tmp_dir / "data"
+    data_dir.mkdir()
 
-    dump_yaml(data_dir / "m1_temp.yaml", {"a": {"b": {"c": 2, "d": 1}}})
+    (data_dir / "m1_temp.yaml").dump({"a": {"b": {"c": 2, "d": 1}}})
     run_copy_metrics(
         str(data_dir / "m1_temp.yaml"),
         str(data_dir / "m1.yaml"),
@@ -239,7 +238,7 @@ def test_metrics_show_overlap(
         name="cp-m1",
         metrics=[str(data_dir / "m1.yaml")],
     )
-    with modify_yaml("dvc.yaml") as d:
+    with (tmp_dir / "dvc.yaml").modify() as d:
         # trying to make an output overlaps error
         d["stages"]["corrupted-stage"] = {
             "cmd": "mkdir data",

tests/func/objects/db/test_index.py

@@ -76,7 +76,7 @@ def test_partial_upload(tmp_dir, dvc, index, mocker):
     tmp_dir.dvc_gen({"foo": "foo content"})
     tmp_dir.dvc_gen({"bar": {"baz": "baz content"}})
 
-    original = LocalFileSystem._upload
+    original = LocalFileSystem.upload
 
     def unreliable_upload(self, from_file, to_info, name=None, **kwargs):
         if "baz" in name:

tests/func/params/test_diff.py

@@ -1,5 +1,4 @@
 from dvc.utils import relpath
-from dvc.utils.serialize import dump_yaml
 
 
 def test_diff_no_params(tmp_dir, scm, dvc):
@@ -140,7 +139,7 @@ def test_no_commits(tmp_dir):
 def test_vars_shows_on_params_diff(tmp_dir, scm, dvc):
     params_file = tmp_dir / "test_params.yaml"
     param_data = {"vars": {"model1": {"epoch": 15}, "model2": {"epoch": 35}}}
-    dump_yaml(params_file, param_data)
+    (tmp_dir / params_file).dump(param_data)
     d = {
         "vars": ["test_params.yaml"],
         "stages": {
@@ -150,7 +149,7 @@ def test_vars_shows_on_params_diff(tmp_dir, scm, dvc):
             }
         },
     }
-    dump_yaml("dvc.yaml", d)
+    (tmp_dir / "dvc.yaml").dump(d)
     assert dvc.params.diff() == {
         "test_params.yaml": {
             "vars.model1.epoch": {"new": 15, "old": None},
@@ -161,7 +160,7 @@ def test_vars_shows_on_params_diff(tmp_dir, scm, dvc):
     scm.commit("added stages")
 
     param_data["vars"]["model1"]["epoch"] = 20
-    dump_yaml(params_file, param_data)
+    (tmp_dir / params_file).dump(param_data)
     assert dvc.params.diff() == {
         "test_params.yaml": {
             "vars.model1.epoch": {"new": 20, "old": 15, "diff": 5}

tests/func/parsing/test_errors.py

@@ -10,7 +10,6 @@ from dvc.parsing import ResolveError
 from dvc.parsing.context import Context
 from dvc.parsing.interpolate import embrace
 from dvc.utils.humanize import join
-from dvc.utils.serialize import dump_yaml
 
 from . import make_entry_definition, make_foreach_def
 
@@ -133,7 +132,7 @@ def test_interpolate_non_string(tmp_dir, dvc):
 
 
 def test_partial_vars_doesnot_exist(tmp_dir, dvc):
-    dump_yaml("test_params.yaml", {"sub1": "sub1", "sub2": "sub2"})
+    (tmp_dir / "test_params.yaml").dump({"sub1": "sub1", "sub2": "sub2"})
 
     definition = make_entry_definition(
         tmp_dir,
@@ -281,7 +280,7 @@ def test_item_key_in_generated_stage_vars(tmp_dir, dvc, redefine, from_file):
     context = Context(foo="bar")
     vars_ = [redefine]
     if from_file:
-        dump_yaml("test_params.yaml", redefine)
+        (tmp_dir / "test_params.yaml").dump(redefine)
         vars_ = ["test_params.yaml"]
 
     definition = make_foreach_def(

tests/func/parsing/test_foreach.py

@@ -5,7 +5,6 @@ import pytest
 
 from dvc.parsing import DEFAULT_PARAMS_FILE, DataResolver, ForeachDefinition
 from dvc.parsing.context import Context
-from dvc.utils.serialize import dump_yaml
 
 
 def test_with_simple_list_data(tmp_dir, dvc):
@@ -111,7 +110,7 @@ def test_foreach_interpolate_with_composite_data(
 def test_params_file_with_dict_tracked(tmp_dir, dvc):
     foreach_data = {"model1": {"thresh": "foo"}, "model2": {"thresh": "bar"}}
     params = {"models": foreach_data}
-    dump_yaml("params.yaml", params)
+    (tmp_dir / "params.yaml").dump(params)
 
     resolver = DataResolver(dvc, tmp_dir, {})
     data = {"foreach": "${models}", "do": {"cmd": "echo ${item.thresh}"}}
@@ -132,7 +131,7 @@ def test_params_file_with_dict_tracked(tmp_dir, dvc):
 def test_params_file_tracked_for_composite_list(tmp_dir, dvc):
     foreach_data = [{"thresh": "foo"}, {"thresh": "bar"}]
     params = {"models": foreach_data}
-    dump_yaml("params.yaml", params)
+    (tmp_dir / "params.yaml").dump(params)
 
     resolver = DataResolver(dvc, tmp_dir, {})
     data = {"foreach": "${models}", "do": {"cmd": "echo ${item.thresh}"}}
@@ -178,8 +177,8 @@ def test_foreach_partial_interpolations(tmp_dir, dvc):
 
 
 def test_mixed_vars_for_foreach_data(tmp_dir, dvc):
-    dump_yaml("params.yaml", {"models": {"model1": "foo"}})
-    dump_yaml("test_params.yaml", {"models": {"model2": "bar"}})
+    (tmp_dir / "params.yaml").dump({"models": {"model1": "foo"}})
+    (tmp_dir / "test_params.yaml").dump({"models": {"model2": "bar"}})
 
     resolver = DataResolver(dvc, tmp_dir, {"vars": ["test_params.yaml"]})
     data = {"foreach": "${models}", "do": {"cmd": "echo ${item}"}}
@@ -197,12 +196,10 @@ def test_mixed_vars_for_foreach_data(tmp_dir, dvc):
 
 
 def test_mixed_vars_for_foreach_data_2(tmp_dir, dvc):
-    dump_yaml(
-        "params.yaml",
+    (tmp_dir / "params.yaml").dump(
         {"models": {"model1": {"thresh": 10}, "model2": {"thresh": 15}}},
     )
-    dump_yaml(
-        "test_params.yaml",
+    (tmp_dir / "test_params.yaml").dump(
         {"models": {"model1": {"epochs": 5}, "model2": {"epochs": 10}}},
     )
 
@@ -288,9 +285,9 @@ def test_foreach_with_local_vars(tmp_dir, dvc):
     ],
 )
 def test_foreach_with_imported_vars(tmp_dir, dvc, local_import):
-    dump_yaml("params.yaml", {"models": {"model1": {"thresh": "foo"}}})
-    dump_yaml(
-        "test_params.yaml", {"train": {"epochs": 10}, "prepare": {"nums": 25}}
+    (tmp_dir / "params.yaml").dump({"models": {"model1": {"thresh": "foo"}}})
+    (tmp_dir / "test_params.yaml").dump(
+        {"train": {"epochs": 10}, "prepare": {"nums": 25}}
     )
     resolver = DataResolver(dvc, tmp_dir, {})
     foreach_data = ["foo", "bar"]
@@ -321,13 +318,12 @@ def test_foreach_with_imported_vars(tmp_dir, dvc, local_import):
 def test_foreach_with_interpolated_wdir_and_local_vars(
     tmp_dir, dvc, local_import
 ):
-    dump_yaml("params.yaml", {"models": {"model1": {"thresh": "foo"}}})
+    (tmp_dir / "params.yaml").dump({"models": {"model1": {"thresh": "foo"}}})
 
     for i in range(5):
         build_dir = tmp_dir / ("model-" + str(i))
         build_dir.mkdir()
-        dump_yaml(
-            build_dir / "params.yaml",
+        (build_dir / "params.yaml").dump(
             {"train": {"epochs": 1 + i}, "prepare": {"nums": 10 * i}},
         )
 

tests/func/parsing/test_interpolated_entry.py

@@ -6,7 +6,6 @@ from dvc.dependency import _merge_params
 from dvc.parsing import DEFAULT_PARAMS_FILE, DataResolver
 from dvc.parsing.context import recurse_not_a_node
 from dvc.path_info import PathInfo
-from dvc.utils.serialize import dump_json, dump_yaml
 
 from . import (
     CONTEXT_DATA,
@@ -30,7 +29,7 @@ def assert_stage_equal(d1, d2):
 
 
 def test_simple(tmp_dir, dvc):
-    dump_yaml(tmp_dir / DEFAULT_PARAMS_FILE, CONTEXT_DATA)
+    (tmp_dir / DEFAULT_PARAMS_FILE).dump(CONTEXT_DATA)
     resolver = DataResolver(
         dvc, PathInfo(str(tmp_dir)), deepcopy(TEMPLATED_DVC_YAML_DATA)
     )
@@ -46,7 +45,7 @@ def test_vars_import(tmp_dir, dvc):
     Test that different file can be loaded using `vars`
     instead of default params.yaml.
     """
-    dump_yaml(tmp_dir / "params2.yaml", CONTEXT_DATA)
+    (tmp_dir / "params2.yaml").dump(CONTEXT_DATA)
     d = deepcopy(TEMPLATED_DVC_YAML_DATA)
     d["vars"] = ["params2.yaml"]
     resolver = DataResolver(dvc, PathInfo(str(tmp_dir)), d)
@@ -68,7 +67,7 @@ def test_vars_and_params_import(tmp_dir, dvc):
         "vars": [DEFAULT_PARAMS_FILE, {"dict": {"foo": "foobar"}}],
         "stages": {"stage1": {"cmd": "echo ${dict.foo} ${dict.bar}"}},
     }
-    dump_yaml(tmp_dir / DEFAULT_PARAMS_FILE, {"dict": {"bar": "bar"}})
+    (tmp_dir / DEFAULT_PARAMS_FILE).dump({"dict": {"bar": "bar"}})
     resolver = DataResolver(dvc, PathInfo(str(tmp_dir)), d)
 
     assert_stage_equal(
@@ -96,8 +95,8 @@ def test_stage_with_wdir(tmp_dir, dvc):
 
     data_dir = tmp_dir / "data"
     data_dir.mkdir()
-    dump_yaml(tmp_dir / DEFAULT_PARAMS_FILE, {"dict": {"bar": "bar"}})
-    dump_json(data_dir / DEFAULT_PARAMS_FILE, {"dict": {"foo": "foo"}})
+    (tmp_dir / DEFAULT_PARAMS_FILE).dump({"dict": {"bar": "bar"}})
+    (data_dir / DEFAULT_PARAMS_FILE).dump({"dict": {"foo": "foo"}})
     resolver = DataResolver(dvc, PathInfo(str(tmp_dir)), d)
 
     assert_stage_equal(
@@ -135,12 +134,12 @@ def test_with_templated_wdir(tmp_dir, dvc):
             }
         }
     }
-    dump_yaml(
-        tmp_dir / DEFAULT_PARAMS_FILE, {"dict": {"bar": "bar", "ws": "data"}}
+    (tmp_dir / DEFAULT_PARAMS_FILE).dump(
+        {"dict": {"bar": "bar", "ws": "data"}}
     )
     data_dir = tmp_dir / "data"
     data_dir.mkdir()
-    dump_json(data_dir / DEFAULT_PARAMS_FILE, {"dict": {"foo": "foo"}})
+    (data_dir / DEFAULT_PARAMS_FILE).dump({"dict": {"foo": "foo"}})
     resolver = DataResolver(dvc, PathInfo(str(tmp_dir)), d)
 
     assert_stage_equal(
@@ -167,7 +166,7 @@ def test_with_templated_wdir(tmp_dir, dvc):
 
 def test_resolve_local_tries_to_load_globally_used_files(tmp_dir, dvc):
     iterable = {"bar": "bar", "foo": "foo"}
-    dump_json(tmp_dir / "params.json", iterable)
+    (tmp_dir / "params.json").dump(iterable)
 
     d = {
         "vars": ["params.json"],
@@ -196,7 +195,7 @@ def test_resolve_local_tries_to_load_globally_used_files(tmp_dir, dvc):
 
 def test_resolve_local_tries_to_load_globally_used_params_yaml(tmp_dir, dvc):
     iterable = {"bar": "bar", "foo": "foo"}
-    dump_yaml(tmp_dir / "params.yaml", iterable)
+    (tmp_dir / "params.yaml").dump(iterable)
 
     d = {
         "stages": {
@@ -224,7 +223,7 @@ def test_resolve_local_tries_to_load_globally_used_params_yaml(tmp_dir, dvc):
 
 def test_vars_relpath_overwrite(tmp_dir, dvc):
     iterable = {"bar": "bar", "foo": "foo"}
-    dump_yaml(tmp_dir / "params.yaml", iterable)
+    (tmp_dir / "params.yaml").dump(iterable)
     d = {
         "vars": ["params.yaml"],
         "stages": {
@@ -252,7 +251,7 @@ def test_vars_relpath_overwrite(tmp_dir, dvc):
 )
 def test_vars_load_partial(tmp_dir, dvc, local, vars_):
     iterable = {"bar": "bar", "foo": "foo"}
-    dump_yaml(tmp_dir / "test_params.yaml", iterable)
+    (tmp_dir / "test_params.yaml").dump(iterable)
     d = {"stages": {"build": {"cmd": "echo ${bar}"}}}
     if local:
         d["stages"]["build"]["vars"] = vars_

tests/func/parsing/test_resolver.py

@@ -5,7 +5,7 @@ import pytest
 
 from dvc.parsing import DEFAULT_PARAMS_FILE, DataResolver, ResolveError
 from dvc.parsing.context import Context
-from dvc.utils.serialize import dump_json, dump_yaml, dumps_yaml
+from dvc.utils.serialize import dumps_yaml
 
 from . import CONTEXT_DATA, RESOLVED_DVC_YAML_DATA, TEMPLATED_DVC_YAML_DATA
 
@@ -50,16 +50,16 @@ def test_vars_interpolation_errors(tmp_dir, dvc, vars_):
     "vars_", [{}, {"vars": []}, {"vars": [DEFAULT_PARAMS_FILE]}]
 )
 def test_default_params_file(tmp_dir, dvc, vars_):
-    dump_yaml(DEFAULT_PARAMS_FILE, DATA)
+    (tmp_dir / DEFAULT_PARAMS_FILE).dump(DATA)
     resolver = DataResolver(dvc, tmp_dir, vars_)
     assert resolver.context == DATA
 
 
 def test_load_vars_from_file(tmp_dir, dvc):
-    dump_yaml(DEFAULT_PARAMS_FILE, DATA)
+    (tmp_dir / DEFAULT_PARAMS_FILE).dump(DATA)
 
     datasets = {"datasets": ["foo", "bar"]}
-    dump_json("params.json", datasets)
+    (tmp_dir / "params.json").dump(datasets)
     d = {"vars": [DEFAULT_PARAMS_FILE, "params.json"]}
     resolver = DataResolver(dvc, tmp_dir, d)
 
@@ -82,7 +82,7 @@ def test_load_vars_with_relpath(tmp_dir, scm, dvc):
 
 
 def test_partial_vars_doesnot_exist(tmp_dir, dvc):
-    dump_yaml("test_params.yaml", {"sub1": "sub1"})
+    (tmp_dir / "test_params.yaml").dump({"sub1": "sub1"})
 
     with pytest.raises(ResolveError) as exc_info:
         DataResolver(dvc, tmp_dir, {"vars": ["test_params.yaml:sub2"]})
@@ -94,8 +94,8 @@ def test_partial_vars_doesnot_exist(tmp_dir, dvc):
 
 
 def test_global_overwrite_error_on_imports(tmp_dir, dvc):
-    dump_yaml(DEFAULT_PARAMS_FILE, DATA)
-    dump_json("params.json", DATA)
+    (tmp_dir / DEFAULT_PARAMS_FILE).dump(DATA)
+    (tmp_dir / "params.json").dump(DATA)
 
     d = {"vars": [DEFAULT_PARAMS_FILE, "params.json"]}
     with pytest.raises(ResolveError) as exc_info:
@@ -109,7 +109,7 @@ def test_global_overwrite_error_on_imports(tmp_dir, dvc):
 
 
 def test_global_overwrite_vars(tmp_dir, dvc):
-    dump_yaml(DEFAULT_PARAMS_FILE, DATA)
+    (tmp_dir / DEFAULT_PARAMS_FILE).dump(DATA)
     d = {"vars": [DATA]}
 
     with pytest.raises(ResolveError) as exc_info:
@@ -123,7 +123,7 @@ def test_global_overwrite_vars(tmp_dir, dvc):
 
 
 def test_local_declared_vars_overwrite(tmp_dir, dvc):
-    dump_yaml(DEFAULT_PARAMS_FILE, DATA)
+    (tmp_dir / DEFAULT_PARAMS_FILE).dump(DATA)
 
     d = {"vars": [DATA["models"], DATA["models"]]}
     with pytest.raises(ResolveError) as exc_info:
@@ -158,7 +158,7 @@ def test_specified_params_file_not_exist(tmp_dir, dvc):
 )
 def test_vars_already_loaded_message(tmp_dir, dvc, local, vars_):
     d = {"stages": {"build": {"cmd": "echo ${sub1} ${sub2}"}}}
-    dump_yaml("test_params.yaml", {"sub1": "sub1", "sub2": "sub2"})
+    (tmp_dir / "test_params.yaml").dump({"sub1": "sub1", "sub2": "sub2"})
     if not local:
         d["vars"] = vars_
     else:
@@ -175,8 +175,8 @@ def test_vars_already_loaded_message(tmp_dir, dvc, local, vars_):
     "vars_, loc", [(DATA, "build.vars[0]"), ("params.json", "params.json")]
 )
 def test_local_overwrite_error(tmp_dir, dvc, vars_, loc):
-    dump_yaml(DEFAULT_PARAMS_FILE, DATA)
-    dump_json("params.json", DATA)
+    (tmp_dir / DEFAULT_PARAMS_FILE).dump(DATA)
+    (tmp_dir / "params.json").dump(DATA)
 
     d = {"stages": {"build": {"cmd": "echo ${models.foo}", "vars": [vars_]}}}
 

tests/func/plots/test_diff.py

@@ -1,8 +1,5 @@
-from tests.func.plots.utils import _write_json
-
-
 def test_diff_dirty(tmp_dir, scm, dvc, run_copy_metrics):
-    _write_json(tmp_dir, [{"y": 2}, {"y": 3}], "metric_t.json")
+    (tmp_dir / "metric_t.json").dump([{"y": 2}, {"y": 3}], sort_keys=True)
     run_copy_metrics(
         "metric_t.json",
         "metric.json",
@@ -11,7 +8,7 @@ def test_diff_dirty(tmp_dir, scm, dvc, run_copy_metrics):
     )
 
     metric_head = [{"y": 3}, {"y": 5}]
-    _write_json(tmp_dir, metric_head, "metric_t.json")
+    (tmp_dir / "metric_t.json").dump_json(metric_head, sort_keys=True)
     run_copy_metrics(
         "metric_t.json",
         "metric.json",
@@ -20,7 +17,7 @@ def test_diff_dirty(tmp_dir, scm, dvc, run_copy_metrics):
     )
 
     metric_1 = [{"y": 5}, {"y": 6}]
-    _write_json(tmp_dir, metric_1, "metric_t.json")
+    (tmp_dir / "metric_t.json").dump_json(metric_1, sort_keys=True)
     run_copy_metrics(
         "metric_t.json", "metric.json", plots_no_cache=["metric.json"]
     )
@@ -35,7 +32,7 @@ def test_diff_dirty(tmp_dir, scm, dvc, run_copy_metrics):
         },
     }
     metric_2 = [{"y": 7}, {"y": 8}]
-    _write_json(tmp_dir, metric_2, "metric.json")
+    (tmp_dir / "metric.json").dump_json(metric_2, sort_keys=True)
 
     diff_result = dvc.plots.diff(props=props)
     assert diff_result == {

tests/func/plots/test_modify.py

@@ -6,14 +6,13 @@ from dvc.dvcfile import PIPELINE_LOCK
 from dvc.repo.plots import PropsNotFoundError
 from dvc.repo.plots.template import TemplateNotFoundError
 from dvc.utils import relpath
-from tests.func.plots.utils import _write_json
 
 
 def test_plots_modify_existing_template(
     tmp_dir, dvc, run_copy_metrics, custom_template
 ):
     metric = [{"a": 1, "b": 2}, {"a": 2, "b": 3}]
-    _write_json(tmp_dir, metric, "metric_t.json")
+    (tmp_dir / "metric_t.json").dump_json(metric, sort_keys=True)
     stage = run_copy_metrics(
         "metric_t.json",
         "metric.json",
@@ -31,7 +30,7 @@ def test_plots_modify_existing_template(
 def test_plots_modify_should_not_change_lockfile(
     tmp_dir, dvc, run_copy_metrics, custom_template
 ):
-    _write_json(tmp_dir, [{"a": 1, "b": 2}], "metric_t.json")
+    (tmp_dir / "metric_t.json").dump_json([{"a": 1, "b": 2}], sort_keys=True)
     run_copy_metrics(
         "metric_t.json",
         "metric.json",
@@ -56,7 +55,7 @@ def test_plots_modify_not_existing_template(dvc):
 
 def test_unset_nonexistent(tmp_dir, dvc, run_copy_metrics, custom_template):
     metric = [{"a": 1, "b": 2}, {"a": 2, "b": 3}]
-    _write_json(tmp_dir, metric, "metric_t.json")
+    (tmp_dir / "metric_t.json").dump_json(metric, sort_keys=True)
     run_copy_metrics(
         "metric_t.json",
         "metric.json",
@@ -76,7 +75,7 @@ def test_dir_plots(tmp_dir, dvc, run_copy_metrics):
     metric = [{"first_val": 100, "val": 2}, {"first_val": 200, "val": 3}]
 
     fname = "file.json"
-    _write_json(tmp_dir, metric, fname)
+    (tmp_dir / fname).dump_json(metric, sort_keys=True)
 
     p1 = os.path.join("subdir", "p1.json")
     p2 = os.path.join("subdir", "p2.json")

tests/func/plots/test_show.py

@@ -6,23 +6,16 @@ from funcy import get_in
 from dvc.dvcfile import PIPELINE_FILE
 from dvc.exceptions import OverlappingOutputPathsError
 from dvc.main import main
-from dvc.path_info import PathInfo
 from dvc.render.vega import PlotMetricTypeError
 from dvc.repo import Repo
 from dvc.utils import onerror_collect
 from dvc.utils.fs import remove
-from dvc.utils.serialize import (
-    EncodingError,
-    YAMLFileCorruptedError,
-    dump_yaml,
-    modify_yaml,
-)
-from tests.func.plots.utils import _write_json
+from dvc.utils.serialize import EncodingError, YAMLFileCorruptedError
 
 
 def test_plot_cache_missing(tmp_dir, scm, dvc, caplog, run_copy_metrics):
     metric1 = [{"y": 2}, {"y": 3}]
-    _write_json(tmp_dir, metric1, "metric_t.json")
+    (tmp_dir / "metric_t.json").dump_json(metric1, sort_keys=True)
     run_copy_metrics(
         "metric_t.json",
         "metric.json",
@@ -33,7 +26,7 @@ def test_plot_cache_missing(tmp_dir, scm, dvc, caplog, run_copy_metrics):
 
     # Make a different plot and then remove its datafile
     metric2 = [{"y": 3}, {"y": 4}]
-    _write_json(tmp_dir, metric2, "metric_t.json")
+    (tmp_dir / "metric_t.json").dump_json(metric2, sort_keys=True)
     stage = run_copy_metrics(
         "metric_t.json",
         "metric.json",
@@ -71,7 +64,7 @@ def test_plot_wrong_metric_type(tmp_dir, scm, dvc, run_copy_metrics):
 @pytest.mark.parametrize("use_dvc", [True, False])
 def test_show_non_plot(tmp_dir, scm, use_dvc):
     metric = [{"first_val": 100, "val": 2}, {"first_val": 200, "val": 3}]
-    _write_json(tmp_dir, metric, "metric.json")
+    (tmp_dir / "metric.json").dump_json(metric, sort_keys=True)
 
     if use_dvc:
         dvc = Repo.init()
@@ -87,7 +80,7 @@ def test_show_non_plot_and_plot_with_params(
     tmp_dir, scm, dvc, run_copy_metrics
 ):
     metric = [{"first_val": 100, "val": 2}, {"first_val": 200, "val": 3}]
-    _write_json(tmp_dir, metric, "metric.json")
+    (tmp_dir / "metric.json").dump_json(metric, sort_keys=True)
     run_copy_metrics(
         "metric.json", "metric2.json", plots_no_cache=["metric2.json"]
     )
@@ -105,7 +98,7 @@ def test_show_from_subdir(tmp_dir, dvc, capsys):
 
     subdir.mkdir()
     metric = [{"first_val": 100, "val": 2}, {"first_val": 200, "val": 3}]
-    _write_json(subdir, metric, "metric.json")
+    (subdir / "metric.json").dump_json(metric, sort_keys=True)
 
     with subdir.chdir():
         assert main(["plots", "show", "metric.json"]) == 0
@@ -127,10 +120,10 @@ def test_plots_show_non_existing(tmp_dir, dvc, caplog):
 
 @pytest.mark.parametrize("clear_before_run", [True, False])
 def test_plots_show_overlap(tmp_dir, dvc, run_copy_metrics, clear_before_run):
-    data_dir = PathInfo("data")
-    (tmp_dir / data_dir).mkdir()
+    data_dir = tmp_dir / "data"
+    data_dir.mkdir()
 
-    dump_yaml(data_dir / "m1_temp.yaml", {"a": {"b": {"c": 2, "d": 1}}})
+    (data_dir / "m1_temp.yaml").dump({"a": {"b": {"c": 2, "d": 1}}})
     run_copy_metrics(
         str(data_dir / "m1_temp.yaml"),
         str(data_dir / "m1.yaml"),
@@ -139,7 +132,7 @@ def test_plots_show_overlap(tmp_dir, dvc, run_copy_metrics, clear_before_run):
         name="cp-m1",
         plots=[str(data_dir / "m1.yaml")],
     )
-    with modify_yaml("dvc.yaml") as d:
+    with (tmp_dir / "dvc.yaml").modify() as d:
         # trying to make an output overlaps error
         d["stages"]["corrupted-stage"] = {
             "cmd": "mkdir data",
@@ -167,7 +160,7 @@ def test_dir_plots(tmp_dir, dvc, run_copy_metrics):
     metric = [{"first_val": 100, "val": 2}, {"first_val": 200, "val": 3}]
 
     fname = "file.json"
-    _write_json(tmp_dir, metric, fname)
+    (tmp_dir / fname).dump_json(metric, sort_keys=True)
 
     p1 = os.path.join("subdir", "p1.json")
     p2 = os.path.join("subdir", "p2.json")
@@ -213,7 +206,7 @@ def test_log_errors(
     tmp_dir, scm, dvc, run_copy_metrics, file, error_path, capsys
 ):
     metric = [{"val": 2}, {"val": 3}]
-    dump_yaml("metric_t.yaml", metric)
+    (tmp_dir / "metric_t.yaml").dump(metric)
     run_copy_metrics(
         "metric_t.yaml",
         "plot.yaml",

tests/func/plots/utils.py

@@ -1,12 +0,0 @@
-import json
-
-from tests.utils import dump_sv
-
-
-def _write_csv(metric, filename, header=True):
-    with open(filename, "w", newline="") as csvobj:
-        dump_sv(csvobj, metric, delimiter=",", header=header)
-
-
-def _write_json(tmp_dir, metric, filename):
-    tmp_dir.gen(filename, json.dumps(metric, sort_keys=True))

tests/func/test_add.py

@@ -55,7 +55,7 @@ def test_add(tmp_dir, dvc):
     assert stage.outs[0].hash_info == HashInfo("md5", md5)
     assert stage.md5 is None
 
-    assert load_yaml("foo.dvc") == {
+    assert (tmp_dir / "foo.dvc").parse() == {
         "outs": [
             {
                 "md5": "acbd18db4cc2f85cedef654fccc4a4d8",
@@ -73,7 +73,7 @@ def test_add_executable(tmp_dir, dvc):
     os.chmod("foo", st.st_mode | stat.S_IEXEC)
     dvc.add("foo")
 
-    assert load_yaml("foo.dvc") == {
+    assert (tmp_dir / "foo.dvc").parse() == {
         "outs": [
             {
                 "md5": "acbd18db4cc2f85cedef654fccc4a4d8",

tests/func/test_analytics.py

@@ -1,5 +1,4 @@
 import os
-from unittest import mock
 from unittest.mock import call
 
 import pytest
@@ -9,17 +8,17 @@ from dvc.main import main
 from dvc.repo import Repo
 
 
-@mock.patch("dvc.analytics.send")
-def test_daemon_analytics(mock_send, tmp_path):
+def test_daemon_analytics(mocker, tmp_path):
+    mock_send = mocker.patch("dvc.analytics.send")
     report = os.fspath(tmp_path)
     assert 0 == main(["daemon", "analytics", report])
 
     mock_send.assert_called_with(report)
 
 
-@mock.patch("dvc.analytics.collect_and_send_report")
-@mock.patch("dvc.analytics.is_enabled", return_value=True)
-def test_main_analytics(mock_is_enabled, mock_report, tmp_dir, dvc):
+def test_main_analytics(mocker, tmp_dir, dvc):
+    mock_is_enabled = mocker.patch("dvc.analytics.collect_and_send_report")
+    mock_report = mocker.patch("dvc.analytics.is_enabled", return_value=True)
     tmp_dir.gen("foo", "text")
     assert 0 == main(["add", "foo"])
     assert mock_is_enabled.called
@@ -46,8 +45,8 @@ class ANY:
         return isinstance(other, self.expected_type)
 
 
-@mock.patch("requests.post")
-def test_collect_and_send_report(mock_post, dvc, mock_daemon):
+def test_collect_and_send_report(mocker, dvc, mock_daemon):
+    mock_post = mocker.patch("requests.post")
     collect_and_send_report()
 
     assert mock_daemon.call_count == 1

tests/func/test_checkout.py

@@ -867,9 +867,9 @@ def test_checkout_external_modified_file(tmp_dir, dvc, scm, mocker, workspace):
 def test_checkout_executable(tmp_dir, dvc):
     tmp_dir.dvc_gen("foo", "foo")
 
-    contents = load_yaml("foo.dvc")
+    contents = (tmp_dir / "foo.dvc").parse()
     contents["outs"][0]["isexec"] = True
-    dump_yaml("foo.dvc", contents)
+    (tmp_dir / "foo.dvc").dump(contents)
 
     dvc.checkout("foo")
 

tests/func/test_commit.py

@@ -6,7 +6,6 @@ from dvc.dependency.base import DependencyDoesNotExistError
 from dvc.dvcfile import PIPELINE_FILE
 from dvc.output import OutputDoesNotExistError
 from dvc.stage.exceptions import StageCommitError
-from dvc.utils.serialize import dump_yaml, load_yaml
 from tests.utils import clean_staging
 
 
@@ -65,9 +64,9 @@ def test_commit_changed_md5(tmp_dir, dvc):
     tmp_dir.gen({"file": "file content"})
     (stage,) = dvc.add("file", no_commit=True)
 
-    stage_file_content = load_yaml(stage.path)
+    stage_file_content = (tmp_dir / stage.path).parse()
     stage_file_content["md5"] = "1111111111"
-    dump_yaml(stage.path, stage_file_content)
+    (tmp_dir / stage.path).dump(stage_file_content)
 
     clean_staging()
 
@@ -75,7 +74,7 @@ def test_commit_changed_md5(tmp_dir, dvc):
         dvc.commit(stage.path)
 
     dvc.commit(stage.path, force=True)
-    assert "md5" not in load_yaml(stage.path)
+    assert "md5" not in (tmp_dir / stage.path).parse()
 
 
 def test_commit_no_exec(tmp_dir, dvc):

tests/func/test_config.py

@@ -77,6 +77,12 @@ def test_config_set_local(tmp_dir, dvc):
     assert (tmp_dir / ".dvc" / "config.local").read_text() == "\n"
 
 
+def test_config_set_in_non_dvc_repo(tmp_dir, caplog):
+    assert main(["config", "core.analytics", "true"]) != 0
+    out = caplog.text
+    assert "Not inside a DVC repo" in out
+
+
 @pytest.mark.parametrize(
     "args, ret, msg",
     [
@@ -128,6 +134,21 @@ def test_config_get(tmp_dir, dvc, capsys, caplog, args, ret, msg):
     assert msg in text
 
 
+@pytest.mark.parametrize(
+    "args, ret",
+    [
+        (["--local", "core.remote"], 251),
+        (["--project", "core.remote"], 251),
+        (["core.remote"], 0),
+    ],
+)
+def test_config_get_in_non_dvc_repo(tmp_dir, caplog, args, ret):
+    assert main(["config"] + args) == ret
+    if ret != 0:
+        out = caplog.text
+        assert "Not inside a DVC repo" in out
+
+
 def test_config_list(tmp_dir, dvc, capsys):
     (tmp_dir / ".dvc" / "config").write_text(
         textwrap.dedent(
@@ -169,6 +190,21 @@ def test_config_list(tmp_dir, dvc, capsys):
     assert "core.remote=myremote" in out
 
 
+@pytest.mark.parametrize(
+    "args, ret",
+    [
+        (["--list", "--local"], 251),
+        (["--list", "--project"], 251),
+        (["--list"], 0),
+    ],
+)
+def test_config_list_in_non_dvc_repo(tmp_dir, caplog, args, ret):
+    assert main(["config"] + args) == ret
+    if ret != 0:
+        out = caplog.text
+        assert "Not inside a DVC repo" in out
+
+
 @pytest.mark.parametrize(
     "args", [["core.analytics"], ["core.analytics", "false"], ["--unset"]]
 )

tests/func/test_data_cloud.py

@@ -10,7 +10,6 @@ from dvc.external_repo import clean_repos
 from dvc.main import main
 from dvc.stage.exceptions import StageNotFound
 from dvc.utils.fs import move, remove
-from dvc.utils.serialize import dump_yaml, load_yaml
 
 all_clouds = [
     pytest.lazy_fixture(cloud)
@@ -204,9 +203,9 @@ def test_warn_on_outdated_stage(tmp_dir, dvc, local_remote, caplog):
     assert main(["push"]) == 0
 
     stage_file_path = stage.relpath
-    content = load_yaml(stage_file_path)
+    content = (tmp_dir / stage_file_path).parse()
     del content["outs"][0]["md5"]
-    dump_yaml(stage_file_path, content)
+    (tmp_dir / stage_file_path).dump(content)
 
     with caplog.at_level(logging.WARNING, logger="dvc"):
         caplog.clear()
@@ -612,8 +611,6 @@ def test_pull_no_00_prefix(tmp_dir, dvc, remote, monkeypatch):
 
 
 def test_output_remote(tmp_dir, dvc, make_remote):
-    from dvc.utils.serialize import modify_yaml
-
     make_remote("default", default=True)
     make_remote("for_foo", default=False)
     make_remote("for_data", default=False)
@@ -622,10 +619,10 @@ def test_output_remote(tmp_dir, dvc, make_remote):
     tmp_dir.dvc_gen("bar", "bar")
     tmp_dir.dvc_gen("data", {"one": "one", "two": "two"})
 
-    with modify_yaml("foo.dvc") as d:
+    with (tmp_dir / "foo.dvc").modify() as d:
         d["outs"][0]["remote"] = "for_foo"
 
-    with modify_yaml("data.dvc") as d:
+    with (tmp_dir / "data.dvc").modify() as d:
         d["outs"][0]["remote"] = "for_data"
 
     dvc.push()
@@ -653,3 +650,35 @@ def test_output_remote(tmp_dir, dvc, make_remote):
         "6b18131dc289fd37006705affe961ef8.dir",
         "b8a9f715dbb64fd5c56e7783c6820a61",
     }
+
+
+def test_target_remote(tmp_dir, dvc, make_remote):
+    make_remote("default", default=True)
+    make_remote("myremote", default=False)
+
+    tmp_dir.dvc_gen("foo", "foo")
+    tmp_dir.dvc_gen("data", {"one": "one", "two": "two"})
+
+    dvc.push(remote="myremote")
+
+    default = dvc.cloud.get_remote_odb("default")
+    myremote = dvc.cloud.get_remote_odb("myremote")
+
+    assert set(default.all()) == set()
+    assert set(myremote.all()) == {
+        "acbd18db4cc2f85cedef654fccc4a4d8",
+        "f97c5d29941bfb1b2fdab0874906ab82",
+        "6b18131dc289fd37006705affe961ef8.dir",
+        "b8a9f715dbb64fd5c56e7783c6820a61",
+    }
+
+    clean(["foo", "data"], dvc)
+
+    dvc.pull(remote="myremote")
+
+    assert set(dvc.odb.local.all()) == {
+        "acbd18db4cc2f85cedef654fccc4a4d8",
+        "f97c5d29941bfb1b2fdab0874906ab82",
+        "6b18131dc289fd37006705affe961ef8.dir",
+        "b8a9f715dbb64fd5c56e7783c6820a61",
+    }

tests/func/test_dvcfile.py

@@ -15,7 +15,6 @@ from dvc.stage.exceptions import (
     StageFileFormatError,
 )
 from dvc.stage.loader import StageNotFound
-from dvc.utils.serialize import dump_yaml
 
 
 def test_run_load_one_for_multistage(tmp_dir, dvc):
@@ -245,14 +244,14 @@ def test_remove_stage_on_lockfile_format_error(tmp_dir, dvc, run_copy):
     lock_data = lock_file.load()
     lock_data["gibberish"] = True
     data["gibberish"] = True
-    dump_yaml(lock_file.relpath, lock_data)
+    (tmp_dir / lock_file.relpath).dump(lock_data)
     with pytest.raises(StageFileFormatError):
         dvc_file.remove_stage(stage)
 
     lock_file.remove()
     dvc_file.dump(stage, update_pipeline=False)
 
-    dump_yaml(dvc_file.relpath, data)
+    (tmp_dir / dvc_file.relpath).dump(data)
     with pytest.raises(StageFileFormatError):
         dvc_file.remove_stage(stage)
 
@@ -335,7 +334,7 @@ def test_dvcfile_dump_preserves_desc(tmp_dir, dvc, run_copy):
 
     data = dvcfile._load()[0]
     data["stages"]["run_copy"]["outs"][0] = {"bar": {"desc": out_desc}}
-    dump_yaml(dvcfile.path, data)
+    (tmp_dir / dvcfile.path).dump(data)
 
     assert stage.desc == stage_desc
     stage.outs[0].desc = out_desc
@@ -376,7 +375,7 @@ def test_dvcfile_dump_preserves_comments(tmp_dir, dvc):
     ],
 )
 def test_dvcfile_try_dumping_parametrized_stage(tmp_dir, dvc, data, name):
-    dump_yaml("dvc.yaml", {"stages": data, "vars": [{"foo": "foobar"}]})
+    (tmp_dir / "dvc.yaml").dump({"stages": data, "vars": [{"foo": "foobar"}]})
 
     stage = dvc.stage.load_one(name=name)
     dvcfile = stage.dvcfile

tests/func/test_external_repo.py

@@ -13,7 +13,7 @@ from tests.unit.fs.test_repo import make_subrepo
 from tests.utils import clean_staging
 
 
-def test_external_repo(erepo_dir):
+def test_external_repo(erepo_dir, mocker):
     with erepo_dir.chdir():
         with erepo_dir.branch("branch", new=True):
             erepo_dir.dvc_gen("file", "branch", commit="create file on branch")
@@ -21,16 +21,17 @@ def test_external_repo(erepo_dir):
 
     url = os.fspath(erepo_dir)
 
-    with patch.object(Git, "clone", wraps=Git.clone) as mock:
-        with external_repo(url) as repo:
-            with repo.open_by_relpath("file") as fd:
-                assert fd.read() == "master"
+    mock = mocker.patch.object(Git, "clone", wraps=Git.clone)
 
-        with external_repo(url, rev="branch") as repo:
-            with repo.open_by_relpath("file") as fd:
-                assert fd.read() == "branch"
+    with external_repo(url) as repo:
+        with repo.open_by_relpath("file") as fd:
+            assert fd.read() == "master"
 
-        assert mock.call_count == 1
+    with external_repo(url, rev="branch") as repo:
+        with repo.open_by_relpath("file") as fd:
+            assert fd.read() == "branch"
+
+    assert mock.call_count == 1
 
 
 def test_source_change(erepo_dir):

tests/func/test_fs.py

@@ -3,6 +3,7 @@ import os
 from operator import itemgetter
 from os.path import join
 
+import fsspec
 import pytest
 
 from dvc.fs import get_cloud_fs
@@ -260,7 +261,6 @@ def test_fs_getsize(dvc, cloud):
         pytest.lazy_fixture("gs"),
         pytest.lazy_fixture("gdrive"),
         pytest.lazy_fixture("hdfs"),
-        pytest.lazy_fixture("http"),
         pytest.lazy_fixture("local_cloud"),
         pytest.lazy_fixture("oss"),
         pytest.lazy_fixture("s3"),
@@ -406,7 +406,7 @@ def test_fs_makedirs_on_upload_and_copy(dvc, cloud):
     fs = cls(**config)
 
     with io.BytesIO(b"foo") as stream:
-        fs.upload_fobj(stream, cloud / "dir" / "foo")
+        fs.upload(stream, cloud / "dir" / "foo")
 
     assert fs.isdir(cloud / "dir")
     assert fs.exists(cloud / "dir" / "foo")
@@ -414,3 +414,154 @@ def test_fs_makedirs_on_upload_and_copy(dvc, cloud):
     fs.copy(cloud / "dir" / "foo", cloud / "dir2" / "foo")
     assert fs.isdir(cloud / "dir2")
     assert fs.exists(cloud / "dir2" / "foo")
+
+
+@pytest.mark.needs_internet
+@pytest.mark.parametrize(
+    "cloud",
+    [
+        pytest.lazy_fixture("azure"),
+        pytest.lazy_fixture("gs"),
+        pytest.lazy_fixture("gdrive"),
+        pytest.lazy_fixture("hdfs"),
+        pytest.lazy_fixture("local_cloud"),
+        pytest.lazy_fixture("oss"),
+        pytest.lazy_fixture("s3"),
+        pytest.lazy_fixture("ssh"),
+        pytest.lazy_fixture("webhdfs"),
+        pytest.lazy_fixture("webdav"),
+        pytest.lazy_fixture("http"),
+    ],
+)
+def test_upload_callback(tmp_dir, dvc, cloud):
+    tmp_dir.gen("foo", "foo")
+    cls, config, _ = get_cloud_fs(dvc, **cloud.config)
+    fs = cls(**config)
+    expected_size = os.path.getsize(tmp_dir / "foo")
+
+    callback = fsspec.Callback()
+    fs.upload(tmp_dir / "foo", cloud / "foo", callback=callback)
+
+    assert callback.size == expected_size
+    assert callback.value == expected_size
+
+
+@pytest.mark.needs_internet
+@pytest.mark.parametrize(
+    "cloud",
+    [
+        pytest.lazy_fixture("azure"),
+        pytest.lazy_fixture("gs"),
+        pytest.lazy_fixture("gdrive"),
+        pytest.lazy_fixture("hdfs"),
+        pytest.lazy_fixture("local_cloud"),
+        pytest.lazy_fixture("oss"),
+        pytest.lazy_fixture("s3"),
+        pytest.lazy_fixture("ssh"),
+        pytest.lazy_fixture("webhdfs"),
+        pytest.lazy_fixture("webdav"),
+        pytest.lazy_fixture("http"),
+    ],
+)
+def test_download_callback(tmp_dir, dvc, cloud, local_cloud):
+    cls, config, _ = get_cloud_fs(dvc, **cloud.config)
+    fs = cls(**config)
+
+    (tmp_dir / "to_upload").write_text("foo")
+    fs.upload(tmp_dir / "to_upload", cloud / "foo")
+    expected_size = fs.getsize(cloud / "foo")
+
+    callback = fsspec.Callback()
+    fs.download_file(cloud / "foo", tmp_dir / "foo", callback=callback)
+
+    assert callback.size == expected_size
+    assert callback.value == expected_size
+    assert (tmp_dir / "foo").read_text() == "foo"
+
+
+@pytest.mark.needs_internet
+@pytest.mark.parametrize(
+    "cloud",
+    [
+        pytest.lazy_fixture("azure"),
+        pytest.lazy_fixture("gs"),
+        pytest.lazy_fixture("hdfs"),
+        pytest.lazy_fixture("local_cloud"),
+        pytest.lazy_fixture("s3"),
+        pytest.param(
+            pytest.lazy_fixture("ssh"),
+            marks=pytest.mark.skipif(
+                os.name == "nt", reason="unsupported on Windows."
+            ),
+        ),
+        pytest.lazy_fixture("gdrive"),
+        pytest.lazy_fixture("webdav"),
+    ],
+)
+def test_download_dir_callback(tmp_dir, dvc, cloud):
+    cls, config, _ = get_cloud_fs(dvc, **cloud.config)
+    fs = cls(**config)
+    cloud.gen({"dir": {"foo": "foo", "bar": "bar"}})
+
+    callback = fsspec.Callback()
+    fs.download(cloud / "dir", tmp_dir / "dir", callback=callback)
+
+    assert callback.size == 2
+    assert callback.value == 2
+    assert (tmp_dir / "dir").read_text() == {"foo": "foo", "bar": "bar"}
+
+
+@pytest.mark.parametrize("fs_type", ["git", "dvc"])
+def test_download_callbacks_on_dvc_git_fs(tmp_dir, dvc, scm, fs_type):
+    gen = tmp_dir.scm_gen if fs_type == "git" else tmp_dir.dvc_gen
+    gen({"dir": {"foo": "foo", "bar": "bar"}, "file": "file"}, commit="gen")
+
+    fs = dvc.dvcfs if fs_type == "dvc" else scm.get_fs("HEAD")
+
+    callback = fsspec.Callback()
+    fs.download(tmp_dir / "file", tmp_dir / "file2", callback=callback)
+
+    size = os.path.getsize(tmp_dir / "file")
+    assert (tmp_dir / "file2").read_text() == "file"
+    assert callback.size == size
+    assert callback.value == size
+
+    if fs_type == "git":
+        pytest.skip("gitfs does not support download_dir")
+
+    callback = fsspec.Callback()
+    fs.download(tmp_dir / "dir", tmp_dir / "dir2", callback=callback)
+
+    assert (tmp_dir / "dir2").read_text() == {"foo": "foo", "bar": "bar"}
+    assert callback.size == 2
+    assert callback.value == 2
+
+
+def test_callback_on_repo_fs(tmp_dir, dvc, scm):
+    tmp_dir.dvc_gen({"dir": {"bar": "bar"}}, commit="dvc")
+    tmp_dir.scm_gen({"dir": {"foo": "foo"}}, commit="git")
+
+    fs = dvc.repo_fs
+
+    callback = fsspec.Callback()
+    fs.download(tmp_dir / "dir", tmp_dir / "dir2", callback=callback)
+
+    assert (tmp_dir / "dir2").read_text() == {"foo": "foo", "bar": "bar"}
+    assert callback.size == 2
+    assert callback.value == 2
+
+    callback = fsspec.Callback()
+    fs.download(tmp_dir / "dir" / "foo", tmp_dir / "foo", callback=callback)
+
+    size = os.path.getsize(tmp_dir / "dir" / "foo")
+    assert (tmp_dir / "foo").read_text() == "foo"
+    assert callback.size == size
+    assert callback.value == size
+
+    callback = fsspec.Callback()
+    fs.download(tmp_dir / "dir" / "bar", tmp_dir / "bar", callback=callback)
+
+    size = os.path.getsize(tmp_dir / "dir" / "bar")
+    assert (tmp_dir / "bar").read_text() == "bar"
+    assert callback.size == size
+    assert callback.value == size

tests/func/test_lockfile.py

@@ -9,12 +9,7 @@ from dvc.dvcfile import PIPELINE_LOCK, Lockfile, LockfileCorruptedError
 from dvc.hash_info import HashInfo
 from dvc.stage.utils import split_params_deps
 from dvc.utils.fs import remove
-from dvc.utils.serialize import (
-    dump_yaml,
-    dumps_yaml,
-    load_yaml,
-    parse_yaml_for_update,
-)
+from dvc.utils.serialize import dumps_yaml, parse_yaml_for_update
 from tests.func.test_run_multistage import supported_params
 
 FS_STRUCTURE = {
@@ -183,7 +178,7 @@ def v1_repo_lock(tmp_dir, dvc):
     }
     dvc.run(cmd="echo foo", name="foo", no_exec=True)
     dvc.run(cmd="echo bar>bar.txt", outs=["bar.txt"], name="bar", no_exec=True)
-    dump_yaml(tmp_dir / "dvc.lock", v1_lockdata)
+    (tmp_dir / "dvc.lock").dump(v1_lockdata)
     yield v1_lockdata
 
 
@@ -202,7 +197,7 @@ def test_migrates_v1_lockfile_to_v2_during_dump(
         assert dvc.reproduce()
 
     assert "Migrating lock file 'dvc.lock' from v1 to v2" in caplog.messages
-    d = load_yaml(tmp_dir / "dvc.lock")
+    d = (tmp_dir / "dvc.lock").parse()
     assert d == {"stages": v1_repo_lock, "schema": "2.0"}
 
 
@@ -211,7 +206,7 @@ def test_migrates_v1_lockfile_to_v2_during_dump(
 )
 def test_lockfile_invalid_versions(tmp_dir, dvc, version_info):
     lockdata = {**version_info, "stages": {"foo": {"cmd": "echo foo"}}}
-    dump_yaml("dvc.lock", lockdata)
+    (tmp_dir / "dvc.lock").dump(lockdata)
     with pytest.raises(LockfileCorruptedError) as exc_info:
         Lockfile(dvc, tmp_dir / "dvc.lock").load()
 

tests/func/test_move.py

@@ -6,7 +6,7 @@ import pytest
 from dvc.dvcfile import DVC_FILE_SUFFIX
 from dvc.exceptions import DvcException, MoveNotDataSourceError
 from dvc.main import main
-from dvc.utils.serialize import dump_yaml, load_yaml
+from dvc.utils.serialize import load_yaml
 from tests.basic_env import TestDvc, TestDvcGit
 from tests.func.test_repro import TestRepro
 from tests.utils import cd
@@ -249,9 +249,9 @@ def test_move_output_overlap(tmp_dir, dvc):
 
 def test_move_meta(tmp_dir, dvc):
     (stage,) = tmp_dir.dvc_gen("foo", "foo")
-    data = load_yaml(stage.path)
+    data = (tmp_dir / stage.path).parse()
     data["meta"] = {"custom_key": 42}
-    dump_yaml(stage.path, data)
+    (tmp_dir / stage.path).dump(data)
 
     dvc.move("foo", "bar")
     res = (tmp_dir / "bar.dvc").read_text()

tests/func/test_repo_index.py

@@ -7,7 +7,6 @@ from pygtrie import Trie
 from dvc.repo.index import Index
 from dvc.stage import PipelineStage, Stage
 from dvc.utils import relpath
-from tests.func.plots.utils import _write_json
 
 
 def test_index(tmp_dir, scm, dvc, run_copy):
@@ -103,7 +102,9 @@ def test_deps_outs_getters(tmp_dir, dvc, run_copy_metrics):
         params=["param"],
         name="copy-metrics",
     )
-    _write_json(tmp_dir, [{"a": 1, "b": 2}, {"a": 2, "b": 3}], "metric_t.json")
+    (tmp_dir / "metric_t.json").dump_json(
+        [{"a": 1, "b": 2}, {"a": 2, "b": 3}], sort_keys=True
+    )
     run_stage2 = run_copy_metrics(
         "metric_t.json",
         "metric.json",

tests/func/test_repro.py

@@ -1244,7 +1244,7 @@ def test_repro_when_cmd_changes(tmp_dir, dvc, run_copy, mocker):
 
     data = SingleStageFile(dvc, stage.path)._load()[0]
     data["cmd"] = "  ".join(stage.cmd.split())  # change cmd spacing by two
-    dump_yaml(stage.path, data)
+    (tmp_dir / stage.path).dump(data)
 
     assert dvc.status([stage.addressing]) == {
         stage.addressing: ["changed checksum"]

tests/func/test_repro_multistage.py

@@ -9,17 +9,17 @@ from dvc.dvcfile import PIPELINE_FILE, PIPELINE_LOCK
 from dvc.exceptions import CyclicGraphError, ReproductionError
 from dvc.main import main
 from dvc.stage import PipelineStage
-from dvc.utils.serialize import dump_yaml, load_yaml
 from tests.func import test_repro
+from tests.utils.scriptify import scriptify
 
-COPY_SCRIPT_FORMAT = dedent(
-    """\
-    import sys
+
+def copy_script(src, dest):
     import shutil
-    shutil.copyfile({}, {})
-"""
-)
-COPY_SCRIPT = COPY_SCRIPT_FORMAT.format("sys.argv[1]", "sys.argv[2]")
+
+    shutil.copyfile(src, dest)
+
+
+COPY_SCRIPT, _ = scriptify(copy_script)
 
 
 class MultiStageRun:
@@ -317,7 +317,7 @@ def test_repro_when_new_deps_is_added_in_dvcfile(tmp_dir, dvc, run_copy):
     dvcfile = Dvcfile(dvc, stage.path)
     data, _ = dvcfile._load()
     data["stages"]["copy-file"]["deps"] += ["copy.py"]
-    dump_yaml(stage.path, data)
+    (tmp_dir / stage.path).dump(data)
 
     assert dvc.reproduce(target)[0] == stage
 
@@ -339,7 +339,7 @@ def test_repro_when_new_outs_is_added_in_dvcfile(tmp_dir, dvc):
     dvcfile = Dvcfile(dvc, stage.path)
     data, _ = dvcfile._load()
     data["stages"]["copy-file"]["outs"] = ["foobar"]
-    dump_yaml(stage.path, data)
+    (tmp_dir / stage.path).dump(data)
 
     assert dvc.reproduce(target)[0] == stage
 
@@ -358,7 +358,10 @@ def test_repro_when_new_deps_is_moved(tmp_dir, dvc):
     target = ":copy-file"
     assert not dvc.reproduce(target)
 
-    tmp_dir.gen("copy.py", COPY_SCRIPT_FORMAT.format("'bar'", "'foobar'"))
+    # hardcode values in source code, ignore sys.argv
+    tmp_dir.gen(
+        "copy.py", COPY_SCRIPT.replace("func(*argv)", 'func("bar", "foobar")')
+    )
     from shutil import move
 
     move("foo", "bar")
@@ -366,7 +369,7 @@ def test_repro_when_new_deps_is_moved(tmp_dir, dvc):
     dvcfile = Dvcfile(dvc, stage.path)
     data, _ = dvcfile._load()
     data["stages"]["copy-file"]["deps"] = ["bar"]
-    dump_yaml(stage.path, data)
+    (tmp_dir / stage.path).dump(data)
 
     assert dvc.reproduce(target)[0] == stage
 
@@ -376,8 +379,7 @@ def test_repro_when_new_out_overlaps_others_stage_outs(tmp_dir, dvc):
 
     tmp_dir.gen({"dir": {"file1": "file1"}, "foo": "foo"})
     dvc.add("dir")
-    dump_yaml(
-        PIPELINE_FILE,
+    (tmp_dir / PIPELINE_FILE).dump(
         {
             "stages": {
                 "run-copy": {
@@ -395,8 +397,7 @@ def test_repro_when_new_out_overlaps_others_stage_outs(tmp_dir, dvc):
 def test_repro_when_new_deps_added_does_not_exist(tmp_dir, dvc):
     tmp_dir.gen("copy.py", COPY_SCRIPT)
     tmp_dir.gen("foo", "foo")
-    dump_yaml(
-        PIPELINE_FILE,
+    (tmp_dir / PIPELINE_FILE).dump(
         {
             "stages": {
                 "run-copy": {
@@ -414,8 +415,7 @@ def test_repro_when_new_deps_added_does_not_exist(tmp_dir, dvc):
 def test_repro_when_new_outs_added_does_not_exist(tmp_dir, dvc):
     tmp_dir.gen("copy.py", COPY_SCRIPT)
     tmp_dir.gen("foo", "foo")
-    dump_yaml(
-        PIPELINE_FILE,
+    (tmp_dir / PIPELINE_FILE).dump(
         {
             "stages": {
                 "run-copy": {
@@ -433,8 +433,7 @@ def test_repro_when_new_outs_added_does_not_exist(tmp_dir, dvc):
 def test_repro_when_lockfile_gets_deleted(tmp_dir, dvc):
     tmp_dir.gen("copy.py", COPY_SCRIPT)
     tmp_dir.gen("foo", "foo")
-    dump_yaml(
-        PIPELINE_FILE,
+    (tmp_dir / PIPELINE_FILE).dump(
         {
             "stages": {
                 "run-copy": {
@@ -464,13 +463,13 @@ def test_cyclic_graph_error(tmp_dir, dvc, run_copy):
     run_copy("bar", "baz", name="copy-bar-baz")
     run_copy("baz", "foobar", name="copy-baz-foobar")
 
-    data = load_yaml(PIPELINE_FILE)
+    data = (tmp_dir / PIPELINE_FILE).parse()
     data["stages"]["copy-baz-foo"] = {
         "cmd": "echo baz > foo",
         "deps": ["baz"],
         "outs": ["foo"],
     }
-    dump_yaml(PIPELINE_FILE, data)
+    (tmp_dir / PIPELINE_FILE).dump(data)
     with pytest.raises(CyclicGraphError):
         dvc.reproduce(":copy-baz-foo")
 
@@ -479,8 +478,8 @@ def test_repro_multiple_params(tmp_dir, dvc):
     from dvc.stage.utils import split_params_deps
     from tests.func.test_run_multistage import supported_params
 
-    dump_yaml(tmp_dir / "params2.yaml", supported_params)
-    dump_yaml(tmp_dir / "params.yaml", supported_params)
+    (tmp_dir / "params2.yaml").dump(supported_params)
+    (tmp_dir / "params.yaml").dump(supported_params)
 
     (tmp_dir / "foo").write_text("foo")
     stage = dvc.run(
@@ -522,7 +521,7 @@ def test_repro_multiple_params(tmp_dir, dvc):
     assert not dvc.reproduce(stage.addressing)
     params = deepcopy(supported_params)
     params["answer"] = 43
-    dump_yaml(tmp_dir / "params.yaml", params)
+    (tmp_dir / "params.yaml").dump(params)
 
     assert dvc.reproduce(stage.addressing) == [stage]
 
@@ -533,7 +532,7 @@ def test_repro_list_of_commands_in_order(tmp_dir, dvc, multiline):
     if multiline:
         cmd = "\n".join(cmd)
 
-    dump_yaml("dvc.yaml", {"stages": {"multi": {"cmd": cmd}}})
+    (tmp_dir / "dvc.yaml").dump({"stages": {"multi": {"cmd": cmd}}})
 
     (tmp_dir / "dvc.yaml").write_text(
         dedent(
@@ -559,7 +558,7 @@ def test_repro_list_of_commands_raise_and_stops_after_failure(
     if multiline:
         cmd = "\n".join(cmd)
 
-    dump_yaml("dvc.yaml", {"stages": {"multi": {"cmd": cmd}}})
+    (tmp_dir / "dvc.yaml").dump({"stages": {"multi": {"cmd": cmd}}})
 
     with pytest.raises(ReproductionError):
         dvc.reproduce(targets=["multi"])