Allow for logging to Studio when not inside a repo

src/dvclive/dvc.py

@@ -147,8 +147,12 @@ def mark_dvclive_only_ended():
 
 
 def get_random_exp_name(scm, baseline_rev):
+    from dvc.repo.experiments.utils import gen_random_name
     from dvc.repo.experiments.utils import (
         get_random_exp_name as dvc_get_random_exp_name,
     )
 
-    return dvc_get_random_exp_name(scm, baseline_rev)
+    if scm and baseline_rev:
+        return dvc_get_random_exp_name(scm, baseline_rev)
+    # TODO: ping studio for list of existing names to check against
+    return gen_random_name()

src/dvclive/live.py

@@ -126,17 +126,21 @@ def _init_cleanup(self):
     def _init_dvc(self):
         from dvc.scm import NoSCM
 
-        if os.getenv(env.DVC_EXP_BASELINE_REV, None):
+        self._dvc_repo = get_dvc_repo()
+
+        self._exp_name = os.getenv(env.DVC_EXP_NAME)
+        self._baseline_rev = os.getenv(env.DVC_EXP_BASELINE_REV)
+        if not self._exp_name:
+            scm = self._dvc_repo.scm if self._dvc_repo else None
+            self._exp_name = get_random_exp_name(scm, self._baseline_rev)
+
+        if self._dvc_repo and self._baseline_rev and self._exp_name:
             # `dvc exp` execution
-            self._baseline_rev = os.getenv(env.DVC_EXP_BASELINE_REV, "")
-            self._exp_name = os.getenv(env.DVC_EXP_NAME, "")
             self._inside_dvc_exp = True
             if self._save_dvc_exp:
                 logger.info("Ignoring `save_dvc_exp` because `dvc exp run` is running")
                 self._save_dvc_exp = False
 
-        self._dvc_repo = get_dvc_repo()
-
         dvc_logger = logging.getLogger("dvc")
         dvc_logger.setLevel(os.getenv(env.DVCLIVE_LOGLEVEL, "WARNING").upper())
 
@@ -161,8 +165,8 @@ def _init_dvc(self):
             return
 
         self._baseline_rev = self._dvc_repo.scm.get_rev()
+
         if self._save_dvc_exp:
-            self._exp_name = get_random_exp_name(self._dvc_repo.scm, self._baseline_rev)
             mark_dvclive_only_started()
             self._include_untracked.append(self.dir)
 
@@ -177,23 +181,6 @@ def _init_studio(self):
             logger.debug("Skipping `studio` report `start` and `done` events.")
             self._studio_events_to_skip.add("start")
             self._studio_events_to_skip.add("done")
-        elif self._dvc_repo is None:
-            logger.warning(
-                "Can't connect to Studio without a DVC Repo."
-                "\nYou can create a DVC Repo by calling `dvc init`."
-            )
-            self._studio_events_to_skip.add("start")
-            self._studio_events_to_skip.add("data")
-            self._studio_events_to_skip.add("done")
-        elif not self._save_dvc_exp:
-            logger.warning(
-                "Can't connect to Studio without creating a DVC experiment."
-                "\nIf you have a DVC Pipeline, run it with `dvc exp run`."
-                "\nIf you are using DVCLive alone, use `save_dvc_exp=True`."
-            )
-            self._studio_events_to_skip.add("start")
-            self._studio_events_to_skip.add("data")
-            self._studio_events_to_skip.add("done")
         else:
             response = post_live_metrics(
                 "start",

src/dvclive/studio.py

@@ -25,18 +25,17 @@ def _cast_to_numbers(datapoints):
     return datapoints
 
 
-def _rel_path(path, dvc_root_path):
+def _rel_path(live, path):
     absolute_path = Path(path).resolve()
-    return str(absolute_path.relative_to(dvc_root_path).as_posix())
+    root = live._dvc_repo.root_dir if live._dvc_repo is not None else os.getcwd()
+    return str(absolute_path.relative_to(root).as_posix())
 
 
 def _adapt_plot_name(live, name):
-    if live._dvc_repo is not None:
-        name = _rel_path(name, live._dvc_repo.root_dir)
+    name = _rel_path(live, name)
     if os.path.isfile(live.dvc_file):
         dvc_file = live.dvc_file
-        if live._dvc_repo is not None:
-            dvc_file = _rel_path(live.dvc_file, live._dvc_repo.root_dir)
+        dvc_file = _rel_path(live, live.dvc_file)
         name = f"{dvc_file}::{name}"
     return name
 
@@ -64,17 +63,15 @@ def _adapt_images(live):
 def get_studio_updates(live):
     if os.path.isfile(live.params_file):
         params_file = live.params_file
-        if live._dvc_repo is not None:
-            params_file = _rel_path(params_file, live._dvc_repo.root_dir)
+        params_file = _rel_path(live, params_file)
         params = {params_file: load_yaml(live.params_file)}
     else:
         params = {}
 
     plots, metrics = parse_metrics(live)
 
     metrics_file = live.metrics_file
-    if live._dvc_repo is not None:
-        metrics_file = _rel_path(metrics_file, live._dvc_repo.root_dir)
+    metrics_file = _rel_path(live, metrics_file)
     metrics = {metrics_file: {"data": metrics}}
 
     plots = {

tests/test_dvc.py

@@ -138,19 +138,18 @@ def test_exp_save_on_end(tmp_dir, save, mocked_dvc_repo):
         )
     else:
         assert live._baseline_rev is not None
-        assert live._exp_name is None
+        assert live._exp_name is not None
         mocked_dvc_repo.experiments.save.assert_not_called()
 
 
-def test_exp_save_skip_on_env_vars(tmp_dir, monkeypatch, mocker):
+def test_exp_save_skip_on_env_vars(tmp_dir, monkeypatch, mocked_dvc_repo):
     monkeypatch.setenv(DVC_EXP_BASELINE_REV, "foo")
     monkeypatch.setenv(DVC_EXP_NAME, "bar")
 
-    with mocker.patch("dvclive.live.get_dvc_repo", return_value=None):
-        live = Live(save_dvc_exp=True)
-        live.end()
+    live = Live(save_dvc_exp=True)
+    live.end()
 
-    assert live._dvc_repo is None
+    assert live._dvc_repo is not None
     assert live._baseline_rev == "foo"
     assert live._exp_name == "bar"
     assert live._inside_dvc_exp

tests/test_studio.py

@@ -299,10 +299,9 @@ def test_post_to_studio_shorten_names(tmp_dir, mocked_dvc_repo, mocked_studio_po
 
 @pytest.mark.studio()
 def test_post_to_studio_inside_dvc_exp(
-    tmp_dir, mocker, monkeypatch, mocked_studio_post
+    tmp_dir, mocker, monkeypatch, mocked_studio_post, mocked_dvc_repo
 ):
     mocked_post, _ = mocked_studio_post
-    mocker.patch("dvclive.live.get_dvc_repo", return_value=None)
 
     monkeypatch.setenv(DVC_EXP_BASELINE_REV, "f" * 40)
     monkeypatch.setenv(DVC_EXP_NAME, "bar")
@@ -398,11 +397,6 @@ def test_post_to_studio_inside_subdir_dvc_exp(
     )
 
 
-def test_post_to_studio_requires_exp(tmp_dir, mocked_dvc_repo, mocked_studio_post):
-    assert Live()._studio_events_to_skip == {"start", "data", "done"}
-    assert not Live(save_dvc_exp=True)._studio_events_to_skip
-
-
 def test_get_dvc_studio_config_none(mocker):
     mocker.patch("dvclive.live.get_dvc_repo", return_value=None)
     live = Live()
@@ -485,3 +479,101 @@ def test_post_to_studio_message(tmp_dir, mocked_dvc_repo, mocked_studio_post):
         },
         timeout=(30, 5),
     )
+
+
+@pytest.mark.parametrize("exp_name", [True, False])
+def test_post_to_studio_no_repo(tmp_dir, monkeypatch, mocked_studio_post, exp_name):
+    monkeypatch.setenv(DVC_STUDIO_TOKEN, "STUDIO_TOKEN")
+    monkeypatch.setenv(DVC_STUDIO_REPO_URL, "STUDIO_REPO_URL")
+    monkeypatch.setenv(DVC_EXP_BASELINE_REV, "f" * 40)
+    if exp_name:
+        monkeypatch.setenv(DVC_EXP_NAME, "bar")
+
+    live = Live(save_dvc_exp=True)
+    live.log_param("fooparam", 1)
+
+    dvc_path = Path(live.dvc_file).as_posix()
+    metrics_path = Path(live.metrics_file).as_posix()
+    params_path = Path(live.params_file).as_posix()
+    foo_path = (Path(live.plots_dir) / Metric.subfolder / "foo.tsv").as_posix()
+
+    mocked_post, _ = mocked_studio_post
+
+    mocked_post.assert_called_with(
+        "https://0.0.0.0/api/live",
+        json={
+            "type": "start",
+            "repo_url": "STUDIO_REPO_URL",
+            "baseline_sha": "f" * 40,
+            "name": live._exp_name,
+            "client": "dvclive",
+        },
+        headers={
+            "Authorization": "token STUDIO_TOKEN",
+            "Content-type": "application/json",
+        },
+        timeout=(30, 5),
+    )
+
+    live.log_metric("foo", 1)
+
+    live.next_step()
+    mocked_post.assert_called_with(
+        "https://0.0.0.0/api/live",
+        json={
+            "type": "data",
+            "repo_url": "STUDIO_REPO_URL",
+            "baseline_sha": "f" * 40,
+            "name": live._exp_name,
+            "step": 0,
+            "metrics": {metrics_path: {"data": {"step": 0, "foo": 1}}},
+            "params": {params_path: {"fooparam": 1}},
+            "plots": {f"{dvc_path}::{foo_path}": {"data": [{"step": 0, "foo": 1.0}]}},
+            "client": "dvclive",
+        },
+        headers={
+            "Authorization": "token STUDIO_TOKEN",
+            "Content-type": "application/json",
+        },
+        timeout=(30, 5),
+    )
+
+    live.log_metric("foo", 2)
+
+    live.next_step()
+    mocked_post.assert_called_with(
+        "https://0.0.0.0/api/live",
+        json={
+            "type": "data",
+            "repo_url": "STUDIO_REPO_URL",
+            "baseline_sha": "f" * 40,
+            "name": live._exp_name,
+            "step": 1,
+            "metrics": {metrics_path: {"data": {"step": 1, "foo": 2}}},
+            "params": {params_path: {"fooparam": 1}},
+            "plots": {f"{dvc_path}::{foo_path}": {"data": [{"step": 1, "foo": 2.0}]}},
+            "client": "dvclive",
+        },
+        headers={
+            "Authorization": "token STUDIO_TOKEN",
+            "Content-type": "application/json",
+        },
+        timeout=(30, 5),
+    )
+
+    live.end()
+    mocked_post.assert_called_with(
+        "https://0.0.0.0/api/live",
+        json={
+            "type": "done",
+            "repo_url": "STUDIO_REPO_URL",
+            "baseline_sha": "f" * 40,
+            "name": live._exp_name,
+            "client": "dvclive",
+        },
+        headers={
+            "Authorization": "token STUDIO_TOKEN",
+            "Content-type": "application/json",
+        },
+        timeout=(30, 5),
+    )