dvc: bump to 1.0.0a9

This one doesn't allow us to release new pre-releases, because pypi
forbids that:

https://travis-ci.com/github/iterative/dvc/jobs/343343967#L2447

Let's install it separately for now, until there is a new official
mock-ssh-server release.

.github/ISSUE_TEMPLATE/bug_report.md

@@ -1,10 +1,19 @@
 ---
-name: Bug report
-about: Create a report to help us improve
-
+name: "\U0001F41B Bug Report"
+about: Create a bug report to help us improve DVC
+labels: bug, triage
 ---
 
+## Bug Report
 
-**Please provide information about your setup**
-DVC version(i.e. `dvc --version`), Platform and method of installation (pip, homebrew, pkg Mac, exe (Windows), DEB(Linux), RPM(Linux))
+### Please provide information about your setup
 
+**Output of `dvc version`:**
+
+```console
+$ dvc version
+```
+
+**Additional Information (if any):**
+
+If applicable, please also provide a `--verbose` output of the command, eg: `dvc add --verbose`.

.github/ISSUE_TEMPLATE/config.yml

@@ -0,0 +1,5 @@
+blank_issues_enabled: false
+contact_links:
+  - name: "🤗 Need help?"
+    url: https://dvc.org/chat
+    about: If you have a question, ask us on Discord. Please join with this invite 👉

.github/ISSUE_TEMPLATE/feature_request.md

@@ -1,6 +1,6 @@
 ---
-name: Feature request
+name: "\U0001F680 Feature Request"
 about: Suggest an idea for this project
-
+labels: feature request, triage
 ---
 

.pre-commit-config.yaml

@@ -27,18 +27,37 @@ repos:
   repo: https://github.com/lovesegfault/beautysh
   rev: master
 - hooks:
-  - id: dvc-pre-commit
-    language_version: python3
+  - args:
+    - git-hook
+    - pre-commit
+    entry: dvc
+    id: dvc-pre-commit
+    language: system
+    name: DVC pre-commit
     stages:
     - commit
-  - id: dvc-pre-push
-    language_version: python3
+    verbose: true
+    require_serial: true
+  - args:
+    - git-hook
+    - pre-push
+    entry: dvc
+    id: dvc-pre-push
+    language: system
+    name: DVC pre-push
     stages:
     - push
+    require_serial: true
   - always_run: true
+    args:
+    - git-hook
+    - post-checkout
+    entry: dvc
     id: dvc-post-checkout
-    language_version: python3
+    language: system
+    minimum_pre_commit_version: 2.2.0
+    name: DVC post-checkout
     stages:
     - post-checkout
-  repo: https://github.com/iterative/dvc
-  rev: master
+    require_serial: true
+  repo: local

.pre-commit-hooks.yaml

@@ -6,6 +6,7 @@
   language: python
   language_version: python3
   name: DVC pre-commit
+  require_serial: true
   stages:
   - commit
   verbose: true
@@ -17,6 +18,7 @@
   language: python
   language_version: python3
   name: DVC pre-push
+  require_serial: true
   stages:
   - push
 - always_run: true
@@ -29,5 +31,6 @@
   language_version: python3
   minimum_pre_commit_version: 2.2.0
   name: DVC post-checkout
+  require_serial: true
   stages:
   - post-checkout

.travis.yml

@@ -46,9 +46,6 @@ jobs:
     env:
       - PYTHON_VERSION=3.8.0
       - PATH=/c/Python38:/c/Python38/Scripts:$PATH
-  - name: "3.5 on Linux"
-    language: python
-    python: 3.5
   - name: "3.6 on Linux"
     language: python
     python: 3.6

README.rst

@@ -101,7 +101,8 @@ Snap (Snapcraft/Linux)
    snap install dvc --classic
 
 This corresponds to the latest tagged release.
-Add ``--edge`` for the latest ``master`` version.
+Add ``--beta`` for the latest tagged release candidate,
+or ``--edge`` for the latest ``master`` version.
 
 Choco (Chocolatey/Windows)
 --------------------------

dvc/analytics.py

@@ -72,7 +72,7 @@ def send(path):
     url = "https://analytics.dvc.org"
     headers = {"content-type": "application/json"}
 
-    with open(path, "r") as fobj:
+    with open(path) as fobj:
         report = json.load(fobj)
 
     report.update(_runtime_info())
@@ -158,7 +158,7 @@ def _find_or_create_user_id():
     try:
         with Lock(lockfile):
             try:
-                with open(fname, "r") as fobj:
+                with open(fname) as fobj:
                     user_id = json.load(fobj)["user_id"]
 
             except (FileNotFoundError, ValueError, KeyError):
@@ -170,6 +170,4 @@ def _find_or_create_user_id():
             return user_id
 
     except LockError:
-        logger.debug(
-            "Failed to acquire '{lockfile}'".format(lockfile=lockfile)
-        )
+        logger.debug(f"Failed to acquire '{lockfile}'")

dvc/api.py

@@ -11,7 +11,7 @@ class UrlNotDvcRepoError(DvcException):
     """Thrown if the given URL is not a DVC repository."""
 
     def __init__(self, url):
-        super().__init__("'{}' is not a DVC repository.".format(url))
+        super().__init__(f"'{url}' is not a DVC repository.")
 
 
 def get_url(path, repo=None, rev=None, remote=None):

dvc/cache.py

@@ -40,7 +40,7 @@ def _make_remote_property(name):
     return cached_property(getter)
 
 
-class Cache(object):
+class Cache:
     """Class that manages cache locations of a DVC repo.
 
     Args:
@@ -101,7 +101,7 @@ class NamedCacheItem:
             self.children[checksum].update(child_item)
 
 
-class NamedCache(object):
+class NamedCache:
     def __init__(self):
         self._items = defaultdict(lambda: defaultdict(NamedCacheItem))
         self.external = defaultdict(set)

dvc/cli.py

@@ -10,9 +10,11 @@ from .command import (
     commit,
     config,
     daemon,
+    dag,
     data_sync,
     destroy,
     diff,
+    freeze,
     gc,
     get,
     get_url,
@@ -21,13 +23,11 @@ from .command import (
     imp_url,
     init,
     install,
-    lock,
     ls,
     metrics,
     move,
     params,
-    pipeline,
-    plot,
+    plots,
     remote,
     remove,
     repro,
@@ -66,15 +66,15 @@ COMMANDS = [
     install,
     root,
     ls,
-    lock,
-    pipeline,
+    freeze,
+    dag,
     daemon,
     commit,
     diff,
     version,
     update,
     git_hook,
-    plot,
+    plots,
 ]
 
 
@@ -116,14 +116,10 @@ def get_parent_parser():
 
     log_level_group = parent_parser.add_mutually_exclusive_group()
     log_level_group.add_argument(
-        "-q", "--quiet", action="store_true", default=False, help="Be quiet."
+        "-q", "--quiet", action="count", default=0, help="Be quiet."
     )
     log_level_group.add_argument(
-        "-v",
-        "--verbose",
-        action="store_true",
-        default=False,
-        help="Be verbose.",
+        "-v", "--verbose", action="count", default=0, help="Be verbose."
     )
 
     return parent_parser

dvc/command/add.py

@@ -18,6 +18,7 @@ class CmdAdd(CmdBase):
                 recursive=self.args.recursive,
                 no_commit=self.args.no_commit,
                 fname=self.args.file,
+                external=self.args.external,
             )
 
         except DvcException:
@@ -49,6 +50,12 @@ def add_parser(subparsers, parent_parser):
         default=False,
         help="Don't put files/directories into cache.",
     )
+    parser.add_argument(
+        "--external",
+        action="store_true",
+        default=False,
+        help="Allow targets that are outside of the DVC repository.",
+    )
     parser.add_argument(
         "-f",
         "--file",

dvc/command/base.py

@@ -26,7 +26,7 @@ def append_doc_link(help_message, path):
     )
 
 
-class CmdBase(object):
+class CmdBase:
     def __init__(self, args):
         from dvc.repo import Repo
         from dvc.updater import Updater
@@ -43,8 +43,7 @@ class CmdBase(object):
         """Default targets for `dvc repro`."""
         from dvc.dvcfile import PIPELINE_FILE
 
-        msg = "assuming default target '{}'.".format(PIPELINE_FILE)
-        logger.warning(msg)
+        logger.debug(f"assuming default target '{PIPELINE_FILE}'.")
         return [PIPELINE_FILE]
 
     # Abstract methods that have to be implemented by any inheritance class

dvc/command/dag.py

@@ -0,0 +1,115 @@
+import argparse
+import logging
+
+from dvc.command.base import CmdBase, append_doc_link
+from dvc.exceptions import DvcException
+
+logger = logging.getLogger(__name__)
+
+
+def _show_ascii(G):
+    from dvc.repo.graph import get_pipelines
+    from dvc.dagascii import draw
+
+    pipelines = get_pipelines(G)
+
+    ret = []
+    for pipeline in pipelines:
+        ret.append(draw(pipeline.nodes, pipeline.edges))
+
+    return "\n".join(ret)
+
+
+def _show_dot(G):
+    import io
+    from networkx.drawing.nx_pydot import write_dot
+
+    dot_file = io.StringIO()
+    write_dot(G, dot_file)
+    return dot_file.getvalue()
+
+
+def _build(G, target=None, full=False):
+    import networkx as nx
+    from dvc.repo.graph import get_pipeline, get_pipelines
+
+    if target:
+        H = get_pipeline(get_pipelines(G), target)
+        if not full:
+            descendants = nx.descendants(G, target)
+            descendants.add(target)
+            H.remove_nodes_from(set(G.nodes()) - descendants)
+    else:
+        H = G
+
+    def _relabel(stage):
+        return stage.addressing
+
+    return nx.relabel_nodes(H, _relabel, copy=False)
+
+
+class CmdDAG(CmdBase):
+    def run(self):
+        try:
+            target = None
+            if self.args.target:
+                stages = self.repo.collect(self.args.target)
+                if len(stages) > 1:
+                    logger.error(
+                        f"'{self.args.target}' contains more than one stage "
+                        "{stages}, please specify one stage"
+                    )
+                    return 1
+                target = stages[0]
+
+            G = _build(self.repo.graph, target=target, full=self.args.full,)
+
+            if self.args.dot:
+                logger.info(_show_dot(G))
+            else:
+                from dvc.utils.pager import pager
+
+                pager(_show_ascii(G))
+
+            return 0
+        except DvcException:
+            msg = "failed to show"
+            if self.args.target:
+                msg += f"a pipeline for '{target}'"
+            else:
+                msg += "pipelines"
+            logger.exception(msg)
+            return 1
+
+
+def add_parser(subparsers, parent_parser):
+    DAG_HELP = "Visualize DVC project DAG."
+    dag_parser = subparsers.add_parser(
+        "dag",
+        parents=[parent_parser],
+        description=append_doc_link(DAG_HELP, "dag"),
+        help=DAG_HELP,
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+    )
+    dag_parser.add_argument(
+        "--dot",
+        action="store_true",
+        default=False,
+        help="Print DAG with .dot format.",
+    )
+    dag_parser.add_argument(
+        "--full",
+        action="store_true",
+        default=False,
+        help=(
+            "Show full DAG that the target belongs too, instead of "
+            "showing DAG consisting only of ancestors."
+        ),
+    )
+    dag_parser.add_argument(
+        "target",
+        nargs="?",
+        help="Stage or output to show pipeline for (optional). "
+        "Finds all stages in the workspace by default.",
+    )
+    dag_parser.set_defaults(func=CmdDAG)

dvc/command/diff.py

@@ -11,6 +11,21 @@ from dvc.exceptions import DvcException
 logger = logging.getLogger(__name__)
 
 
+def _show_md(diff):
+    from dvc.utils.diff import table
+
+    rows = []
+    for status in ["added", "deleted", "modified"]:
+        entries = diff.get(status, [])
+        if not entries:
+            continue
+        paths = sorted([entry["path"] for entry in entries])
+        for path in paths:
+            rows.append([status, path])
+
+    return table(["Status", "Path"], rows, True)
+
+
 class CmdDiff(CmdBase):
     @staticmethod
     def _format(diff):
@@ -103,6 +118,8 @@ class CmdDiff(CmdBase):
 
             if self.args.show_json:
                 logger.info(json.dumps(diff))
+            elif self.args.show_md:
+                logger.info(_show_md(diff))
             elif diff:
                 logger.info(self._format(diff))
 
@@ -147,4 +164,10 @@ def add_parser(subparsers, parent_parser):
         action="store_true",
         default=False,
     )
+    diff_parser.add_argument(
+        "--show-md",
+        help="Show tabulated output in the Markdown format (GFM).",
+        action="store_true",
+        default=False,
+    )
     diff_parser.set_defaults(func=CmdDiff)

dvc/command/freeze.py

@@ -0,0 +1,57 @@
+import argparse
+import logging
+
+from dvc.command.base import CmdBase, append_doc_link
+from dvc.exceptions import DvcException
+
+logger = logging.getLogger(__name__)
+
+
+class CmdFreezeBase(CmdBase):
+    def _run(self, func, name):
+        ret = 0
+        for target in self.args.targets:
+            try:
+                func(target)
+            except DvcException:
+                logger.exception(f"failed to {name} '{target}'")
+                ret = 1
+        return ret
+
+
+class CmdFreeze(CmdFreezeBase):
+    def run(self):
+        return self._run(self.repo.freeze, "freeze")
+
+
+class CmdUnfreeze(CmdFreezeBase):
+    def run(self):
+        return self._run(self.repo.unfreeze, "unfreeze")
+
+
+def add_parser(subparsers, parent_parser):
+    FREEZE_HELP = "Freeze DVC-files."
+    freeze_parser = subparsers.add_parser(
+        "freeze",
+        parents=[parent_parser],
+        description=append_doc_link(FREEZE_HELP, "freeze"),
+        help=FREEZE_HELP,
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+    )
+    freeze_parser.add_argument(
+        "targets", nargs="+", help="DVC-files to freeze."
+    )
+    freeze_parser.set_defaults(func=CmdFreeze)
+
+    UNFREEZE_HELP = "Unfreeze DVC-files."
+    unfreeze_parser = subparsers.add_parser(
+        "unfreeze",
+        parents=[parent_parser],
+        description=append_doc_link(UNFREEZE_HELP, "unfreeze"),
+        help=UNFREEZE_HELP,
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+    )
+    unfreeze_parser.add_argument(
+        "targets", nargs="+", help="DVC-files to unfreeze."
+    )
+    unfreeze_parser.set_defaults(func=CmdUnfreeze)

dvc/command/gc.py

@@ -21,7 +21,7 @@ class CmdGC(CmdBase):
 
         msg = "This will remove all cache except items used in "
 
-        msg += "the working tree"
+        msg += "the workspace"
         if self.args.all_commits:
             msg += " and all git commits"
         elif self.args.all_branches and self.args.all_tags:
@@ -77,7 +77,7 @@ def add_parser(subparsers, parent_parser):
         "--workspace",
         action="store_true",
         default=False,
-        help="Keep data files used in the current workspace (working tree).",
+        help="Keep data files used in the current workspace.",
     )
     gc_parser.add_argument(
         "-a",

dvc/command/get_url.py

@@ -16,7 +16,7 @@ class CmdGetUrl(CmdBaseNoRepo):
             Repo.get_url(self.args.url, out=self.args.out)
             return 0
         except DvcException:
-            logger.exception("failed to get '{}'".format(self.args.url))
+            logger.exception(f"failed to get '{self.args.url}'")
             return 1
 
 

dvc/command/lock.py

@@ -1,59 +0,0 @@
-import argparse
-import logging
-
-from dvc.command.base import CmdBase, append_doc_link
-from dvc.exceptions import DvcException
-
-logger = logging.getLogger(__name__)
-
-
-class CmdLockBase(CmdBase):
-    def _run(self, unlock):
-        for target in self.args.targets:
-            try:
-                self.repo.lock_stage(target, unlock=unlock)
-            except DvcException:
-                logger.exception(
-                    "failed to {}lock '{}'".format(
-                        "un" if unlock else "", target
-                    )
-                )
-
-                return 1
-        return 0
-
-
-class CmdLock(CmdLockBase):
-    def run(self):
-        return self._run(False)
-
-
-class CmdUnlock(CmdLockBase):
-    def run(self):
-        return self._run(True)
-
-
-def add_parser(subparsers, parent_parser):
-    LOCK_HELP = "Lock DVC-files."
-    lock_parser = subparsers.add_parser(
-        "lock",
-        parents=[parent_parser],
-        description=append_doc_link(LOCK_HELP, "lock"),
-        help=LOCK_HELP,
-        formatter_class=argparse.RawDescriptionHelpFormatter,
-    )
-    lock_parser.add_argument("targets", nargs="+", help="DVC-files to lock.")
-    lock_parser.set_defaults(func=CmdLock)
-
-    UNLOCK_HELP = "Unlock DVC-files."
-    unlock_parser = subparsers.add_parser(
-        "unlock",
-        parents=[parent_parser],
-        description=append_doc_link(UNLOCK_HELP, "unlock"),
-        help=UNLOCK_HELP,
-        formatter_class=argparse.RawDescriptionHelpFormatter,
-    )
-    unlock_parser.add_argument(
-        "targets", nargs="+", help="DVC-files to unlock."
-    )
-    unlock_parser.set_defaults(func=CmdUnlock)

dvc/command/ls/__init__.py

@@ -31,14 +31,14 @@ class CmdList(CmdBaseNoRepo):
                 self.args.path,
                 rev=self.args.rev,
                 recursive=self.args.recursive,
-                outs_only=self.args.outs_only,
+                dvc_only=self.args.dvc_only,
             )
             if entries:
                 entries = _prettify(entries, sys.stdout.isatty())
                 logger.info("\n".join(entries))
             return 0
         except DvcException:
-            logger.exception("failed to list '{}'".format(self.args.url))
+            logger.exception(f"failed to list '{self.args.url}'")
             return 1
 
 
@@ -62,7 +62,7 @@ def add_parser(subparsers, parent_parser):
         help="Recursively list files.",
     )
     list_parser.add_argument(
-        "--outs-only", action="store_true", help="Show only DVC outputs."
+        "--dvc-only", action="store_true", help="Show only DVC outputs."
     )
     list_parser.add_argument(
         "--rev",

dvc/command/ls/ls_colors.py

@@ -1,7 +1,7 @@
 import os
 
 
-class LsColors(object):
+class LsColors:
     default = "rs=0:di=01;34:ex=01;32"
 
     def __init__(self, lscolors=None):
@@ -45,4 +45,4 @@ class LsColors(object):
         if not val:
             return text
         rs = self._codes.get("rs", 0)
-        return "\033[{}m{}\033[{}m".format(val, text, rs)
+        return f"\033[{val}m{text}\033[{rs}m"

dvc/command/metrics.py

@@ -19,16 +19,16 @@ def show_metrics(
 
     for branch, val in metrics.items():
         if all_branches or all_tags or all_commits:
-            logger.info("{branch}:".format(branch=branch))
+            logger.info(f"{branch}:")
 
         for fname, metric in val.items():
             if not isinstance(metric, dict):
                 logger.info("\t{}: {}".format(fname, str(metric)))
                 continue
 
-            logger.info("\t{}:".format(fname))
+            logger.info(f"\t{fname}:")
             for key, value in flatten(format_dict(metric), ".").items():
-                logger.info("\t\t{}: {}".format(key, value))
+                logger.info(f"\t\t{key}: {value}")
 
     if missing:
         raise BadMetricError(missing)
@@ -63,31 +63,7 @@ class CmdMetricsShow(CmdBase):
         return 0
 
 
-class CmdMetricsAdd(CmdBase):
-    def run(self):
-        try:
-            self.repo.metrics.add(self.args.path)
-        except DvcException:
-            msg = "failed to add metric file '{}'".format(self.args.path)
-            logger.exception(msg)
-            return 1
-
-        return 0
-
-
-class CmdMetricsRemove(CmdBase):
-    def run(self):
-        try:
-            self.repo.metrics.remove(self.args.path)
-        except DvcException:
-            msg = "failed to remove metric file '{}'".format(self.args.path)
-            logger.exception(msg)
-            return 1
-
-        return 0
-
-
-def _show_diff(diff):
+def _show_diff(diff, markdown=False, no_path=False, old=False):
     from collections import OrderedDict
 
     from dvc.utils.diff import table
@@ -96,16 +72,23 @@ def _show_diff(diff):
     for fname, mdiff in diff.items():
         sorted_mdiff = OrderedDict(sorted(mdiff.items()))
         for metric, change in sorted_mdiff.items():
-            rows.append(
-                [
-                    fname,
-                    metric,
-                    change["new"],
-                    change.get("diff", "diff not supported"),
-                ]
-            )
+            row = [] if no_path else [fname]
+            row.append(metric)
+            if old:
+                row.append(change.get("old"))
+            row.append(change["new"])
+            row.append(change.get("diff", "diff not supported"))
+            rows.append(row)
 
-    return table(["Path", "Metric", "Value", "Change"], rows)
+    header = [] if no_path else ["Path"]
+    header.append("Metric")
+    if old:
+        header.extend(["Old", "New"])
+    else:
+        header.append("Value")
+    header.append("Change")
+
+    return table(header, rows, markdown)
 
 
 class CmdMetricsDiff(CmdBase):
@@ -124,7 +107,9 @@ class CmdMetricsDiff(CmdBase):
 
                 logger.info(json.dumps(diff))
             else:
-                table = _show_diff(diff)
+                table = _show_diff(
+                    diff, self.args.show_md, self.args.no_path, self.args.old
+                )
                 if table:
                     logger.info(table)
 
@@ -136,7 +121,7 @@ class CmdMetricsDiff(CmdBase):
 
 
 def add_parser(subparsers, parent_parser):
-    METRICS_HELP = "Commands to add, manage, collect, and display metrics."
+    METRICS_HELP = "Commands to display and compare metrics."
 
     metrics_parser = subparsers.add_parser(
         "metrics",
@@ -153,17 +138,6 @@ def add_parser(subparsers, parent_parser):
 
     fix_subparsers(metrics_subparsers)
 
-    METRICS_ADD_HELP = "Mark a DVC-tracked file as a metric."
-    metrics_add_parser = metrics_subparsers.add_parser(
-        "add",
-        parents=[parent_parser],
-        description=append_doc_link(METRICS_ADD_HELP, "metrics/add"),
-        help=METRICS_ADD_HELP,
-        formatter_class=argparse.RawDescriptionHelpFormatter,
-    )
-    metrics_add_parser.add_argument("path", help="Path to a metric file.")
-    metrics_add_parser.set_defaults(func=CmdMetricsAdd)
-
     METRICS_SHOW_HELP = "Print metrics, with optional formatting."
     metrics_show_parser = metrics_subparsers.add_parser(
         "show",
@@ -263,15 +237,22 @@ def add_parser(subparsers, parent_parser):
         default=False,
         help="Show output in JSON format.",
     )
-    metrics_diff_parser.set_defaults(func=CmdMetricsDiff)
-
-    METRICS_REMOVE_HELP = "Remove metric mark on a DVC-tracked file."
-    metrics_remove_parser = metrics_subparsers.add_parser(
-        "remove",
-        parents=[parent_parser],
-        description=append_doc_link(METRICS_REMOVE_HELP, "metrics/remove"),
-        help=METRICS_REMOVE_HELP,
-        formatter_class=argparse.RawDescriptionHelpFormatter,
+    metrics_diff_parser.add_argument(
+        "--show-md",
+        action="store_true",
+        default=False,
+        help="Show tabulated output in the Markdown format (GFM).",
     )
-    metrics_remove_parser.add_argument("path", help="Path to a metric file.")
-    metrics_remove_parser.set_defaults(func=CmdMetricsRemove)
+    metrics_diff_parser.add_argument(
+        "--no-path",
+        action="store_true",
+        default=False,
+        help="Don't show metric path.",
+    )
+    metrics_diff_parser.add_argument(
+        "--old",
+        action="store_true",
+        default=False,
+        help="Show old metric value.",
+    )
+    metrics_diff_parser.set_defaults(func=CmdMetricsDiff)

dvc/command/params.py

@@ -8,16 +8,25 @@ from dvc.exceptions import DvcException
 logger = logging.getLogger(__name__)
 
 
-def _show_diff(diff):
+def _show_diff(diff, markdown=False, no_path=False):
     from dvc.utils.diff import table
 
     rows = []
     for fname, pdiff in diff.items():
         sorted_pdiff = OrderedDict(sorted(pdiff.items()))
         for param, change in sorted_pdiff.items():
-            rows.append([fname, param, change["old"], change["new"]])
+            row = [] if no_path else [fname]
+            row.append(param)
+            row.append(change["old"])
+            row.append(change["new"])
+            rows.append(row)
 
-    return table(["Path", "Param", "Old", "New"], rows)
+    header = [] if no_path else ["Path"]
+    header.append("Param")
+    header.append("Old")
+    header.append("New")
+
+    return table(header, rows, markdown)
 
 
 class CmdParamsDiff(CmdBase):
@@ -34,7 +43,7 @@ class CmdParamsDiff(CmdBase):
 
                 logger.info(json.dumps(diff))
             else:
-                table = _show_diff(diff)
+                table = _show_diff(diff, self.args.show_md, self.args.no_path)
                 if table:
                     logger.info(table)
 
@@ -94,4 +103,16 @@ def add_parser(subparsers, parent_parser):
         default=False,
         help="Show output in JSON format.",
     )
+    params_diff_parser.add_argument(
+        "--show-md",
+        action="store_true",
+        default=False,
+        help="Show tabulated output in the Markdown format (GFM).",
+    )
+    params_diff_parser.add_argument(
+        "--no-path",
+        action="store_true",
+        default=False,
+        help="Don't show params path.",
+    )
     params_diff_parser.set_defaults(func=CmdParamsDiff)

dvc/command/pipeline.py

@@ -1,246 +0,0 @@
-import argparse
-import logging
-
-from dvc.command.base import CmdBase, append_doc_link, fix_subparsers
-from dvc.exceptions import DvcException
-
-logger = logging.getLogger(__name__)
-
-
-class CmdPipelineShow(CmdBase):
-    def _show(self, target, commands, outs, locked):
-        import networkx
-        from dvc import dvcfile
-        from dvc.utils import parse_target
-
-        path, name = parse_target(target)
-        stage = dvcfile.Dvcfile(self.repo, path).stages[name]
-        G = self.repo.graph
-        stages = networkx.dfs_postorder_nodes(G, stage)
-        if locked:
-            stages = [s for s in stages if s.locked]
-
-        for stage in stages:
-            if commands:
-                if stage.cmd is None:
-                    continue
-                logger.info(stage.cmd)
-            elif outs:
-                for out in stage.outs:
-                    logger.info(str(out))
-            else:
-                logger.info(stage.addressing)
-
-    def _build_graph(self, target, commands=False, outs=False):
-        import networkx
-        from dvc import dvcfile
-        from dvc.repo.graph import get_pipeline
-        from dvc.utils import parse_target
-
-        path, name = parse_target(target)
-        target_stage = dvcfile.Dvcfile(self.repo, path).stages[name]
-        G = get_pipeline(self.repo.pipelines, target_stage)
-
-        nodes = set()
-        for stage in networkx.dfs_preorder_nodes(G, target_stage):
-            if commands:
-                if stage.cmd is None:
-                    continue
-                nodes.add(stage.cmd)
-            elif outs:
-                for out in stage.outs:
-                    nodes.add(str(out))
-            else:
-                nodes.add(stage.addressing)
-
-        edges = []
-        for from_stage, to_stage in networkx.edge_dfs(G, target_stage):
-            if commands:
-                if to_stage.cmd is None:
-                    continue
-                edges.append((from_stage.cmd, to_stage.cmd))
-            elif outs:
-                for from_out in from_stage.outs:
-                    for to_out in to_stage.outs:
-                        edges.append((str(from_out), str(to_out)))
-            else:
-                edges.append((from_stage.addressing, to_stage.addressing))
-
-        return list(nodes), edges, networkx.is_tree(G)
-
-    def _show_ascii(self, target, commands, outs):
-        from dvc.dagascii import draw
-
-        nodes, edges, _ = self._build_graph(target, commands, outs)
-
-        if not nodes:
-            return
-
-        draw(nodes, edges)
-
-    def _show_dependencies_tree(self, target, commands, outs):
-        from treelib import Tree
-
-        nodes, edges, is_tree = self._build_graph(target, commands, outs)
-        if not nodes:
-            return
-        if not is_tree:
-            raise DvcException(
-                "DAG is not a tree, can not print it in tree-structure way, "
-                "please use --ascii instead"
-            )
-
-        tree = Tree()
-        tree.create_node(target, target)  # Root node
-        observe_list = [target]
-        while len(observe_list) > 0:
-            current_root = observe_list[0]
-            for edge in edges:
-                if edge[0] == current_root:
-                    tree.create_node(edge[1], edge[1], parent=current_root)
-                    observe_list.append(edge[1])
-            observe_list.pop(0)
-        tree.show()
-
-    def _write_dot(self, target, commands, outs):
-        import io
-        import networkx
-        from networkx.drawing.nx_pydot import write_dot
-
-        _, edges, _ = self._build_graph(target, commands, outs)
-        edges = [edge[::-1] for edge in edges]
-
-        simple_g = networkx.DiGraph()
-        simple_g.add_edges_from(edges)
-
-        dot_file = io.StringIO()
-        write_dot(simple_g, dot_file)
-        logger.info(dot_file.getvalue())
-
-    def run(self):
-        from dvc.dvcfile import DVC_FILE
-
-        if not self.args.targets:
-            self.args.targets = [DVC_FILE]
-
-        for target in self.args.targets:
-            try:
-                if self.args.ascii:
-                    self._show_ascii(
-                        target, self.args.commands, self.args.outs
-                    )
-                elif self.args.dot:
-                    self._write_dot(target, self.args.commands, self.args.outs)
-                elif self.args.tree:
-                    self._show_dependencies_tree(
-                        target, self.args.commands, self.args.outs
-                    )
-                else:
-                    self._show(
-                        target,
-                        self.args.commands,
-                        self.args.outs,
-                        self.args.locked,
-                    )
-            except DvcException:
-                msg = "failed to show pipeline for '{}'".format(target)
-                logger.exception(msg)
-                return 1
-        return 0
-
-
-class CmdPipelineList(CmdBase):
-    def run(self):
-        pipelines = self.repo.pipelines
-        for pipeline in pipelines:
-            for stage in pipeline:
-                logger.info(stage.addressing)
-            if len(pipeline) != 0:
-                logger.info("=" * 80)
-        logger.info("{} pipelines total".format(len(pipelines)))
-
-        return 0
-
-
-def add_parser(subparsers, parent_parser):
-    PIPELINE_HELP = "Manage pipelines."
-    pipeline_parser = subparsers.add_parser(
-        "pipeline",
-        parents=[parent_parser],
-        description=append_doc_link(PIPELINE_HELP, "pipeline"),
-        help=PIPELINE_HELP,
-        formatter_class=argparse.RawDescriptionHelpFormatter,
-    )
-
-    pipeline_subparsers = pipeline_parser.add_subparsers(
-        dest="cmd",
-        help="Use `dvc pipeline CMD --help` for command-specific help.",
-    )
-
-    fix_subparsers(pipeline_subparsers)
-
-    PIPELINE_LIST_HELP = "List connected groups of stages (pipelines)."
-    pipeline_list_parser = pipeline_subparsers.add_parser(
-        "list",
-        parents=[parent_parser],
-        description=append_doc_link(PIPELINE_LIST_HELP, "pipeline/list"),
-        help=PIPELINE_LIST_HELP,
-        formatter_class=argparse.RawDescriptionHelpFormatter,
-    )
-    pipeline_list_parser.set_defaults(func=CmdPipelineList)
-
-    PIPELINE_SHOW_HELP = "Show stages in a pipeline."
-    pipeline_show_parser = pipeline_subparsers.add_parser(
-        "show",
-        parents=[parent_parser],
-        description=append_doc_link(PIPELINE_SHOW_HELP, "pipeline/show"),
-        help=PIPELINE_SHOW_HELP,
-        formatter_class=argparse.RawDescriptionHelpFormatter,
-    )
-    pipeline_show_group = pipeline_show_parser.add_mutually_exclusive_group()
-    pipeline_show_group.add_argument(
-        "-c",
-        "--commands",
-        action="store_true",
-        default=False,
-        help="Print commands instead of paths to DVC-files.",
-    )
-    pipeline_show_group.add_argument(
-        "-o",
-        "--outs",
-        action="store_true",
-        default=False,
-        help="Print output files instead of paths to DVC-files.",
-    )
-    pipeline_show_parser.add_argument(
-        "-l",
-        "--locked",
-        action="store_true",
-        default=False,
-        help="Print locked DVC stages",
-    )
-    pipeline_show_parser.add_argument(
-        "--ascii",
-        action="store_true",
-        default=False,
-        help="Output DAG as ASCII.",
-    )
-    pipeline_show_parser.add_argument(
-        "--dot",
-        action="store_true",
-        default=False,
-        help="Print DAG with .dot format.",
-    )
-    pipeline_show_parser.add_argument(
-        "--tree",
-        action="store_true",
-        default=False,
-        help="Output DAG as Dependencies Tree.",
-    )
-    pipeline_show_parser.add_argument(
-        "targets",
-        nargs="*",
-        help="DVC-files to show pipeline for. Optional. "
-        "(Finds all DVC-files in the workspace by default.)",
-    )
-    pipeline_show_parser.set_defaults(func=CmdPipelineShow)

dvc/command/plot.py

@@ -1,240 +0,0 @@
-import argparse
-import logging
-import os
-
-from dvc.command.base import CmdBase, append_doc_link, fix_subparsers
-from dvc.exceptions import DvcException
-from dvc.repo.plot.data import WORKSPACE_REVISION_NAME
-
-logger = logging.getLogger(__name__)
-
-
-class CmdPLot(CmdBase):
-    def _revisions(self):
-        raise NotImplementedError
-
-    def _result_file(self):
-        if self.args.file:
-            return self.args.file
-
-        extension = self._result_extension()
-        base = self._result_basename()
-
-        result_file = base + extension
-        return result_file
-
-    def _result_basename(self):
-        if self.args.datafile:
-            return self.args.datafile
-        return "plot"
-
-    def _result_extension(self):
-        if not self.args.no_html:
-            return ".html"
-        elif self.args.template:
-            return os.path.splitext(self.args.template)[-1]
-        return ".json"
-
-    def run(self):
-        fields = None
-        jsonpath = None
-        if self.args.select:
-            if self.args.select.startswith("$"):
-                jsonpath = self.args.select
-            else:
-                fields = set(self.args.select.split(","))
-        try:
-            plot_string = self.repo.plot(
-                datafile=self.args.datafile,
-                template=self.args.template,
-                revisions=self._revisions(),
-                fields=fields,
-                x_field=self.args.x,
-                y_field=self.args.y,
-                path=jsonpath,
-                embed=not self.args.no_html,
-                csv_header=not self.args.no_csv_header,
-                title=self.args.title,
-                x_title=self.args.xlab,
-                y_title=self.args.ylab,
-            )
-
-            if self.args.stdout:
-                logger.info(plot_string)
-            else:
-                result_path = self._result_file()
-                with open(result_path, "w") as fobj:
-                    fobj.write(plot_string)
-
-                logger.info(
-                    "file://{}".format(
-                        os.path.join(self.repo.root_dir, result_path)
-                    )
-                )
-
-        except DvcException:
-            logger.exception("")
-            return 1
-
-        return 0
-
-
-class CmdPlotShow(CmdPLot):
-    def _revisions(self):
-        return None
-
-
-class CmdPlotDiff(CmdPLot):
-    def _revisions(self):
-        revisions = self.args.revisions or []
-        if len(revisions) <= 1:
-            if len(revisions) == 0 and self.repo.scm.is_dirty():
-                revisions.append("HEAD")
-            revisions.append(WORKSPACE_REVISION_NAME)
-        return revisions
-
-
-def add_parser(subparsers, parent_parser):
-    PLOT_HELP = (
-        "Generating plots for metrics stored in structured files "
-        "(JSON, CSV, TSV)."
-    )
-
-    plot_parser = subparsers.add_parser(
-        "plot",
-        parents=[parent_parser],
-        description=append_doc_link(PLOT_HELP, "plot"),
-        help=PLOT_HELP,
-        formatter_class=argparse.RawDescriptionHelpFormatter,
-    )
-    plot_subparsers = plot_parser.add_subparsers(
-        dest="cmd",
-        help="Use `dvc plot CMD --help` to display command-specific help.",
-    )
-
-    fix_subparsers(plot_subparsers)
-
-    SHOW_HELP = "Generate a plot image file from a metrics file."
-    plot_show_parser = plot_subparsers.add_parser(
-        "show",
-        parents=[parent_parser],
-        description=append_doc_link(SHOW_HELP, "plot/show"),
-        help=SHOW_HELP,
-        formatter_class=argparse.RawDescriptionHelpFormatter,
-    )
-    plot_show_parser.add_argument(
-        "-t",
-        "--template",
-        nargs="?",
-        default=None,
-        help="File to be injected with data.",
-    )
-    plot_show_parser.add_argument(
-        "-f", "--file", default=None, help="Name of the generated file."
-    )
-    plot_show_parser.add_argument(
-        "-s",
-        "--select",
-        default=None,
-        help="Choose which field(s) or JSONPath to include in the plot.",
-    )
-    plot_show_parser.add_argument(
-        "-x", default=None, help="Field name for x axis."
-    )
-    plot_show_parser.add_argument(
-        "-y", default=None, help="Field name for y axis."
-    )
-    plot_show_parser.add_argument(
-        "--stdout",
-        action="store_true",
-        default=False,
-        help="Print plot specification to stdout.",
-    )
-    plot_show_parser.add_argument(
-        "--no-csv-header",
-        action="store_true",
-        default=False,
-        help="Required when CSV or TSV datafile does not have a header.",
-    )
-    plot_show_parser.add_argument(
-        "--no-html",
-        action="store_true",
-        default=False,
-        help="Do not wrap Vega plot JSON with HTML.",
-    )
-    plot_show_parser.add_argument("--title", default=None, help="Plot title.")
-    plot_show_parser.add_argument("--xlab", default=None, help="X axis title.")
-    plot_show_parser.add_argument("--ylab", default=None, help="Y axis title.")
-    plot_show_parser.add_argument(
-        "datafile", nargs="?", default=None, help="Metrics file to visualize.",
-    )
-    plot_show_parser.set_defaults(func=CmdPlotShow)
-
-    PLOT_DIFF_HELP = (
-        "Plot metrics differences between commits in the DVC "
-        "repository, or between the last commit and the workspace."
-    )
-    plot_diff_parser = plot_subparsers.add_parser(
-        "diff",
-        parents=[parent_parser],
-        description=append_doc_link(PLOT_DIFF_HELP, "plot/diff"),
-        help=PLOT_DIFF_HELP,
-        formatter_class=argparse.RawDescriptionHelpFormatter,
-    )
-    plot_diff_parser.add_argument(
-        "-t",
-        "--template",
-        nargs="?",
-        default=None,
-        help="File to be injected with data.",
-    )
-    plot_diff_parser.add_argument(
-        "-d",
-        "--datafile",
-        nargs="?",
-        default=None,
-        help="Metrics file to visualize.",
-    )
-    plot_diff_parser.add_argument(
-        "-f", "--file", default=None, help="Name of the generated file."
-    )
-    plot_diff_parser.add_argument(
-        "-s",
-        "--select",
-        default=None,
-        help="Choose which field(s) or JSONPath to include in the plot.",
-    )
-    plot_diff_parser.add_argument(
-        "-x", default=None, help="Field name for x axis."
-    )
-    plot_diff_parser.add_argument(
-        "-y", default=None, help="Field name for y axis."
-    )
-    plot_diff_parser.add_argument(
-        "--stdout",
-        action="store_true",
-        default=False,
-        help="Print plot specification to stdout.",
-    )
-    plot_diff_parser.add_argument(
-        "--no-csv-header",
-        action="store_true",
-        default=False,
-        help="Provided CSV ot TSV datafile does not have a header.",
-    )
-    plot_diff_parser.add_argument(
-        "--no-html",
-        action="store_true",
-        default=False,
-        help="Do not wrap Vega plot JSON with HTML.",
-    )
-    plot_diff_parser.add_argument("--title", default=None, help="Plot title.")
-    plot_diff_parser.add_argument("--xlab", default=None, help="X axis title.")
-    plot_diff_parser.add_argument("--ylab", default=None, help="Y axis title.")
-    plot_diff_parser.add_argument(
-        "revisions",
-        nargs="*",
-        default=None,
-        help="Git revisions to plot from",
-    )
-    plot_diff_parser.set_defaults(func=CmdPlotDiff)

dvc/command/plots.py

@@ -0,0 +1,213 @@
+import argparse
+import logging
+import os
+
+from dvc.command.base import CmdBase, append_doc_link, fix_subparsers
+from dvc.exceptions import DvcException
+from dvc.schema import PLOT_PROPS
+from dvc.utils import format_link
+
+logger = logging.getLogger(__name__)
+
+PAGE_HTML = """<!DOCTYPE html>
+<html>
+<head>
+    <title>DVC Plot</title>
+    <script src="https://cdn.jsdelivr.net/npm/[email protected]"></script>
+    <script src="https://cdn.jsdelivr.net/npm/[email protected]"></script>
+    <script src="https://cdn.jsdelivr.net/npm/[email protected]"></script>
+</head>
+<body>
+    {divs}
+</body>
+</html>"""
+
+DIV_HTML = """<div id = "{id}"></div>
+<script type = "text/javascript">
+    var spec = {vega_json};
+    vegaEmbed('#{id}', spec);
+</script>"""
+
+
+class CmdPlots(CmdBase):
+    def _func(self, *args, **kwargs):
+        raise NotImplementedError
+
+    def _props(self):
+        # Pass only props specified by user, to not shadow ones from plot def
+        props = {p: getattr(self.args, p) for p in PLOT_PROPS}
+        return {k: v for k, v in props.items() if v is not None}
+
+    def run(self):
+        if self.args.show_vega:
+            if not self.args.targets:
+                logger.error("please specify a target for `--show-vega`")
+                return 1
+            if len(self.args.targets) > 1:
+                logger.error(
+                    "you can only specify one target for `--show-vega`"
+                )
+                return 1
+
+        try:
+            plots = self._func(targets=self.args.targets, props=self._props())
+
+            if self.args.show_vega:
+                target = self.args.targets[0]
+                logger.info(plots[target])
+                return 0
+
+            divs = [
+                DIV_HTML.format(id=f"plot{i}", vega_json=plot)
+                for i, plot in enumerate(plots.values())
+            ]
+            html = PAGE_HTML.format(divs="\n".join(divs))
+            path = self.args.out or "plots.html"
+
+            with open(path, "w") as fobj:
+                fobj.write(html)
+
+            logger.info(
+                "file://{}".format(os.path.join(self.repo.root_dir, path))
+            )
+
+        except DvcException:
+            logger.exception("")
+            return 1
+
+        return 0
+
+
+class CmdPlotsShow(CmdPlots):
+    def _func(self, *args, **kwargs):
+        return self.repo.plots.show(*args, **kwargs)
+
+
+class CmdPlotsDiff(CmdPlots):
+    def _func(self, *args, **kwargs):
+        return self.repo.plots.diff(*args, revs=self.args.revisions, **kwargs)
+
+
+class CmdPlotsModify(CmdPlots):
+    def run(self):
+        self.repo.plots.modify(
+            self.args.target, props=self._props(), unset=self.args.unset,
+        )
+        return 0
+
+
+def add_parser(subparsers, parent_parser):
+    PLOTS_HELP = (
+        "Generating plots for metrics stored in structured files "
+        "(JSON, CSV, TSV)."
+    )
+
+    plots_parser = subparsers.add_parser(
+        "plots",
+        parents=[parent_parser],
+        description=append_doc_link(PLOTS_HELP, "plots"),
+        help=PLOTS_HELP,
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+    )
+    plots_subparsers = plots_parser.add_subparsers(
+        dest="cmd",
+        help="Use `dvc plots CMD --help` to display command-specific help.",
+    )
+
+    fix_subparsers(plots_subparsers)
+
+    SHOW_HELP = "Generate a plots image file from a metrics file."
+    plots_show_parser = plots_subparsers.add_parser(
+        "show",
+        parents=[parent_parser],
+        description=append_doc_link(SHOW_HELP, "plots/show"),
+        help=SHOW_HELP,
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+    )
+    plots_show_parser.add_argument(
+        "targets",
+        nargs="*",
+        help="Plots files to visualize. Shows all plots by default.",
+    )
+    _add_props_arguments(plots_show_parser)
+    _add_output_arguments(plots_show_parser)
+    plots_show_parser.set_defaults(func=CmdPlotsShow)
+
+    PLOTS_DIFF_HELP = (
+        "Plot differences in metrics between commits in the DVC "
+        "repository, or between the last commit and the workspace."
+    )
+    plots_diff_parser = plots_subparsers.add_parser(
+        "diff",
+        parents=[parent_parser],
+        description=append_doc_link(PLOTS_DIFF_HELP, "plots/diff"),
+        help=PLOTS_DIFF_HELP,
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+    )
+    plots_diff_parser.add_argument(
+        "--targets",
+        nargs="*",
+        help="Plots file to visualize. Shows all plots by default.",
+    )
+    plots_diff_parser.add_argument(
+        "revisions", nargs="*", default=None, help="Git commits to plot from",
+    )
+    _add_props_arguments(plots_diff_parser)
+    _add_output_arguments(plots_diff_parser)
+    plots_diff_parser.set_defaults(func=CmdPlotsDiff)
+
+    PLOTS_MODIFY_HELP = "Modify plot props associated with a target file."
+    plots_modify_parser = plots_subparsers.add_parser(
+        "modify",
+        parents=[parent_parser],
+        description=append_doc_link(PLOTS_MODIFY_HELP, "plots/modify"),
+        help=PLOTS_MODIFY_HELP,
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+    )
+    plots_modify_parser.add_argument(
+        "target", help="Plot file to set props to.",
+    )
+    _add_props_arguments(plots_modify_parser)
+    plots_modify_parser.add_argument(
+        "--unset", nargs="*", help="Props to unset.",
+    )
+    plots_modify_parser.set_defaults(func=CmdPlotsModify)
+
+
+def _add_props_arguments(parser):
+    parser.add_argument(
+        "-t",
+        "--template",
+        nargs="?",
+        default=None,
+        help=(
+            "Special JSON or HTML schema file to inject with the data. "
+            "See {}".format(
+                format_link("https://man.dvc.org/plots#plot-templates")
+            )
+        ),
+    )
+    parser.add_argument("-x", default=None, help="Field name for x axis.")
+    parser.add_argument("-y", default=None, help="Field name for y axis.")
+    parser.add_argument(
+        "--no-csv-header",
+        action="store_false",
+        dest="csv_header",
+        default=None,  # Use default None to distinguish when it's not used
+        help="Provided CSV ot TSV datafile does not have a header.",
+    )
+    parser.add_argument("--title", default=None, help="Plot title.")
+    parser.add_argument("--x-label", default=None, help="X axis label.")
+    parser.add_argument("--y-label", default=None, help="Y axis lebel.")
+
+
+def _add_output_arguments(parser):
+    parser.add_argument(
+        "-o", "--out", default=None, help="Destination path to save plots to.",
+    )
+    parser.add_argument(
+        "--show-vega",
+        action="store_true",
+        default=False,
+        help="Show output in Vega format.",
+    )

dvc/command/remote.py

@@ -18,17 +18,13 @@ class CmdRemote(CmdConfig):
 
     def _check_exists(self, conf):
         if self.args.name not in conf["remote"]:
-            raise ConfigError(
-                "remote '{}' doesn't exists.".format(self.args.name)
-            )
+            raise ConfigError(f"remote '{self.args.name}' doesn't exists.")
 
 
 class CmdRemoteAdd(CmdRemote):
     def run(self):
         if self.args.default:
-            logger.info(
-                "Setting '{}' as a default remote.".format(self.args.name)
-            )
+            logger.info(f"Setting '{self.args.name}' as a default remote.")
 
         with self.config.edit(self.args.level) as conf:
             if self.args.name in conf["remote"] and not self.args.force:
@@ -66,7 +62,11 @@ class CmdRemoteModify(CmdRemote):
     def run(self):
         with self.config.edit(self.args.level) as conf:
             self._check_exists(conf)
-            conf["remote"][self.args.name][self.args.option] = self.args.value
+            section = conf["remote"][self.args.name]
+            if self.args.unset:
+                section.pop(self.args.option, None)
+            else:
+                section[self.args.option] = self.args.value
         return 0
 
 
@@ -85,7 +85,18 @@ class CmdRemoteDefault(CmdRemote):
                 if self.args.unset:
                     conf["core"].pop("remote", None)
                 else:
-                    conf["core"]["remote"] = self.args.name
+                    merged_conf = self.config.load_config_to_level(
+                        self.args.level
+                    )
+                    if (
+                        self.args.name in conf["remote"]
+                        or self.args.name in merged_conf["remote"]
+                    ):
+                        conf["core"]["remote"] = self.args.name
+                    else:
+                        raise ConfigError(
+                            "default remote must be present in remote list."
+                        )
         return 0
 
 
@@ -97,6 +108,35 @@ class CmdRemoteList(CmdRemote):
         return 0
 
 
+class CmdRemoteRename(CmdRemote):
+    def _rename_default(self, conf):
+        if conf["core"].get("remote") == self.args.name:
+            conf["core"]["remote"] = self.args.new
+
+    def run(self):
+        all_config = self.config.load_config_to_level(None)
+        if self.args.new in all_config.get("remote", {}):
+            raise ConfigError(
+                "Rename failed. Remote name '{}' already exists.".format(
+                    {self.args.new}
+                )
+            )
+
+        with self.config.edit(self.args.level) as conf:
+            self._check_exists(conf)
+            conf["remote"][self.args.new] = conf["remote"][self.args.name]
+            del conf["remote"][self.args.name]
+            self._rename_default(conf)
+
+        for level in reversed(self.config.LEVELS):
+            if level == self.args.level:
+                break
+            with self.config.edit(level) as level_conf:
+                self._rename_default(level_conf)
+
+        return 0
+
+
 def add_parser(subparsers, parent_parser):
     from dvc.command.config import parent_config_parser
 
@@ -213,3 +253,14 @@ def add_parser(subparsers, parent_parser):
         "name", help="Name of the remote to remove."
     )
     remote_remove_parser.set_defaults(func=CmdRemoteRemove)
+    REMOTE_RENAME_HELP = "Rename a DVC remote"
+    remote_rename_parser = remote_subparsers.add_parser(
+        "rename",
+        parents=[parent_config_parser, parent_parser],
+        description=append_doc_link(REMOTE_RENAME_HELP, "remote/rename"),
+        help=REMOTE_RENAME_HELP,
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+    )
+    remote_rename_parser.add_argument("name", help="Remote to be renamed")
+    remote_rename_parser.add_argument("new", help="New name of the remote")
+    remote_rename_parser.set_defaults(func=CmdRemoteRename)

dvc/command/remove.py

@@ -1,7 +1,6 @@
 import argparse
 import logging
 
-import dvc.prompt as prompt
 from dvc.command.base import CmdBase, append_doc_link
 from dvc.exceptions import DvcException
 
@@ -9,38 +8,18 @@ logger = logging.getLogger(__name__)
 
 
 class CmdRemove(CmdBase):
-    def _is_outs_only(self, target):
-        if not self.args.purge:
-            return True
-
-        if self.args.force:
-            return False
-
-        msg = "Are you sure you want to remove '{}' with its outputs?".format(
-            target
-        )
-
-        if prompt.confirm(msg):
-            return False
-
-        raise DvcException(
-            "Cannot purge without a confirmation from the user."
-            " Use `-f` to force."
-        )
-
     def run(self):
         for target in self.args.targets:
             try:
-                outs_only = self._is_outs_only(target)
-                self.repo.remove(target, outs_only=outs_only)
+                self.repo.remove(target, outs=self.args.outs)
             except DvcException:
-                logger.exception("failed to remove '{}'".format(target))
+                logger.exception(f"failed to remove '{target}'")
                 return 1
         return 0
 
 
 def add_parser(subparsers, parent_parser):
-    REMOVE_HELP = "Remove DVC-tracked files or directories."
+    REMOVE_HELP = "Remove stage entry and unprotect outputs"
     remove_parser = subparsers.add_parser(
         "remove",
         parents=[parent_parser],
@@ -48,27 +27,11 @@ def add_parser(subparsers, parent_parser):
         help=REMOVE_HELP,
         formatter_class=argparse.RawDescriptionHelpFormatter,
     )
-    remove_parser_group = remove_parser.add_mutually_exclusive_group()
-    remove_parser_group.add_argument(
-        "-o",
+    remove_parser.add_argument(
         "--outs",
         action="store_true",
-        default=True,
-        help="Only remove DVC-file outputs. (Default)",
-    )
-    remove_parser_group.add_argument(
-        "-p",
-        "--purge",
-        action="store_true",
         default=False,
-        help="Remove DVC-file and all its outputs.",
-    )
-    remove_parser.add_argument(
-        "-f",
-        "--force",
-        action="store_true",
-        default=False,
-        help="Force purge.",
+        help="Remove outputs as well.",
     )
     remove_parser.add_argument(
         "targets", nargs="+", help="DVC-files to remove."

dvc/command/repro.py

@@ -5,6 +5,7 @@ import os
 from dvc.command.base import CmdBase, append_doc_link
 from dvc.command.metrics import show_metrics
 from dvc.command.status import CmdDataStatus
+from dvc.dvcfile import PIPELINE_FILE
 from dvc.exceptions import DvcException
 
 logger = logging.getLogger(__name__)
@@ -33,10 +34,11 @@ class CmdRepro(CmdBase):
                     interactive=self.args.interactive,
                     pipeline=self.args.pipeline,
                     all_pipelines=self.args.all_pipelines,
-                    ignore_build_cache=self.args.ignore_build_cache,
+                    run_cache=not self.args.no_run_cache,
                     no_commit=self.args.no_commit,
                     downstream=self.args.downstream,
                     recursive=self.args.recursive,
+                    force_downstream=self.args.force_downstream,
                 )
 
                 if len(stages) == 0:
@@ -68,7 +70,7 @@ def add_parser(subparsers, parent_parser):
     repro_parser.add_argument(
         "targets",
         nargs="*",
-        help="DVC-file to reproduce. 'Dvcfile' by default.",
+        help=f"Stages to reproduce. '{PIPELINE_FILE}' by default.",
     )
     repro_parser.add_argument(
         "-f",
@@ -136,7 +138,16 @@ def add_parser(subparsers, parent_parser):
         help="Reproduce all stages in the specified directory.",
     )
     repro_parser.add_argument(
-        "--ignore-build-cache",
+        "--no-run-cache",
+        action="store_true",
+        default=False,
+        help=(
+            "Execute stage commands even if they have already been run with "
+            "the same command/dependencies/outputs/etc before."
+        ),
+    )
+    repro_parser.add_argument(
+        "--force-downstream",
         action="store_true",
         default=False,
         help="Reproduce all descendants of a changed stage even if their "

dvc/command/run.py

@@ -16,6 +16,8 @@ class CmdRun(CmdBase):
                 self.args.outs_no_cache,
                 self.args.metrics,
                 self.args.metrics_no_cache,
+                self.args.plots,
+                self.args.plots_no_cache,
                 self.args.outs_persist,
                 self.args.outs_persist_no_cache,
                 self.args.params,
@@ -24,8 +26,8 @@ class CmdRun(CmdBase):
         ):  # pragma: no cover
             logger.error(
                 "too few arguments. Specify at least one: `-d`, `-o`, `-O`, "
-                "`-m`, `-M`, `-p`, `--outs-persist`, "
-                "`--outs-persist-no-cache`, `command`."
+                "`-m`, `-M`, `-p`, `--plots`, `--plots-no-cache`, "
+                "`--outs-persist`, `--outs-persist-no-cache`, `command`."
             )
             return 1
 
@@ -36,19 +38,22 @@ class CmdRun(CmdBase):
                 outs_no_cache=self.args.outs_no_cache,
                 metrics=self.args.metrics,
                 metrics_no_cache=self.args.metrics_no_cache,
+                plots=self.args.plots,
+                plots_no_cache=self.args.plots_no_cache,
                 deps=self.args.deps,
                 params=self.args.params,
                 fname=self.args.file,
                 wdir=self.args.wdir,
                 no_exec=self.args.no_exec,
-                overwrite=self.args.overwrite_dvcfile,
-                ignore_build_cache=self.args.ignore_build_cache,
+                overwrite=self.args.overwrite,
+                run_cache=not self.args.no_run_cache,
                 no_commit=self.args.no_commit,
                 outs_persist=self.args.outs_persist,
                 outs_persist_no_cache=self.args.outs_persist_no_cache,
                 always_changed=self.args.always_changed,
                 name=self.args.name,
                 single_stage=self.args.single_stage,
+                external=self.args.external,
             )
         except DvcException:
             logger.exception("")
@@ -75,7 +80,7 @@ class CmdRun(CmdBase):
         if " " not in argument or '"' in argument:
             return argument
 
-        return '"{}"'.format(argument)
+        return f'"{argument}"'
 
 
 def add_parser(subparsers, parent_parser):
@@ -140,6 +145,20 @@ def add_parser(subparsers, parent_parser):
         "(do not put into DVC cache).",
         metavar="<path>",
     )
+    run_parser.add_argument(
+        "--plots",
+        action="append",
+        default=[],
+        help="Declare output plot file.",
+        metavar="<path>",
+    )
+    run_parser.add_argument(
+        "--plots-no-cache",
+        action="append",
+        default=[],
+        help="Declare output plot file (do not put into DVC cache).",
+        metavar="<path>",
+    )
     run_parser.add_argument(
         "-f",
         "--file",
@@ -159,17 +178,19 @@ def add_parser(subparsers, parent_parser):
         help="Only create stage file without actually running it.",
     )
     run_parser.add_argument(
-        "--overwrite-dvcfile",
+        "--overwrite",
         action="store_true",
         default=False,
-        help="Overwrite existing DVC-file without asking for confirmation.",
+        help="Overwrite existing stage",
     )
     run_parser.add_argument(
-        "--ignore-build-cache",
+        "--no-run-cache",
         action="store_true",
         default=False,
-        help="Run this stage even if it has been already ran with the same "
-        "command/dependencies/outputs/etc before.",
+        help=(
+            "Execute the command even if this stage has already been run "
+            "with the same command/dependencies/outputs/etc before."
+        ),
     )
     run_parser.add_argument(
         "--no-commit",
@@ -205,6 +226,12 @@ def add_parser(subparsers, parent_parser):
         default=False,
         help=argparse.SUPPRESS,
     )
+    run_parser.add_argument(
+        "--external",
+        action="store_true",
+        default=False,
+        help="Allow outputs that are outside of the DVC repository.",
+    )
     run_parser.add_argument(
         "command", nargs=argparse.REMAINDER, help="Command to execute."
     )

dvc/command/status.py

@@ -19,7 +19,7 @@ class CmdDataStatus(CmdDataBase):
         ind = indent * self.STATUS_INDENT
 
         if isinstance(status, str):
-            logger.info("{}{}".format(ind, status))
+            logger.info(f"{ind}{status}")
             return
 
         if isinstance(status, list):
@@ -33,7 +33,7 @@ class CmdDataStatus(CmdDataBase):
             if isinstance(value, str):
                 logger.info("{}{}{}".format(ind, self._normalize(value), key))
             elif value:
-                logger.info("{}{}:".format(ind, key))
+                logger.info(f"{ind}{key}:")
                 self._show(value, indent + 1)
 
     def run(self):

dvc/command/unprotect.py

@@ -13,7 +13,7 @@ class CmdUnprotect(CmdBase):
             try:
                 self.repo.unprotect(target)
             except DvcException:
-                msg = "failed to unprotect '{}'".format(target)
+                msg = f"failed to unprotect '{target}'"
                 logger.exception(msg)
                 return 1
         return 0

dvc/command/update.py

@@ -10,12 +10,15 @@ logger = logging.getLogger(__name__)
 class CmdUpdate(CmdBase):
     def run(self):
         ret = 0
-        for target in self.args.targets:
-            try:
-                self.repo.update(target, self.args.rev)
-            except DvcException:
-                logger.exception("failed to update '{}'.".format(target))
-                ret = 1
+        try:
+            self.repo.update(
+                targets=self.args.targets,
+                rev=self.args.rev,
+                recursive=self.args.recursive,
+            )
+        except DvcException:
+            logger.exception("failed update data")
+            ret = 1
         return ret
 
 
@@ -37,4 +40,11 @@ def add_parser(subparsers, parent_parser):
         help="Git revision (e.g. SHA, branch, tag)",
         metavar="<commit>",
     )
+    update_parser.add_argument(
+        "-R",
+        "--recursive",
+        action="store_true",
+        default=False,
+        help="Update all stages in the specified directory.",
+    )
     update_parser.set_defaults(func=CmdUpdate)

dvc/command/version.py

@@ -28,12 +28,12 @@ class CmdVersion(CmdBaseNoRepo):
         from dvc.repo import Repo
 
         info = [
-            "DVC version: {}".format(__version__),
-            "Python version: {}".format(platform.python_version()),
-            "Platform: {}".format(platform.platform()),
-            "Binary: {}".format(is_binary()),
-            "Package: {}".format(PKG),
-            "Supported remotes: {}".format(self.get_supported_remotes()),
+            f"DVC version: {__version__}",
+            f"Python version: {platform.python_version()}",
+            f"Platform: {platform.platform()}",
+            f"Binary: {is_binary()}",
+            f"Package: {PKG}",
+            f"Supported remotes: {self.get_supported_remotes()}",
         ]
 
         try:
@@ -51,7 +51,7 @@ class CmdVersion(CmdBaseNoRepo):
                 if psutil:
                     fs_type = self.get_fs_type(repo.cache.local.cache_dir)
                     info.append(
-                        "Filesystem type (cache directory): {}".format(fs_type)
+                        f"Filesystem type (cache directory): {fs_type}"
                     )
             else:
                 logger.warning(
@@ -72,7 +72,7 @@ class CmdVersion(CmdBaseNoRepo):
 
         if psutil:
             fs_root = self.get_fs_type(os.path.abspath(root_directory))
-            info.append("Filesystem type (workspace): {}".format(fs_root))
+            info.append(f"Filesystem type (workspace): {fs_root}")
 
         logger.info("\n".join(info))
         return 0
@@ -115,7 +115,7 @@ class CmdVersion(CmdBaseNoRepo):
                 os.unlink(dst)
             except DvcException:
                 status = "not supported"
-            cache.append("{name} - {status}".format(name=name, status=status))
+            cache.append(f"{name} - {status}")
         os.remove(src)
 
         return ", ".join(cache)

dvc/compat.py

@@ -1,42 +0,0 @@
-"""Python version compatibility code"""
-
-# Backport os.fspath() from Python 3.6
-try:
-    from os import fspath  # noqa: F821
-
-    fspath_py35 = lambda s: s  # noqa: E731
-except ImportError:
-
-    def fspath(path):
-        """Return the path representation of a path-like object.
-
-        If str or bytes is passed in, it is returned unchanged. Otherwise the
-        os.PathLike interface is used to get the path representation. If the
-        path representation is not str or bytes, TypeError is raised. If the
-        provided path is not str, bytes, or os.PathLike, TypeError is raised.
-        """
-        if isinstance(path, (str, bytes)):
-            return path
-
-        # Work from the object's type to match method resolution of other magic
-        # methods.
-        path_type = type(path)
-        try:
-            path_repr = path_type.__fspath__(path)
-        except AttributeError:
-            if hasattr(path_type, "__fspath__"):
-                raise
-            else:
-                raise TypeError(
-                    "expected str, bytes or os.PathLike object, "
-                    "not " + path_type.__name__
-                )
-        if isinstance(path_repr, (str, bytes)):
-            return path_repr
-        else:
-            raise TypeError(
-                "expected {}.__fspath__() to return str or bytes, "
-                "not {}".format(path_type.__name__, type(path_repr).__name__)
-            )
-
-    fspath_py35 = fspath

dvc/config.py

@@ -31,7 +31,7 @@ class ConfigError(DvcException):
     """DVC config exception."""
 
     def __init__(self, msg):
-        super().__init__("config file error: {}".format(msg))
+        super().__init__(f"config file error: {msg}")
 
 
 class NoRemoteError(ConfigError):
@@ -89,7 +89,7 @@ def ByUrl(mapping):
         if os.name == "nt" and len(parsed.scheme) == 1 and parsed.netloc == "":
             return schemas[""](data)
         if parsed.scheme not in schemas:
-            raise Invalid("Unsupported URL type {}://".format(parsed.scheme))
+            raise Invalid(f"Unsupported URL type {parsed.scheme}://")
 
         return schemas[parsed.scheme](data)
 
@@ -151,6 +151,7 @@ SCHEMA = {
                     Optional("listobjects", default=False): Bool,
                     Optional("use_ssl", default=True): Bool,
                     "sse": str,
+                    "sse_kms_key_id": str,
                     "acl": str,
                     "grant_read": str,
                     "grant_read_acp": str,
@@ -289,7 +290,7 @@ class Config(dict):
         Raises:
             ConfigError: thrown if config has an invalid format.
         """
-        conf = self._load_config_to_level()
+        conf = self.load_config_to_level()
 
         if validate:
             conf = self.validate(conf)
@@ -349,7 +350,7 @@ class Config(dict):
         }
         return Schema(dirs_schema, extra=ALLOW_EXTRA)(conf)
 
-    def _load_config_to_level(self, level=None):
+    def load_config_to_level(self, level=None):
         merged_conf = {}
         for merge_level in self.LEVELS:
             if merge_level == level:
@@ -368,7 +369,7 @@ class Config(dict):
 
         conf = self._save_paths(conf, self.files[level])
 
-        merged_conf = self._load_config_to_level(level)
+        merged_conf = self.load_config_to_level(level)
         _merge(merged_conf, conf)
         self.validate(merged_conf)
 
@@ -389,7 +390,7 @@ def _load_config(filename):
 
 
 def _save_config(filename, conf_dict):
-    logger.debug("Writing '{}'.".format(filename))
+    logger.debug(f"Writing '{filename}'.")
     os.makedirs(os.path.dirname(filename), exist_ok=True)
 
     config = configobj.ConfigObj(_pack_remotes(conf_dict))
@@ -416,7 +417,7 @@ def _pack_remotes(conf):
 
     # Transform remote.name -> 'remote "name"'
     for name, val in conf["remote"].items():
-        result['remote "{}"'.format(name)] = val
+        result[f'remote "{name}"'] = val
     result.pop("remote", None)
 
     return result

dvc/daemon.py

@@ -66,7 +66,7 @@ def _spawn_posix(cmd, env):
 
 
 def _spawn(cmd, env):
-    logger.debug("Trying to spawn '{}'".format(cmd))
+    logger.debug(f"Trying to spawn '{cmd}'")
 
     if os.name == "nt":
         _spawn_windows(cmd, env)
@@ -75,7 +75,7 @@ def _spawn(cmd, env):
     else:
         raise NotImplementedError
 
-    logger.debug("Spawned '{}'".format(cmd))
+    logger.debug(f"Spawned '{cmd}'")
 
 
 def daemon(args):

dvc/dagascii.py

@@ -37,7 +37,7 @@ def find_pager():
     if env_pager:
         return make_pager(env_pager)
 
-    if os.system("({}) 2>{}".format(DEFAULT_PAGER, os.devnull)) == 0:
+    if os.system(f"({DEFAULT_PAGER}) 2>{os.devnull}") == 0:
         return make_pager(DEFAULT_PAGER_FORMATTED)
 
     logger.warning(
@@ -49,7 +49,7 @@ def find_pager():
     return pydoc.plainpager
 
 
-class VertexViewer(object):
+class VertexViewer:
     """Class to define vertex box boundaries that will be accounted for during
     graph building by grandalf.
 
@@ -75,7 +75,7 @@ class VertexViewer(object):
         return self._w
 
 
-class AsciiCanvas(object):
+class AsciiCanvas:
     """Class for drawing in ASCII.
 
     Args:
@@ -96,10 +96,9 @@ class AsciiCanvas(object):
 
     def draw(self):
         """Draws ASCII canvas on the screen."""
-        pager = find_pager()
         lines = map("".join, self.canvas)
         joined_lines = os.linesep.join(lines)
-        pager(joined_lines)
+        return joined_lines
 
     def point(self, x, y, char):
         """Create a point on ASCII canvas.
@@ -145,21 +144,21 @@ class AsciiCanvas(object):
                 if dx == 0:
                     y = y0
                 else:
-                    y = y0 + int(round((x - x0) * dy / float((dx))))
+                    y = y0 + int(round((x - x0) * dy / float(dx)))
                 self.point(x, y, char)
         elif y0 < y1:
             for y in range(y0, y1 + 1):
                 if dy == 0:
                     x = x0
                 else:
-                    x = x0 + int(round((y - y0) * dx / float((dy))))
+                    x = x0 + int(round((y - y0) * dx / float(dy)))
                 self.point(x, y, char)
         else:
             for y in range(y1, y0 + 1):
                 if dy == 0:
                     x = x0
                 else:
-                    x = x1 + int(round((y - y1) * dx / float((dy))))
+                    x = x1 + int(round((y - y1) * dx / float(dy)))
                 self.point(x, y, char)
 
     def text(self, x, y, text):
@@ -213,7 +212,7 @@ def _build_sugiyama_layout(vertexes, edges):
     # Y
     #
 
-    vertexes = {v: Vertex(" {} ".format(v)) for v in vertexes}
+    vertexes = {v: Vertex(f" {v} ") for v in vertexes}
     # NOTE: reverting edges to correctly orientate the graph
     edges = [Edge(vertexes[e], vertexes[s]) for s, e in edges]
     vertexes = vertexes.values()
@@ -316,4 +315,4 @@ def draw(vertexes, edges):
             int(round(x - minx)) + 1, int(round(y - miny)) + 1, vertex.data
         )
 
-    canvas.draw()
+    return canvas.draw()

dvc/data_cloud.py

@@ -8,7 +8,7 @@ from dvc.remote import Remote
 logger = logging.getLogger(__name__)
 
 
-class DataCloud(object):
+class DataCloud:
     """Class that manages dvc remotes.
 
     Args:
@@ -48,12 +48,7 @@ class DataCloud(object):
         return Remote(self.repo, name=name)
 
     def push(
-        self,
-        cache,
-        jobs=None,
-        remote=None,
-        show_checksums=False,
-        run_cache=False,
+        self, cache, jobs=None, remote=None, show_checksums=False,
     ):
         """Push data items in a cloud-agnostic way.
 
@@ -67,20 +62,12 @@ class DataCloud(object):
         """
         remote = self.get_remote(remote, "push")
 
-        if run_cache:
-            self.repo.stage_cache.push(remote)
-
         return self.repo.cache.local.push(
             cache, jobs=jobs, remote=remote, show_checksums=show_checksums,
         )
 
     def pull(
-        self,
-        cache,
-        jobs=None,
-        remote=None,
-        show_checksums=False,
-        run_cache=False,
+        self, cache, jobs=None, remote=None, show_checksums=False,
     ):
         """Pull data items in a cloud-agnostic way.
 
@@ -94,9 +81,6 @@ class DataCloud(object):
         """
         remote = self.get_remote(remote, "pull")
 
-        if run_cache:
-            self.repo.stage_cache.pull(remote)
-
         downloaded_items_num = self.repo.cache.local.pull(
             cache, jobs=jobs, remote=remote, show_checksums=show_checksums
         )
@@ -109,7 +93,7 @@ class DataCloud(object):
     def _save_pulled_checksums(self, cache):
         for checksum in cache.scheme_keys("local"):
             cache_file = self.repo.cache.local.checksum_to_path_info(checksum)
-            if self.repo.cache.local.exists(cache_file):
+            if self.repo.cache.local.tree.exists(cache_file):
                 # We can safely save here, as existing corrupted files will
                 # be removed upon status, while files corrupted during
                 # download will not be moved from tmp_file

dvc/dependency/__init__.py

@@ -2,6 +2,7 @@ from collections import defaultdict
 from urllib.parse import urlparse
 
 import dvc.output as output
+from dvc.dependency.azure import AzureDependency
 from dvc.dependency.gs import GSDependency
 from dvc.dependency.hdfs import HDFSDependency
 from dvc.dependency.http import HTTPDependency
@@ -17,6 +18,7 @@ from dvc.scheme import Schemes
 from .repo import RepoDependency
 
 DEPS = [
+    AzureDependency,
     GSDependency,
     HDFSDependency,
     HTTPDependency,
@@ -30,6 +32,7 @@ DEP_MAP = {
     Schemes.LOCAL: LocalDependency,
     Schemes.SSH: SSHDependency,
     Schemes.S3: S3Dependency,
+    Schemes.AZURE: AzureDependency,
     Schemes.GS: GSDependency,
     Schemes.HDFS: HDFSDependency,
     Schemes.HTTP: HTTPDependency,

dvc/dependency/azure.py

@@ -0,0 +1,7 @@
+from dvc.dependency.base import BaseDependency
+from dvc.output.base import BaseOutput
+from dvc.remote.azure import AzureRemote
+
+
+class AzureDependency(BaseDependency, BaseOutput):
+    REMOTE = AzureRemote

dvc/dependency/base.py

@@ -3,24 +3,22 @@ from dvc.exceptions import DvcException
 
 class DependencyDoesNotExistError(DvcException):
     def __init__(self, path):
-        msg = "dependency '{}' does not exist".format(path)
+        msg = f"dependency '{path}' does not exist"
         super().__init__(msg)
 
 
 class DependencyIsNotFileOrDirError(DvcException):
     def __init__(self, path):
-        msg = "dependency '{}' is not a file or directory".format(path)
+        msg = f"dependency '{path}' is not a file or directory"
         super().__init__(msg)
 
 
 class DependencyIsStageFileError(DvcException):
     def __init__(self, path):
-        super().__init__(
-            "Stage file '{}' cannot be a dependency.".format(path)
-        )
+        super().__init__(f"Stage file '{path}' cannot be a dependency.")
 
 
-class BaseDependency(object):
+class BaseDependency:
     IS_DEPENDENCY = True
 
     DoesNotExistError = DependencyDoesNotExistError

dvc/dependency/param.py

@@ -5,7 +5,6 @@ import dpath.util
 import yaml
 from voluptuous import Any
 
-from dvc.compat import fspath_py35
 from dvc.dependency.local import LocalDependency
 from dvc.exceptions import DvcException
 
@@ -87,12 +86,12 @@ class ParamsDependency(LocalDependency):
         if not self.exists:
             return {}
 
-        with self.repo.tree.open(fspath_py35(self.path_info), "r") as fobj:
+        with self.repo.tree.open(self.path_info, "r") as fobj:
             try:
                 config = yaml.safe_load(fobj)
             except yaml.YAMLError as exc:
                 raise BadParamFileError(
-                    "Unable to read parameters from '{}'".format(self)
+                    f"Unable to read parameters from '{self}'"
                 ) from exc
 
         ret = {}

dvc/dependency/repo.py

@@ -50,13 +50,24 @@ class RepoDependency(LocalDependency):
         return external_repo(d["url"], rev=rev)
 
     def _get_checksum(self, locked=True):
+        from dvc.repo.tree import RepoTree
+
         with self._make_repo(locked=locked) as repo:
             try:
                 return repo.find_out_by_relpath(self.def_path).info["md5"]
             except OutputNotFoundError:
                 path = PathInfo(os.path.join(repo.root_dir, self.def_path))
+
+                # we want stream but not fetch, so DVC out directories are
+                # walked, but dir contents is not fetched
+                tree = RepoTree(repo, stream=True)
+
                 # We are polluting our repo cache with some dir listing here
-                return self.repo.cache.local.get_checksum(path)
+                if tree.isdir(path):
+                    return self.repo.cache.local.get_dir_checksum(
+                        path, tree=tree
+                    )
+                return tree.get_file_checksum(path)
 
     def status(self):
         current_checksum = self._get_checksum(locked=True)
@@ -76,16 +87,16 @@ class RepoDependency(LocalDependency):
     def download(self, to):
         with self._make_repo() as repo:
             if self.def_repo.get(self.PARAM_REV_LOCK) is None:
-                self.def_repo[self.PARAM_REV_LOCK] = repo.scm.get_rev()
+                self.def_repo[self.PARAM_REV_LOCK] = repo.get_rev()
 
-            if hasattr(repo, "cache"):
-                repo.cache.local.cache_dir = self.repo.cache.local.cache_dir
-
-            repo.pull_to(self.def_path, to.path_info)
+            cache = self.repo.cache.local
+            with repo.use_cache(cache):
+                _, _, cache_infos = repo.fetch_external([self.def_path])
+            cache.checkout(to.path_info, cache_infos[0])
 
     def update(self, rev=None):
         if rev:
             self.def_repo[self.PARAM_REV] = rev
 
         with self._make_repo(locked=False) as repo:
-            self.def_repo[self.PARAM_REV_LOCK] = repo.scm.get_rev()
+            self.def_repo[self.PARAM_REV_LOCK] = repo.get_rev()

dvc/dvcfile.py

@@ -17,11 +17,7 @@ from dvc.stage.exceptions import (
 from dvc.stage.loader import SingleStageLoader, StageLoader
 from dvc.utils import relpath
 from dvc.utils.collections import apply_diff
-from dvc.utils.stage import (
-    dump_stage_file,
-    parse_stage,
-    parse_stage_for_update,
-)
+from dvc.utils.yaml import dump_yaml, parse_yaml, parse_yaml_for_update
 
 logger = logging.getLogger(__name__)
 
@@ -32,8 +28,7 @@ PIPELINE_LOCK = "dvc.lock"
 
 
 class LockfileCorruptedError(DvcException):
-    def __init__(self, path):
-        super().__init__("Lockfile '{}' is corrupted.".format(path))
+    pass
 
 
 def is_valid_filename(path):
@@ -80,7 +75,7 @@ class FileMixin:
         ) == os.path.abspath(other.path)
 
     def __str__(self):
-        return "{}: {}".format(self.__class__.__name__, self.relpath)
+        return f"{self.__class__.__name__}: {self.relpath}"
 
     @property
     def relpath(self):
@@ -102,8 +97,8 @@ class FileMixin:
 
         with self.repo.tree.open(self.path) as fd:
             stage_text = fd.read()
-        d = parse_stage(stage_text, self.path)
-        self.validate(d, self.path)
+        d = parse_yaml(stage_text, self.path)
+        self.validate(d, self.relpath)
         return d, stage_text
 
     @classmethod
@@ -112,7 +107,7 @@ class FileMixin:
         try:
             cls.SCHEMA(d)
         except MultipleInvalid as exc:
-            raise StageFileFormatError(fname, exc)
+            raise StageFileFormatError(f"'{fname}' format error: {exc}")
 
     def remove_with_prompt(self, force=False):
         raise NotImplementedError
@@ -150,8 +145,8 @@ class SingleStageFile(FileMixin):
         logger.debug(
             "Saving information to '{file}'.".format(file=relpath(self.path))
         )
-        dump_stage_file(self.path, serialize.to_single_stage_file(stage))
-        self.repo.scm.track_file(relpath(self.path))
+        dump_yaml(self.path, serialize.to_single_stage_file(stage))
+        self.repo.scm.track_file(self.relpath)
 
     def remove_with_prompt(self, force=False):
         if not self.exists():
@@ -166,6 +161,9 @@ class SingleStageFile(FileMixin):
 
         self.remove()
 
+    def remove_stage(self, stage):
+        self.remove()
+
 
 class PipelineFile(FileMixin):
     """Abstraction for pipelines file, .yaml + .lock combined."""
@@ -176,25 +174,29 @@ class PipelineFile(FileMixin):
     def _lockfile(self):
         return Lockfile(self.repo, os.path.splitext(self.path)[0] + ".lock")
 
-    def dump(self, stage, update_pipeline=False, **kwargs):
+    def dump(self, stage, update_pipeline=False, no_lock=False):
         """Dumps given stage appropriately in the dvcfile."""
         from dvc.stage import PipelineStage
 
         assert isinstance(stage, PipelineStage)
         check_dvc_filename(self.path)
-        self._dump_lockfile(stage)
+
         if update_pipeline and not stage.is_data_source:
             self._dump_pipeline_file(stage)
 
+        if not no_lock:
+            self._dump_lockfile(stage)
+
     def _dump_lockfile(self, stage):
         self._lockfile.dump(stage)
 
     def _dump_pipeline_file(self, stage):
         data = {}
         if self.exists():
-            with open(self.path, "r") as fd:
-                data = parse_stage_for_update(fd.read(), self.path)
+            with open(self.path) as fd:
+                data = parse_yaml_for_update(fd.read(), self.path)
         else:
+            logger.info("Creating '%s'", self.relpath)
             open(self.path, "w+").close()
 
         data["stages"] = data.get("stages", {})
@@ -205,8 +207,11 @@ class PipelineFile(FileMixin):
         else:
             data["stages"].update(stage_data)
 
-        dump_stage_file(self.path, data)
-        self.repo.scm.track_file(relpath(self.path))
+        logger.info(
+            "Adding stage '%s' to '%s'", stage.name, self.relpath,
+        )
+        dump_yaml(self.path, data)
+        self.repo.scm.track_file(self.relpath)
 
     @property
     def stage(self):
@@ -228,6 +233,22 @@ class PipelineFile(FileMixin):
         super().remove()
         self._lockfile.remove()
 
+    def remove_stage(self, stage):
+        self._lockfile.remove_stage(stage)
+        if not self.exists():
+            return
+
+        with open(self.path, "r") as f:
+            d = parse_yaml_for_update(f.read(), self.path)
+
+        self.validate(d, self.path)
+        if stage.name not in d.get("stages", {}):
+            return
+
+        logger.debug("Removing '%s' from '%s'", stage.name, self.path)
+        del d["stages"][stage.name]
+        dump_yaml(self.path, d)
+
 
 class Lockfile(FileMixin):
     from dvc.schema import COMPILED_LOCKFILE_SCHEMA as SCHEMA
@@ -236,25 +257,50 @@ class Lockfile(FileMixin):
         if not self.exists():
             return {}
         with self.repo.tree.open(self.path) as fd:
-            data = parse_stage(fd.read(), self.path)
+            data = parse_yaml(fd.read(), self.path)
         try:
-            self.validate(data, fname=self.path)
+            self.validate(data, fname=self.relpath)
         except StageFileFormatError:
-            raise LockfileCorruptedError(self.path)
+            raise LockfileCorruptedError(
+                f"Lockfile '{self.relpath}' is corrupted."
+            )
         return data
 
     def dump(self, stage, **kwargs):
         stage_data = serialize.to_lockfile(stage)
         if not self.exists():
+            modified = True
+            logger.info("Generating lock file '%s'", self.relpath)
             data = stage_data
             open(self.path, "w+").close()
         else:
             with self.repo.tree.open(self.path, "r") as fd:
-                data = parse_stage_for_update(fd.read(), self.path)
+                data = parse_yaml_for_update(fd.read(), self.path)
+            modified = data.get(stage.name, {}) != stage_data.get(
+                stage.name, {}
+            )
+            if modified:
+                logger.info("Updating lock file '%s'", self.relpath)
             data.update(stage_data)
+        dump_yaml(self.path, data)
+        if modified:
+            self.repo.scm.track_file(self.relpath)
 
-        dump_stage_file(self.path, data)
-        self.repo.scm.track_file(relpath(self.path))
+    def remove_stage(self, stage):
+        if not self.exists():
+            return
+
+        with open(self.path) as f:
+            d = parse_yaml_for_update(f.read(), self.path)
+        self.validate(d, self.path)
+
+        if stage.name not in d:
+            return
+
+        logger.debug("Removing '%s' from '%s'", stage.name, self.path)
+        del d[stage.name]
+
+        dump_yaml(self.path, d)
 
 
 class Dvcfile:

dvc/exceptions.py

@@ -34,8 +34,7 @@ class OutputDuplicationError(DvcException):
             )
         else:
             msg = "output '{}' is already specified in stages:\n{}".format(
-                output,
-                "\n".join("\t- {}".format(s.addressing) for s in stages),
+                output, "\n".join(f"\t- {s.addressing}" for s in stages),
             )
         super().__init__(msg)
         self.stages = stages
@@ -102,7 +101,7 @@ class ArgumentDuplicationError(DvcException):
 
     def __init__(self, path):
         assert isinstance(path, str)
-        super().__init__("file '{}' is specified more than once.".format(path))
+        super().__init__(f"file '{path}' is specified more than once.")
 
 
 class MoveNotDataSourceError(DvcException):
@@ -158,7 +157,7 @@ class InitError(DvcException):
 class ReproductionError(DvcException):
     def __init__(self, dvc_file_name):
         self.path = dvc_file_name
-        super().__init__("failed to reproduce '{}'".format(dvc_file_name))
+        super().__init__(f"failed to reproduce '{dvc_file_name}'")
 
 
 class BadMetricError(DvcException):
@@ -166,7 +165,7 @@ class BadMetricError(DvcException):
         super().__init__(
             "the following metrics do not exist, "
             "are not metric files or are malformed: {paths}".format(
-                paths=", ".join("'{}'".format(path) for path in paths)
+                paths=", ".join(f"'{path}'" for path in paths)
             )
         )
 
@@ -174,17 +173,24 @@ class BadMetricError(DvcException):
 class NoMetricsError(DvcException):
     def __init__(self):
         super().__init__(
-            "no metric files in this repository. "
-            "Use `dvc metrics add` to add a metric file to track."
+            "no metric files in this repository. Use `-m/-M` options for "
+            "`dvc run` to mark stage outputs as  metrics."
         )
 
 
-class StageFileCorruptedError(DvcException):
+class NoPlotsError(DvcException):
+    def __init__(self):
+        super().__init__(
+            "no plots in this repository. Use `--plots/--plots-no-cache` "
+            "options for `dvc run` to mark stage outputs as plots."
+        )
+
+
+class YAMLFileCorruptedError(DvcException):
     def __init__(self, path):
         path = relpath(path)
         super().__init__(
-            "unable to read DVC-file: {} "
-            "YAML file structure is corrupted".format(path)
+            f"unable to read: '{path}', YAML file structure is corrupted"
         )
 
 
@@ -204,7 +210,7 @@ class OverlappingOutputPathsError(DvcException):
 
 class CheckoutErrorSuggestGit(DvcException):
     def __init__(self, target):
-        super().__init__("Did you mean `git checkout {}`?".format(target))
+        super().__init__(f"Did you mean `git checkout {target}`?")
 
 
 class ETagMismatchError(DvcException):
@@ -218,9 +224,7 @@ class ETagMismatchError(DvcException):
 class FileMissingError(DvcException):
     def __init__(self, path):
         self.path = path
-        super().__init__(
-            "Can't find '{}' neither locally nor on remote".format(path)
-        )
+        super().__init__(f"Can't find '{path}' neither locally nor on remote")
 
 
 class DvcIgnoreInCollectedDirError(DvcException):
@@ -245,18 +249,14 @@ class DownloadError(DvcException):
     def __init__(self, amount):
         self.amount = amount
 
-        super().__init__(
-            "{amount} files failed to download".format(amount=amount)
-        )
+        super().__init__(f"{amount} files failed to download")
 
 
 class UploadError(DvcException):
     def __init__(self, amount):
         self.amount = amount
 
-        super().__init__(
-            "{amount} files failed to upload".format(amount=amount)
-        )
+        super().__init__(f"{amount} files failed to upload")
 
 
 class CheckoutError(DvcException):
@@ -278,7 +278,7 @@ class CollectCacheError(DvcException):
 class NoRemoteInExternalRepoError(DvcException):
     def __init__(self, url):
         super().__init__(
-            "No DVC remote is specified in target repository '{}'.".format(url)
+            f"No DVC remote is specified in target repository '{url}'."
         )
 
 
@@ -293,7 +293,7 @@ class NoOutputInExternalRepoError(DvcException):
 
 class HTTPError(DvcException):
     def __init__(self, code, reason):
-        super().__init__("'{} {}'".format(code, reason))
+        super().__init__(f"'{code} {reason}'")
 
 
 class PathMissingError(DvcException):
@@ -301,19 +301,15 @@ class PathMissingError(DvcException):
         "The path '{}' does not exist in the target repository '{}'"
         " neither as a DVC output nor as a Git-tracked file."
     )
-    default_msg_output_only = (
+    default_msg_dvc_only = (
         "The path '{}' does not exist in the target repository '{}'"
         " as an DVC output."
     )
 
-    def __init__(self, path, repo, output_only=False):
-        msg = (
-            self.default_msg
-            if not output_only
-            else self.default_msg_output_only
-        )
+    def __init__(self, path, repo, dvc_only=False):
+        msg = self.default_msg if not dvc_only else self.default_msg_dvc_only
         super().__init__(msg.format(path, repo))
-        self.output_only = output_only
+        self.dvc_only = dvc_only
 
 
 class RemoteCacheRequiredError(DvcException):
@@ -333,3 +329,15 @@ class RemoteCacheRequiredError(DvcException):
 
 class IsADirectoryError(DvcException):
     """Raised when a file operation is requested on a directory."""
+
+
+class NoOutputOrStageError(DvcException):
+    """
+    Raised when the target is neither an output nor a stage name in dvc.yaml
+    """
+
+    def __init__(self, target, file):
+        super().__init__(
+            f"'{target}' "
+            f"does not exist as an output or a stage name in '{file}'"
+        )

dvc/external_repo.py

@@ -4,13 +4,12 @@ import tempfile
 import threading
 from contextlib import contextmanager
 from distutils.dir_util import copy_tree
+from typing import Iterable
 
-from funcy import cached_property, retry, suppress, wrap_with
+from funcy import cached_property, retry, wrap_with
 
-from dvc.compat import fspath
 from dvc.config import NoRemoteError, NotDvcRepoError
 from dvc.exceptions import (
-    CheckoutError,
     FileMissingError,
     NoOutputInExternalRepoError,
     NoRemoteInExternalRepoError,
@@ -19,9 +18,10 @@ from dvc.exceptions import (
 )
 from dvc.path_info import PathInfo
 from dvc.repo import Repo
+from dvc.repo.tree import RepoTree
 from dvc.scm.git import Git
-from dvc.utils import tmp_fname
-from dvc.utils.fs import fs_copy, move, remove
+from dvc.scm.tree import is_working_tree
+from dvc.utils.fs import remove
 
 logger = logging.getLogger(__name__)
 
@@ -30,10 +30,12 @@ logger = logging.getLogger(__name__)
 def external_repo(url, rev=None, for_write=False):
     logger.debug("Creating external repo %s@%s", url, rev)
     path = _cached_clone(url, rev, for_write=for_write)
+    if not rev:
+        rev = "HEAD"
     try:
-        repo = ExternalRepo(path, url)
+        repo = ExternalRepo(path, url, rev, for_write=for_write)
     except NotDvcRepoError:
-        repo = ExternalGitRepo(path, url)
+        repo = ExternalGitRepo(path, url, rev)
 
     try:
         yield repo
@@ -65,59 +67,99 @@ def clean_repos():
         _remove(path)
 
 
-class ExternalRepo(Repo):
-    def __init__(self, root_dir, url):
-        super().__init__(root_dir)
+class BaseExternalRepo:
+
+    _local_cache = None
+
+    @property
+    def local_cache(self):
+        if hasattr(self, "cache"):
+            return self.cache.local
+        return self._local_cache
+
+    @contextmanager
+    def use_cache(self, cache):
+        """Use the specified cache in place of default tmpdir cache for
+        download operations.
+        """
+        if hasattr(self, "cache"):
+            save_cache = self.cache.local
+            self.cache.local = cache
+        self._local_cache = cache
+
+        yield
+
+        if hasattr(self, "cache"):
+            self.cache.local = save_cache
+        self._local_cache = None
+
+    @cached_property
+    def repo_tree(self):
+        return RepoTree(self, fetch=True)
+
+    def get_rev(self):
+        if is_working_tree(self.tree):
+            return self.scm.get_rev()
+        if hasattr(self.tree, "tree"):
+            return self.tree.tree.rev
+        return self.tree.rev
+
+    def fetch_external(self, paths: Iterable, **kwargs):
+        """Fetch specified external repo paths into cache.
+
+        Returns 3-tuple in the form
+            (downloaded, failed, list(cache_infos))
+        where cache_infos can be used as checkout targets for the
+        fetched paths.
+        """
+        download_results = []
+        failed = 0
+
+        paths = [PathInfo(self.root_dir) / path for path in paths]
+
+        def download_update(result):
+            download_results.append(result)
+
+        save_infos = []
+        for path in paths:
+            if not self.repo_tree.exists(path):
+                raise PathMissingError(path, self.url)
+            save_info = self.local_cache.save(
+                path,
+                None,
+                tree=self.repo_tree,
+                download_callback=download_update,
+            )
+            save_infos.append(save_info)
+
+        return sum(download_results), failed, save_infos
+
+    def get_external(self, path, dest):
+        """Convenience wrapper for fetch_external and checkout."""
+        if self.local_cache:
+            # fetch DVC and git files to tmpdir cache, then checkout
+            _, _, save_infos = self.fetch_external([path])
+            self.local_cache.checkout(PathInfo(dest), save_infos[0])
+        else:
+            # git-only erepo with no cache, just copy files directly
+            # to dest
+            path = PathInfo(self.root_dir) / path
+            if not self.repo_tree.exists(path):
+                raise PathMissingError(path, self.url)
+            self.repo_tree.copytree(path, dest)
+
+
+class ExternalRepo(Repo, BaseExternalRepo):
+    def __init__(self, root_dir, url, rev, for_write=False):
+        if for_write:
+            super().__init__(root_dir)
+        else:
+            root_dir = os.path.realpath(root_dir)
+            super().__init__(root_dir, scm=Git(root_dir), rev=rev)
         self.url = url
         self._set_cache_dir()
         self._fix_upstream()
 
-    def pull_to(self, path, to_info):
-        """
-        Pull the corresponding file or directory specified by `path` and
-        checkout it into `to_info`.
-
-        It works with files tracked by Git and DVC, and also local files
-        outside the repository.
-        """
-        out = None
-        path_info = PathInfo(self.root_dir) / path
-
-        with suppress(OutputNotFoundError):
-            (out,) = self.find_outs_by_path(fspath(path_info), strict=False)
-
-        try:
-            if out and out.use_cache:
-                self._pull_cached(out, path_info, to_info)
-                return
-
-            # Check if it is handled by Git (it can't have an absolute path)
-            if os.path.isabs(path):
-                raise FileNotFoundError
-
-            fs_copy(fspath(path_info), fspath(to_info))
-        except FileNotFoundError:
-            raise PathMissingError(path, self.url)
-
-    def _pull_cached(self, out, path_info, dest):
-        with self.state:
-            tmp = PathInfo(tmp_fname(dest))
-            src = tmp / path_info.relative_to(out.path_info)
-
-            out.path_info = tmp
-
-            # Only pull unless all needed cache is present
-            if out.changed_cache(filter_info=src):
-                self.cloud.pull(out.get_used_cache(filter_info=src))
-
-            try:
-                out.checkout(filter_info=src)
-            except CheckoutError:
-                raise FileNotFoundError
-
-            move(src, dest)
-            remove(tmp)
-
     @wrap_with(threading.Lock())
     def _set_cache_dir(self):
         try:
@@ -126,6 +168,7 @@ class ExternalRepo(Repo):
             cache_dir = CACHE_DIRS[self.url] = tempfile.mkdtemp("dvc-cache")
 
         self.cache.local.cache_dir = cache_dir
+        self._local_cache = self.cache.local
 
     def _fix_upstream(self):
         if not os.path.isdir(self.url):
@@ -166,10 +209,11 @@ class ExternalRepo(Repo):
         self.config["core"]["remote"] = "auto-generated-upstream"
 
 
-class ExternalGitRepo:
-    def __init__(self, root_dir, url):
-        self.root_dir = root_dir
+class ExternalGitRepo(BaseExternalRepo):
+    def __init__(self, root_dir, url, rev):
+        self.root_dir = os.path.realpath(root_dir)
         self.url = url
+        self.tree = self.scm.get_tree(rev)
 
     @cached_property
     def scm(self):
@@ -182,23 +226,15 @@ class ExternalGitRepo:
     def find_out_by_relpath(self, path):
         raise OutputNotFoundError(path, self)
 
-    def pull_to(self, path, to_info):
-        try:
-            # Git handled files can't have absolute path
-            if os.path.isabs(path):
-                raise FileNotFoundError
-
-            fs_copy(os.path.join(self.root_dir, path), fspath(to_info))
-        except FileNotFoundError:
-            raise PathMissingError(path, self.url)
-
     @contextmanager
     def open_by_relpath(self, path, mode="r", encoding=None, **kwargs):
         """Opens a specified resource as a file object."""
+        tree = RepoTree(self)
         try:
-            abs_path = os.path.join(self.root_dir, path)
-            with open(abs_path, mode, encoding=encoding) as fd:
-                yield fd
+            with tree.open(
+                path, mode=mode, encoding=encoding, **kwargs
+            ) as fobj:
+                yield fobj
         except FileNotFoundError:
             raise PathMissingError(path, self.url)
 
@@ -210,14 +246,12 @@ def _cached_clone(url, rev, for_write=False):
     revision checked out. If for_write is set prevents reusing this dir via
     cache.
     """
-    if not for_write and Git.is_sha(rev) and (url, rev) in CLONES:
-        return CLONES[url, rev]
-
+    # even if we have already cloned this repo, we may need to
+    # fetch/fast-forward to get specified rev
     clone_path = _clone_default_branch(url, rev)
-    rev_sha = Git(clone_path).resolve_rev(rev or "HEAD")
 
-    if not for_write and (url, rev_sha) in CLONES:
-        return CLONES[url, rev_sha]
+    if not for_write and (url) in CLONES:
+        return CLONES[url]
 
     # Copy to a new dir to keep the clone clean
     repo_path = tempfile.mkdtemp("dvc-erepo")
@@ -225,11 +259,10 @@ def _cached_clone(url, rev, for_write=False):
     copy_tree(clone_path, repo_path)
 
     # Check out the specified revision
-    if rev is not None:
+    if for_write:
         _git_checkout(repo_path, rev)
-
-    if not for_write:
-        CLONES[url, rev_sha] = repo_path
+    else:
+        CLONES[url] = repo_path
     return repo_path
 
 

dvc/ignore.py

@@ -5,13 +5,14 @@ from funcy import cached_property
 from pathspec import PathSpec
 from pathspec.patterns import GitWildMatchPattern
 
+from dvc.path_info import PathInfo
 from dvc.scm.tree import BaseTree
 from dvc.utils import relpath
 
 logger = logging.getLogger(__name__)
 
 
-class DvcIgnore(object):
+class DvcIgnore:
     DVCIGNORE_FILE = ".dvcignore"
 
     def __call__(self, root, dirs, files):
@@ -35,12 +36,19 @@ class DvcIgnorePatterns(DvcIgnore):
         return dirs, files
 
     def matches(self, dirname, basename):
-        abs_path = os.path.join(dirname, basename)
-        rel_path = relpath(abs_path, self.dirname)
-
-        if os.pardir + os.sep in rel_path:
+        # NOTE: `relpath` is too slow, so we have to assume that both
+        # `dirname` and `self.dirname` are relative or absolute together.
+        prefix = self.dirname + os.sep
+        if dirname == self.dirname:
+            path = basename
+        elif dirname.startswith(prefix):
+            rel = dirname[len(prefix) :]
+            # NOTE: `os.path.join` is ~x5.5 slower
+            path = f"{rel}{os.sep}{basename}"
+        else:
             return False
-        return self.ignore_spec.match_file(rel_path)
+
+        return self.ignore_spec.match_file(path)
 
     def __hash__(self):
         return hash(self.ignore_file_path)
@@ -76,21 +84,22 @@ class DvcIgnoreRepo(DvcIgnore):
         def is_dvc_repo(directory):
             from dvc.repo import Repo
 
-            return os.path.isdir(os.path.join(directory, Repo.DVC_DIR))
+            return os.path.isdir(os.path.join(root, directory, Repo.DVC_DIR))
 
         dirs = [d for d in dirs if not is_dvc_repo(d)]
 
         return dirs, files
 
 
-class DvcIgnoreFilter(object):
-    def __init__(self, tree):
+class DvcIgnoreFilter:
+    def __init__(self, tree, root_dir):
         self.tree = tree
+        self.root_dir = root_dir
         self.ignores = {
             DvcIgnoreDirs([".git", ".hg", ".dvc"]),
             DvcIgnoreRepo(),
         }
-        for root, dirs, files in self.tree.walk(self.tree.tree_root):
+        for root, dirs, files in self.tree.walk(self.root_dir):
             self._update(root)
             dirs[:], files[:] = self(root, dirs, files)
 
@@ -107,39 +116,108 @@ class DvcIgnoreFilter(object):
 
 
 class CleanTree(BaseTree):
-    def __init__(self, tree):
+    def __init__(self, tree, tree_root=None):
         self.tree = tree
+        if tree_root:
+            self._tree_root = tree_root
+        else:
+            self._tree_root = self.tree.tree_root
 
     @cached_property
     def dvcignore(self):
-        return DvcIgnoreFilter(self.tree)
+        return DvcIgnoreFilter(self.tree, self.tree_root)
 
     @property
     def tree_root(self):
-        return self.tree.tree_root
+        return self._tree_root
 
     def open(self, path, mode="r", encoding="utf-8"):
-        return self.tree.open(path, mode, encoding)
+        if self.isfile(path):
+            return self.tree.open(path, mode, encoding)
+        raise FileNotFoundError
 
     def exists(self, path):
-        return self.tree.exists(path)
+        if self.tree.exists(path) and self._parents_exist(path):
+            if self.tree.isdir(path):
+                return self._valid_dirname(path)
+            return self._valid_filename(path)
+        return False
 
     def isdir(self, path):
-        return self.tree.isdir(path)
+        return (
+            self.tree.isdir(path)
+            and self._parents_exist(path)
+            and self._valid_dirname(path)
+        )
+
+    def _valid_dirname(self, path):
+        path = os.path.abspath(path)
+        if path == self.tree_root:
+            return True
+        dirname, basename = os.path.split(path)
+        dirs, _ = self.dvcignore(dirname, [basename], [])
+        if dirs:
+            return True
+        return False
 
     def isfile(self, path):
-        return self.tree.isfile(path)
+        return (
+            self.tree.isfile(path)
+            and self._parents_exist(path)
+            and self._valid_filename(path)
+        )
+
+    def _valid_filename(self, path):
+        dirname, basename = os.path.split(os.path.normpath(path))
+        _, files = self.dvcignore(os.path.abspath(dirname), [], [basename])
+        if files:
+            return True
+        return False
 
     def isexec(self, path):
-        return self.tree.isexec(path)
+        return self.exists(path) and self.tree.isexec(path)
+
+    def _parents_exist(self, path):
+        from dvc.repo import Repo
+
+        path = PathInfo(path)
+
+        # if parent is tree_root or inside a .dvc dir we can skip this check
+        if path.parent == self.tree_root or Repo.DVC_DIR in path.parts:
+            return True
+
+        # if path is outside of tree, assume this is a local remote/local cache
+        # link/move operation where we do not need to filter ignores
+        path = relpath(path, self.tree_root)
+        if path.startswith("..") or (
+            os.name == "nt"
+            and not os.path.commonprefix(
+                [os.path.abspath(path), self.tree_root]
+            )
+        ):
+            return True
+
+        # check if parent directories are in our ignores, starting from
+        # tree_root
+        for parent_dir in reversed(PathInfo(path).parents):
+            dirname, basename = os.path.split(parent_dir)
+            if basename == ".":
+                # parent_dir == tree_root
+                continue
+            dirs, _ = self.dvcignore(os.path.abspath(dirname), [basename], [])
+            if not dirs:
+                return False
+        return True
 
     def walk(self, top, topdown=True):
         for root, dirs, files in self.tree.walk(top, topdown):
-            dirs[:], files[:] = self.dvcignore(root, dirs, files)
+            dirs[:], files[:] = self.dvcignore(
+                os.path.abspath(root), dirs, files
+            )
 
             yield root, dirs, files
 
-    def walk_files(self, top):
-        for root, _, files in self.walk(top):
-            for file in files:
-                yield os.path.join(root, file)
+    def stat(self, path):
+        if self.exists(path):
+            return self.tree.stat(path)
+        raise FileNotFoundError

dvc/istextfile.py

@@ -7,13 +7,17 @@
 TEXT_CHARS = bytes(range(32, 127)) + b"\n\r\t\f\b"
 
 
-def istextfile(fname, blocksize=512):
+def istextfile(fname, blocksize=512, tree=None):
     """ Uses heuristics to guess whether the given file is text or binary,
         by reading a single block of bytes from the file.
         If more than 30% of the chars in the block are non-text, or there
         are NUL ('\x00') bytes in the block, assume this is a binary file.
     """
-    with open(fname, "rb") as fobj:
+    if tree:
+        open_func = tree.open
+    else:
+        open_func = open
+    with open_func(fname, "rb") as fobj:
         block = fobj.read(blocksize)
 
     if not block:

dvc/lock.py

@@ -25,7 +25,7 @@ class LockError(DvcException):
     """Thrown when unable to acquire the lock for DVC repo."""
 
 
-class Lock(object):
+class Lock:
     """Class for DVC repo lock.
 
     Uses zc.lockfile as backend.
@@ -47,7 +47,7 @@ class Lock(object):
                 disable=not self._friendly,
                 desc=(
                     "If DVC froze, see `hardlink_lock` in {}".format(
-                        format_link("man.dvc.org/config#core")
+                        format_link("https://man.dvc.org/config#core")
                     )
                 ),
             ):

dvc/logger.py

@@ -18,20 +18,45 @@ FOOTER = (
 )
 
 
+def addLoggingLevel(levelName, levelNum, methodName=None):
+    """
+    Adds a new logging level to the `logging` module and the
+    currently configured logging class.
+
+    Based on https://stackoverflow.com/questions/2183233
+    """
+    if methodName is None:
+        methodName = levelName.lower()
+
+    assert not hasattr(logging, levelName)
+    assert not hasattr(logging, methodName)
+    assert not hasattr(logging.getLoggerClass(), methodName)
+
+    def logForLevel(self, message, *args, **kwargs):
+        if self.isEnabledFor(levelNum):
+            self._log(levelNum, message, args, **kwargs)
+
+    def logToRoot(message, *args, **kwargs):
+        logging.log(levelNum, message, *args, **kwargs)
+
+    logging.addLevelName(levelNum, levelName)
+    setattr(logging, levelName, levelNum)
+    setattr(logging.getLoggerClass(), methodName, logForLevel)
+    setattr(logging, methodName, logToRoot)
+
+
 class LoggingException(Exception):
     def __init__(self, record):
         msg = "failed to log {}".format(str(record))
         super().__init__(msg)
 
 
-class ExcludeErrorsFilter(logging.Filter):
-    def filter(self, record):
-        return record.levelno < logging.WARNING
+def excludeFilter(level):
+    class ExcludeLevelFilter(logging.Filter):
+        def filter(self, record):
+            return record.levelno < level
 
-
-class ExcludeInfoFilter(logging.Filter):
-    def filter(self, record):
-        return record.levelno < logging.INFO
+    return ExcludeLevelFilter
 
 
 class ColorFormatter(logging.Formatter):
@@ -47,6 +72,7 @@ class ColorFormatter(logging.Formatter):
     """
 
     color_code = {
+        "TRACE": colorama.Fore.GREEN,
         "DEBUG": colorama.Fore.BLUE,
         "WARNING": colorama.Fore.YELLOW,
         "ERROR": colorama.Fore.RED,
@@ -116,7 +142,11 @@ class LoggerHandler(logging.StreamHandler):
 
 
 def _is_verbose():
-    return logging.getLogger("dvc").getEffectiveLevel() == logging.DEBUG
+    return (
+        logging.NOTSET
+        < logging.getLogger("dvc").getEffectiveLevel()
+        <= logging.DEBUG
+    )
 
 
 def _iter_causes(exc):
@@ -152,12 +182,14 @@ def disable_other_loggers():
 def setup(level=logging.INFO):
     colorama.init()
 
+    addLoggingLevel("TRACE", logging.DEBUG - 5)
     logging.config.dictConfig(
         {
             "version": 1,
             "filters": {
-                "exclude_errors": {"()": ExcludeErrorsFilter},
-                "exclude_info": {"()": ExcludeInfoFilter},
+                "exclude_errors": {"()": excludeFilter(logging.WARNING)},
+                "exclude_info": {"()": excludeFilter(logging.INFO)},
+                "exclude_debug": {"()": excludeFilter(logging.DEBUG)},
             },
             "formatters": {"color": {"()": ColorFormatter}},
             "handlers": {
@@ -175,6 +207,13 @@ def setup(level=logging.INFO):
                     "stream": "ext://sys.stdout",
                     "filters": ["exclude_info"],
                 },
+                "console_trace": {
+                    "class": "dvc.logger.LoggerHandler",
+                    "level": "TRACE",
+                    "formatter": "color",
+                    "stream": "ext://sys.stdout",
+                    "filters": ["exclude_debug"],
+                },
                 "console_errors": {
                     "class": "dvc.logger.LoggerHandler",
                     "level": "WARNING",
@@ -188,6 +227,7 @@ def setup(level=logging.INFO):
                     "handlers": [
                         "console_info",
                         "console_debug",
+                        "console_trace",
                         "console_errors",
                     ],
                 },

dvc/main.py

@@ -18,7 +18,6 @@ from dvc.utils import format_link
 
 "".encode("idna")
 
-
 logger = logging.getLogger("dvc")
 
 
@@ -38,11 +37,17 @@ def main(argv=None):
     try:
         args = parse_args(argv)
 
-        if args.quiet:
-            logger.setLevel(logging.CRITICAL)
-
-        elif args.verbose:
-            logger.setLevel(logging.DEBUG)
+        verbosity = args.verbose - args.quiet
+        if verbosity:
+            logger.setLevel(
+                {
+                    -2: logging.CRITICAL,
+                    -1: logging.ERROR,
+                    1: logging.DEBUG,
+                    2: logging.TRACE,
+                }[max(-2, min(verbosity, 2))]
+            )
+        logger.trace(args)
 
         cmd = args.func(args)
         ret = cmd.run()

dvc/output/__init__.py

@@ -54,10 +54,11 @@ SCHEMA = CHECKSUMS_SCHEMA.copy()
 SCHEMA[Required(BaseOutput.PARAM_PATH)] = str
 SCHEMA[BaseOutput.PARAM_CACHE] = bool
 SCHEMA[BaseOutput.PARAM_METRIC] = BaseOutput.METRIC_SCHEMA
+SCHEMA[BaseOutput.PARAM_PLOT] = bool
 SCHEMA[BaseOutput.PARAM_PERSIST] = bool
 
 
-def _get(stage, p, info, cache, metric, persist=False):
+def _get(stage, p, info, cache, metric, plot=False, persist=False):
     parsed = urlparse(p)
 
     if parsed.scheme == "remote":
@@ -69,6 +70,7 @@ def _get(stage, p, info, cache, metric, persist=False):
             cache=cache,
             remote=remote,
             metric=metric,
+            plot=plot,
             persist=persist,
         )
 
@@ -81,6 +83,7 @@ def _get(stage, p, info, cache, metric, persist=False):
                 cache=cache,
                 remote=None,
                 metric=metric,
+                plot=plot,
                 persist=persist,
             )
     return LocalOutput(
@@ -90,6 +93,7 @@ def _get(stage, p, info, cache, metric, persist=False):
         cache=cache,
         remote=None,
         metric=metric,
+        plot=plot,
         persist=persist,
     )
 
@@ -100,26 +104,34 @@ def loadd_from(stage, d_list):
         p = d.pop(BaseOutput.PARAM_PATH)
         cache = d.pop(BaseOutput.PARAM_CACHE, True)
         metric = d.pop(BaseOutput.PARAM_METRIC, False)
+        plot = d.pop(BaseOutput.PARAM_PLOT, False)
         persist = d.pop(BaseOutput.PARAM_PERSIST, False)
-        ret.append(
-            _get(
-                stage, p, info=d, cache=cache, metric=metric, persist=persist,
-            )
-        )
-    return ret
-
-
-def loads_from(stage, s_list, use_cache=True, metric=False, persist=False):
-    ret = []
-    for s in s_list:
         ret.append(
             _get(
                 stage,
-                s,
-                info={},
-                cache=use_cache,
+                p,
+                info=d,
+                cache=cache,
                 metric=metric,
+                plot=plot,
                 persist=persist,
             )
         )
     return ret
+
+
+def loads_from(
+    stage, s_list, use_cache=True, metric=False, plot=False, persist=False
+):
+    return [
+        _get(
+            stage,
+            s,
+            info={},
+            cache=use_cache,
+            metric=metric,
+            plot=plot,
+            persist=persist,
+        )
+        for s in s_list
+    ]

dvc/output/base.py

@@ -19,28 +19,32 @@ logger = logging.getLogger(__name__)
 
 class OutputDoesNotExistError(DvcException):
     def __init__(self, path):
-        msg = "output '{}' does not exist".format(path)
+        msg = f"output '{path}' does not exist"
         super().__init__(msg)
 
 
 class OutputIsNotFileOrDirError(DvcException):
     def __init__(self, path):
-        msg = "output '{}' is not a file or directory".format(path)
+        msg = f"output '{path}' is not a file or directory"
         super().__init__(msg)
 
 
 class OutputAlreadyTrackedError(DvcException):
     def __init__(self, path):
-        msg = "output '{}' is already tracked by SCM (e.g. Git)".format(path)
+        msg = f""" output '{path}' is already tracked by SCM (e.g. Git).
+    You can remove it from Git, then add to DVC.
+        To stop tracking from Git:
+            git rm -r --cached '{path}'
+            git commit -m "stop tracking {path}" """
         super().__init__(msg)
 
 
 class OutputIsStageFileError(DvcException):
     def __init__(self, path):
-        super().__init__("Stage file '{}' cannot be an output.".format(path))
+        super().__init__(f"Stage file '{path}' cannot be an output.")
 
 
-class BaseOutput(object):
+class BaseOutput:
     IS_DEPENDENCY = False
 
     REMOTE = BaseRemote
@@ -50,6 +54,14 @@ class BaseOutput(object):
     PARAM_METRIC = "metric"
     PARAM_METRIC_TYPE = "type"
     PARAM_METRIC_XPATH = "xpath"
+    PARAM_PLOT = "plot"
+    PARAM_PLOT_TEMPLATE = "template"
+    PARAM_PLOT_X = "x"
+    PARAM_PLOT_Y = "y"
+    PARAM_PLOT_X_LABEL = "x_label"
+    PARAM_PLOT_Y_LABEL = "y_label"
+    PARAM_PLOT_TITLE = "title"
+    PARAM_PLOT_CSV_HEADER = "csv_header"
     PARAM_PERSIST = "persist"
 
     METRIC_SCHEMA = Any(
@@ -75,6 +87,7 @@ class BaseOutput(object):
         remote=None,
         cache=True,
         metric=False,
+        plot=False,
         persist=False,
     ):
         self._validate_output_path(path)
@@ -95,6 +108,7 @@ class BaseOutput(object):
         self.remote = remote or self.REMOTE(self.repo, {})
         self.use_cache = False if self.IS_DEPENDENCY else cache
         self.metric = False if self.IS_DEPENDENCY else metric
+        self.plot = False if self.IS_DEPENDENCY else plot
         self.persist = persist
 
         self.path_info = self._parse_path(remote, path)
@@ -167,7 +181,7 @@ class BaseOutput(object):
 
     @property
     def exists(self):
-        return self.remote.exists(self.path_info)
+        return self.remote.tree.exists(self.path_info)
 
     def save_info(self):
         return self.remote.save_info(self.path_info)
@@ -203,13 +217,13 @@ class BaseOutput(object):
 
     @property
     def is_empty(self):
-        return self.remote.is_empty(self.path_info)
+        return self.remote.tree.is_empty(self.path_info)
 
     def isdir(self):
-        return self.remote.isdir(self.path_info)
+        return self.remote.tree.isdir(self.path_info)
 
     def isfile(self):
-        return self.remote.isfile(self.path_info)
+        return self.remote.tree.isfile(self.path_info)
 
     def ignore(self):
         if not self.use_scm_ignore:
@@ -228,28 +242,24 @@ class BaseOutput(object):
             raise self.IsNotFileOrDirError(self)
 
         if self.is_empty:
-            logger.warning("'{}' is empty.".format(self))
+            logger.warning(f"'{self}' is empty.")
 
         self.ignore()
 
         if not self.use_cache:
             self.info = self.save_info()
-            if self.metric:
+            if self.metric or self.plot:
                 self.verify_metric()
             if not self.IS_DEPENDENCY:
-                logger.info(
-                    "Output '{}' doesn't use cache. Skipping saving.".format(
-                        self
-                    )
+                logger.debug(
+                    "Output '%s' doesn't use cache. Skipping saving.", self
                 )
             return
 
         assert not self.IS_DEPENDENCY
 
         if not self.changed():
-            logger.info(
-                "Output '{}' didn't change. Skipping saving.".format(self)
-            )
+            logger.debug("Output '%s' didn't change. Skipping saving.", self)
             return
 
         self.info = self.save_info()
@@ -265,7 +275,8 @@ class BaseOutput(object):
         if self.IS_DEPENDENCY:
             return ret
 
-        ret[self.PARAM_CACHE] = self.use_cache
+        if not self.use_cache:
+            ret[self.PARAM_CACHE] = self.use_cache
 
         if isinstance(self.metric, dict):
             if (
@@ -274,15 +285,19 @@ class BaseOutput(object):
             ):
                 del self.metric[self.PARAM_METRIC_XPATH]
 
-        ret[self.PARAM_METRIC] = self.metric
-        ret[self.PARAM_PERSIST] = self.persist
+        if self.metric:
+            ret[self.PARAM_METRIC] = self.metric
+
+        if self.plot:
+            ret[self.PARAM_PLOT] = self.plot
+
+        if self.persist:
+            ret[self.PARAM_PERSIST] = self.persist
 
         return ret
 
     def verify_metric(self):
-        raise DvcException(
-            "verify metric is not supported for {}".format(self.scheme)
-        )
+        raise DvcException(f"verify metric is not supported for {self.scheme}")
 
     def download(self, to):
         self.remote.download(self.path_info, to.path_info)
@@ -311,7 +326,7 @@ class BaseOutput(object):
         )
 
     def remove(self, ignore_remove=False):
-        self.remote.remove(self.path_info)
+        self.remote.tree.remove(self.path_info)
         if self.scheme != "local":
             return
 
@@ -322,7 +337,7 @@ class BaseOutput(object):
         if self.scheme == "local" and self.use_scm_ignore:
             self.repo.scm.ignore_remove(self.fspath)
 
-        self.remote.move(self.path_info, out.path_info)
+        self.remote.tree.move(self.path_info, out.path_info)
         self.def_path = out.def_path
         self.path_info = out.path_info
         self.save()
@@ -343,7 +358,18 @@ class BaseOutput(object):
         if self.exists:
             self.remote.unprotect(self.path_info)
 
-    def _collect_used_dir_cache(
+    def get_dir_cache(self, **kwargs):
+        if not self.is_dir_checksum:
+            raise DvcException("cannot get dir cache for file checksum")
+        if self.cache.changed_cache_file(self.checksum):
+            self.repo.cloud.pull(
+                NamedCache.make("local", self.checksum, str(self)),
+                show_checksums=False,
+                **kwargs,
+            )
+        return self.dir_cache
+
+    def collect_used_dir_cache(
         self, remote=None, force=False, jobs=None, filter_info=None
     ):
         """Get a list of `info`s related to the given directory.
@@ -367,16 +393,10 @@ class BaseOutput(object):
 
         cache = NamedCache()
 
-        if self.cache.changed_cache_file(self.checksum):
-            try:
-                self.repo.cloud.pull(
-                    NamedCache.make("local", self.checksum, str(self)),
-                    jobs=jobs,
-                    remote=remote,
-                    show_checksums=False,
-                )
-            except DvcException:
-                logger.debug("failed to pull cache for '{}'".format(self))
+        try:
+            self.get_dir_cache(jobs=jobs, remote=remote)
+        except DvcException:
+            logger.debug(f"failed to pull cache for '{self}'")
 
         if self.cache.changed_cache_file(self.checksum):
             msg = (
@@ -453,7 +473,7 @@ class BaseOutput(object):
             return ret
 
         ret.add_child_cache(
-            self.checksum, self._collect_used_dir_cache(**kwargs),
+            self.checksum, self.collect_used_dir_cache(**kwargs),
         )
 
         return ret

dvc/output/local.py

@@ -2,7 +2,6 @@ import logging
 import os
 from urllib.parse import urlparse
 
-from dvc.compat import fspath_py35
 from dvc.exceptions import DvcException
 from dvc.istextfile import istextfile
 from dvc.output.base import BaseOutput
@@ -38,7 +37,7 @@ class LocalOutput(BaseOutput):
             if not p.is_absolute():
                 p = self.stage.wdir / p
 
-        abs_p = os.path.abspath(os.path.normpath(fspath_py35(p)))
+        abs_p = os.path.abspath(os.path.normpath(p))
         return self.REMOTE.path_cls(abs_p)
 
     def __str__(self):
@@ -72,17 +71,18 @@ class LocalOutput(BaseOutput):
         return ret
 
     def verify_metric(self):
-        if not self.metric:
+        if not self.metric or self.plot:
             return
 
-        path = fspath_py35(self.path_info)
+        path = os.fspath(self.path_info)
         if not os.path.exists(path):
             return
 
+        name = "metrics" if self.metric else "plot"
         if os.path.isdir(path):
-            msg = "directory '{}' cannot be used as metrics."
-            raise DvcException(msg.format(self.path_info))
+            msg = "directory '{}' cannot be used as {}."
+            raise DvcException(msg.format(self.path_info, name))
 
         if not istextfile(path):
-            msg = "binary file '{}' cannot be used as metrics."
-            raise DvcException(msg.format(self.path_info))
+            msg = "binary file '{}' cannot be used as {}."
+            raise DvcException(msg.format(self.path_info, name))

dvc/path_info.py

@@ -8,7 +8,7 @@ from funcy import cached_property
 from dvc.utils import relpath
 
 
-class _BasePath(object):
+class _BasePath:
     def overlaps(self, other):
         if isinstance(other, (str, bytes)):
             other = self.__class__(other)
@@ -50,7 +50,6 @@ class PathInfo(pathlib.PurePath, _BasePath):
         return "{}: '{}'".format(type(self).__name__, self)
 
     # This permits passing it to file utils directly in Python 3.6+
-    # With Python 2.7, Python 3.5+ we are stuck with path_info.fspath for now
     def __fspath__(self):
         return pathlib.PurePath.__str__(self)
 
@@ -88,7 +87,7 @@ class _URLPathInfo(PosixPathInfo):
     __unicode__ = __str__
 
 
-class _URLPathParents(object):
+class _URLPathParents:
     def __init__(self, src):
         self.src = src
         self._parents = self.src._path.parents
@@ -100,7 +99,7 @@ class _URLPathParents(object):
         return self.src.replace(path=self._parents[idx])
 
     def __repr__(self):
-        return "<{}.parents>".format(self.src)
+        return f"<{self.src}.parents>"
 
 
 class URLInfo(_BasePath):
@@ -120,7 +119,7 @@ class URLInfo(_BasePath):
         assert bool(host) ^ bool(netloc)
 
         if netloc is not None:
-            return cls("{}://{}{}".format(scheme, netloc, path))
+            return cls(f"{scheme}://{netloc}{path}")
 
         obj = cls.__new__(cls)
         obj._fill_parts(scheme, host, user, port, path)
@@ -154,7 +153,7 @@ class URLInfo(_BasePath):
 
     @cached_property
     def url(self):
-        return "{}://{}{}".format(self.scheme, self.netloc, self._spath)
+        return f"{self.scheme}://{self.netloc}{self._spath}"
 
     def __str__(self):
         return self.url
@@ -216,10 +215,10 @@ class URLInfo(_BasePath):
         if isinstance(other, (str, bytes)):
             other = self.__class__(other)
         if self.__class__ != other.__class__:
-            msg = "'{}' has incompatible class with '{}'".format(self, other)
+            msg = f"'{self}' has incompatible class with '{other}'"
             raise ValueError(msg)
         if self._base_parts != other._base_parts:
-            msg = "'{}' does not start with '{}'".format(self, other)
+            msg = f"'{self}' does not start with '{other}'"
             raise ValueError(msg)
         return self._path.relative_to(other._path)
 

dvc/prompt.py

@@ -38,7 +38,7 @@ def confirm(statement):
     Returns:
         bool: whether or not specified statement was confirmed.
     """
-    prompt = "{statement} [y/n]".format(statement=statement)
+    prompt = f"{statement} [y/n]"
     answer = _ask(prompt, limited_to=["yes", "no", "y", "n"])
     return answer and answer.startswith("y")
 
@@ -52,5 +52,5 @@ def password(statement):
     Returns:
         str: password entered by the user.
     """
-    logger.info("{statement}: ".format(statement=statement))
+    logger.info(f"{statement}: ")
     return getpass("")

dvc/remote/azure.py

@@ -1,64 +1,73 @@
 import logging
 import os
 import posixpath
-import re
 import threading
 from datetime import datetime, timedelta
-from urllib.parse import urlparse
 
 from funcy import cached_property, wrap_prop
 
 from dvc.path_info import CloudURLInfo
 from dvc.progress import Tqdm
-from dvc.remote.base import BaseRemote
+from dvc.remote.base import BaseRemote, BaseRemoteTree
 from dvc.scheme import Schemes
 
 logger = logging.getLogger(__name__)
 
 
+class AzureRemoteTree(BaseRemoteTree):
+    @property
+    def blob_service(self):
+        return self.remote.blob_service
+
+    def _generate_download_url(self, path_info, expires=3600):
+        from azure.storage.blob import BlobPermissions
+
+        expires_at = datetime.utcnow() + timedelta(seconds=expires)
+
+        sas_token = self.blob_service.generate_blob_shared_access_signature(
+            path_info.bucket,
+            path_info.path,
+            permission=BlobPermissions.READ,
+            expiry=expires_at,
+        )
+        download_url = self.blob_service.make_blob_url(
+            path_info.bucket, path_info.path, sas_token=sas_token
+        )
+        return download_url
+
+    def exists(self, path_info):
+        paths = self.remote.list_paths(path_info.bucket, path_info.path)
+        return any(path_info.path == path for path in paths)
+
+    def remove(self, path_info):
+        if path_info.scheme != self.scheme:
+            raise NotImplementedError
+
+        logger.debug(f"Removing {path_info}")
+        self.blob_service.delete_blob(path_info.bucket, path_info.path)
+
+
 class AzureRemote(BaseRemote):
     scheme = Schemes.AZURE
     path_cls = CloudURLInfo
-    REGEX = (
-        r"azure://((?P<path>[^=;]*)?|("
-        # backward compatibility
-        r"(ContainerName=(?P<container_name>[^;]+);?)?"
-        r"(?P<connection_string>.+)?)?)$"
-    )
     REQUIRES = {"azure-storage-blob": "azure.storage.blob"}
     PARAM_CHECKSUM = "etag"
     COPY_POLL_SECONDS = 5
     LIST_OBJECT_PAGE_SIZE = 5000
+    TREE_CLS = AzureRemoteTree
 
     def __init__(self, repo, config):
         super().__init__(repo, config)
 
         url = config.get("url", "azure://")
+        self.path_info = self.path_cls(url)
 
-        match = re.match(self.REGEX, url)  # backward compatibility
-        path = match.group("path")
-        bucket = (
-            urlparse(url if path else "").netloc
-            or match.group("container_name")  # backward compatibility
-            or os.getenv("AZURE_STORAGE_CONTAINER_NAME")
-        )
+        if not self.path_info.bucket:
+            container = os.getenv("AZURE_STORAGE_CONTAINER_NAME")
+            self.path_info = self.path_cls(f"azure://{container}")
 
-        self.connection_string = (
-            config.get("connection_string")
-            or match.group("connection_string")  # backward compatibility
-            or os.getenv("AZURE_STORAGE_CONNECTION_STRING")
-        )
-
-        if not bucket:
-            raise ValueError("azure storage container name missing")
-
-        if not self.connection_string:
-            raise ValueError("azure storage connection string missing")
-
-        self.path_info = (
-            self.path_cls(url)
-            if path
-            else self.path_cls.from_parts(scheme=self.scheme, netloc=bucket)
+        self.connection_string = config.get("connection_string") or os.getenv(
+            "AZURE_STORAGE_CONNECTION_STRING"
         )
 
     @wrap_prop(threading.Lock())
@@ -67,12 +76,12 @@ class AzureRemote(BaseRemote):
         from azure.storage.blob import BlockBlobService
         from azure.common import AzureMissingResourceHttpError
 
-        logger.debug("URL {}".format(self.path_info))
-        logger.debug("Connection string {}".format(self.connection_string))
+        logger.debug(f"URL {self.path_info}")
+        logger.debug(f"Connection string {self.connection_string}")
         blob_service = BlockBlobService(
             connection_string=self.connection_string
         )
-        logger.debug("Container name {}".format(self.path_info.bucket))
+        logger.debug(f"Container name {self.path_info.bucket}")
         try:  # verify that container exists
             blob_service.list_blobs(
                 self.path_info.bucket, delimiter="/", num_results=1
@@ -81,14 +90,16 @@ class AzureRemote(BaseRemote):
             blob_service.create_container(self.path_info.bucket)
         return blob_service
 
-    def remove(self, path_info):
-        if path_info.scheme != self.scheme:
-            raise NotImplementedError
+    def get_etag(self, path_info):
+        etag = self.blob_service.get_blob_properties(
+            path_info.bucket, path_info.path
+        ).properties.etag
+        return etag.strip('"')
 
-        logger.debug("Removing {}".format(path_info))
-        self.blob_service.delete_blob(path_info.bucket, path_info.path)
+    def get_file_checksum(self, path_info):
+        return self.get_etag(path_info)
 
-    def _list_paths(self, bucket, prefix, progress_callback=None):
+    def list_paths(self, bucket, prefix, progress_callback=None):
         blob_service = self.blob_service
         next_marker = None
         while True:
@@ -113,7 +124,7 @@ class AzureRemote(BaseRemote):
             )
         else:
             prefix = self.path_info.path
-        return self._list_paths(
+        return self.list_paths(
             self.path_info.bucket, prefix, progress_callback
         )
 
@@ -138,23 +149,3 @@ class AzureRemote(BaseRemote):
                 to_file,
                 progress_callback=pbar.update_to,
             )
-
-    def exists(self, path_info):
-        paths = self._list_paths(path_info.bucket, path_info.path)
-        return any(path_info.path == path for path in paths)
-
-    def _generate_download_url(self, path_info, expires=3600):
-        from azure.storage.blob import BlobPermissions
-
-        expires_at = datetime.utcnow() + timedelta(seconds=expires)
-
-        sas_token = self.blob_service.generate_blob_shared_access_signature(
-            path_info.bucket,
-            path_info.path,
-            permission=BlobPermissions.READ,
-            expiry=expires_at,
-        )
-        download_url = self.blob_service.make_blob_url(
-            path_info.bucket, path_info.path, sas_token=sas_token
-        )
-        return download_url

dvc/remote/base.py

@@ -26,6 +26,7 @@ from dvc.path_info import PathInfo, URLInfo, WindowsPathInfo
 from dvc.progress import Tqdm
 from dvc.remote.index import RemoteIndex, RemoteIndexNoop
 from dvc.remote.slow_link_detection import slow_link_guard
+from dvc.scm.tree import is_working_tree
 from dvc.state import StateNoop
 from dvc.utils import tmp_fname
 from dvc.utils.fs import makedirs, move
@@ -57,7 +58,7 @@ class RemoteCmdError(DvcException):
 
 class RemoteActionNotImplemented(DvcException):
     def __init__(self, action, scheme):
-        m = "{} is not supported for {} remotes".format(action, scheme)
+        m = f"{action} is not supported for {scheme} remotes"
         super().__init__(m)
 
 
@@ -68,7 +69,7 @@ class RemoteMissingDepsError(DvcException):
 class DirCacheError(DvcException):
     def __init__(self, checksum):
         super().__init__(
-            "Failed to load dir cache for hash value: '{}'.".format(checksum)
+            f"Failed to load dir cache for hash value: '{checksum}'."
         )
 
 
@@ -82,12 +83,99 @@ def index_locked(f):
     return wrapper
 
 
-class BaseRemote(object):
+class BaseRemoteTree:
+    SHARED_MODE_MAP = {None: (None, None), "group": (None, None)}
+
+    def __init__(self, remote, config):
+        self.remote = remote
+        shared = config.get("shared")
+        self._file_mode, self._dir_mode = self.SHARED_MODE_MAP[shared]
+
+    @property
+    def file_mode(self):
+        return self._file_mode
+
+    @property
+    def dir_mode(self):
+        return self._dir_mode
+
+    @property
+    def scheme(self):
+        return self.remote.scheme
+
+    @property
+    def path_cls(self):
+        return self.remote.path_cls
+
+    def open(self, path_info, mode="r", encoding=None):
+        if hasattr(self, "_generate_download_url"):
+            get_url = partial(self._generate_download_url, path_info)
+            return open_url(get_url, mode=mode, encoding=encoding)
+
+        raise RemoteActionNotImplemented("open", self.scheme)
+
+    def exists(self, path_info):
+        raise NotImplementedError
+
+    def isdir(self, path_info):
+        """Optional: Overwrite only if the remote has a way to distinguish
+        between a directory and a file.
+        """
+        return False
+
+    def isfile(self, path_info):
+        """Optional: Overwrite only if the remote has a way to distinguish
+        between a directory and a file.
+        """
+        return True
+
+    def iscopy(self, path_info):
+        """Check if this file is an independent copy."""
+        return False  # We can't be sure by default
+
+    def walk_files(self, path_info):
+        """Return a generator with `PathInfo`s to all the files"""
+        raise NotImplementedError
+
+    def is_empty(self, path_info):
+        return False
+
+    def remove(self, path_info):
+        raise RemoteActionNotImplemented("remove", self.scheme)
+
+    def makedirs(self, path_info):
+        """Optional: Implement only if the remote needs to create
+        directories before copying/linking/moving data
+        """
+
+    def move(self, from_info, to_info, mode=None):
+        assert mode is None
+        self.copy(from_info, to_info)
+        self.remove(from_info)
+
+    def copy(self, from_info, to_info):
+        raise RemoteActionNotImplemented("copy", self.scheme)
+
+    def copy_fobj(self, fobj, to_info):
+        raise RemoteActionNotImplemented("copy_fobj", self.scheme)
+
+    def symlink(self, from_info, to_info):
+        raise RemoteActionNotImplemented("symlink", self.scheme)
+
+    def hardlink(self, from_info, to_info):
+        raise RemoteActionNotImplemented("hardlink", self.scheme)
+
+    def reflink(self, from_info, to_info):
+        raise RemoteActionNotImplemented("reflink", self.scheme)
+
+
+class BaseRemote:
     scheme = "base"
     path_cls = URLInfo
     REQUIRES = {}
     JOBS = 4 * cpu_count()
     INDEX_CLS = RemoteIndex
+    TREE_CLS = BaseRemoteTree
 
     PARAM_RELPATH = "relpath"
     CHECKSUM_DIR_SUFFIX = ".dir"
@@ -101,7 +189,6 @@ class BaseRemote(object):
     CAN_TRAVERSE = True
 
     CACHE_MODE = None
-    SHARED_MODE_MAP = {None: (None, None), "group": (None, None)}
 
     state = StateNoop()
 
@@ -110,9 +197,6 @@ class BaseRemote(object):
 
         self._check_requires(config)
 
-        shared = config.get("shared")
-        self._file_mode, self._dir_mode = self.SHARED_MODE_MAP[shared]
-
         self.checksum_jobs = (
             config.get("checksum_jobs")
             or (self.repo and self.repo.config["core"].get("checksum_jobs"))
@@ -133,6 +217,8 @@ class BaseRemote(object):
         else:
             self.index = RemoteIndexNoop()
 
+        self.tree = self.TREE_CLS(self, config)
+
     @classmethod
     def get_missing_deps(cls):
         import importlib
@@ -151,7 +237,7 @@ class BaseRemote(object):
         if not missing:
             return
 
-        url = config.get("url", "{}://".format(self.scheme))
+        url = config.get("url", f"{self.scheme}://")
         msg = (
             "URL '{}' is supported but requires these missing "
             "dependencies: {}. If you have installed dvc using pip, "
@@ -211,23 +297,33 @@ class BaseRemote(object):
                 checksums = dict(zip(file_infos, tasks))
         return checksums
 
-    def _collect_dir(self, path_info):
+    def _collect_dir(self, path_info, tree=None, save_tree=False, **kwargs):
         file_infos = set()
 
-        for fname in self.walk_files(path_info):
+        if tree:
+            walk_files = tree.walk_files
+        else:
+            walk_files = self.tree.walk_files
+
+        for fname in walk_files(path_info, **kwargs):
             if DvcIgnore.DVCIGNORE_FILE == fname.name:
                 raise DvcIgnoreInCollectedDirError(fname.parent)
 
             file_infos.add(fname)
 
-        checksums = {fi: self.state.get(fi) for fi in file_infos}
-        not_in_state = {
-            fi for fi, checksum in checksums.items() if checksum is None
-        }
+        if tree:
+            checksums = {fi: tree.get_file_checksum(fi) for fi in file_infos}
+            if save_tree:
+                for fi, checksum in checksums.items():
+                    self._save_file(fi, checksum, tree=tree, **kwargs)
+        else:
+            checksums = {fi: self.state.get(fi) for fi in file_infos}
+            not_in_state = {
+                fi for fi, checksum in checksums.items() if checksum is None
+            }
 
-        new_checksums = self._calculate_checksums(not_in_state)
-
-        checksums.update(new_checksums)
+            new_checksums = self._calculate_checksums(not_in_state)
+            checksums.update(new_checksums)
 
         result = [
             {
@@ -248,18 +344,25 @@ class BaseRemote(object):
         # Sorting the list by path to ensure reproducibility
         return sorted(result, key=itemgetter(self.PARAM_RELPATH))
 
-    def get_dir_checksum(self, path_info):
+    def get_dir_checksum(self, path_info, tree=None):
         if not self.cache:
             raise RemoteCacheRequiredError(path_info)
 
-        dir_info = self._collect_dir(path_info)
+        dir_info = self._collect_dir(path_info, tree=None)
+        if tree:
+            # don't save state entry for path_info if it is a tree path
+            path_info = None
+        return self._save_dir_info(dir_info, path_info)
+
+    def _save_dir_info(self, dir_info, path_info=None):
         checksum, tmp_info = self._get_dir_info_checksum(dir_info)
         new_info = self.cache.checksum_to_path_info(checksum)
         if self.cache.changed_cache_file(checksum):
-            self.cache.makedirs(new_info.parent)
-            self.cache.move(tmp_info, new_info, mode=self.CACHE_MODE)
+            self.cache.tree.makedirs(new_info.parent)
+            self.cache.tree.move(tmp_info, new_info, mode=self.CACHE_MODE)
 
-        self.state.save(path_info, checksum)
+        if path_info:
+            self.state.save(path_info, checksum)
         self.state.save(new_info, checksum)
 
         return checksum
@@ -319,12 +422,14 @@ class BaseRemote(object):
 
     @classmethod
     def is_dir_checksum(cls, checksum):
+        if not checksum:
+            return False
         return checksum.endswith(cls.CHECKSUM_DIR_SUFFIX)
 
     def get_checksum(self, path_info):
         assert isinstance(path_info, str) or path_info.scheme == self.scheme
 
-        if not self.exists(path_info):
+        if not self.tree.exists(path_info):
             return None
 
         checksum = self.state.get(path_info)
@@ -335,14 +440,16 @@ class BaseRemote(object):
         if (
             checksum
             and self.is_dir_checksum(checksum)
-            and not self.exists(self.cache.checksum_to_path_info(checksum))
+            and not self.tree.exists(
+                self.cache.checksum_to_path_info(checksum)
+            )
         ):
             checksum = None
 
         if checksum:
             return checksum
 
-        if self.isdir(path_info):
+        if self.tree.isdir(path_info):
             checksum = self.get_dir_checksum(path_info)
         else:
             checksum = self.get_file_checksum(path_info)
@@ -376,7 +483,7 @@ class BaseRemote(object):
             "checking if '%s'('%s') has changed.", path_info, checksum_info
         )
 
-        if not self.exists(path_info):
+        if not self.tree.exists(path_info):
             logger.debug("'%s' doesn't exist.", path_info)
             return True
 
@@ -408,9 +515,9 @@ class BaseRemote(object):
         self._link(from_info, to_info, self.cache_types)
 
     def _link(self, from_info, to_info, link_types):
-        assert self.isfile(from_info)
+        assert self.tree.isfile(from_info)
 
-        self.makedirs(to_info.parent)
+        self.tree.makedirs(to_info.parent)
 
         self._try_links(from_info, to_info, link_types)
 
@@ -418,17 +525,17 @@ class BaseRemote(object):
         if self.cache_type_confirmed:
             return
 
-        is_link = getattr(self, "is_{}".format(link_type), None)
+        is_link = getattr(self.tree, f"is_{link_type}", None)
         if is_link and not is_link(path_info):
-            self.remove(path_info)
-            raise DvcException("failed to verify {}".format(link_type))
+            self.tree.remove(path_info)
+            raise DvcException(f"failed to verify {link_type}")
 
         self.cache_type_confirmed = True
 
     @slow_link_guard
     def _try_links(self, from_info, to_info, link_types):
         while link_types:
-            link_method = getattr(self, link_types[0])
+            link_method = getattr(self.tree, link_types[0])
             try:
                 self._do_link(from_info, to_info, link_method)
                 self._verify_link(to_info, link_types[0])
@@ -443,8 +550,8 @@ class BaseRemote(object):
         raise DvcException("no possible cache types left to try out.")
 
     def _do_link(self, from_info, to_info, link_method):
-        if self.exists(to_info):
-            raise DvcException("Link '{}' already exists!".format(to_info))
+        if self.tree.exists(to_info):
+            raise DvcException(f"Link '{to_info}' already exists!")
 
         link_method(from_info, to_info)
 
@@ -452,28 +559,47 @@ class BaseRemote(object):
             "Created '%s': %s -> %s", self.cache_types[0], from_info, to_info,
         )
 
-    def _save_file(self, path_info, checksum, save_link=True):
+    def _save_file(
+        self, path_info, checksum, save_link=True, tree=None, **kwargs
+    ):
         assert checksum
 
         cache_info = self.checksum_to_path_info(checksum)
-        if self.changed_cache(checksum):
-            self.move(path_info, cache_info, mode=self.CACHE_MODE)
-            self.link(cache_info, path_info)
-        elif self.iscopy(path_info) and self._cache_is_copy(path_info):
-            # Default relink procedure involves unneeded copy
-            self.unprotect(path_info)
+        if tree:
+            if self.changed_cache(checksum):
+                with tree.open(path_info, mode="rb") as fobj:
+                    # if tree has fetch enabled, DVC out will be fetched on
+                    # open and we do not need to read/copy any data
+                    if not (
+                        tree.isdvc(path_info, strict=False) and tree.fetch
+                    ):
+                        self.tree.copy_fobj(fobj, cache_info)
+                callback = kwargs.get("download_callback")
+                if callback:
+                    callback(1)
         else:
-            self.remove(path_info)
-            self.link(cache_info, path_info)
+            if self.changed_cache(checksum):
+                self.tree.move(path_info, cache_info, mode=self.CACHE_MODE)
+                self.link(cache_info, path_info)
+            elif self.tree.iscopy(path_info) and self._cache_is_copy(
+                path_info
+            ):
+                # Default relink procedure involves unneeded copy
+                self.unprotect(path_info)
+            else:
+                self.tree.remove(path_info)
+                self.link(cache_info, path_info)
 
-        if save_link:
-            self.state.save_link(path_info)
+            if save_link:
+                self.state.save_link(path_info)
 
         # we need to update path and cache, since in case of reflink,
         # or copy cache type moving original file results in updates on
         # next executed command, which causes md5 recalculation
-        self.state.save(path_info, checksum)
+        if not tree or is_working_tree(tree):
+            self.state.save(path_info, checksum)
         self.state.save(cache_info, checksum)
+        return {self.PARAM_CHECKSUM: checksum}
 
     def _cache_is_copy(self, path_info):
         """Checks whether cache uses copies."""
@@ -485,79 +611,88 @@ class BaseRemote(object):
 
         workspace_file = path_info.with_name("." + uuid())
         test_cache_file = self.path_info / ".cache_type_test_file"
-        if not self.exists(test_cache_file):
-            with self.open(test_cache_file, "wb") as fobj:
+        if not self.tree.exists(test_cache_file):
+            with self.tree.open(test_cache_file, "wb") as fobj:
                 fobj.write(bytes(1))
         try:
             self.link(test_cache_file, workspace_file)
         finally:
-            self.remove(workspace_file)
-            self.remove(test_cache_file)
+            self.tree.remove(workspace_file)
+            self.tree.remove(test_cache_file)
 
         self.cache_type_confirmed = True
         return self.cache_types[0] == "copy"
 
-    def _save_dir(self, path_info, checksum, save_link=True):
+    def _save_dir(
+        self, path_info, checksum, save_link=True, tree=None, **kwargs
+    ):
+        if tree:
+            dir_info = self._collect_dir(
+                path_info, tree=tree, save_tree=True, **kwargs
+            )
+            checksum = self._save_dir_info(dir_info)
+        else:
+            dir_info = self.get_dir_cache(checksum)
+
+            for entry in Tqdm(
+                dir_info, desc="Saving " + path_info.name, unit="file"
+            ):
+                entry_info = path_info / entry[self.PARAM_RELPATH]
+                entry_checksum = entry[self.PARAM_CHECKSUM]
+                self._save_file(entry_info, entry_checksum, save_link=False)
+
+            if save_link:
+                self.state.save_link(path_info)
+
         cache_info = self.checksum_to_path_info(checksum)
-        dir_info = self.get_dir_cache(checksum)
-
-        for entry in Tqdm(
-            dir_info, desc="Saving " + path_info.name, unit="file"
-        ):
-            entry_info = path_info / entry[self.PARAM_RELPATH]
-            entry_checksum = entry[self.PARAM_CHECKSUM]
-            self._save_file(entry_info, entry_checksum, save_link=False)
-
-        if save_link:
-            self.state.save_link(path_info)
-
         self.state.save(cache_info, checksum)
-        self.state.save(path_info, checksum)
-
-    def is_empty(self, path_info):
-        return False
-
-    def isfile(self, path_info):
-        """Optional: Overwrite only if the remote has a way to distinguish
-        between a directory and a file.
-        """
-        return True
-
-    def isdir(self, path_info):
-        """Optional: Overwrite only if the remote has a way to distinguish
-        between a directory and a file.
-        """
-        return False
-
-    def iscopy(self, path_info):
-        """Check if this file is an independent copy."""
-        return False  # We can't be sure by default
-
-    def walk_files(self, path_info):
-        """Return a generator with `PathInfo`s to all the files"""
-        raise NotImplementedError
+        if not tree or is_working_tree(tree):
+            self.state.save(path_info, checksum)
+        return {self.PARAM_CHECKSUM: checksum}
 
     @staticmethod
     def protect(path_info):
         pass
 
-    def save(self, path_info, checksum_info, save_link=True):
+    def save(
+        self, path_info, checksum_info, save_link=True, tree=None, **kwargs
+    ):
         if path_info.scheme != self.scheme:
             raise RemoteActionNotImplemented(
-                "save {} -> {}".format(path_info.scheme, self.scheme),
-                self.scheme,
+                f"save {path_info.scheme} -> {self.scheme}", self.scheme,
             )
 
-        checksum = checksum_info[self.PARAM_CHECKSUM]
-        self._save(path_info, checksum, save_link)
+        if tree:
+            if tree.isdir(path_info):
+                # save checksum will be computed during tree walk
+                checksum = None
+            else:
+                checksum = tree.get_file_checksum(path_info)
+        else:
+            checksum = checksum_info[self.PARAM_CHECKSUM]
+        return self._save(path_info, checksum, save_link, tree, **kwargs)
 
-    def _save(self, path_info, checksum, save_link=True):
-        to_info = self.checksum_to_path_info(checksum)
-        logger.debug("Saving '%s' to '%s'.", path_info, to_info)
-        if self.isdir(path_info):
-            self._save_dir(path_info, checksum, save_link)
-            return
-        self._save_file(path_info, checksum, save_link)
+    def _save(self, path_info, checksum, save_link=True, tree=None, **kwargs):
+        if tree:
+            logger.debug("Saving tree path '%s' to cache.", path_info)
+        else:
+            to_info = self.checksum_to_path_info(checksum)
+            logger.debug("Saving '%s' to '%s'.", path_info, to_info)
+
+        if tree:
+            isdir = tree.isdir
+            save_link = False
+        else:
+            isdir = self.tree.isdir
+
+        if isdir(path_info):
+            return self._save_dir(
+                path_info, checksum, save_link, tree, **kwargs
+            )
+        return self._save_file(path_info, checksum, save_link, tree, **kwargs)
+
+    def open(self, *args, **kwargs):
+        return self.tree.open(*args, **kwargs)
 
     def _handle_transfer_exception(
         self, from_info, to_info, exception, operation
@@ -614,13 +749,13 @@ class BaseRemote(object):
             raise NotImplementedError
 
         if to_info.scheme == self.scheme != "local":
-            self.copy(from_info, to_info)
+            self.tree.copy(from_info, to_info)
             return 0
 
         if to_info.scheme != "local":
             raise NotImplementedError
 
-        if self.isdir(from_info):
+        if self.tree.isdir(from_info):
             return self._download_dir(
                 from_info, to_info, name, no_progress_bar, file_mode, dir_mode
             )
@@ -631,7 +766,7 @@ class BaseRemote(object):
     def _download_dir(
         self, from_info, to_info, name, no_progress_bar, file_mode, dir_mode
     ):
-        from_infos = list(self.walk_files(from_info))
+        from_infos = list(self.tree.walk_files(from_info))
         to_infos = (
             to_info / info.relative_to(from_info) for info in from_infos
         )
@@ -678,41 +813,11 @@ class BaseRemote(object):
 
         return 0
 
-    def open(self, path_info, mode="r", encoding=None):
-        if hasattr(self, "_generate_download_url"):
-            get_url = partial(self._generate_download_url, path_info)
-            return open_url(get_url, mode=mode, encoding=encoding)
-
-        raise RemoteActionNotImplemented("open", self.scheme)
-
-    def remove(self, path_info):
-        raise RemoteActionNotImplemented("remove", self.scheme)
-
-    def move(self, from_info, to_info, mode=None):
-        assert mode is None
-        self.copy(from_info, to_info)
-        self.remove(from_info)
-
-    def copy(self, from_info, to_info):
-        raise RemoteActionNotImplemented("copy", self.scheme)
-
-    def symlink(self, from_info, to_info):
-        raise RemoteActionNotImplemented("symlink", self.scheme)
-
-    def hardlink(self, from_info, to_info):
-        raise RemoteActionNotImplemented("hardlink", self.scheme)
-
-    def reflink(self, from_info, to_info):
-        raise RemoteActionNotImplemented("reflink", self.scheme)
-
-    def exists(self, path_info):
-        raise NotImplementedError
-
     def path_to_checksum(self, path):
         parts = self.path_cls(path).parts[-2:]
 
         if not (len(parts) == 2 and parts[0] and len(parts[0]) == 2):
-            raise ValueError("Bad cache file path '{}'".format(path))
+            raise ValueError(f"Bad cache file path '{path}'")
 
         return "".join(parts)
 
@@ -762,7 +867,7 @@ class BaseRemote(object):
 
     @index_locked
     def gc(self, named_cache, jobs=None):
-        used = self.extract_used_local_checksums(named_cache)
+        used = set(named_cache.scheme_keys("local"))
 
         if self.scheme != "":
             used.update(named_cache.scheme_keys(self.scheme))
@@ -778,8 +883,9 @@ class BaseRemote(object):
                 continue
             path_info = self.checksum_to_path_info(checksum)
             if self.is_dir_checksum(checksum):
+                # backward compatibility
                 self._remove_unpacked_dir(checksum)
-            self.remove(path_info)
+            self.tree.remove(path_info)
             removed = True
         if removed:
             self.index.clear()
@@ -826,9 +932,9 @@ class BaseRemote(object):
             self.protect(cache_info)
             return False
 
-        if self.exists(cache_info):
+        if self.tree.exists(cache_info):
             logger.warning("corrupted cache file '%s'.", cache_info)
-            self.remove(cache_info)
+            self.tree.remove(cache_info)
 
         return True
 
@@ -836,11 +942,6 @@ class BaseRemote(object):
         if self.changed_cache_file(checksum):
             return True
 
-        if not (path_info and filter_info) and not self._changed_unpacked_dir(
-            checksum
-        ):
-            return False
-
         for entry in self.get_dir_cache(checksum):
             entry_checksum = entry[self.PARAM_CHECKSUM]
 
@@ -852,9 +953,6 @@ class BaseRemote(object):
             if self.changed_cache_file(entry_checksum):
                 return True
 
-        if not (path_info and filter_info):
-            self._update_unpacked_dir(checksum)
-
         return False
 
     def changed_cache(self, checksum, path_info=None, filter_info=None):
@@ -991,7 +1089,7 @@ class BaseRemote(object):
 
         with Tqdm(
             desc="Estimating size of "
-            + ("cache in '{}'".format(name) if name else "remote cache"),
+            + (f"cache in '{name}'" if name else "remote cache"),
             unit="file",
         ) as pbar:
 
@@ -1010,7 +1108,7 @@ class BaseRemote(object):
                 remote_size = total_prefixes * len(remote_checksums)
             else:
                 remote_size = total_prefixes
-            logger.debug("Estimated remote size: {} files".format(remote_size))
+            logger.debug(f"Estimated remote size: {remote_size} files")
         return remote_size, remote_checksums
 
     def _cache_checksums_traverse(
@@ -1043,7 +1141,7 @@ class BaseRemote(object):
         else:
             yield from remote_checksums
             initial = len(remote_checksums)
-            traverse_prefixes = ["{:02x}".format(i) for i in range(1, 256)]
+            traverse_prefixes = [f"{i:02x}" for i in range(1, 256)]
             if self.TRAVERSE_PREFIX_LEN > 2:
                 traverse_prefixes += [
                     "{0:0{1}x}".format(i, self.TRAVERSE_PREFIX_LEN)
@@ -1051,7 +1149,7 @@ class BaseRemote(object):
                 ]
         with Tqdm(
             desc="Querying "
-            + ("cache in '{}'".format(name) if name else "remote cache"),
+            + (f"cache in '{name}'" if name else "remote cache"),
             total=remote_size,
             initial=initial,
             unit="file",
@@ -1080,7 +1178,7 @@ class BaseRemote(object):
         ) as pbar:
 
             def exists_with_progress(path_info):
-                ret = self.exists(path_info)
+                ret = self.tree.exists(path_info)
                 pbar.update_msg(str(path_info))
                 return ret
 
@@ -1099,7 +1197,7 @@ class BaseRemote(object):
         return not self.changed_cache(current)
 
     def safe_remove(self, path_info, force=False):
-        if not self.exists(path_info):
+        if not self.tree.exists(path_info):
             return
 
         if not force and not self.already_cached(path_info):
@@ -1111,7 +1209,7 @@ class BaseRemote(object):
             if not prompt.confirm(msg):
                 raise ConfirmRemoveError(str(path_info))
 
-        self.remove(path_info)
+        self.tree.remove(path_info)
 
     def _checkout_file(
         self, path_info, checksum, force, progress_callback=None, relink=False
@@ -1119,7 +1217,7 @@ class BaseRemote(object):
         """The file is changed we need to checkout a new copy"""
         added, modified = True, False
         cache_info = self.checksum_to_path_info(checksum)
-        if self.exists(path_info):
+        if self.tree.exists(path_info):
             logger.debug("data '%s' will be replaced.", path_info)
             self.safe_remove(path_info, force=force)
             added, modified = False, True
@@ -1132,11 +1230,6 @@ class BaseRemote(object):
 
         return added, modified and not relink
 
-    def makedirs(self, path_info):
-        """Optional: Implement only if the remote needs to create
-        directories before copying/linking/moving data
-        """
-
     def _checkout_dir(
         self,
         path_info,
@@ -1149,9 +1242,9 @@ class BaseRemote(object):
         added, modified = False, False
         # Create dir separately so that dir is created
         # even if there are no files in it
-        if not self.exists(path_info):
+        if not self.tree.exists(path_info):
             added = True
-            self.makedirs(path_info)
+            self.tree.makedirs(path_info)
 
         dir_info = self.get_dir_cache(checksum)
 
@@ -1187,7 +1280,7 @@ class BaseRemote(object):
         return added, not added and modified and not relink
 
     def _remove_redundant_files(self, path_info, dir_info, force):
-        existing_files = set(self.walk_files(path_info))
+        existing_files = set(self.tree.walk_files(path_info))
 
         needed_files = {
             path_info / entry[self.PARAM_RELPATH] for entry in dir_info
@@ -1293,19 +1386,5 @@ class BaseRemote(object):
     def unprotect(path_info):
         pass
 
-    def _get_unpacked_dir_names(self, checksums):
-        return set()
-
-    def extract_used_local_checksums(self, named_cache):
-        used = set(named_cache.scheme_keys("local"))
-        unpacked = self._get_unpacked_dir_names(used)
-        return used | unpacked
-
-    def _changed_unpacked_dir(self, checksum):
-        return True
-
-    def _update_unpacked_dir(self, checksum):
-        pass
-
     def _remove_unpacked_dir(self, checksum):
         pass

dvc/remote/gdrive.py

@@ -12,7 +12,7 @@ from funcy.py3 import cat
 from dvc.exceptions import DvcException
 from dvc.path_info import CloudURLInfo
 from dvc.progress import Tqdm
-from dvc.remote.base import BaseRemote
+from dvc.remote.base import BaseRemote, BaseRemoteTree
 from dvc.scheme import Schemes
 from dvc.utils import format_link, tmp_fname
 
@@ -22,10 +22,8 @@ FOLDER_MIME_TYPE = "application/vnd.google-apps.folder"
 
 class GDrivePathNotFound(DvcException):
     def __init__(self, path_info, hint):
-        hint = "" if hint is None else " {}".format(hint)
-        super().__init__(
-            "GDrive path '{}' not found.{}".format(path_info, hint)
-        )
+        hint = "" if hint is None else f" {hint}"
+        super().__init__(f"GDrive path '{path_info}' not found.{hint}")
 
 
 class GDriveAuthError(DvcException):
@@ -62,7 +60,7 @@ def _gdrive_retry(func):
                 "rateLimitExceeded",
             ]
         if result:
-            logger.debug("Retrying GDrive API call, error: {}.".format(exc))
+            logger.debug(f"Retrying GDrive API call, error: {exc}.")
 
         return result
 
@@ -89,6 +87,20 @@ class GDriveURLInfo(CloudURLInfo):
         self._spath = re.sub("/{2,}", "/", self._spath.rstrip("/"))
 
 
+class GDriveRemoteTree(BaseRemoteTree):
+    def exists(self, path_info):
+        try:
+            self.remote.get_item_id(path_info)
+        except GDrivePathNotFound:
+            return False
+        else:
+            return True
+
+    def remove(self, path_info):
+        item_id = self.remote.get_item_id(path_info)
+        self.remote.gdrive_delete_file(item_id)
+
+
 class GDriveRemote(BaseRemote):
     scheme = Schemes.GDRIVE
     path_cls = GDriveURLInfo
@@ -97,6 +109,7 @@ class GDriveRemote(BaseRemote):
     # Always prefer traverse for GDrive since API usage quotas are a concern.
     TRAVERSE_WEIGHT_MULTIPLIER = 1
     TRAVERSE_PREFIX_LEN = 2
+    TREE_CLS = GDriveRemoteTree
 
     GDRIVE_CREDENTIALS_DATA = "GDRIVE_CREDENTIALS_DATA"
     DEFAULT_USER_CREDENTIALS_FILE = "gdrive-user-credentials.json"
@@ -283,7 +296,7 @@ class GDriveRemote(BaseRemote):
         cache = {
             "dirs": defaultdict(list),
             "ids": {},
-            "root_id": self._get_item_id(
+            "root_id": self.get_item_id(
                 self.path_info,
                 use_cache=False,
                 hint="Confirm the directory exists and you can access it.",
@@ -342,7 +355,7 @@ class GDriveRemote(BaseRemote):
                     "use the `gdrive_user_credentials_file` config\n"
                     "   option if you use multiple GDrive remotes with "
                     "different email accounts.\n\nDetails".format(
-                        item_id, self.path_info, self._credentials_location
+                        item_id, self.path_info, self.credentials_location
                     )
                 ) from exc
             raise
@@ -396,7 +409,7 @@ class GDriveRemote(BaseRemote):
             gdrive_file.GetContentFile(to_file, callback=pbar.update_to)
 
     @_gdrive_retry
-    def _gdrive_delete_file(self, item_id):
+    def gdrive_delete_file(self, item_id):
         from pydrive2.files import ApiRequestError
 
         param = {"id": item_id}
@@ -465,7 +478,7 @@ class GDriveRemote(BaseRemote):
             return None
         query = "trashed=false and ({})".format(
             " or ".join(
-                "'{}' in parents".format(parent_id) for parent_id in parent_ids
+                f"'{parent_id}' in parents" for parent_id in parent_ids
             )
         )
         query += " and title='{}'".format(title.replace("'", "\\'"))
@@ -500,7 +513,7 @@ class GDriveRemote(BaseRemote):
             [self._create_dir(min(parent_ids), title, path)] if create else []
         )
 
-    def _get_item_id(self, path_info, create=False, use_cache=True, hint=None):
+    def get_item_id(self, path_info, create=False, use_cache=True, hint=None):
         assert path_info.bucket == self._bucket
 
         item_ids = self._path_to_item_ids(path_info.path, create, use_cache)
@@ -510,25 +523,17 @@ class GDriveRemote(BaseRemote):
         assert not create
         raise GDrivePathNotFound(path_info, hint)
 
-    def exists(self, path_info):
-        try:
-            self._get_item_id(path_info)
-        except GDrivePathNotFound:
-            return False
-        else:
-            return True
-
     def _upload(self, from_file, to_info, name=None, no_progress_bar=False):
         dirname = to_info.parent
         assert dirname
-        parent_id = self._get_item_id(dirname, True)
+        parent_id = self.get_item_id(dirname, True)
 
         self._gdrive_upload_file(
             parent_id, to_info.name, no_progress_bar, from_file, name
         )
 
     def _download(self, from_info, to_file, name=None, no_progress_bar=False):
-        item_id = self._get_item_id(from_info)
+        item_id = self.get_item_id(from_info)
         self._gdrive_download_file(item_id, to_file, name, no_progress_bar)
 
     def list_cache_paths(self, prefix=None, progress_callback=None):
@@ -542,9 +547,9 @@ class GDriveRemote(BaseRemote):
         else:
             dir_ids = self._ids_cache["ids"]
         parents_query = " or ".join(
-            "'{}' in parents".format(dir_id) for dir_id in dir_ids
+            f"'{dir_id}' in parents" for dir_id in dir_ids
         )
-        query = "({}) and trashed=false".format(parents_query)
+        query = f"({parents_query}) and trashed=false"
 
         for item in self._gdrive_list(query):
             if progress_callback:
@@ -554,12 +559,5 @@ class GDriveRemote(BaseRemote):
                 self._ids_cache["ids"][parent_id], item["title"]
             )
 
-    def remove(self, path_info):
-        item_id = self._get_item_id(path_info)
-        self._gdrive_delete_file(item_id)
-
     def get_file_checksum(self, path_info):
         raise NotImplementedError
-
-    def walk_files(self, path_info):
-        raise NotImplementedError

dvc/remote/gs.py

@@ -1,4 +1,3 @@
-import io
 import logging
 import os.path
 import posixpath
@@ -11,7 +10,7 @@ from funcy import cached_property, wrap_prop
 from dvc.exceptions import DvcException
 from dvc.path_info import CloudURLInfo
 from dvc.progress import Tqdm
-from dvc.remote.base import BaseRemote
+from dvc.remote.base import BaseRemote, BaseRemoteTree
 from dvc.scheme import Schemes
 
 logger = logging.getLogger(__name__)
@@ -55,7 +54,7 @@ def _upload_to_bucket(
     no_progress_bar=False,
 ):
     blob = bucket.blob(to_info.path, chunk_size=chunk_size)
-    with io.open(from_file, mode="rb") as fobj:
+    with open(from_file, mode="rb") as fobj:
         with Tqdm.wrapattr(
             fobj,
             "read",
@@ -66,11 +65,82 @@ def _upload_to_bucket(
             blob.upload_from_file(wrapped)
 
 
+class GSRemoteTree(BaseRemoteTree):
+    @property
+    def gs(self):
+        return self.remote.gs
+
+    def _generate_download_url(self, path_info, expires=3600):
+        expiration = timedelta(seconds=int(expires))
+
+        bucket = self.gs.bucket(path_info.bucket)
+        blob = bucket.get_blob(path_info.path)
+        if blob is None:
+            raise FileNotFoundError
+        return blob.generate_signed_url(expiration=expiration)
+
+    def exists(self, path_info):
+        """Check if the blob exists. If it does not exist,
+        it could be a part of a directory path.
+
+        eg: if `data/file.txt` exists, check for `data` should return True
+        """
+        return self.isfile(path_info) or self.isdir(path_info)
+
+    def isdir(self, path_info):
+        dir_path = path_info / ""
+        return bool(list(self.remote.list_paths(dir_path, max_items=1)))
+
+    def isfile(self, path_info):
+        if path_info.path.endswith("/"):
+            return False
+
+        blob = self.gs.bucket(path_info.bucket).blob(path_info.path)
+        return blob.exists()
+
+    def walk_files(self, path_info):
+        for fname in self.remote.list_paths(path_info / ""):
+            # skip nested empty directories
+            if fname.endswith("/"):
+                continue
+            yield path_info.replace(fname)
+
+    def remove(self, path_info):
+        if path_info.scheme != "gs":
+            raise NotImplementedError
+
+        logger.debug(f"Removing gs://{path_info}")
+        blob = self.gs.bucket(path_info.bucket).get_blob(path_info.path)
+        if not blob:
+            return
+
+        blob.delete()
+
+    def makedirs(self, path_info):
+        if not path_info.path:
+            return
+
+        self.gs.bucket(path_info.bucket).blob(
+            (path_info / "").path
+        ).upload_from_string("")
+
+    def copy(self, from_info, to_info):
+        from_bucket = self.gs.bucket(from_info.bucket)
+        blob = from_bucket.get_blob(from_info.path)
+        if not blob:
+            msg = f"'{from_info.path}' doesn't exist in the cloud"
+            raise DvcException(msg)
+
+        to_bucket = self.gs.bucket(to_info.bucket)
+        from_bucket.copy_blob(blob, to_bucket, new_name=to_info.path)
+
+
 class GSRemote(BaseRemote):
     scheme = Schemes.GS
     path_cls = CloudURLInfo
     REQUIRES = {"google-cloud-storage": "google.cloud.storage"}
     PARAM_CHECKSUM = "md5"
+    TREE_CLS = GSRemoteTree
 
     def __init__(self, repo, config):
         super().__init__(repo, config)
@@ -106,28 +176,7 @@ class GSRemote(BaseRemote):
         md5 = base64.b64decode(b64_md5)
         return codecs.getencoder("hex")(md5)[0].decode("utf-8")
 
-    def copy(self, from_info, to_info):
-        from_bucket = self.gs.bucket(from_info.bucket)
-        blob = from_bucket.get_blob(from_info.path)
-        if not blob:
-            msg = "'{}' doesn't exist in the cloud".format(from_info.path)
-            raise DvcException(msg)
-
-        to_bucket = self.gs.bucket(to_info.bucket)
-        from_bucket.copy_blob(blob, to_bucket, new_name=to_info.path)
-
-    def remove(self, path_info):
-        if path_info.scheme != "gs":
-            raise NotImplementedError
-
-        logger.debug("Removing gs://{}".format(path_info))
-        blob = self.gs.bucket(path_info.bucket).get_blob(path_info.path)
-        if not blob:
-            return
-
-        blob.delete()
-
-    def _list_paths(
+    def list_paths(
         self, path_info, max_items=None, prefix=None, progress_callback=None
     ):
         if prefix:
@@ -142,44 +191,10 @@ class GSRemote(BaseRemote):
             yield blob.name
 
     def list_cache_paths(self, prefix=None, progress_callback=None):
-        return self._list_paths(
+        return self.list_paths(
             self.path_info, prefix=prefix, progress_callback=progress_callback
         )
 
-    def walk_files(self, path_info):
-        for fname in self._list_paths(path_info / ""):
-            # skip nested empty directories
-            if fname.endswith("/"):
-                continue
-            yield path_info.replace(fname)
-
-    def makedirs(self, path_info):
-        if not path_info.path:
-            return
-
-        self.gs.bucket(path_info.bucket).blob(
-            (path_info / "").path
-        ).upload_from_string("")
-
-    def isdir(self, path_info):
-        dir_path = path_info / ""
-        return bool(list(self._list_paths(dir_path, max_items=1)))
-
-    def isfile(self, path_info):
-        if path_info.path.endswith("/"):
-            return False
-
-        blob = self.gs.bucket(path_info.bucket).blob(path_info.path)
-        return blob.exists()
-
-    def exists(self, path_info):
-        """Check if the blob exists. If it does not exist,
-        it could be a part of a directory path.
-
-        eg: if `data/file.txt` exists, check for `data` should return True
-        """
-        return self.isfile(path_info) or self.isdir(path_info)
-
     def _upload(self, from_file, to_info, name=None, no_progress_bar=False):
         bucket = self.gs.bucket(to_info.bucket)
         _upload_to_bucket(
@@ -193,7 +208,7 @@ class GSRemote(BaseRemote):
     def _download(self, from_info, to_file, name=None, no_progress_bar=False):
         bucket = self.gs.bucket(from_info.bucket)
         blob = bucket.get_blob(from_info.path)
-        with io.open(to_file, mode="wb") as fobj:
+        with open(to_file, mode="wb") as fobj:
             with Tqdm.wrapattr(
                 fobj,
                 "write",
@@ -202,12 +217,3 @@ class GSRemote(BaseRemote):
                 disable=no_progress_bar,
             ) as wrapped:
                 blob.download_to_file(wrapped)
-
-    def _generate_download_url(self, path_info, expires=3600):
-        expiration = timedelta(seconds=int(expires))
-
-        bucket = self.gs.bucket(path_info.bucket)
-        blob = bucket.get_blob(path_info.path)
-        if blob is None:
-            raise FileNotFoundError
-        return blob.generate_signed_url(expiration=expiration)

dvc/remote/hdfs.py

@@ -11,18 +11,75 @@ from urllib.parse import urlparse
 from dvc.scheme import Schemes
 from dvc.utils import fix_env, tmp_fname
 
-from .base import BaseRemote, RemoteCmdError
+from .base import BaseRemote, BaseRemoteTree, RemoteCmdError
 from .pool import get_connection
 
 logger = logging.getLogger(__name__)
 
 
+class HDFSRemoteTree(BaseRemoteTree):
+    @property
+    def hdfs(self):
+        return self.remote.hdfs
+
+    @contextmanager
+    def open(self, path_info, mode="r", encoding=None):
+        assert mode in {"r", "rt", "rb"}
+
+        try:
+            with self.hdfs(path_info) as hdfs, closing(
+                hdfs.open(path_info.path, mode="rb")
+            ) as fd:
+                if mode == "rb":
+                    yield fd
+                else:
+                    yield io.TextIOWrapper(fd, encoding=encoding)
+        except OSError as e:
+            # Empty .errno and not specific enough error class in pyarrow,
+            # see https://issues.apache.org/jira/browse/ARROW-6248
+            if "file does not exist" in str(e):
+                raise FileNotFoundError(*e.args)
+            raise
+
+    def exists(self, path_info):
+        assert not isinstance(path_info, list)
+        assert path_info.scheme == "hdfs"
+        with self.hdfs(path_info) as hdfs:
+            return hdfs.exists(path_info.path)
+
+    def remove(self, path_info):
+        if path_info.scheme != "hdfs":
+            raise NotImplementedError
+
+        if self.exists(path_info):
+            logger.debug(f"Removing {path_info.path}")
+            with self.hdfs(path_info) as hdfs:
+                hdfs.rm(path_info.path)
+
+    def copy(self, from_info, to_info, **_kwargs):
+        dname = posixpath.dirname(to_info.path)
+        with self.hdfs(to_info) as hdfs:
+            hdfs.mkdir(dname)
+            # NOTE: this is how `hadoop fs -cp` works too: it copies through
+            # your local machine.
+            with hdfs.open(from_info.path, "rb") as from_fobj:
+                tmp_info = to_info.parent / tmp_fname(to_info.name)
+                try:
+                    with hdfs.open(tmp_info.path, "wb") as tmp_fobj:
+                        tmp_fobj.upload(from_fobj)
+                    hdfs.rename(tmp_info.path, to_info.path)
+                except Exception:
+                    self.remove(tmp_info)
+                    raise
+
+
 class HDFSRemote(BaseRemote):
     scheme = Schemes.HDFS
     REGEX = r"^hdfs://((?P<user>.*)@)?.*$"
     PARAM_CHECKSUM = "checksum"
     REQUIRES = {"pyarrow": "pyarrow"}
     TRAVERSE_PREFIX_LEN = 2
+    TREE_CLS = HDFSRemoteTree
 
     def __init__(self, repo, config):
         super().__init__(repo, config)
@@ -55,7 +112,7 @@ class HDFSRemote(BaseRemote):
     def hadoop_fs(self, cmd, user=None):
         cmd = "hadoop fs -" + cmd
         if user:
-            cmd = "HADOOP_USER_NAME={} ".format(user) + cmd
+            cmd = f"HADOOP_USER_NAME={user} " + cmd
 
         # NOTE: close_fds doesn't work with redirected stdin/stdout/stderr.
         # See https://github.com/iterative/dvc/issues/1197.
@@ -87,41 +144,10 @@ class HDFSRemote(BaseRemote):
         # NOTE: pyarrow doesn't support checksum, so we need to use hadoop
         regex = r".*\t.*\t(?P<checksum>.*)"
         stdout = self.hadoop_fs(
-            "checksum {}".format(path_info.path), user=path_info.user
+            f"checksum {path_info.path}", user=path_info.user
         )
         return self._group(regex, stdout, "checksum")
 
-    def copy(self, from_info, to_info, **_kwargs):
-        dname = posixpath.dirname(to_info.path)
-        with self.hdfs(to_info) as hdfs:
-            hdfs.mkdir(dname)
-            # NOTE: this is how `hadoop fs -cp` works too: it copies through
-            # your local machine.
-            with hdfs.open(from_info.path, "rb") as from_fobj:
-                tmp_info = to_info.parent / tmp_fname(to_info.name)
-                try:
-                    with hdfs.open(tmp_info.path, "wb") as tmp_fobj:
-                        tmp_fobj.upload(from_fobj)
-                    hdfs.rename(tmp_info.path, to_info.path)
-                except Exception:
-                    self.remove(tmp_info)
-                    raise
-
-    def remove(self, path_info):
-        if path_info.scheme != "hdfs":
-            raise NotImplementedError
-
-        if self.exists(path_info):
-            logger.debug("Removing {}".format(path_info.path))
-            with self.hdfs(path_info) as hdfs:
-                hdfs.rm(path_info.path)
-
-    def exists(self, path_info):
-        assert not isinstance(path_info, list)
-        assert path_info.scheme == "hdfs"
-        with self.hdfs(path_info) as hdfs:
-            return hdfs.exists(path_info.path)
-
     def _upload(self, from_file, to_info, **_kwargs):
         with self.hdfs(to_info) as hdfs:
             hdfs.mkdir(posixpath.dirname(to_info.path))
@@ -135,27 +161,8 @@ class HDFSRemote(BaseRemote):
             with open(to_file, "wb+") as fobj:
                 hdfs.download(from_info.path, fobj)
 
-    @contextmanager
-    def open(self, path_info, mode="r", encoding=None):
-        assert mode in {"r", "rt", "rb"}
-
-        try:
-            with self.hdfs(path_info) as hdfs, closing(
-                hdfs.open(path_info.path, mode="rb")
-            ) as fd:
-                if mode == "rb":
-                    yield fd
-                else:
-                    yield io.TextIOWrapper(fd, encoding=encoding)
-        except IOError as e:
-            # Empty .errno and not specific enough error class in pyarrow,
-            # see https://issues.apache.org/jira/browse/ARROW-6248
-            if "file does not exist" in str(e):
-                raise FileNotFoundError(*e.args)
-            raise
-
     def list_cache_paths(self, prefix=None, progress_callback=None):
-        if not self.exists(self.path_info):
+        if not self.tree.exists(self.path_info):
             return
 
         if prefix:
@@ -165,6 +172,8 @@ class HDFSRemote(BaseRemote):
         dirs = deque([root])
 
         with self.hdfs(self.path_info) as hdfs:
+            if prefix and not hdfs.exists(root):
+                return
             while dirs:
                 try:
                     entries = hdfs.ls(dirs.pop(), detail=True)
@@ -175,7 +184,7 @@ class HDFSRemote(BaseRemote):
                             if progress_callback:
                                 progress_callback()
                             yield urlparse(entry["name"]).path
-                except IOError as e:
+                except OSError as e:
                     # When searching for a specific prefix pyarrow raises an
                     # exception if the specified cache dir does not exist
                     if not prefix:

dvc/remote/http.py

@@ -8,7 +8,7 @@ import dvc.prompt as prompt
 from dvc.exceptions import DvcException, HTTPError
 from dvc.path_info import HTTPURLInfo
 from dvc.progress import Tqdm
-from dvc.remote.base import BaseRemote
+from dvc.remote.base import BaseRemote, BaseRemoteTree
 from dvc.scheme import Schemes
 
 logger = logging.getLogger(__name__)
@@ -23,6 +23,11 @@ def ask_password(host, user):
     )
 
 
+class HTTPRemoteTree(BaseRemoteTree):
+    def exists(self, path_info):
+        return bool(self.remote.request("HEAD", path_info.url))
+
+
 class HTTPRemote(BaseRemote):
     scheme = Schemes.HTTP
     path_cls = HTTPURLInfo
@@ -32,6 +37,7 @@ class HTTPRemote(BaseRemote):
     CHUNK_SIZE = 2 ** 16
     PARAM_CHECKSUM = "etag"
     CAN_TRAVERSE = False
+    TREE_CLS = HTTPRemoteTree
 
     def __init__(self, repo, config):
         super().__init__(repo, config)
@@ -52,7 +58,7 @@ class HTTPRemote(BaseRemote):
         self.headers = {}
 
     def _download(self, from_info, to_file, name=None, no_progress_bar=False):
-        response = self._request("GET", from_info.url, stream=True)
+        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:
@@ -88,20 +94,17 @@ class HTTPRemote(BaseRemote):
                             break
                         yield chunk
 
-        response = self._request("POST", to_info.url, data=chunks())
+        response = self.request("POST", to_info.url, data=chunks())
         if response.status_code not in (200, 201):
             raise HTTPError(response.status_code, response.reason)
 
-    def exists(self, path_info):
-        return bool(self._request("HEAD", path_info.url))
-
     def _content_length(self, response):
         res = response.headers.get("Content-Length")
         return int(res) if res else None
 
     def get_file_checksum(self, path_info):
         url = path_info.url
-        headers = self._request("HEAD", url).headers
+        headers = self.request("HEAD", url).headers
         etag = headers.get("ETag") or headers.get("Content-MD5")
 
         if not etag:
@@ -155,7 +158,7 @@ class HTTPRemote(BaseRemote):
 
         return session
 
-    def _request(self, method, url, **kwargs):
+    def request(self, method, url, **kwargs):
         import requests
 
         kwargs.setdefault("allow_redirects", True)
@@ -185,7 +188,7 @@ class HTTPRemote(BaseRemote):
             return res
 
         except requests.exceptions.RequestException:
-            raise DvcException("could not perform a {} request".format(method))
+            raise DvcException(f"could not perform a {method} request")
 
     def gc(self):
         raise NotImplementedError

dvc/remote/index.py

@@ -69,9 +69,7 @@ class RemoteIndex:
     INDEX_TABLE_LAYOUT = "checksum TEXT PRIMARY KEY, " "dir INTEGER NOT NULL"
 
     def __init__(self, repo, name, dir_suffix=".dir"):
-        self.path = os.path.join(
-            repo.index_dir, "{}{}".format(name, self.INDEX_SUFFIX)
-        )
+        self.path = os.path.join(repo.index_dir, f"{name}{self.INDEX_SUFFIX}")
 
         self.dir_suffix = dir_suffix
         self.database = None
@@ -80,7 +78,7 @@ class RemoteIndex:
         self.lock = threading.Lock()
 
     def __iter__(self):
-        cmd = "SELECT checksum FROM {}".format(self.INDEX_TABLE)
+        cmd = f"SELECT checksum FROM {self.INDEX_TABLE}"
         for (checksum,) in self._execute(cmd):
             yield checksum
 
@@ -105,7 +103,7 @@ class RemoteIndex:
 
     def dir_checksums(self):
         """Iterate over .dir checksums stored in the index."""
-        cmd = "SELECT checksum FROM {} WHERE dir = 1".format(self.INDEX_TABLE)
+        cmd = f"SELECT checksum FROM {self.INDEX_TABLE} WHERE dir = 1"
         for (checksum,) in self._execute(cmd):
             yield checksum
 
@@ -184,7 +182,7 @@ class RemoteIndex:
 
         Changes to the index will not committed until dump() is called.
         """
-        cmd = "DELETE FROM {}".format(self.INDEX_TABLE)
+        cmd = f"DELETE FROM {self.INDEX_TABLE}"
         self._execute(cmd)
 
     def update(self, dir_checksums, file_checksums):

dvc/remote/local.py

@@ -8,7 +8,6 @@ from functools import partial
 from funcy import cached_property, concat
 from shortuuid import uuid
 
-from dvc.compat import fspath_py35
 from dvc.exceptions import DownloadError, DvcException, UploadError
 from dvc.path_info import PathInfo
 from dvc.progress import Tqdm
@@ -18,103 +17,86 @@ from dvc.remote.base import (
     STATUS_MISSING,
     STATUS_NEW,
     BaseRemote,
+    BaseRemoteTree,
     index_locked,
 )
 from dvc.remote.index import RemoteIndexNoop
 from dvc.scheme import Schemes
-from dvc.scm.tree import is_working_tree
+from dvc.scm.tree import WorkingTree, is_working_tree
 from dvc.system import System
 from dvc.utils import file_md5, relpath, tmp_fname
-from dvc.utils.fs import copyfile, makedirs, move, remove, walk_files
+from dvc.utils.fs import (
+    copy_fobj_to_file,
+    copyfile,
+    makedirs,
+    move,
+    remove,
+    walk_files,
+)
 
 logger = logging.getLogger(__name__)
 
 
-class LocalRemote(BaseRemote):
-    scheme = Schemes.LOCAL
-    path_cls = PathInfo
-    PARAM_CHECKSUM = "md5"
-    PARAM_PATH = "path"
-    TRAVERSE_PREFIX_LEN = 2
-    INDEX_CLS = RemoteIndexNoop
-
-    UNPACKED_DIR_SUFFIX = ".unpacked"
-
-    DEFAULT_CACHE_TYPES = ["reflink", "copy"]
-
-    CACHE_MODE = 0o444
+class LocalRemoteTree(BaseRemoteTree):
     SHARED_MODE_MAP = {None: (0o644, 0o755), "group": (0o664, 0o775)}
 
-    def __init__(self, repo, config):
-        super().__init__(repo, config)
-        self.cache_dir = config.get("url")
-        self._dir_info = {}
-
     @property
-    def state(self):
-        return self.repo.state
-
-    @property
-    def cache_dir(self):
-        return self.path_info.fspath if self.path_info else None
-
-    @cache_dir.setter
-    def cache_dir(self, value):
-        self.path_info = PathInfo(value) if value else None
-
-    @classmethod
-    def supported(cls, config):
-        return True
+    def repo(self):
+        return self.remote.repo
 
     @cached_property
-    def cache_path(self):
-        return os.path.abspath(self.cache_dir)
+    def _work_tree(self):
+        if self.repo:
+            return WorkingTree(self.repo.root_dir)
+        return None
 
-    def checksum_to_path(self, checksum):
-        return os.path.join(self.cache_path, checksum[0:2], checksum[2:])
+    @property
+    def work_tree(self):
+        # When using repo.brancher, repo.tree may change to/from WorkingTree to
+        # GitTree arbitarily. When repo.tree is GitTree, local cache needs to
+        # use its own WorkingTree instance.
+        if self.repo and not is_working_tree(self.repo.tree):
+            return self._work_tree
+        return None
 
-    def list_cache_paths(self, prefix=None, progress_callback=None):
-        assert self.path_info is not None
-        if prefix:
-            path_info = self.path_info / prefix[:2]
-        else:
-            path_info = self.path_info
-        if progress_callback:
-            for path in walk_files(path_info):
-                progress_callback()
-                yield path
-        else:
-            yield from walk_files(path_info)
-
-    def get(self, md5):
-        if not md5:
-            return None
-
-        return self.checksum_to_path_info(md5).url
+    @staticmethod
+    def open(path_info, mode="r", encoding=None):
+        return open(path_info, mode=mode, encoding=encoding)
 
     def exists(self, path_info):
-        assert is_working_tree(self.repo.tree)
         assert isinstance(path_info, str) or path_info.scheme == "local"
-        return self.repo.tree.exists(fspath_py35(path_info))
+        if not self.repo:
+            return os.path.exists(path_info)
+        if self.work_tree and self.work_tree.exists(path_info):
+            return True
+        return self.repo.tree.exists(path_info)
 
-    def makedirs(self, path_info):
-        makedirs(path_info, exist_ok=True, mode=self._dir_mode)
+    def isfile(self, path_info):
+        if not self.repo:
+            return os.path.isfile(path_info)
+        if self.work_tree and self.work_tree.isfile(path_info):
+            return True
+        return self.repo.tree.isfile(path_info)
 
-    def already_cached(self, path_info):
-        assert path_info.scheme in ["", "local"]
+    def isdir(self, path_info):
+        if not self.repo:
+            return os.path.isdir(path_info)
+        if self.work_tree and self.work_tree.isdir(path_info):
+            return True
+        return self.repo.tree.isdir(path_info)
 
-        current_md5 = self.get_checksum(path_info)
+    def iscopy(self, path_info):
+        return not (
+            System.is_symlink(path_info) or System.is_hardlink(path_info)
+        )
 
-        if not current_md5:
-            return False
-
-        return not self.changed_cache(current_md5)
-
-    def _verify_link(self, path_info, link_type):
-        if link_type == "hardlink" and self.getsize(path_info) == 0:
-            return
-
-        super()._verify_link(path_info, link_type)
+    def walk_files(self, path_info):
+        if self.work_tree:
+            tree = self.work_tree
+        else:
+            tree = self.repo.tree
+        for fname in tree.walk_files(path_info):
+            yield PathInfo(fname)
 
     def is_empty(self, path_info):
         path = path_info.fspath
@@ -127,32 +109,6 @@ class LocalRemote(BaseRemote):
 
         return False
 
-    @staticmethod
-    def isfile(path_info):
-        return os.path.isfile(fspath_py35(path_info))
-
-    @staticmethod
-    def isdir(path_info):
-        return os.path.isdir(fspath_py35(path_info))
-
-    def iscopy(self, path_info):
-        return not (
-            System.is_symlink(path_info) or System.is_hardlink(path_info)
-        )
-
-    @staticmethod
-    def getsize(path_info):
-        return os.path.getsize(fspath_py35(path_info))
-
-    def walk_files(self, path_info):
-        assert is_working_tree(self.repo.tree)
-
-        for fname in self.repo.tree.walk_files(path_info):
-            yield PathInfo(fname)
-
-    def get_file_checksum(self, path_info):
-        return file_md5(path_info)[0]
-
     def remove(self, path_info):
         if isinstance(path_info, PathInfo):
             if path_info.scheme != "local":
@@ -164,6 +120,9 @@ class LocalRemote(BaseRemote):
         if self.exists(path):
             remove(path)
 
+    def makedirs(self, path_info):
+        makedirs(path_info, exist_ok=True, mode=self.dir_mode)
+
     def move(self, from_info, to_info, mode=None):
         if from_info.scheme != "local" or to_info.scheme != "local":
             raise NotImplementedError
@@ -172,9 +131,9 @@ class LocalRemote(BaseRemote):
 
         if mode is None:
             if self.isfile(from_info):
-                mode = self._file_mode
+                mode = self.file_mode
             else:
-                mode = self._dir_mode
+                mode = self.dir_mode
 
         move(from_info, to_info, mode=mode)
 
@@ -182,8 +141,19 @@ class LocalRemote(BaseRemote):
         tmp_info = to_info.parent / tmp_fname(to_info.name)
         try:
             System.copy(from_info, tmp_info)
-            os.chmod(fspath_py35(tmp_info), self._file_mode)
-            os.rename(fspath_py35(tmp_info), fspath_py35(to_info))
+            os.chmod(tmp_info, self.file_mode)
+            os.rename(tmp_info, to_info)
+        except Exception:
+            self.remove(tmp_info)
+            raise
+
+    def copy_fobj(self, fobj, to_info):
+        self.makedirs(to_info.parent)
+        tmp_info = to_info.parent / tmp_fname(to_info.name)
+        try:
+            copy_fobj_to_file(fobj, tmp_info)
+            os.chmod(tmp_info, self.file_mode)
+            os.rename(tmp_info, to_info)
         except Exception:
             self.remove(tmp_info)
             raise
@@ -231,8 +201,101 @@ class LocalRemote(BaseRemote):
         System.reflink(from_info, tmp_info)
         # NOTE: reflink has its own separate inode, so you can set permissions
         # that are different from the source.
-        os.chmod(fspath_py35(tmp_info), self._file_mode)
-        os.rename(fspath_py35(tmp_info), fspath_py35(to_info))
+        os.chmod(tmp_info, self.file_mode)
+        os.rename(tmp_info, to_info)
+
+    @staticmethod
+    def getsize(path_info):
+        return os.path.getsize(path_info)
+
+
+class LocalRemote(BaseRemote):
+    scheme = Schemes.LOCAL
+    path_cls = PathInfo
+    PARAM_CHECKSUM = "md5"
+    PARAM_PATH = "path"
+    TRAVERSE_PREFIX_LEN = 2
+    INDEX_CLS = RemoteIndexNoop
+    TREE_CLS = LocalRemoteTree
+
+    UNPACKED_DIR_SUFFIX = ".unpacked"
+
+    DEFAULT_CACHE_TYPES = ["reflink", "copy"]
+
+    CACHE_MODE = 0o444
+
+    def __init__(self, repo, config):
+        super().__init__(repo, config)
+        self.cache_dir = config.get("url")
+        self._dir_info = {}
+
+    @property
+    def state(self):
+        return self.repo.state
+
+    @property
+    def cache_dir(self):
+        return self.path_info.fspath if self.path_info else None
+
+    @cache_dir.setter
+    def cache_dir(self, value):
+        self.path_info = PathInfo(value) if value else None
+
+    @classmethod
+    def supported(cls, config):
+        return True
+
+    @cached_property
+    def cache_path(self):
+        return os.path.abspath(self.cache_dir)
+
+    def checksum_to_path(self, checksum):
+        # NOTE: `self.cache_path` is already normalized so we can simply use
+        # `os.sep` instead of `os.path.join`. This results in this helper
+        # being ~5.5 times faster.
+        return (
+            f"{self.cache_path}{os.sep}{checksum[0:2]}{os.sep}{checksum[2:]}"
+        )
+
+    def list_cache_paths(self, prefix=None, progress_callback=None):
+        assert self.path_info is not None
+        if prefix:
+            path_info = self.path_info / prefix[:2]
+            if not self.tree.exists(path_info):
+                return
+        else:
+            path_info = self.path_info
+        if progress_callback:
+            for path in walk_files(path_info):
+                progress_callback()
+                yield path
+        else:
+            yield from walk_files(path_info)
+
+    def get(self, md5):
+        if not md5:
+            return None
+
+        return self.checksum_to_path_info(md5).url
+
+    def already_cached(self, path_info):
+        assert path_info.scheme in ["", "local"]
+
+        current_md5 = self.get_checksum(path_info)
+
+        if not current_md5:
+            return False
+
+        return not self.changed_cache(current_md5)
+
+    def _verify_link(self, path_info, link_type):
+        if link_type == "hardlink" and self.tree.getsize(path_info) == 0:
+            return
+
+        super()._verify_link(path_info, link_type)
+
+    def get_file_checksum(self, path_info):
+        return file_md5(path_info)[0]
 
     def cache_exists(self, checksums, jobs=None, name=None):
         return [
@@ -255,7 +318,9 @@ class LocalRemote(BaseRemote):
         copyfile(
             from_file, tmp_file, name=name, no_progress_bar=no_progress_bar
         )
-        os.rename(tmp_file, fspath_py35(to_info))
+
+        self.protect(tmp_file)
+        os.rename(tmp_file, to_info)
 
     def _download(
         self, from_info, to_file, name=None, no_progress_bar=False, **_kwargs
@@ -264,10 +329,6 @@ class LocalRemote(BaseRemote):
             from_info, to_file, no_progress_bar=no_progress_bar, name=name
         )
 
-    @staticmethod
-    def open(path_info, mode="r", encoding=None):
-        return open(fspath_py35(path_info), mode=mode, encoding=encoding)
-
     @index_locked
     def status(
         self,
@@ -302,9 +363,7 @@ class LocalRemote(BaseRemote):
         {dir_checksum: set(file_checksum, ...)} which can be used to map
         a .dir file to its file contents.
         """
-        logger.debug(
-            "Preparing to collect status from {}".format(remote.path_info)
-        )
+        logger.debug(f"Preparing to collect status from {remote.path_info}")
         md5s = set(named_cache.scheme_keys(self.scheme))
 
         logger.debug("Collecting information from local cache...")
@@ -453,8 +512,8 @@ class LocalRemote(BaseRemote):
         if download:
             func = partial(
                 remote.download,
-                dir_mode=self._dir_mode,
-                file_mode=self._file_mode,
+                dir_mode=self.tree.dir_mode,
+                file_mode=self.tree.file_mode,
             )
             status = STATUS_DELETED
             desc = "Downloading"
@@ -550,9 +609,7 @@ class LocalRemote(BaseRemote):
                     "failed to upload full contents of '{}', "
                     "aborting .dir file upload".format(name)
                 )
-                logger.error(
-                    "failed to upload '{}' to '{}'".format(from_info, to_info)
-                )
+                logger.error(f"failed to upload '{from_info}' to '{to_info}'")
                 return 1
         return func(from_info, to_info, name)
 
@@ -596,7 +653,7 @@ class LocalRemote(BaseRemote):
 
     def _unprotect_file(self, path):
         if System.is_symlink(path) or System.is_hardlink(path):
-            logger.debug("Unprotecting '{}'".format(path))
+            logger.debug(f"Unprotecting '{path}'")
             tmp = os.path.join(os.path.dirname(path), "." + uuid())
 
             # The operations order is important here - if some application
@@ -614,7 +671,7 @@ class LocalRemote(BaseRemote):
                 "a symlink or a hardlink.".format(path)
             )
 
-        os.chmod(path, self._file_mode)
+        os.chmod(path, self.tree.file_mode)
 
     def _unprotect_dir(self, path):
         assert is_working_tree(self.repo.tree)
@@ -625,9 +682,7 @@ class LocalRemote(BaseRemote):
     def unprotect(self, path_info):
         path = path_info.fspath
         if not os.path.exists(path):
-            raise DvcException(
-                "can't unprotect non-existing data '{}'".format(path)
-            )
+            raise DvcException(f"can't unprotect non-existing data '{path}'")
 
         if os.path.isdir(path):
             self._unprotect_dir(path)
@@ -635,7 +690,7 @@ class LocalRemote(BaseRemote):
             self._unprotect_file(path)
 
     def protect(self, path_info):
-        path = fspath_py35(path_info)
+        path = os.fspath(path_info)
         mode = self.CACHE_MODE
 
         try:
@@ -654,70 +709,15 @@ class LocalRemote(BaseRemote):
             if actual != mode:
                 raise
 
-    def _get_unpacked_dir_path_info(self, checksum):
-        info = self.checksum_to_path_info(checksum)
-        return info.with_name(info.name + self.UNPACKED_DIR_SUFFIX)
-
     def _remove_unpacked_dir(self, checksum):
-        path_info = self._get_unpacked_dir_path_info(checksum)
-        self.remove(path_info)
-
-    def _path_info_changed(self, path_info):
-        if self.exists(path_info) and self.state.get(path_info):
-            return False
-        return True
-
-    def _update_unpacked_dir(self, checksum):
-        unpacked_dir_info = self._get_unpacked_dir_path_info(checksum)
-
-        if not self._path_info_changed(unpacked_dir_info):
-            return
-
-        self.remove(unpacked_dir_info)
-
-        try:
-            dir_info = self.get_dir_cache(checksum)
-            self._create_unpacked_dir(checksum, dir_info, unpacked_dir_info)
-        except DvcException:
-            logger.warning("Could not create '{}'".format(unpacked_dir_info))
-
-            self.remove(unpacked_dir_info)
-
-    def _create_unpacked_dir(self, checksum, dir_info, unpacked_dir_info):
-        self.makedirs(unpacked_dir_info)
-
-        for entry in Tqdm(dir_info, desc="Creating unpacked dir", unit="file"):
-            entry_cache_info = self.checksum_to_path_info(
-                entry[self.PARAM_CHECKSUM]
-            )
-            relative_path = entry[self.PARAM_RELPATH]
-            # In shared cache mode some cache files might not be owned by the
-            # user, so we need to use symlinks because, unless
-            # /proc/sys/fs/protected_hardlinks is disabled, the user is not
-            # allowed to create hardlinks to files that he doesn't own.
-            link_types = ["hardlink", "symlink"]
-            self._link(
-                entry_cache_info, unpacked_dir_info / relative_path, link_types
-            )
-
-        self.state.save(unpacked_dir_info, checksum)
-
-    def _changed_unpacked_dir(self, checksum):
-        status_unpacked_dir_info = self._get_unpacked_dir_path_info(checksum)
-
-        return not self.state.get(status_unpacked_dir_info)
-
-    def _get_unpacked_dir_names(self, checksums):
-        unpacked = set()
-        for c in checksums:
-            if self.is_dir_checksum(c):
-                unpacked.add(c + self.UNPACKED_DIR_SUFFIX)
-        return unpacked
+        info = self.checksum_to_path_info(checksum)
+        path_info = info.with_name(info.name + self.UNPACKED_DIR_SUFFIX)
+        self.tree.remove(path_info)
 
     def is_protected(self, path_info):
-        if not self.exists(path_info):
+        try:
+            mode = os.stat(path_info).st_mode
+        except FileNotFoundError:
             return False
 
-        mode = os.stat(fspath_py35(path_info)).st_mode
-
         return stat.S_IMODE(mode) == self.CACHE_MODE

dvc/remote/oss.py

@@ -7,12 +7,34 @@ from funcy import cached_property, wrap_prop
 
 from dvc.path_info import CloudURLInfo
 from dvc.progress import Tqdm
-from dvc.remote.base import BaseRemote
+from dvc.remote.base import BaseRemote, BaseRemoteTree
 from dvc.scheme import Schemes
 
 logger = logging.getLogger(__name__)
 
 
+class OSSRemoteTree(BaseRemoteTree):
+    @property
+    def oss_service(self):
+        return self.remote.oss_service
+
+    def _generate_download_url(self, path_info, expires=3600):
+        assert path_info.bucket == self.remote.path_info.bucket
+
+        return self.oss_service.sign_url("GET", path_info.path, expires)
+
+    def exists(self, path_info):
+        paths = self.remote.list_paths(path_info.path)
+        return any(path_info.path == path for path in paths)
+
+    def remove(self, path_info):
+        if path_info.scheme != self.scheme:
+            raise NotImplementedError
+
+        logger.debug(f"Removing oss://{path_info}")
+        self.oss_service.delete_object(path_info.path)
+
+
 class OSSRemote(BaseRemote):
     """
     oss2 document:
@@ -38,6 +60,7 @@ class OSSRemote(BaseRemote):
     PARAM_CHECKSUM = "etag"
     COPY_POLL_SECONDS = 5
     LIST_OBJECT_PAGE_SIZE = 100
+    TREE_CLS = OSSRemoteTree
 
     def __init__(self, repo, config):
         super().__init__(repo, config)
@@ -64,9 +87,9 @@ class OSSRemote(BaseRemote):
     def oss_service(self):
         import oss2
 
-        logger.debug("URL: {}".format(self.path_info))
-        logger.debug("key id: {}".format(self.key_id))
-        logger.debug("key secret: {}".format(self.key_secret))
+        logger.debug(f"URL: {self.path_info}")
+        logger.debug(f"key id: {self.key_id}")
+        logger.debug(f"key secret: {self.key_secret}")
 
         auth = oss2.Auth(self.key_id, self.key_secret)
         bucket = oss2.Bucket(auth, self.endpoint, self.path_info.bucket)
@@ -83,14 +106,7 @@ class OSSRemote(BaseRemote):
             )
         return bucket
 
-    def remove(self, path_info):
-        if path_info.scheme != self.scheme:
-            raise NotImplementedError
-
-        logger.debug("Removing oss://{}".format(path_info))
-        self.oss_service.delete_object(path_info.path)
-
-    def _list_paths(self, prefix, progress_callback=None):
+    def list_paths(self, prefix, progress_callback=None):
         import oss2
 
         for blob in oss2.ObjectIterator(self.oss_service, prefix=prefix):
@@ -105,7 +121,7 @@ class OSSRemote(BaseRemote):
             )
         else:
             prefix = self.path_info.path
-        return self._list_paths(prefix, progress_callback)
+        return self.list_paths(prefix, progress_callback)
 
     def _upload(
         self, from_file, to_info, name=None, no_progress_bar=False, **_kwargs
@@ -122,12 +138,3 @@ class OSSRemote(BaseRemote):
             self.oss_service.get_object_to_file(
                 from_info.path, to_file, progress_callback=pbar.update_to
             )
-
-    def _generate_download_url(self, path_info, expires=3600):
-        assert path_info.bucket == self.path_info.bucket
-
-        return self.oss_service.sign_url("GET", path_info.path, expires)
-
-    def exists(self, path_info):
-        paths = self._list_paths(path_info.path)
-        return any(path_info.path == path for path in paths)

dvc/remote/pool.py

@@ -30,7 +30,7 @@ def close_pools():
     get_pool.memory.clear()
 
 
-class Pool(object):
+class Pool:
     def __init__(self, conn_func, *conn_args, **conn_kwargs):
         self._conn_func = conn_func
         self._conn_args = conn_args

dvc/remote/s3.py

@@ -1,5 +1,3 @@
-# -*- coding: utf-8 -*-
-
 import logging
 import os
 import posixpath
@@ -11,83 +9,98 @@ from dvc.config import ConfigError
 from dvc.exceptions import DvcException, ETagMismatchError
 from dvc.path_info import CloudURLInfo
 from dvc.progress import Tqdm
-from dvc.remote.base import BaseRemote
+from dvc.remote.base import BaseRemote, BaseRemoteTree
 from dvc.scheme import Schemes
 
 logger = logging.getLogger(__name__)
 
 
-class S3Remote(BaseRemote):
-    scheme = Schemes.S3
-    path_cls = CloudURLInfo
-    REQUIRES = {"boto3": "boto3"}
-    PARAM_CHECKSUM = "etag"
-
-    def __init__(self, repo, config):
-        super().__init__(repo, config)
-
-        url = config.get("url", "s3://")
-        self.path_info = self.path_cls(url)
-
-        self.region = config.get("region")
-        self.profile = config.get("profile")
-        self.endpoint_url = config.get("endpointurl")
-
-        if config.get("listobjects"):
-            self.list_objects_api = "list_objects"
-        else:
-            self.list_objects_api = "list_objects_v2"
-
-        self.use_ssl = config.get("use_ssl", True)
-
-        self.extra_args = {}
-
-        self.sse = config.get("sse")
-        if self.sse:
-            self.extra_args["ServerSideEncryption"] = self.sse
-
-        self.acl = config.get("acl")
-        if self.acl:
-            self.extra_args["ACL"] = self.acl
-
-        self._append_aws_grants_to_extra_args(config)
-
-        shared_creds = config.get("credentialpath")
-        if shared_creds:
-            os.environ.setdefault("AWS_SHARED_CREDENTIALS_FILE", shared_creds)
-
-    @wrap_prop(threading.Lock())
-    @cached_property
+class S3RemoteTree(BaseRemoteTree):
+    @property
     def s3(self):
-        import boto3
+        return self.remote.s3
 
-        session = boto3.session.Session(
-            profile_name=self.profile, region_name=self.region
+    def _generate_download_url(self, path_info, expires=3600):
+        params = {"Bucket": path_info.bucket, "Key": path_info.path}
+        return self.s3.generate_presigned_url(
+            ClientMethod="get_object", Params=params, ExpiresIn=int(expires)
         )
 
-        return session.client(
-            "s3", endpoint_url=self.endpoint_url, use_ssl=self.use_ssl
-        )
+    def exists(self, path_info):
+        """Check if the blob exists. If it does not exist,
+        it could be a part of a directory path.
 
-    @classmethod
-    def get_etag(cls, s3, bucket, path):
-        obj = cls.get_head_object(s3, bucket, path)
+        eg: if `data/file.txt` exists, check for `data` should return True
+        """
+        return self.isfile(path_info) or self.isdir(path_info)
 
-        return obj["ETag"].strip('"')
+    def isdir(self, path_info):
+        # S3 doesn't have a concept for directories.
+        #
+        # Using `head_object` with a path pointing to a directory
+        # will throw a 404 error.
+        #
+        # A reliable way to know if a given path is a directory is by
+        # checking if there are more files sharing the same prefix
+        # with a `list_objects` call.
+        #
+        # We need to make sure that the path ends with a forward slash,
+        # since we can end with false-positives like the following example:
+        #
+        #       bucket
+        #       └── data
+        #          ├── alice
+        #          └── alpha
+        #
+        # Using `data/al` as prefix will return `[data/alice, data/alpha]`,
+        # While `data/al/` will return nothing.
+        #
+        dir_path = path_info / ""
+        return bool(list(self.remote.list_paths(dir_path, max_items=1)))
 
-    def get_file_checksum(self, path_info):
-        return self.get_etag(self.s3, path_info.bucket, path_info.path)
+    def isfile(self, path_info):
+        from botocore.exceptions import ClientError
 
-    @staticmethod
-    def get_head_object(s3, bucket, path, *args, **kwargs):
+        if path_info.path.endswith("/"):
+            return False
 
         try:
-            obj = s3.head_object(Bucket=bucket, Key=path, *args, **kwargs)
-        except Exception as exc:
-            raise DvcException(
-                "s3://{}/{} does not exist".format(bucket, path)
-            ) from exc
-        return obj
+            self.s3.head_object(Bucket=path_info.bucket, Key=path_info.path)
+        except ClientError as exc:
+            if exc.response["Error"]["Code"] != "404":
+                raise
+            return False
+
+        return True
+
+    def walk_files(self, path_info, max_items=None):
+        for fname in self.remote.list_paths(path_info / "", max_items):
+            if fname.endswith("/"):
+                continue
+
+            yield path_info.replace(path=fname)
+
+    def remove(self, path_info):
+        if path_info.scheme != "s3":
+            raise NotImplementedError
+
+        logger.debug(f"Removing {path_info}")
+        self.s3.delete_object(Bucket=path_info.bucket, Key=path_info.path)
+
+    def makedirs(self, path_info):
+        # We need to support creating empty directories, which means
+        # creating an object with an empty body and a trailing slash `/`.
+        #
+        # We are not creating directory objects for every parent prefix,
+        # as it is not required.
+        if not path_info.path:
+            return
+
+        dir_path = path_info / ""
+        self.s3.put_object(Bucket=path_info.bucket, Key=dir_path.path, Body="")
+
+    def copy(self, from_info, to_info):
+        self._copy(self.s3, from_info, to_info, self.remote.extra_args)
 
     @classmethod
     def _copy_multipart(
@@ -101,7 +114,7 @@ class S3Remote(BaseRemote):
         parts = []
         byte_position = 0
         for i in range(1, n_parts + 1):
-            obj = cls.get_head_object(
+            obj = S3Remote.get_head_object(
                 s3, from_info.bucket, from_info.path, PartNumber=i
             )
             part_size = obj["ContentLength"]
@@ -109,7 +122,7 @@ class S3Remote(BaseRemote):
             if lastbyte > size:
                 lastbyte = size - 1
 
-            srange = "bytes={}-{}".format(byte_position, lastbyte)
+            srange = f"bytes={byte_position}-{lastbyte}"
 
             part = s3.upload_part_copy(
                 Bucket=to_info.bucket,
@@ -156,7 +169,7 @@ class S3Remote(BaseRemote):
         # object is transfered in the same chunks as it was originally.
         from boto3.s3.transfer import TransferConfig
 
-        obj = cls.get_head_object(s3, from_info.bucket, from_info.path)
+        obj = S3Remote.get_head_object(s3, from_info.bucket, from_info.path)
         etag = obj["ETag"].strip('"')
         size = obj["ContentLength"]
 
@@ -176,19 +189,85 @@ class S3Remote(BaseRemote):
                 Config=TransferConfig(multipart_threshold=size + 1),
             )
 
-        cached_etag = cls.get_etag(s3, to_info.bucket, to_info.path)
+        cached_etag = S3Remote.get_etag(s3, to_info.bucket, to_info.path)
         if etag != cached_etag:
             raise ETagMismatchError(etag, cached_etag)
 
-    def copy(self, from_info, to_info):
-        self._copy(self.s3, from_info, to_info, self.extra_args)
 
-    def remove(self, path_info):
-        if path_info.scheme != "s3":
-            raise NotImplementedError
+class S3Remote(BaseRemote):
+    scheme = Schemes.S3
+    path_cls = CloudURLInfo
+    REQUIRES = {"boto3": "boto3"}
+    PARAM_CHECKSUM = "etag"
+    TREE_CLS = S3RemoteTree
 
-        logger.debug("Removing {}".format(path_info))
-        self.s3.delete_object(Bucket=path_info.bucket, Key=path_info.path)
+    def __init__(self, repo, config):
+        super().__init__(repo, config)
+
+        url = config.get("url", "s3://")
+        self.path_info = self.path_cls(url)
+
+        self.region = config.get("region")
+        self.profile = config.get("profile")
+        self.endpoint_url = config.get("endpointurl")
+
+        if config.get("listobjects"):
+            self.list_objects_api = "list_objects"
+        else:
+            self.list_objects_api = "list_objects_v2"
+
+        self.use_ssl = config.get("use_ssl", True)
+
+        self.extra_args = {}
+
+        self.sse = config.get("sse")
+        if self.sse:
+            self.extra_args["ServerSideEncryption"] = self.sse
+
+        self.sse_kms_key_id = config.get("sse_kms_key_id")
+        if self.sse_kms_key_id:
+            self.extra_args["SSEKMSKeyId"] = self.sse_kms_key_id
+
+        self.acl = config.get("acl")
+        if self.acl:
+            self.extra_args["ACL"] = self.acl
+
+        self._append_aws_grants_to_extra_args(config)
+
+        shared_creds = config.get("credentialpath")
+        if shared_creds:
+            os.environ.setdefault("AWS_SHARED_CREDENTIALS_FILE", shared_creds)
+
+    @wrap_prop(threading.Lock())
+    @cached_property
+    def s3(self):
+        import boto3
+
+        session = boto3.session.Session(
+            profile_name=self.profile, region_name=self.region
+        )
+
+        return session.client(
+            "s3", endpoint_url=self.endpoint_url, use_ssl=self.use_ssl
+        )
+
+    @classmethod
+    def get_etag(cls, s3, bucket, path):
+        obj = cls.get_head_object(s3, bucket, path)
+
+        return obj["ETag"].strip('"')
+
+    def get_file_checksum(self, path_info):
+        return self.get_etag(self.s3, path_info.bucket, path_info.path)
+
+    @staticmethod
+    def get_head_object(s3, bucket, path, *args, **kwargs):
+
+        try:
+            obj = s3.head_object(Bucket=bucket, Key=path, *args, **kwargs)
+        except Exception as exc:
+            raise DvcException(f"s3://{bucket}/{path} does not exist") from exc
+        return obj
 
     def _list_objects(
         self, path_info, max_items=None, prefix=None, progress_callback=None
@@ -211,7 +290,7 @@ class S3Remote(BaseRemote):
             else:
                 yield from contents
 
-    def _list_paths(
+    def list_paths(
         self, path_info, max_items=None, prefix=None, progress_callback=None
     ):
         return (
@@ -222,69 +301,10 @@ class S3Remote(BaseRemote):
         )
 
     def list_cache_paths(self, prefix=None, progress_callback=None):
-        return self._list_paths(
+        return self.list_paths(
             self.path_info, prefix=prefix, progress_callback=progress_callback
         )
 
-    def isfile(self, path_info):
-        from botocore.exceptions import ClientError
-
-        if path_info.path.endswith("/"):
-            return False
-
-        try:
-            self.s3.head_object(Bucket=path_info.bucket, Key=path_info.path)
-        except ClientError as exc:
-            if exc.response["Error"]["Code"] != "404":
-                raise
-            return False
-
-        return True
-
-    def exists(self, path_info):
-        """Check if the blob exists. If it does not exist,
-        it could be a part of a directory path.
-
-        eg: if `data/file.txt` exists, check for `data` should return True
-        """
-        return self.isfile(path_info) or self.isdir(path_info)
-
-    def makedirs(self, path_info):
-        # We need to support creating empty directories, which means
-        # creating an object with an empty body and a trailing slash `/`.
-        #
-        # We are not creating directory objects for every parent prefix,
-        # as it is not required.
-        if not path_info.path:
-            return
-
-        dir_path = path_info / ""
-        self.s3.put_object(Bucket=path_info.bucket, Key=dir_path.path, Body="")
-
-    def isdir(self, path_info):
-        # S3 doesn't have a concept for directories.
-        #
-        # Using `head_object` with a path pointing to a directory
-        # will throw a 404 error.
-        #
-        # A reliable way to know if a given path is a directory is by
-        # checking if there are more files sharing the same prefix
-        # with a `list_objects` call.
-        #
-        # We need to make sure that the path ends with a forward slash,
-        # since we can end with false-positives like the following example:
-        #
-        #       bucket
-        #       └── data
-        #          ├── alice
-        #          └── alpha
-        #
-        # Using `data/al` as prefix will return `[data/alice, data/alpha]`,
-        # While `data/al/` will return nothing.
-        #
-        dir_path = path_info / ""
-        return bool(list(self._list_paths(dir_path, max_items=1)))
-
     def _upload(self, from_file, to_info, name=None, no_progress_bar=False):
         total = os.path.getsize(from_file)
         with Tqdm(
@@ -312,19 +332,6 @@ class S3Remote(BaseRemote):
                 from_info.bucket, from_info.path, to_file, Callback=pbar.update
             )
 
-    def _generate_download_url(self, path_info, expires=3600):
-        params = {"Bucket": path_info.bucket, "Key": path_info.path}
-        return self.s3.generate_presigned_url(
-            ClientMethod="get_object", Params=params, ExpiresIn=int(expires)
-        )
-
-    def walk_files(self, path_info, max_items=None):
-        for fname in self._list_paths(path_info / "", max_items):
-            if fname.endswith("/"):
-                continue
-
-            yield path_info.replace(path=fname)
-
     def _append_aws_grants_to_extra_args(self, config):
         # Keys for extra_args can be one of the following list:
         # https://boto3.amazonaws.com/v1/documentation/api/latest/reference/customizations/s3.html#boto3.s3.transfer.S3Transfer.ALLOWED_UPLOAD_ARGS

dvc/remote/ssh/__init__.py

@@ -14,7 +14,7 @@ from funcy import first, memoize, silent, wrap_with
 
 import dvc.prompt as prompt
 from dvc.progress import Tqdm
-from dvc.remote.base import BaseRemote
+from dvc.remote.base import BaseRemote, BaseRemoteTree
 from dvc.remote.pool import get_connection
 from dvc.scheme import Schemes
 from dvc.utils import to_chunks
@@ -33,6 +33,105 @@ def ask_password(host, user, port):
     )
 
 
+class SSHRemoteTree(BaseRemoteTree):
+    @property
+    def ssh(self):
+        return self.remote.ssh
+
+    @contextmanager
+    def open(self, path_info, mode="r", encoding=None):
+        assert mode in {"r", "rt", "rb", "wb"}
+
+        with self.ssh(path_info) as ssh, closing(
+            ssh.sftp.open(path_info.path, mode)
+        ) as fd:
+            if "b" in mode:
+                yield fd
+            else:
+                yield io.TextIOWrapper(fd, encoding=encoding)
+
+    def exists(self, path_info):
+        with self.ssh(path_info) as ssh:
+            return ssh.exists(path_info.path)
+
+    def isdir(self, path_info):
+        with self.ssh(path_info) as ssh:
+            return ssh.isdir(path_info.path)
+
+    def isfile(self, path_info):
+        with self.ssh(path_info) as ssh:
+            return ssh.isfile(path_info.path)
+
+    def walk_files(self, path_info):
+        with self.ssh(path_info) as ssh:
+            for fname in ssh.walk_files(path_info.path):
+                yield path_info.replace(path=fname)
+
+    def remove(self, path_info):
+        if path_info.scheme != self.scheme:
+            raise NotImplementedError
+
+        with self.ssh(path_info) as ssh:
+            ssh.remove(path_info.path)
+
+    def makedirs(self, path_info):
+        with self.ssh(path_info) as ssh:
+            ssh.makedirs(path_info.path)
+
+    def move(self, from_info, to_info, mode=None):
+        assert mode is None
+        if from_info.scheme != self.scheme or to_info.scheme != self.scheme:
+            raise NotImplementedError
+
+        with self.ssh(from_info) as ssh:
+            ssh.move(from_info.path, to_info.path)
+
+    def copy(self, from_info, to_info):
+        if not from_info.scheme == to_info.scheme == self.scheme:
+            raise NotImplementedError
+
+        with self.ssh(from_info) as ssh:
+            ssh.atomic_copy(from_info.path, to_info.path)
+
+    def symlink(self, from_info, to_info):
+        if not from_info.scheme == to_info.scheme == self.scheme:
+            raise NotImplementedError
+
+        with self.ssh(from_info) as ssh:
+            ssh.symlink(from_info.path, to_info.path)
+
+    def hardlink(self, from_info, to_info):
+        if not from_info.scheme == to_info.scheme == self.scheme:
+            raise NotImplementedError
+
+        # See dvc/remote/local/__init__.py - hardlink()
+        if self.getsize(from_info) == 0:
+
+            with self.ssh(to_info) as ssh:
+                ssh.sftp.open(to_info.path, "w").close()
+
+            logger.debug(
+                "Created empty file: {src} -> {dest}".format(
+                    src=str(from_info), dest=str(to_info)
+                )
+            )
+            return
+
+        with self.ssh(from_info) as ssh:
+            ssh.hardlink(from_info.path, to_info.path)
+
+    def reflink(self, from_info, to_info):
+        if from_info.scheme != self.scheme or to_info.scheme != self.scheme:
+            raise NotImplementedError
+
+        with self.ssh(from_info) as ssh:
+            ssh.reflink(from_info.path, to_info.path)
+
+    def getsize(self, path_info):
+        with self.ssh(path_info) as ssh:
+            return ssh.getsize(path_info.path)
+
+
 class SSHRemote(BaseRemote):
     scheme = Schemes.SSH
     REQUIRES = {"paramiko": "paramiko"}
@@ -46,6 +145,7 @@ class SSHRemote(BaseRemote):
     # We use conservative setting of 4 instead to not exhaust max sessions.
     CHECKSUM_JOBS = 4
     TRAVERSE_PREFIX_LEN = 2
+    TREE_CLS = SSHRemoteTree
 
     DEFAULT_CACHE_TYPES = ["copy"]
 
@@ -148,10 +248,6 @@ class SSHRemote(BaseRemote):
             sock=self.sock,
         )
 
-    def exists(self, path_info):
-        with self.ssh(path_info) as ssh:
-            return ssh.exists(path_info.path)
-
     def get_file_checksum(self, path_info):
         if path_info.scheme != self.scheme:
             raise NotImplementedError
@@ -159,74 +255,6 @@ class SSHRemote(BaseRemote):
         with self.ssh(path_info) as ssh:
             return ssh.md5(path_info.path)
 
-    def isdir(self, path_info):
-        with self.ssh(path_info) as ssh:
-            return ssh.isdir(path_info.path)
-
-    def isfile(self, path_info):
-        with self.ssh(path_info) as ssh:
-            return ssh.isfile(path_info.path)
-
-    def getsize(self, path_info):
-        with self.ssh(path_info) as ssh:
-            return ssh.getsize(path_info.path)
-
-    def copy(self, from_info, to_info):
-        if not from_info.scheme == to_info.scheme == self.scheme:
-            raise NotImplementedError
-
-        with self.ssh(from_info) as ssh:
-            ssh.atomic_copy(from_info.path, to_info.path)
-
-    def symlink(self, from_info, to_info):
-        if not from_info.scheme == to_info.scheme == self.scheme:
-            raise NotImplementedError
-
-        with self.ssh(from_info) as ssh:
-            ssh.symlink(from_info.path, to_info.path)
-
-    def hardlink(self, from_info, to_info):
-        if not from_info.scheme == to_info.scheme == self.scheme:
-            raise NotImplementedError
-
-        # See dvc/remote/local/__init__.py - hardlink()
-        if self.getsize(from_info) == 0:
-
-            with self.ssh(to_info) as ssh:
-                ssh.sftp.open(to_info.path, "w").close()
-
-            logger.debug(
-                "Created empty file: {src} -> {dest}".format(
-                    src=str(from_info), dest=str(to_info)
-                )
-            )
-            return
-
-        with self.ssh(from_info) as ssh:
-            ssh.hardlink(from_info.path, to_info.path)
-
-    def reflink(self, from_info, to_info):
-        if from_info.scheme != self.scheme or to_info.scheme != self.scheme:
-            raise NotImplementedError
-
-        with self.ssh(from_info) as ssh:
-            ssh.reflink(from_info.path, to_info.path)
-
-    def remove(self, path_info):
-        if path_info.scheme != self.scheme:
-            raise NotImplementedError
-
-        with self.ssh(path_info) as ssh:
-            ssh.remove(path_info.path)
-
-    def move(self, from_info, to_info, mode=None):
-        assert mode is None
-        if from_info.scheme != self.scheme or to_info.scheme != self.scheme:
-            raise NotImplementedError
-
-        with self.ssh(from_info) as ssh:
-            ssh.move(from_info.path, to_info.path)
-
     def _download(self, from_info, to_file, name=None, no_progress_bar=False):
         assert from_info.isin(self.path_info)
         with self.ssh(self.path_info) as ssh:
@@ -247,24 +275,14 @@ class SSHRemote(BaseRemote):
                 no_progress_bar=no_progress_bar,
             )
 
-    @contextmanager
-    def open(self, path_info, mode="r", encoding=None):
-        assert mode in {"r", "rt", "rb", "wb"}
-
-        with self.ssh(path_info) as ssh, closing(
-            ssh.sftp.open(path_info.path, mode)
-        ) as fd:
-            if "b" in mode:
-                yield fd
-            else:
-                yield io.TextIOWrapper(fd, encoding=encoding)
-
     def list_cache_paths(self, prefix=None, progress_callback=None):
         if prefix:
             root = posixpath.join(self.path_info.path, prefix[:2])
         else:
             root = self.path_info.path
         with self.ssh(self.path_info) as ssh:
+            if prefix and not ssh.exists(root):
+                return
             # If we simply return an iterator then with above closes instantly
             if progress_callback:
                 for path in ssh.walk_files(root):
@@ -273,15 +291,6 @@ class SSHRemote(BaseRemote):
             else:
                 yield from ssh.walk_files(root)
 
-    def walk_files(self, path_info):
-        with self.ssh(path_info) as ssh:
-            for fname in ssh.walk_files(path_info.path):
-                yield path_info.replace(path=fname)
-
-    def makedirs(self, path_info):
-        with self.ssh(path_info) as ssh:
-            ssh.makedirs(path_info.path)
-
     def batch_exists(self, path_infos, callback):
         def _exists(chunk_and_channel):
             chunk, channel = chunk_and_channel
@@ -290,7 +299,7 @@ class SSHRemote(BaseRemote):
                 try:
                     channel.stat(path)
                     ret.append(True)
-                except IOError as exc:
+                except OSError as exc:
                     if exc.errno != errno.ENOENT:
                         raise
                     ret.append(False)

dvc/remote/ssh/connection.py

@@ -25,9 +25,9 @@ def sizeof_fmt(num, suffix="B"):
     """ Convert number of bytes to human-readable string """
     for unit in ["", "K", "M", "G", "T", "P", "E", "Z"]:
         if abs(num) < 1024.0:
-            return "%3.1f%s%s" % (num, unit, suffix)
+            return f"{num:3.1f}{unit}{suffix}"
         num /= 1024.0
-    return "%.1f%s%s" % (num, "Y", suffix)
+    return "{:.1f}{}{}".format(num, "Y", suffix)
 
 
 class SSHConnection:
@@ -100,7 +100,7 @@ class SSHConnection:
 
         if stat.S_ISREG(st_mode) or stat.S_ISLNK(st_mode):
             raise DvcException(
-                "a file with the same name '{}' already exists".format(path)
+                f"a file with the same name '{path}' already exists"
             )
 
         head, tail = posixpath.split(path)
@@ -111,12 +111,12 @@ class SSHConnection:
         if tail:
             try:
                 self.sftp.mkdir(path)
-            except IOError as exc:
+            except OSError as exc:
                 # Since paramiko errors are very vague we need to recheck
                 # whether it's because path already exists or something else
                 if exc.errno == errno.EACCES or not self.exists(path):
                     raise DvcException(
-                        "unable to create remote directory '{}'".format(path)
+                        f"unable to create remote directory '{path}'"
                     ) from exc
 
     def walk(self, directory, topdown=True):
@@ -126,7 +126,7 @@ class SSHConnection:
         # [1] https://github.com/python/cpython/blob/master/Lib/os.py
         try:
             dir_entries = self.sftp.listdir_attr(directory)
-        except IOError as exc:
+        except OSError as exc:
             raise DvcException(
                 "couldn't get the '{}' remote directory files list".format(
                     directory
@@ -237,11 +237,15 @@ class SSHConnection:
             or channel.recv_ready()
             or channel.recv_stderr_ready()
         ):
-            import select
+            import selectors
+
+            selector = selectors.DefaultSelector()
+            selector.register(stdout.channel, selectors.EVENT_READ)
 
             got_chunk = False
-            readq, _, _ = select.select([stdout.channel], [], [], self.timeout)
-            for c in readq:
+            events = selector.select(self.timeout)
+            for key, _ in events:
+                c = key.fileobj
                 if c.recv_ready():
                     stdout_chunks.append(stdout.channel.recv(len(c.in_buffer)))
                     got_chunk = True
@@ -292,14 +296,14 @@ class SSHConnection:
             md5 = self.execute("md5 " + path).split()[-1]
         else:
             raise DvcException(
-                "'{}' is not supported as a SSH remote".format(self.uname)
+                f"'{self.uname}' is not supported as a SSH remote"
             )
 
         assert len(md5) == 32
         return md5
 
     def copy(self, src, dest):
-        self.execute("cp {} {}".format(src, dest))
+        self.execute(f"cp {src} {dest}")
 
     def open_max_sftp_channels(self):
         # If there are more than 1 it means we've already opened max amount
@@ -321,14 +325,12 @@ class SSHConnection:
 
     def reflink(self, src, dest):
         if self.uname == "Linux":
-            return self.execute("cp --reflink {} {}".format(src, dest))
+            return self.execute(f"cp --reflink {src} {dest}")
 
         if self.uname == "Darwin":
-            return self.execute("cp -c {} {}".format(src, dest))
+            return self.execute(f"cp -c {src} {dest}")
 
-        raise DvcException(
-            "'{}' is not supported as a SSH remote".format(self.uname)
-        )
+        raise DvcException(f"'{self.uname}' is not supported as a SSH remote")
 
     def hardlink(self, src, dest):
-        self.execute("ln {} {}".format(src, dest))
+        self.execute(f"ln {src} {dest}")

dvc/repo/__init__.py

@@ -5,22 +5,27 @@ from functools import wraps
 
 from funcy import cached_property, cat, first
 
-from dvc.compat import fspath_py35
 from dvc.config import Config
+from dvc.dvcfile import PIPELINE_FILE, Dvcfile, is_valid_filename
+from dvc.exceptions import FileMissingError
+from dvc.exceptions import IsADirectoryError as DvcIsADirectoryError
 from dvc.exceptions import (
-    FileMissingError,
-    IsADirectoryError,
+    NoOutputOrStageError,
     NotDvcRepoError,
     OutputNotFoundError,
 )
 from dvc.ignore import CleanTree
 from dvc.path_info import PathInfo
-from dvc.remote.base import RemoteActionNotImplemented
+from dvc.repo.tree import RepoTree
+from dvc.scm.tree import is_working_tree
 from dvc.utils.fs import path_isin
 
+from ..stage.exceptions import StageFileDoesNotExistError, StageNotFound
 from ..utils import parse_target
 from .graph import check_acyclic, get_pipeline, get_pipelines
 
+logger = logging.getLogger(__name__)
+
 
 def locked(f):
     @wraps(f)
@@ -35,7 +40,7 @@ def locked(f):
     return wrapper
 
 
-class Repo(object):
+class Repo:
     DVC_DIR = ".dvc"
 
     from dvc.repo.destroy import destroy
@@ -43,7 +48,7 @@ class Repo(object):
     from dvc.repo.add import add
     from dvc.repo.remove import remove
     from dvc.repo.ls import ls
-    from dvc.repo.lock import lock as lock_stage
+    from dvc.repo.freeze import freeze, unfreeze
     from dvc.repo.move import move
     from dvc.repo.run import run
     from dvc.repo.imp import imp
@@ -61,31 +66,38 @@ class Repo(object):
     from dvc.repo.get import get
     from dvc.repo.get_url import get_url
     from dvc.repo.update import update
-    from dvc.repo.plot import plot
 
-    def __init__(self, root_dir=None):
-        from dvc.state import State
+    def __init__(self, root_dir=None, scm=None, rev=None):
+        from dvc.state import State, StateNoop
         from dvc.lock import make_lock
         from dvc.scm import SCM
         from dvc.cache import Cache
         from dvc.data_cloud import DataCloud
         from dvc.repo.metrics import Metrics
+        from dvc.repo.plots import Plots
         from dvc.repo.params import Params
         from dvc.scm.tree import WorkingTree
         from dvc.utils.fs import makedirs
         from dvc.stage.cache import StageCache
 
-        root_dir = self.find_root(root_dir)
+        if scm:
+            # use GitTree instead of WorkingTree as default repo tree instance
+            tree = scm.get_tree(rev)
+            self.root_dir = self.find_root(root_dir, tree)
+            self.scm = scm
+            self.tree = tree
+            self.state = StateNoop()
+        else:
+            root_dir = self.find_root(root_dir)
+            self.root_dir = os.path.abspath(os.path.realpath(root_dir))
 
-        self.root_dir = os.path.abspath(os.path.realpath(root_dir))
         self.dvc_dir = os.path.join(self.root_dir, self.DVC_DIR)
-
         self.config = Config(self.dvc_dir)
 
-        no_scm = self.config["core"].get("no_scm", False)
-        self.scm = SCM(self.root_dir, no_scm=no_scm)
-
-        self.tree = WorkingTree(self.root_dir)
+        if not scm:
+            no_scm = self.config["core"].get("no_scm", False)
+            self.scm = SCM(self.root_dir, no_scm=no_scm)
+            self.tree = WorkingTree(self.root_dir)
 
         self.tmp_dir = os.path.join(self.dvc_dir, "tmp")
         self.index_dir = os.path.join(self.tmp_dir, "index")
@@ -99,9 +111,11 @@ class Repo(object):
             friendly=True,
         )
 
-        # NOTE: storing state and link_state in the repository itself to avoid
-        # any possible state corruption in 'shared cache dir' scenario.
-        self.state = State(self)
+        if not scm:
+            # NOTE: storing state and link_state in the repository itself to
+            # avoid any possible state corruption in 'shared cache dir'
+            # scenario.
+            self.state = State(self)
 
         self.cache = Cache(self)
         self.cloud = DataCloud(self)
@@ -109,6 +123,7 @@ class Repo(object):
         self.stage_cache = StageCache(self)
 
         self.metrics = Metrics(self)
+        self.plots = Plots(self)
         self.params = Params(self)
 
         self._ignore()
@@ -119,20 +134,31 @@ class Repo(object):
 
     @tree.setter
     def tree(self, tree):
-        self._tree = tree if isinstance(tree, CleanTree) else CleanTree(tree)
+        if is_working_tree(tree) or tree.tree_root == self.root_dir:
+            root = None
+        else:
+            root = self.root_dir
+        self._tree = (
+            tree if isinstance(tree, CleanTree) else CleanTree(tree, root)
+        )
         # Our graph cache is no longer valid, as it was based on the previous
         # tree.
         self._reset()
 
     def __repr__(self):
-        return "{}: '{}'".format(self.__class__.__name__, self.root_dir)
+        return f"{self.__class__.__name__}: '{self.root_dir}'"
 
     @classmethod
-    def find_root(cls, root=None):
+    def find_root(cls, root=None, tree=None):
         root_dir = os.path.realpath(root or os.curdir)
 
+        if tree:
+            if tree.isdir(os.path.join(root_dir, cls.DVC_DIR)):
+                return root_dir
+            raise NotDvcRepoError(f"'{root}' does not contain DVC directory")
+
         if not os.path.isdir(root_dir):
-            raise NotDvcRepoError("directory '{}' does not exist".format(root))
+            raise NotDvcRepoError(f"directory '{root}' does not exist")
 
         while True:
             dvc_dir = os.path.join(root_dir, cls.DVC_DIR)
@@ -171,6 +197,25 @@ class Repo(object):
 
         self.scm.ignore_list(flist)
 
+    def get_stage(self, path=None, name=None):
+        if not path:
+            path = PIPELINE_FILE
+            logger.debug("Assuming '%s' to be a stage inside '%s'", name, path)
+
+        dvcfile = Dvcfile(self, path)
+        return dvcfile.stages[name]
+
+    def get_stages(self, path=None, name=None):
+        if not path:
+            path = PIPELINE_FILE
+            logger.debug("Assuming '%s' to be a stage inside '%s'", name, path)
+
+        if name:
+            return [self.get_stage(path, name)]
+
+        dvcfile = Dvcfile(self, path)
+        return list(dvcfile.stages.values())
+
     def check_modified_graph(self, new_stages):
         """Generate graph including the new stage to check for errors"""
         # Building graph might be costly for the ones with many DVC-files,
@@ -194,10 +239,9 @@ class Repo(object):
         stages = nx.dfs_postorder_nodes(graph)
         return [stage for stage in stages if path_isin(stage.path, path)]
 
-    def collect(self, target, with_deps=False, recursive=False, graph=None):
-        import networkx as nx
-        from ..dvcfile import Dvcfile
-
+    def collect(
+        self, target=None, with_deps=False, recursive=False, graph=None
+    ):
         if not target:
             return list(graph) if graph else self.stages
 
@@ -207,36 +251,81 @@ class Repo(object):
             )
 
         path, name = parse_target(target)
-        dvcfile = Dvcfile(self, path)
-        stages = list(dvcfile.stages.filter(name).values())
+        stages = self.get_stages(path, name)
         if not with_deps:
             return stages
 
         res = set()
         for stage in stages:
-            pipeline = get_pipeline(get_pipelines(graph or self.graph), stage)
-            res.update(nx.dfs_postorder_nodes(pipeline, stage))
+            res.update(self._collect_pipeline(stage, graph=graph))
         return res
 
-    def collect_granular(self, target, *args, **kwargs):
-        from ..dvcfile import Dvcfile, is_valid_filename
+    def _collect_pipeline(self, stage, graph=None):
+        import networkx as nx
 
+        pipeline = get_pipeline(get_pipelines(graph or self.graph), stage)
+        return nx.dfs_postorder_nodes(pipeline, stage)
+
+    def _collect_from_default_dvcfile(self, target):
+        dvcfile = Dvcfile(self, PIPELINE_FILE)
+        if dvcfile.exists():
+            return dvcfile.stages.get(target)
+
+    def collect_granular(
+        self, target=None, with_deps=False, recursive=False, graph=None
+    ):
+        """
+        Priority is in the order of following in case of ambiguity:
+            - .dvc file or .yaml file
+            - dir if recursive and directory exists
+            - stage_name
+            - output file
+        """
         if not target:
             return [(stage, None) for stage in self.stages]
 
         file, name = parse_target(target)
-        if is_valid_filename(file) and not kwargs.get("with_deps"):
-            # Optimization: do not collect the graph for a specific .dvc target
-            stages = Dvcfile(self, file).stages.filter(name)
-            return [(stage, None) for stage in stages.values()]
+        stages = []
 
-        try:
-            (out,) = self.find_outs_by_path(file, strict=False)
-            filter_info = PathInfo(os.path.abspath(file))
-            return [(out.stage, filter_info)]
-        except OutputNotFoundError:
-            stages = self.collect(target, *args, **kwargs)
-            return [(stage, None) for stage in stages]
+        # Optimization: do not collect the graph for a specific target
+        if not file:
+            # parsing is ambiguous when it does not have a colon
+            # or if it's not a dvcfile, as it can be a stage name
+            # in `dvc.yaml` or, an output in a stage.
+            logger.debug(
+                "Checking if stage '%s' is in '%s'", target, PIPELINE_FILE
+            )
+            if not (recursive and os.path.isdir(target)):
+                stage = self._collect_from_default_dvcfile(target)
+                if stage:
+                    stages = (
+                        self._collect_pipeline(stage) if with_deps else [stage]
+                    )
+        elif not with_deps and is_valid_filename(file):
+            stages = self.get_stages(file, name)
+
+        if not stages:
+            if not (recursive and os.path.isdir(target)):
+                try:
+                    (out,) = self.find_outs_by_path(target, strict=False)
+                    filter_info = PathInfo(os.path.abspath(target))
+                    return [(out.stage, filter_info)]
+                except OutputNotFoundError:
+                    pass
+
+            try:
+                stages = self.collect(target, with_deps, recursive, graph)
+            except StageFileDoesNotExistError as exc:
+                # collect() might try to use `target` as a stage name
+                # and throw error that dvc.yaml does not exist, whereas it
+                # should say that both stage name and file does not exist.
+                if file and is_valid_filename(file):
+                    raise
+                raise NoOutputOrStageError(target, exc.file) from exc
+            except StageNotFound as exc:
+                raise NoOutputOrStageError(target, exc.file) from exc
+
+        return [(stage, None) for stage in stages]
 
     def used_cache(
         self,
@@ -249,6 +338,7 @@ class Repo(object):
         force=False,
         jobs=None,
         recursive=False,
+        used_run_cache=None,
     ):
         """Get the stages related to the given target and collect
         the `info` of its outputs.
@@ -282,7 +372,7 @@ class Repo(object):
                 for target in targets
             )
 
-            suffix = "({})".format(branch) if branch else ""
+            suffix = f"({branch})" if branch else ""
             for stage, filter_info in pairs:
                 used_cache = stage.get_used_cache(
                     remote=remote,
@@ -292,6 +382,12 @@ class Repo(object):
                 )
                 cache.update(used_cache, suffix=suffix)
 
+        if used_run_cache:
+            used_cache = self.stage_cache.get_used_cache(
+                used_run_cache, remote=remote, force=force, jobs=jobs,
+            )
+            cache.update(used_cache)
+
         return cache
 
     def _collect_graph(self, stages):
@@ -345,7 +441,7 @@ class Repo(object):
         stages = stages or self.stages
         outs = Trie()  # Use trie to efficiently find overlapping outs and deps
 
-        for stage in filter(bool, stages):
+        for stage in filter(bool, stages):  # bug? not using it later
             for out in stage.outs:
                 out_key = out.path_info.parts
 
@@ -421,28 +517,23 @@ class Repo(object):
 
     @cached_property
     def plot_templates(self):
-        from dvc.repo.plot.template import PlotTemplates
+        from .plots.template import PlotTemplates
 
         return PlotTemplates(self.dvc_dir)
 
     def _collect_stages(self):
-        from dvc.dvcfile import Dvcfile, is_valid_filename
-
         stages = []
         outs = set()
 
         for root, dirs, files in self.tree.walk(self.root_dir):
             for file_name in filter(is_valid_filename, files):
-                path = os.path.join(root, file_name)
-                stage_loader = Dvcfile(self, path).stages
-                with stage_loader.log_level(at=logging.DEBUG):
-                    stages.extend(stage_loader.values())
+                new_stages = self.get_stages(os.path.join(root, file_name))
+                stages.extend(new_stages)
                 outs.update(
                     out.fspath
-                    for stage in stages
-                    for out in (
-                        out for out in stage.outs if out.scheme == "local"
-                    )
+                    for stage in new_stages
+                    for out in stage.outs
+                    if out.scheme == "local"
                 )
             dirs[:] = [d for d in dirs if os.path.join(root, d) not in outs]
         return stages
@@ -482,49 +573,22 @@ class Repo(object):
     @contextmanager
     def open_by_relpath(self, path, remote=None, mode="r", encoding=None):
         """Opens a specified resource as a file descriptor"""
-        cause = None
+
+        tree = RepoTree(self, stream=True)
+        path = os.path.join(self.root_dir, path)
         try:
-            out = self.find_out_by_relpath(path)
-        except OutputNotFoundError as exc:
-            out = None
-            cause = exc
-
-        if out and out.use_cache:
-            try:
-                with self._open_cached(out, remote, mode, encoding) as fd:
-                    yield fd
-                return
-            except FileNotFoundError as exc:
-                raise FileMissingError(path) from exc
-
-        abs_path = os.path.join(self.root_dir, path)
-        if os.path.exists(abs_path):
-            with open(abs_path, mode=mode, encoding=encoding) as fd:
-                yield fd
-            return
-
-        raise FileMissingError(path) from cause
-
-    def _open_cached(self, out, remote=None, mode="r", encoding=None):
-        if out.isdir():
-            raise IsADirectoryError("Can't open a dir")
-
-        cache_file = self.cache.local.checksum_to_path_info(out.checksum)
-        cache_file = fspath_py35(cache_file)
-
-        if os.path.exists(cache_file):
-            return open(cache_file, mode=mode, encoding=encoding)
-
-        try:
-            remote_obj = self.cloud.get_remote(remote)
-            remote_info = remote_obj.checksum_to_path_info(out.checksum)
-            return remote_obj.open(remote_info, mode=mode, encoding=encoding)
-        except RemoteActionNotImplemented:
             with self.state:
-                cache_info = out.get_used_cache(remote=remote)
-                self.cloud.pull(cache_info, remote=remote)
-
-            return open(cache_file, mode=mode, encoding=encoding)
+                with tree.open(
+                    os.path.join(self.root_dir, path),
+                    mode=mode,
+                    encoding=encoding,
+                    remote=remote,
+                ) as fobj:
+                    yield fobj
+        except FileNotFoundError as exc:
+            raise FileMissingError(path) from exc
+        except IsADirectoryError as exc:
+            raise DvcIsADirectoryError(f"'{path}' is a directory") from exc
 
     def close(self):
         self.scm.close()

dvc/repo/add.py

@@ -21,7 +21,9 @@ logger = logging.getLogger(__name__)
 
 @locked
 @scm_context
-def add(repo, targets, recursive=False, no_commit=False, fname=None):
+def add(
+    repo, targets, recursive=False, no_commit=False, fname=None, external=False
+):
     if recursive and fname:
         raise RecursiveAddingWhileUsingFilename()
 
@@ -52,7 +54,9 @@ def add(repo, targets, recursive=False, no_commit=False, fname=None):
                     )
                 )
 
-            stages = _create_stages(repo, sub_targets, fname, pbar=pbar)
+            stages = _create_stages(
+                repo, sub_targets, fname, pbar=pbar, external=external
+            )
 
             try:
                 repo.check_modified_graph(stages)
@@ -120,7 +124,7 @@ def _find_all_targets(repo, target, recursive):
     return [target]
 
 
-def _create_stages(repo, targets, fname, pbar=None):
+def _create_stages(repo, targets, fname, pbar=None, external=False):
     from dvc.stage import Stage, create_stage
 
     stages = []
@@ -132,7 +136,14 @@ def _create_stages(repo, targets, fname, pbar=None):
         unit="file",
     ):
         path, wdir, out = resolve_paths(repo, out)
-        stage = create_stage(Stage, repo, fname or path, wdir=wdir, outs=[out])
+        stage = create_stage(
+            Stage,
+            repo,
+            fname or path,
+            wdir=wdir,
+            outs=[out],
+            external=external,
+        )
         if stage:
             Dvcfile(repo, stage.path).remove_with_prompt(force=True)
 

dvc/repo/brancher.py

@@ -18,19 +18,22 @@ def brancher(  # noqa: E302
         str: the display name for the currently selected tree, it could be:
             - a git revision identifier
             - empty string it there is no branches to iterate over
-            - "Working Tree" if there are uncommitted changes in the SCM repo
+            - "workspace" if there are uncommitted changes in the SCM repo
     """
     if not any([revs, all_branches, all_tags, all_commits]):
         yield ""
         return
 
     saved_tree = self.tree
-    revs = revs or []
+    revs = revs.copy() if revs else []
 
     scm = self.scm
 
     self.tree = WorkingTree(self.root_dir)
-    yield "working tree"
+    yield "workspace"
+
+    if revs and "workspace" in revs:
+        revs.remove("workspace")
 
     if all_commits:
         revs = scm.list_all_commits()
@@ -45,6 +48,9 @@ def brancher(  # noqa: E302
         if revs:
             for sha, names in group_by(scm.resolve_rev, revs).items():
                 self.tree = scm.get_tree(sha)
-                yield ", ".join(names)
+                # ignore revs that don't contain repo root
+                # (i.e. revs from before a subdir=True repo was init'ed)
+                if self.tree.exists(self.root_dir):
+                    yield ", ".join(names)
     finally:
         self.tree = saved_tree

dvc/repo/checkout.py

@@ -1,8 +1,11 @@
 import logging
 import os
 
-from dvc.compat import fspath
-from dvc.exceptions import CheckoutError, CheckoutErrorSuggestGit
+from dvc.exceptions import (
+    CheckoutError,
+    CheckoutErrorSuggestGit,
+    NoOutputOrStageError,
+)
 from dvc.progress import Tqdm
 from dvc.utils import relpath
 
@@ -19,11 +22,11 @@ def _get_unused_links(repo):
     return repo.state.get_unused_links(used)
 
 
-def _fspath_dir(path, root):
+def _fspath_dir(path):
     if not os.path.exists(str(path)):
         return str(path)
 
-    path = relpath(fspath(path), root)
+    path = relpath(path)
     return os.path.join(path, "") if os.path.isdir(path) else path
 
 
@@ -57,9 +60,12 @@ def _checkout(
         targets = [None]
         unused = _get_unused_links(self)
 
-    stats["deleted"] = [_fspath_dir(u, self.root_dir) for u in unused]
+    stats["deleted"] = [_fspath_dir(u) for u in unused]
     self.state.remove_links(unused)
 
+    if isinstance(targets, str):
+        targets = [targets]
+
     pairs = set()
     for target in targets:
         try:
@@ -68,7 +74,11 @@ def _checkout(
                     target, with_deps=with_deps, recursive=recursive
                 )
             )
-        except (StageFileDoesNotExistError, StageFileBadNameError) as exc:
+        except (
+            StageFileDoesNotExistError,
+            StageFileBadNameError,
+            NoOutputOrStageError,
+        ) as exc:
             if not target:
                 raise
             raise CheckoutErrorSuggestGit(target) from exc
@@ -84,10 +94,8 @@ def _checkout(
                 relink=relink,
                 filter_info=filter_info,
             )
-            for data in ["failed", "added", "modified"]:
-                stats[data].extend(
-                    _fspath_dir(path, self.root_dir) for path in result[data]
-                )
+            for key, items in result.items():
+                stats[key].extend(_fspath_dir(path) for path in items)
 
     if stats.get("failed"):
         raise CheckoutError(stats["failed"], stats)

dvc/repo/commit.py

@@ -1,13 +1,49 @@
+from dvc import prompt
 from dvc.dvcfile import Dvcfile
+from dvc.stage.exceptions import StageCommitError
 
 from . import locked
 
 
+def _prepare_message(stage, changes):
+    changed_deps, changed_outs, changed_stage = changes
+    if changed_deps and changed_outs:
+        msg = "dependencies {deps} and outputs {outs} of {stage} changed."
+    elif changed_deps:
+        msg = "dependencies {deps} of {stage} changed."
+    elif changed_outs:
+        msg = "outputs {outs} of {stage} changed."
+    else:
+        msg = "{stage_changed}"
+
+    msg += " Are you sure you want to commit it?"
+
+    kw = {
+        "stage": stage,
+        "deps": changed_deps,
+        "outs": changed_outs,
+        "stage_changed": changed_stage,
+    }
+    return msg.format_map(kw)
+
+
+def prompt_to_commit(stage, changes, force=False):
+    if not (force or prompt.confirm(_prepare_message(stage, changes))):
+        raise StageCommitError(
+            "unable to commit changed {}. Use `-f|--force` to "
+            "force.".format(stage)
+        )
+
+
 @locked
 def commit(self, target, with_deps=False, recursive=False, force=False):
     stages = self.collect(target, with_deps=with_deps, recursive=recursive)
     for stage in stages:
-        stage.check_can_commit(force=force)
+        changes = stage.changed_entries()
+        if any(changes):
+            prompt_to_commit(stage, changes, force=force)
+            stage.save()
         stage.commit()
 
         Dvcfile(self, stage.path).dump(stage)
+    return stages

dvc/repo/diff.py

@@ -7,7 +7,7 @@ from dvc.scm.tree import is_working_tree
 @locked
 def diff(self, a_rev="HEAD", b_rev=None):
     """
-    By default, it compares the working tree with the last commit's tree.
+    By default, it compares the workspace with the last commit's tree.
 
     This implementation differs from `git diff` since DVC doesn't have
     the concept of `index`, but it keeps the same interface, thus,
@@ -52,6 +52,9 @@ def diff(self, a_rev="HEAD", b_rev=None):
             if _exists(output)
         }
 
+    if self.scm.no_commits:
+        return {}
+
     working_tree = self.tree
     a_tree = self.scm.get_tree(a_rev)
     b_tree = self.scm.get_tree(b_rev) if b_rev else working_tree

dvc/repo/fetch.py

@@ -1,9 +1,7 @@
 import logging
 
-from dvc.cache import NamedCache
 from dvc.config import NoRemoteError
-from dvc.exceptions import DownloadError, OutputNotFoundError
-from dvc.path_info import PathInfo
+from dvc.exceptions import DownloadError
 from dvc.scm.base import CloneError
 
 logger = logging.getLogger(__name__)
@@ -34,6 +32,12 @@ def _fetch(
         config.NoRemoteError: thrown when downloading only local files and no
             remote is configured
     """
+
+    used_run_cache = self.stage_cache.pull(remote) if run_cache else []
+
+    if isinstance(targets, str):
+        targets = [targets]
+
     used = self.used_cache(
         targets,
         all_branches=all_branches,
@@ -44,6 +48,7 @@ def _fetch(
         remote=remote,
         jobs=jobs,
         recursive=recursive,
+        used_run_cache=used_run_cache,
     )
 
     downloaded = 0
@@ -51,11 +56,7 @@ def _fetch(
 
     try:
         downloaded += self.cloud.pull(
-            used,
-            jobs,
-            remote=remote,
-            show_checksums=show_checksums,
-            run_cache=run_cache,
+            used, jobs, remote=remote, show_checksums=show_checksums,
         )
     except NoRemoteError:
         if not used.external and used["local"]:
@@ -75,35 +76,15 @@ def _fetch(
 
 
 def _fetch_external(self, repo_url, repo_rev, files, jobs):
-    from dvc.external_repo import external_repo, ExternalRepo
+    from dvc.external_repo import external_repo
 
     failed, downloaded = 0, 0
     try:
         with external_repo(repo_url, repo_rev) as repo:
-            is_dvc_repo = isinstance(repo, ExternalRepo)
-            # gather git-only tracked files if dvc repo
-            git_files = [] if is_dvc_repo else files
-            if is_dvc_repo:
-                repo.cache.local.cache_dir = self.cache.local.cache_dir
-                with repo.state:
-                    cache = NamedCache()
-                    for name in files:
-                        try:
-                            out = repo.find_out_by_relpath(name)
-                        except OutputNotFoundError:
-                            # try to add to cache if they are git-tracked files
-                            git_files.append(name)
-                        else:
-                            cache.update(out.get_used_cache())
-
-                        try:
-                            downloaded += repo.cloud.pull(cache, jobs=jobs)
-                        except DownloadError as exc:
-                            failed += exc.amount
-
-            d, f = _git_to_cache(self.cache.local, repo.root_dir, git_files)
-            downloaded += d
-            failed += f
+            with repo.use_cache(self.cache.local):
+                d, f, _ = repo.fetch_external(files, jobs=jobs)
+                downloaded += d
+                failed += f
     except CloneError:
         failed += 1
         logger.exception(
@@ -111,27 +92,3 @@ def _fetch_external(self, repo_url, repo_rev, files, jobs):
         )
 
     return downloaded, failed
-
-
-def _git_to_cache(cache, repo_root, files):
-    """Save files from a git repo directly to the cache."""
-    failed = set()
-    num_downloads = 0
-    repo_root = PathInfo(repo_root)
-    for file in files:
-        info = cache.save_info(repo_root / file)
-        if info.get(cache.PARAM_CHECKSUM) is None:
-            failed.add(file)
-            continue
-
-        if cache.changed_cache(info[cache.PARAM_CHECKSUM]):
-            logger.debug("fetched '%s' from '%s' repo", file, repo_root)
-            num_downloads += 1
-            cache.save(repo_root / file, info, save_link=False)
-
-    if failed:
-        logger.exception(
-            "failed to fetch data for {}".format(", ".join(failed))
-        )
-
-    return num_downloads, len(failed)

dvc/repo/freeze.py

@@ -0,0 +1,21 @@
+from . import locked
+
+
+@locked
+def _set(repo, target, frozen):
+    from dvc.utils import parse_target
+
+    path, name = parse_target(target)
+    stage = repo.get_stage(path, name)
+    stage.frozen = frozen
+    stage.dvcfile.dump(stage, update_pipeline=True)
+
+    return stage
+
+
+def freeze(repo, target):
+    return _set(repo, target, True)
+
+
+def unfreeze(repo, target):
+    return _set(repo, target, False)

dvc/repo/gc.py

@@ -11,7 +11,7 @@ logger = logging.getLogger(__name__)
 def _do_gc(typ, func, clist, jobs=None):
     removed = func(clist, jobs=jobs)
     if not removed:
-        logger.info("No unused '{}' cache to remove.".format(typ))
+        logger.info(f"No unused '{typ}' cache to remove.")
 
 
 def _raise_error_if_all_disabled(**kwargs):

dvc/repo/get.py

@@ -4,7 +4,6 @@ import os
 import shortuuid
 
 from dvc.exceptions import DvcException
-from dvc.path_info import PathInfo
 from dvc.utils import resolve_output
 from dvc.utils.fs import remove
 
@@ -51,7 +50,6 @@ def get(url, path, out=None, rev=None):
                 # Also, we can't use theoretical "move" link type here, because
                 # the same cache file might be used a few times in a directory.
                 repo.cache.local.cache_types = ["reflink", "hardlink", "copy"]
-
-            repo.pull_to(path, PathInfo(out))
+            repo.get_external(path, out)
     finally:
         remove(tmp_dir)

dvc/repo/imp.py

@@ -3,4 +3,4 @@ def imp(self, url, path, out=None, rev=None):
     if rev is not None:
         erepo["rev"] = rev
 
-    return self.imp_url(path, out=out, erepo=erepo, locked=True)
+    return self.imp_url(path, out=out, erepo=erepo, frozen=True)

dvc/repo/imp_url.py

@@ -5,20 +5,24 @@ from dvc.utils import relpath, resolve_output, resolve_paths
 from dvc.utils.fs import path_isin
 
 from ..exceptions import OutputDuplicationError
-from . import locked as locked_repo
+from . import locked
 
 
-@locked_repo
+@locked
 @scm_context
-def imp_url(self, url, out=None, fname=None, erepo=None, locked=True):
+def imp_url(self, url, out=None, fname=None, erepo=None, frozen=True):
     from dvc.dvcfile import Dvcfile
     from dvc.stage import Stage, create_stage
 
     out = resolve_output(url, out)
     path, wdir, out = resolve_paths(self, out)
 
-    # NOTE: when user is importing something from within his own repository
-    if os.path.exists(url) and path_isin(os.path.abspath(url), self.root_dir):
+    # NOTE: when user is importing something from within their own repository
+    if (
+        erepo is None
+        and os.path.exists(url)
+        and path_isin(os.path.abspath(url), self.root_dir)
+    ):
         url = relpath(url, wdir)
 
     stage = create_stage(
@@ -44,7 +48,7 @@ def imp_url(self, url, out=None, fname=None, erepo=None, locked=True):
 
     stage.run()
 
-    stage.locked = locked
+    stage.frozen = frozen
 
     dvcfile.dump(stage)
 

dvc/repo/lock.py

@@ -1,15 +0,0 @@
-from . import locked
-
-
-@locked
-def lock(self, target, unlock=False):
-    from .. import dvcfile
-    from dvc.utils import parse_target
-
-    path, name = parse_target(target)
-    dvcfile = dvcfile.Dvcfile(self, path)
-    stage = dvcfile.stages[name]
-    stage.locked = False if unlock else True
-    dvcfile.dump(stage, update_pipeline=True)
-
-    return stage

dvc/repo/ls.py

@@ -4,7 +4,7 @@ from dvc.path_info import PathInfo
 
 @staticmethod
 def ls(
-    url, path=None, rev=None, recursive=None, outs_only=False,
+    url, path=None, rev=None, recursive=None, dvc_only=False,
 ):
     """Methods for getting files and outputs for the repo.
 
@@ -13,7 +13,7 @@ def ls(
         path (str, optional): relative path into the repo
         rev (str, optional): SHA commit, branch or tag name
         recursive (bool, optional): recursively walk the repo
-        outs_only (bool, optional): show only DVC-artifacts
+        dvc_only (bool, optional): show only DVC-artifacts
 
     Returns:
         list of `entry`
@@ -28,25 +28,16 @@ def ls(
         }
     """
     from dvc.external_repo import external_repo
-    from dvc.repo import Repo
 
     with external_repo(url, rev) as repo:
         path_info = PathInfo(repo.root_dir)
         if path:
             path_info /= path
 
-        ret = {}
-        if isinstance(repo, Repo):
-            ret = _ls(repo, path_info, recursive, True)
-
-        nondvc = {}
-        if not outs_only:
-            nondvc = _ls(repo, path_info, recursive, False)
-
-        ret.update(nondvc)
+        ret = _ls(repo, path_info, recursive, dvc_only)
 
         if path and not ret:
-            raise PathMissingError(path, repo, output_only=outs_only)
+            raise PathMissingError(path, repo, dvc_only=dvc_only)
 
         ret_list = []
         for path, info in ret.items():
@@ -56,46 +47,52 @@ def ls(
         return ret_list
 
 
-def _ls(repo, path_info, recursive=None, dvc=False):
-    from dvc.ignore import CleanTree
-    from dvc.repo.tree import DvcTree
-    from dvc.scm.tree import WorkingTree
+def _ls(repo, path_info, recursive=None, dvc_only=False):
+    from dvc.repo.tree import RepoTree
 
-    if dvc:
-        tree = DvcTree(repo)
-    else:
-        tree = CleanTree(WorkingTree(repo.root_dir))
+    # use our own RepoTree instance instead of repo.repo_tree since we do not
+    # want fetch/stream enabled for ls
+    tree = RepoTree(repo)
 
     ret = {}
     try:
-        for root, dirs, files in tree.walk(path_info.fspath):
+        for root, dirs, files in tree.walk(path_info.fspath, dvcfiles=True):
             for fname in files:
                 info = PathInfo(root) / fname
-                path = str(info.relative_to(path_info))
-                ret[path] = {
-                    "isout": dvc,
-                    "isdir": False,
-                    "isexec": False if dvc else tree.isexec(info.fspath),
-                }
+                dvc = tree.isdvc(info)
+                if dvc or not dvc_only:
+                    path = str(info.relative_to(path_info))
+                    ret[path] = {
+                        "isout": dvc,
+                        "isdir": False,
+                        "isexec": False if dvc else tree.isexec(info),
+                    }
 
             if not recursive:
                 for dname in dirs:
                     info = PathInfo(root) / dname
-                    path = str(info.relative_to(path_info))
-                    ret[path] = {
-                        "isout": tree.isdvc(info.fspath) if dvc else False,
-                        "isdir": True,
-                        "isexec": False if dvc else tree.isexec(info.fspath),
-                    }
+                    if not dvc_only or (
+                        tree.dvctree and tree.dvctree.exists(info)
+                    ):
+                        dvc = tree.isdvc(info)
+                        path = str(info.relative_to(path_info))
+                        ret[path] = {
+                            "isout": dvc,
+                            "isdir": True,
+                            "isexec": False if dvc else tree.isexec(info),
+                        }
                 break
     except NotADirectoryError:
-        return {
-            path_info.name: {
-                "isout": dvc,
-                "isdir": False,
-                "isexec": False if dvc else tree.isexec(path_info.fspath),
+        dvc = tree.isdvc(path_info)
+        if dvc or not dvc_only:
+            return {
+                path_info.name: {
+                    "isout": dvc,
+                    "isdir": False,
+                    "isexec": False if dvc else tree.isexec(path_info),
+                }
             }
-        }
+        return {}
     except FileNotFoundError:
         return {}
 

dvc/repo/metrics/__init__.py

@@ -1,22 +1,12 @@
-class Metrics(object):
+class Metrics:
     def __init__(self, repo):
         self.repo = repo
 
-    def add(self, *args, **kwargs):
-        from dvc.repo.metrics.add import add
-
-        return add(self.repo, *args, **kwargs)
-
     def show(self, *args, **kwargs):
         from dvc.repo.metrics.show import show
 
         return show(self.repo, *args, **kwargs)
 
-    def remove(self, *args, **kwargs):
-        from dvc.repo.metrics.remove import remove
-
-        return remove(self.repo, *args, **kwargs)
-
     def diff(self, *args, **kwargs):
         from .diff import diff
 

dvc/repo/metrics/add.py

@@ -1,5 +0,0 @@
-from dvc.repo.metrics.modify import modify
-
-
-def add(repo, path):
-    modify(repo, path)

dvc/repo/metrics/diff.py

@@ -14,6 +14,9 @@ def _get_metrics(repo, *args, rev=None, **kwargs):
 
 
 def diff(repo, *args, a_rev=None, b_rev=None, **kwargs):
+    if repo.scm.no_commits:
+        return {}
+
     with_unchanged = kwargs.pop("all", False)
 
     old = _get_metrics(repo, *args, **kwargs, rev=(a_rev or "HEAD"))

dvc/repo/metrics/modify.py

@@ -1,22 +0,0 @@
-from dvc.dvcfile import Dvcfile
-from dvc.exceptions import DvcException
-from dvc.repo import locked
-
-
-@locked
-def modify(repo, path, delete=False):
-    outs = repo.find_outs_by_path(path)
-    assert len(outs) == 1
-    out = outs[0]
-
-    if out.scheme != "local":
-        msg = "output '{}' scheme '{}' is not supported for metrics"
-        raise DvcException(msg.format(out.path, out.path_info.scheme))
-
-    if delete:
-        out.metric = None
-
-    out.verify_metric()
-
-    dvcfile = Dvcfile(repo, out.stage.path)
-    dvcfile.dump(out.stage)

dvc/repo/metrics/remove.py

@@ -1,5 +0,0 @@
-from dvc.repo.metrics.modify import modify
-
-
-def remove(repo, path):
-    modify(repo, path, delete=True)

dvc/repo/metrics/show.py

@@ -3,7 +3,6 @@ import os
 
 import yaml
 
-from dvc.compat import fspath_py35
 from dvc.exceptions import NoMetricsError
 from dvc.path_info import PathInfo
 from dvc.repo import locked
@@ -58,10 +57,10 @@ def _read_metrics(repo, metrics, rev):
 
     res = {}
     for metric in metrics:
-        if not tree.exists(fspath_py35(metric)):
+        if not tree.exists(metric):
             continue
 
-        with tree.open(fspath_py35(metric), "r") as fobj:
+        with tree.open(metric, "r") as fobj:
             try:
                 # NOTE this also supports JSON
                 val = yaml.safe_load(fobj)
@@ -105,13 +104,13 @@ def show(
     if not res:
         raise NoMetricsError()
 
-    # Hide working tree metrics if they are the same as in the active branch
+    # Hide workspace metrics if they are the same as in the active branch
     try:
         active_branch = repo.scm.active_branch()
     except TypeError:
         pass  # Detached head
     else:
-        if res.get("working tree") == res.get(active_branch):
-            res.pop("working tree", None)
+        if res.get("workspace") == res.get(active_branch):
+            res.pop("workspace", None)
 
     return res

dvc/repo/params/__init__.py

@@ -1,4 +1,4 @@
-class Params(object):
+class Params:
     def __init__(self, repo):
         self.repo = repo
 

dvc/repo/params/diff.py

@@ -13,6 +13,9 @@ def _get_params(repo, *args, rev=None, **kwargs):
 
 
 def diff(repo, *args, a_rev=None, b_rev=None, **kwargs):
+    if repo.scm.no_commits:
+        return {}
+
     with_unchanged = kwargs.pop("all", False)
 
     old = _get_params(repo, *args, **kwargs, rev=(a_rev or "HEAD"))

dvc/repo/params/show.py

@@ -2,7 +2,6 @@ import logging
 
 import yaml
 
-from dvc.compat import fspath_py35
 from dvc.dependency.param import ParamsDependency
 from dvc.exceptions import DvcException
 from dvc.path_info import PathInfo
@@ -30,10 +29,10 @@ def _collect_configs(repo):
 def _read_params(repo, configs, rev):
     res = {}
     for config in configs:
-        if not repo.tree.exists(fspath_py35(config)):
+        if not repo.tree.exists(config):
             continue
 
-        with repo.tree.open(fspath_py35(config), "r") as fobj:
+        with repo.tree.open(config, "r") as fobj:
             try:
                 res[str(config)] = yaml.safe_load(fobj)
             except yaml.YAMLError:
@@ -59,13 +58,13 @@ def show(repo, revs=None):
     if not res:
         raise NoParamsError("no parameter configs files in this repository")
 
-    # Hide working tree params if they are the same as in the active branch
+    # Hide workspace params if they are the same as in the active branch
     try:
         active_branch = repo.scm.active_branch()
     except TypeError:
         pass  # Detached head
     else:
-        if res.get("working tree") == res.get(active_branch):
-            res.pop("working tree", None)
+        if res.get("workspace") == res.get(active_branch):
+            res.pop("workspace", None)
 
     return res

dvc/repo/plot/__init__.py

@@ -1,164 +0,0 @@
-import logging
-import os
-
-from funcy import first, last
-
-from dvc.exceptions import DvcException
-from dvc.repo import locked
-from dvc.repo.plot.data import PlotData
-from dvc.repo.plot.template import NoDataForTemplateError, Template
-
-logger = logging.getLogger(__name__)
-
-PAGE_HTML = """<html>
-<head>
-    <title>DVC Plot</title>
-    <script src="https://cdn.jsdelivr.net/npm/[email protected]"></script>
-    <script src="https://cdn.jsdelivr.net/npm/[email protected]"></script>
-    <script src="https://cdn.jsdelivr.net/npm/[email protected]"></script>
-</head>
-<body>
-    {divs}
-</body>
-</html>"""
-
-DIV_HTML = """<div id = "{id}"></div>
-<script type = "text/javascript">
-    var spec = {vega_json};
-    vegaEmbed('#{id}', spec);
-</script>"""
-
-
-class TooManyDataSourcesError(DvcException):
-    def __init__(self, datafile, template_datafiles):
-        super().__init__(
-            "Unable to infer which of possible data sources: '{}' "
-            "should be replaced with '{}'.".format(
-                ", ".join(template_datafiles), datafile
-            )
-        )
-
-
-class NoDataOrTemplateProvided(DvcException):
-    def __init__(self):
-        super().__init__("Datafile or template is not specified.")
-
-
-def _evaluate_templatepath(repo, template=None):
-    if not template:
-        return repo.plot_templates.default_template
-
-    if os.path.exists(template):
-        return template
-    return repo.plot_templates.get_template(template)
-
-
-@locked
-def fill_template(
-    repo,
-    datafile,
-    template_path,
-    revisions,
-    fields=None,
-    path=None,
-    csv_header=True,
-    x_field=None,
-    y_field=None,
-    **kwargs
-):
-    if x_field and fields:
-        fields.add(x_field)
-
-    if y_field and fields:
-        fields.add(y_field)
-
-    template_datafiles, x_anchor, y_anchor = _parse_template(
-        template_path, datafile
-    )
-    append_index = x_anchor and not x_field
-    if append_index:
-        x_field = PlotData.INDEX_FIELD
-
-    template_data = {}
-    for template_datafile in template_datafiles:
-        from dvc.repo.plot.data import _load_from_revisions
-
-        plot_datas = _load_from_revisions(repo, template_datafile, revisions)
-        tmp_data = []
-        for pd in plot_datas:
-            rev_data_points = pd.to_datapoints(
-                fields=fields,
-                path=path,
-                csv_header=csv_header,
-                append_index=append_index,
-            )
-
-            if y_anchor and not y_field:
-                y_field = _infer_y_field(rev_data_points, x_field)
-            tmp_data.extend(rev_data_points)
-
-        template_data[template_datafile] = tmp_data
-
-    if len(template_data) == 0:
-        raise NoDataForTemplateError(template_path)
-
-    return Template.fill(
-        template_path,
-        template_data,
-        priority_datafile=datafile,
-        x_field=x_field,
-        y_field=y_field,
-        **kwargs
-    )
-
-
-def _infer_y_field(rev_data_points, x_field):
-    all_fields = list(first(rev_data_points).keys())
-    all_fields.remove(PlotData.REVISION_FIELD)
-    if x_field and x_field in all_fields:
-        all_fields.remove(x_field)
-    y_field = last(all_fields)
-    return y_field
-
-
-def plot(
-    repo, datafile=None, template=None, revisions=None, embed=False, **kwargs
-):
-    if revisions is None:
-        from dvc.repo.plot.data import WORKSPACE_REVISION_NAME
-
-        revisions = [WORKSPACE_REVISION_NAME]
-
-    if not datafile and not template:
-        raise NoDataOrTemplateProvided()
-
-    template_path = _evaluate_templatepath(repo, template)
-
-    plot_content = fill_template(
-        repo, datafile, template_path, revisions, **kwargs
-    )
-
-    if embed:
-        div = DIV_HTML.format(id="plot", vega_json=plot_content)
-        plot_content = PAGE_HTML.format(divs=div)
-
-    return plot_content
-
-
-def _parse_template(template_path, priority_datafile):
-    with open(template_path, "r") as fobj:
-        tempalte_content = fobj.read()
-
-    template_datafiles = Template.parse_data_anchors(tempalte_content)
-    if priority_datafile:
-        if len(template_datafiles) > 1:
-            raise TooManyDataSourcesError(
-                priority_datafile, template_datafiles
-            )
-        template_datafiles = {priority_datafile}
-
-    return (
-        template_datafiles,
-        Template.X_ANCHOR in tempalte_content,
-        Template.Y_ANCHOR in tempalte_content,
-    )

dvc/repo/plots/__init__.py

@@ -0,0 +1,35 @@
+class Plots:
+    def __init__(self, repo):
+        self.repo = repo
+
+    def show(self, *args, **kwargs):
+        from .show import show
+
+        return show(self.repo, *args, **kwargs)
+
+    def diff(self, *args, **kwargs):
+        from .diff import diff
+
+        return diff(self.repo, *args, **kwargs)
+
+    def modify(self, path, props=None, unset=None):
+        from dvc.dvcfile import Dvcfile
+
+        (out,) = self.repo.find_outs_by_path(path)
+
+        # This out will become a plot unless it is one already
+        if not isinstance(out.plot, dict):
+            out.plot = {}
+
+        for field in unset or ():
+            out.plot.pop(field, None)
+        out.plot.update(props or {})
+
+        # Empty dict will move it to non-plots
+        if not out.plot:
+            out.plot = True
+
+        out.verify_metric()
+
+        dvcfile = Dvcfile(self.repo, out.stage.path)
+        dvcfile.dump(out.stage, update_pipeline=True)

dvc/repo/plots/data.py

@@ -14,8 +14,6 @@ from dvc.exceptions import DvcException, PathMissingError
 
 logger = logging.getLogger(__name__)
 
-WORKSPACE_REVISION_NAME = "workspace"
-
 
 class PlotMetricTypeError(DvcException):
     def __init__(self, file):
@@ -29,7 +27,7 @@ class PlotDataStructureError(DvcException):
     def __init__(self):
         super().__init__(
             "Plot data extraction failed. Please see "
-            "documentation for supported data formats."
+            "https://man.dvc.org/plot for supported data formats."
         )
 
 
@@ -45,14 +43,12 @@ class NoMetricOnRevisionError(DvcException):
     def __init__(self, path, revision):
         self.path = path
         self.revision = revision
-        super().__init__(
-            "Could not find '{}' on revision '{}'".format(path, revision)
-        )
+        super().__init__(f"Could not find '{path}' on revision '{revision}'")
 
 
 class NoMetricInHistoryError(DvcException):
     def __init__(self, path):
-        super().__init__("Could not find '{}'.".format(path))
+        super().__init__(f"Could not find '{path}'.")
 
 
 def plot_data(filename, revision, content):
@@ -194,13 +190,13 @@ class JSONPlotData(PlotData):
         return json.loads(self.content, object_pairs_hook=OrderedDict)
 
     def _processors(self):
-        parent_processors = super(JSONPlotData, self)._processors()
+        parent_processors = super()._processors()
         return [_apply_path, _find_data] + parent_processors
 
 
 class CSVPlotData(PlotData):
     def __init__(self, filename, revision, content, delimiter=","):
-        super(CSVPlotData, self).__init__(filename, revision, content)
+        super().__init__(filename, revision, content)
         self.delimiter = delimiter
 
     def raw(self, csv_header=True, **kwargs):
@@ -243,20 +239,12 @@ class YAMLPlotData(PlotData):
 
 
 def _load_from_revision(repo, datafile, revision):
-    if revision is WORKSPACE_REVISION_NAME:
+    from dvc.repo.tree import RepoTree
 
-        def open_datafile():
-            return repo.tree.open(datafile, "r")
-
-    else:
-
-        def open_datafile():
-            from dvc import api
-
-            return api.open(datafile, repo.root_dir, revision)
+    tree = RepoTree(repo)
 
     try:
-        with open_datafile() as fobj:
+        with tree.open(datafile) as fobj:
             datafile_content = fobj.read()
 
     except (FileNotFoundError, PathMissingError):
@@ -269,7 +257,10 @@ def _load_from_revisions(repo, datafile, revisions):
     data = []
     exceptions = []
 
-    for rev in revisions:
+    for rev in repo.brancher(revs=revisions):
+        if rev == "workspace" and rev not in revisions:
+            continue
+
         try:
             data.append(_load_from_revision(repo, datafile, rev))
         except NoMetricOnRevisionError as e:
@@ -277,7 +268,7 @@ def _load_from_revisions(repo, datafile, revisions):
         except PlotMetricTypeError:
             raise
         except (yaml.error.YAMLError, json.decoder.JSONDecodeError, csv.Error):
-            logger.error("Failed to parse '{}' at '{}'.".format(datafile, rev))
+            logger.error(f"Failed to parse '{datafile}' at '{rev}'.")
             raise
 
     if not data and exceptions:

dvc/repo/plots/diff.py

@@ -0,0 +1,13 @@
+def _revisions(revs, is_dirty):
+    revisions = revs or []
+    if len(revisions) <= 1:
+        if len(revisions) == 0 and is_dirty:
+            revisions.append("HEAD")
+        revisions.append("workspace")
+    return revisions
+
+
+def diff(repo, *args, revs=None, **kwargs):
+    return repo.plots.show(
+        *args, revs=_revisions(revs, repo.scm.is_dirty()), **kwargs
+    )

dvc/repo/plots/show.py

@@ -0,0 +1,217 @@
+import copy
+import logging
+import os
+
+from funcy import first, last, project
+
+from dvc.exceptions import DvcException, NoPlotsError
+from dvc.repo import locked
+from dvc.schema import PLOT_PROPS
+
+from .data import NoMetricInHistoryError, PlotData
+from .template import NoDataForTemplateError, Template
+
+logger = logging.getLogger(__name__)
+
+
+class TooManyDataSourcesError(DvcException):
+    def __init__(self, datafile, template_datafiles):
+        super().__init__(
+            "Unable to infer which of possible data sources: '{}' "
+            "should be replaced with '{}'.".format(
+                ", ".join(template_datafiles), datafile
+            )
+        )
+
+
+class NoDataOrTemplateProvided(DvcException):
+    def __init__(self):
+        super().__init__("Datafile or template is not specified.")
+
+
+class TooManyTemplatesError(DvcException):
+    pass
+
+
+def _evaluate_templatepath(repo, template=None):
+    if not template:
+        return repo.plot_templates.default_template
+
+    if os.path.exists(template):
+        return template
+    return repo.plot_templates.get_template(template)
+
+
+@locked
+def fill_template(
+    repo, datafile, template_path, revisions, props,
+):
+    # Copy things to not modify passed values
+    props = props.copy()
+    fields = copy.copy(props.get("fields"))
+
+    if props.get("x") and fields:
+        fields.add(props.get("x"))
+
+    if props.get("y") and fields:
+        fields.add(props.get("y"))
+
+    template_datafiles, x_anchor, y_anchor = _parse_template(
+        template_path, datafile
+    )
+    append_index = x_anchor and not props.get("x")
+    if append_index:
+        props["x"] = PlotData.INDEX_FIELD
+
+    template_data = {}
+    for template_datafile in template_datafiles:
+        from .data import _load_from_revisions
+
+        plot_datas = _load_from_revisions(repo, template_datafile, revisions)
+        tmp_data = []
+        for pd in plot_datas:
+            rev_data_points = pd.to_datapoints(
+                fields=fields,
+                path=props.get("path"),
+                csv_header=props.get("csv_header", True),
+                append_index=append_index,
+            )
+
+            if y_anchor and not props.get("y"):
+                props["y"] = _infer_y_field(rev_data_points, props.get("x"))
+            tmp_data.extend(rev_data_points)
+
+        template_data[template_datafile] = tmp_data
+
+    if len(template_data) == 0:
+        raise NoDataForTemplateError(template_path)
+
+    content = Template.fill(
+        template_path, template_data, priority_datafile=datafile, props=props,
+    )
+
+    path = datafile or ",".join(template_datafiles)
+
+    return path, content
+
+
+def _infer_y_field(rev_data_points, x_field):
+    all_fields = list(first(rev_data_points).keys())
+    all_fields.remove(PlotData.REVISION_FIELD)
+    if x_field and x_field in all_fields:
+        all_fields.remove(x_field)
+    y_field = last(all_fields)
+    return y_field
+
+
+def _show(repo, datafile=None, revs=None, props=None):
+    if revs is None:
+        revs = ["workspace"]
+
+    if props is None:
+        props = {}
+
+    if not datafile and not props.get("template"):
+        raise NoDataOrTemplateProvided()
+
+    template_path = _evaluate_templatepath(repo, props.get("template"))
+
+    plot_datafile, plot_content = fill_template(
+        repo, datafile, template_path, revs, props
+    )
+
+    return plot_datafile, plot_content
+
+
+def _parse_template(template_path, priority_datafile):
+    with open(template_path) as fobj:
+        tempalte_content = fobj.read()
+
+    template_datafiles = Template.parse_data_anchors(tempalte_content)
+    if priority_datafile:
+        if len(template_datafiles) > 1:
+            raise TooManyDataSourcesError(
+                priority_datafile, template_datafiles
+            )
+        template_datafiles = {priority_datafile}
+
+    return (
+        template_datafiles,
+        Template.X_ANCHOR in tempalte_content,
+        Template.Y_ANCHOR in tempalte_content,
+    )
+
+
+def _collect_plots(repo, targets=None):
+    from dvc.exceptions import OutputNotFoundError
+    from contextlib import suppress
+
+    def _targets_to_outs(targets):
+        for t in targets:
+            with suppress(OutputNotFoundError):
+                (out,) = repo.find_outs_by_path(t)
+                yield out
+
+    if targets:
+        outs = _targets_to_outs(targets)
+    else:
+        outs = (out for stage in repo.stages for out in stage.outs if out.plot)
+
+    return {str(out): _plot_props(out) for out in outs}
+
+
+def _plot_props(out):
+    if not out.plot:
+        raise DvcException(
+            f"'{out}' is not a plot. Use `dvc plots modify` to change that."
+        )
+    if isinstance(out.plot, list):
+        raise DvcException("Multiple plots per data file not supported yet.")
+    if isinstance(out.plot, bool):
+        return {}
+
+    return project(out.plot, PLOT_PROPS)
+
+
+def show(repo, targets=None, revs=None, props=None) -> dict:
+    if isinstance(targets, str):
+        targets = [targets]
+    if props is None:
+        props = {}
+
+    # Collect plot data files with associated props
+    plots = {}
+    for rev in repo.brancher(revs=revs):
+        if revs is not None and rev not in revs:
+            continue
+
+        for datafile, file_props in _collect_plots(repo, targets).items():
+            # props from command line overwrite plot props from out definition
+            full_props = {**file_props, **props}
+
+            if datafile in plots:
+                saved_rev, saved_props = plots[datafile]
+                if saved_props != props:
+                    logger.warning(
+                        f"Inconsistent plot props for '{datafile}' in "
+                        f"'{saved_rev}' and '{rev}'. "
+                        f"Going to use ones from '{saved_rev}'"
+                    )
+            else:
+                plots[datafile] = rev, full_props
+
+    if not plots:
+        if targets:
+            raise NoMetricInHistoryError(", ".join(targets))
+
+        try:
+            datafile, plot = _show(repo, datafile=None, revs=revs, props=props)
+        except NoDataOrTemplateProvided:
+            raise NoPlotsError()
+
+        return {datafile: plot}
+
+    return {
+        datafile: _show(repo, datafile=datafile, revs=revs, props=props)[1]
+        for datafile, (_, props) in plots.items()
+    }

dvc/repo/plots/template.py

@@ -13,7 +13,7 @@ logger = logging.getLogger(__name__)
 
 class TemplateNotFoundError(DvcException):
     def __init__(self, path):
-        super().__init__("Template '{}' not found.".format(path))
+        super().__init__(f"Template '{path}' not found.")
 
 
 class NoDataForTemplateError(DvcException):
@@ -26,7 +26,7 @@ class NoDataForTemplateError(DvcException):
 class NoFieldInDataError(DvcException):
     def __init__(self, field_name):
         super().__init__(
-            "Field '{}' does not exist in provided data.".format(field_name)
+            f"Field '{field_name}' does not exist in provided data."
         )
 
 
@@ -38,8 +38,8 @@ class Template:
     X_ANCHOR = "<DVC_METRIC_X>"
     Y_ANCHOR = "<DVC_METRIC_Y>"
     TITLE_ANCHOR = "<DVC_METRIC_TITLE>"
-    X_TITLE_ANCHOR = "<DVC_METRIC_X_TITLE>"
-    Y_TITLE_ANCHOR = "<DVC_METRIC_Y_TITLE>"
+    X_LABEL_ANCHOR = "<DVC_METRIC_X_LABEL>"
+    Y_LABEL_ANCHOR = "<DVC_METRIC_Y_LABEL>"
 
     def __init__(self, templates_dir):
         self.plot_templates_dir = templates_dir
@@ -59,6 +59,7 @@ class Template:
                 indent=self.INDENT,
                 separators=self.SEPARATORS,
             )
+            fobj.write("\n")
 
     @staticmethod
     def get_data_anchor(template_content):
@@ -85,29 +86,24 @@ class Template:
 
     @staticmethod
     def fill(
-        template_path,
-        data,
-        priority_datafile=None,
-        x_field=None,
-        y_field=None,
-        title=None,
-        x_title=None,
-        y_title=None,
+        template_path, data, priority_datafile=None, props=None,
     ):
-        with open(template_path, "r") as fobj:
+        props = props or {}
+
+        with open(template_path) as fobj:
             result_content = fobj.read()
 
-        if x_field:
-            Template._check_field_exists(data, x_field)
-        if y_field:
-            Template._check_field_exists(data, y_field)
+        if props.get("x"):
+            Template._check_field_exists(data, props.get("x"))
+        if props.get("y"):
+            Template._check_field_exists(data, props.get("y"))
 
         result_content = Template._replace_data_anchors(
             result_content, data, priority_datafile
         )
 
         result_content = Template._replace_metadata_anchors(
-            result_content, title, x_field, x_title, y_field, y_title
+            result_content, props
         )
 
         return result_content
@@ -121,34 +117,23 @@ class Template:
                 raise NoFieldInDataError(field)
 
     @staticmethod
-    def _replace_metadata_anchors(
-        result_content, title, x_field, x_title, y_field, y_title
-    ):
-        if Template.TITLE_ANCHOR in result_content:
-            if title:
-                result_content = result_content.replace(
-                    Template.TITLE_ANCHOR, title
-                )
-            else:
-                result_content = result_content.replace(
-                    Template.TITLE_ANCHOR, ""
-                )
-        if Template.X_ANCHOR in result_content and x_field:
-            result_content = result_content.replace(Template.X_ANCHOR, x_field)
-        if Template.Y_ANCHOR in result_content and y_field:
-            result_content = result_content.replace(Template.Y_ANCHOR, y_field)
-        if Template.X_TITLE_ANCHOR in result_content:
-            if not x_title and x_field:
-                x_title = x_field
-            result_content = result_content.replace(
-                Template.X_TITLE_ANCHOR, x_title
-            )
-        if Template.Y_TITLE_ANCHOR in result_content:
-            if not y_title and y_field:
-                y_title = y_field
-            result_content = result_content.replace(
-                Template.Y_TITLE_ANCHOR, y_title
-            )
+    def _replace_metadata_anchors(result_content, props):
+        props.setdefault("title", "")
+        props.setdefault("x_label", props.get("x"))
+        props.setdefault("y_label", props.get("y"))
+
+        replace_pairs = [
+            (Template.TITLE_ANCHOR, "title"),
+            (Template.X_ANCHOR, "x"),
+            (Template.Y_ANCHOR, "y"),
+            (Template.X_LABEL_ANCHOR, "x_label"),
+            (Template.Y_LABEL_ANCHOR, "y_label"),
+        ]
+        for anchor, key in replace_pairs:
+            value = props.get(key)
+            if anchor in result_content and value is not None:
+                result_content = result_content.replace(anchor, value)
+
         return result_content
 
     @staticmethod
@@ -185,12 +170,13 @@ class DefaultLinearTemplate(Template):
             "x": {
                 "field": Template.X_ANCHOR,
                 "type": "quantitative",
-                "title": Template.X_TITLE_ANCHOR,
+                "title": Template.X_LABEL_ANCHOR,
             },
             "y": {
                 "field": Template.Y_ANCHOR,
                 "type": "quantitative",
-                "title": Template.Y_TITLE_ANCHOR,
+                "title": Template.Y_LABEL_ANCHOR,
+                "scale": {"zero": False},
             },
             "color": {"field": "rev", "type": "nominal"},
         },
@@ -209,13 +195,13 @@ class DefaultConfusionTemplate(Template):
                 "field": Template.X_ANCHOR,
                 "type": "nominal",
                 "sort": "ascending",
-                "title": Template.X_TITLE_ANCHOR,
+                "title": Template.X_LABEL_ANCHOR,
             },
             "y": {
                 "field": Template.Y_ANCHOR,
                 "type": "nominal",
                 "sort": "ascending",
-                "title": Template.Y_TITLE_ANCHOR,
+                "title": Template.Y_LABEL_ANCHOR,
             },
             "color": {"aggregate": "count", "type": "quantitative"},
             "facet": {"field": "rev", "type": "nominal"},
@@ -234,12 +220,13 @@ class DefaultScatterTemplate(Template):
             "x": {
                 "field": Template.X_ANCHOR,
                 "type": "quantitative",
-                "title": Template.X_TITLE_ANCHOR,
+                "title": Template.X_LABEL_ANCHOR,
             },
             "y": {
                 "field": Template.Y_ANCHOR,
                 "type": "quantitative",
-                "title": Template.Y_TITLE_ANCHOR,
+                "title": Template.Y_LABEL_ANCHOR,
+                "scale": {"zero": False},
             },
             "color": {"field": "rev", "type": "nominal"},
         },
@@ -247,7 +234,7 @@ class DefaultScatterTemplate(Template):
 
 
 class PlotTemplates:
-    TEMPLATES_DIR = "plot"
+    TEMPLATES_DIR = "plots"
     TEMPLATES = [
         DefaultLinearTemplate,
         DefaultConfusionTemplate,

dvc/repo/pull.py

@@ -19,6 +19,9 @@ def pull(
     all_commits=False,
     run_cache=False,
 ):
+    if isinstance(targets, str):
+        targets = [targets]
+
     processed_files_count = self._fetch(
         targets,
         jobs,