lamin_cli 0.21.4__tar.gz → 1.0a1__tar.gz

{lamin_cli-0.21.4 → lamin_cli-1.0a1}/.gitignore

@@ -5,7 +5,7 @@ docs/guide/lnschema-bionty.ipynb
 docs/guide/lnschema-core.ipynb
 docs/paradisi05_laminopathic_nuclei.jpg
 lnschema_bionty_docs/
-lnschema_core_docs/
+lamindb_docs/
 _build
 mydata/
 lamin-intro/

{lamin_cli-0.21.4 → lamin_cli-1.0a1}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.3
 Name: lamin_cli
-Version: 0.21.4
+Version: 1.0a1
 Summary: Lamin CLI.
 Author-email: Lamin Labs <open-source@lamin.ai>
 Description-Content-Type: text/markdown

lamin_cli-1.0a1/lamin_cli/__init__.py

@@ -0,0 +1,3 @@
+"""Lamin CLI."""
+
+__version__ = "1.0a1"

{lamin_cli-0.21.4 → lamin_cli-1.0a1}/lamin_cli/__main__.py

@@ -165,7 +165,7 @@ def connect(instance: str):
     from lamindb_setup import settings as settings_, connect as connect_
 
     settings_.auto_connect = True
-    return connect_(slug=instance)
+    return connect_(slug=instance, _reload_lamindb=False)
 
 
 @main.command()
@@ -239,7 +239,7 @@ def load(entity: str, uid: str = None, key: str = None, with_env: bool = False):
         #     f"! please use: lamin connect {entity}"
         # )
         settings_.auto_connect = True
-        return connect(slug=entity)
+        return connect(slug=entity, _reload_lamindb=False)
     else:
         from lamin_cli._load import load as load_
 

{lamin_cli-0.21.4 → lamin_cli-1.0a1}/lamin_cli/_load.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 from typing import Tuple
 from lamin_utils import logger
 import shutil
+import re
 from pathlib import Path
 
 
@@ -27,7 +28,7 @@ def load(entity: str, uid: str = None, key: str = None, with_env: bool = False):
         instance = ln_setup.settings.instance.slug
 
     ln_setup.connect(instance)
-    from lnschema_core import models as ln
+    import lamindb as ln
 
     def script_to_notebook(
         transform: ln.Transform, notebook_path: Path, bump_revision: bool = False
@@ -35,16 +36,48 @@ def load(entity: str, uid: str = None, key: str = None, with_env: bool = False):
         import jupytext
         from lamin_utils._base62 import increment_base62
 
-        py_content = transform.source_code.replace(
-            "# # transform.name", f"# # {transform.name}"
-        )
+        if notebook_path.suffix == ".ipynb":
+            # below is backward compat
+            if "# # transform.name" in transform.source_code:
+                new_content = transform.source_code.replace(
+                    "# # transform.name", f"# # {transform.description}"
+                )
+            elif transform.source_code.startswith("# %% [markdown]\n#\n"):
+                new_content = transform.source_code.replace(
+                    "# %% [markdown]\n#\n",
+                    f"# %% [markdown]\n# # {transform.description}\n",
+                )
+        else:  # R notebook
+            # Pattern to match title only within YAML header section
+            title_pattern = r'^---\n.*?title:\s*"([^"]*)".*?---'
+            title_match = re.search(
+                title_pattern, transform.source_code, flags=re.DOTALL | re.MULTILINE
+            )
+            new_content = transform.source_code
+            if title_match:
+                current_title = title_match.group(1)
+                if current_title != transform.description:
+                    pattern = r'^(---\n.*?title:\s*)"([^"]*)"(.*?---)'
+                    replacement = f'\\1"{transform.description}"\\3'
+                    new_content = re.sub(
+                        pattern,
+                        replacement,
+                        new_content,
+                        flags=re.DOTALL | re.MULTILINE,
+                    )
+                    logger.important(
+                        f"fixed title: {current_title} → {transform.description}"
+                    )
         if bump_revision:
             uid = transform.uid
             new_uid = f"{uid[:-4]}{increment_base62(uid[-4:])}"
-            py_content = py_content.replace(uid, new_uid)
+            new_content = new_content.replace(uid, new_uid)
             logger.important(f"updated uid: {uid} → {new_uid}")
-        notebook = jupytext.reads(py_content, fmt="py:percent")
-        jupytext.write(notebook, notebook_path)
+        if notebook_path.suffix == ".ipynb":
+            notebook = jupytext.reads(new_content, fmt="py:percent")
+            jupytext.write(notebook, notebook_path)
+        else:
+            notebook_path.write_text(new_content)
 
     query_by_uid = uid is not None
 
@@ -61,42 +94,36 @@ def load(entity: str, uid: str = None, key: str = None, with_env: bool = False):
             transforms = ln.Transform.objects.filter(key=key, source_code__isnull=False)
 
         if (n_transforms := len(transforms)) == 0:
-            err_msg = (
-                f"uid strating with {uid}"
-                if query_by_uid
-                else f"key={key} and source_code"
-            )
+            err_msg = f"uid {uid}" if query_by_uid else f"key={key} and source_code"
             raise SystemExit(f"Transform with {err_msg} does not exist.")
 
         if n_transforms > 1:
             transforms = transforms.order_by("-created_at")
         transform = transforms.first()
 
-        target_filename = transform.key
-        if Path(target_filename).exists():
-            response = input(f"! {target_filename} exists: replace? (y/n)")
+        target_relpath = Path(transform.key)
+        if len(target_relpath.parents) > 1:
+            logger.important(
+                "preserve the folder structure for versioning:"
+                f" {target_relpath.parent}/"
+            )
+            target_relpath.parent.mkdir(parents=True, exist_ok=True)
+        if target_relpath.exists():
+            response = input(f"! {target_relpath} exists: replace? (y/n)")
             if response != "y":
                 raise SystemExit("Aborted.")
-        if transform._source_code_artifact_id is not None:  # backward compat
-            # need lamindb here to have .cache() available
-            import lamindb as ln
 
-            ln.settings.track_run_inputs = False
-            filepath_cache = transform._source_code_artifact.cache()
-            if not target_filename.endswith(transform._source_code_artifact.suffix):
-                target_filename += transform._source_code_artifact.suffix
-            shutil.move(filepath_cache, target_filename)
-        elif transform.source_code is not None:
-            if transform.key.endswith(".ipynb"):
-                script_to_notebook(transform, target_filename, bump_revision=True)
+        if transform.source_code is not None:
+            if target_relpath.suffix in (".ipynb", ".Rmd", ".qmd"):
+                script_to_notebook(transform, target_relpath, bump_revision=True)
             else:
-                Path(target_filename).write_text(transform.source_code)
+                target_relpath.write_text(transform.source_code)
         else:
             raise SystemExit("No source code available for this transform.")
-        logger.important(f"{transform.type} is here: {target_filename}")
-        if with_env:
-            import lamindb as ln
 
+        logger.important(f"{transform.type} is here: {target_relpath}")
+
+        if with_env:
             ln.settings.track_run_inputs = False
             if (
                 transform.latest_run is not None
@@ -104,16 +131,15 @@ def load(entity: str, uid: str = None, key: str = None, with_env: bool = False):
             ):
                 filepath_env_cache = transform.latest_run.environment.cache()
                 target_env_filename = (
-                    ".".join(target_filename.split(".")[:-1]) + "__requirements.txt"
+                    target_relpath.parent / f"{target_relpath.stem}__requirements.txt"
                 )
                 shutil.move(filepath_env_cache, target_env_filename)
                 logger.important(f"environment is here: {target_env_filename}")
             else:
                 logger.warning("latest transform run with environment doesn't exist")
-        return target_filename
-    elif entity == "artifact":
-        import lamindb as ln
 
+        return target_relpath
+    elif entity == "artifact":
         ln.settings.track_run_inputs = False
 
         if query_by_uid:
@@ -124,7 +150,7 @@ def load(entity: str, uid: str = None, key: str = None, with_env: bool = False):
             artifacts = ln.Artifact.filter(key=key)
 
         if (n_artifacts := len(artifacts)) == 0:
-            err_msg = f"uid strating with {uid}" if query_by_uid else f"key={key}"
+            err_msg = f"uid={uid}" if query_by_uid else f"key={key}"
             raise SystemExit(f"Artifact with {err_msg} does not exist.")
 
         if n_artifacts > 1:

{lamin_cli-0.21.4 → lamin_cli-1.0a1}/lamin_cli/_save.py

@@ -1,43 +1,27 @@
 from __future__ import annotations
 from pathlib import Path
 from typing import Union
-import lamindb_setup as ln_setup
 from lamin_utils import logger
 import re
 
 
-def parse_uid_from_code(
-    content: str, suffix: str
-) -> tuple[str | None, str | None, str | None]:
+def parse_uid_from_code(content: str, suffix: str) -> str | None:
     if suffix == ".py":
         track_pattern = re.compile(
             r'ln\.track\(\s*(?:transform\s*=\s*)?(["\'])([a-zA-Z0-9]{16})\1'
         )
-        # backward compat
         uid_pattern = re.compile(r'\.context\.uid\s*=\s*["\']([^"\']+)["\']')
-        stem_uid_pattern = re.compile(
-            r'\.transform\.stem_uid\s*=\s*["\']([^"\']+)["\']'
-        )
-        version_pattern = re.compile(r'\.transform\.version\s*=\s*["\']([^"\']+)["\']')
     elif suffix == ".ipynb":
         track_pattern = re.compile(
             r'ln\.track\(\s*(?:transform\s*=\s*)?(?:\\"|\')([a-zA-Z0-9]{16})(?:\\"|\')'
         )
         # backward compat
         uid_pattern = re.compile(r'\.context\.uid\s*=\s*\\["\']([^"\']+)\\["\']')
-        stem_uid_pattern = re.compile(
-            r'\.transform\.stem_uid\s*=\s*\\["\']([^"\']+)\\["\']'
-        )
-        version_pattern = re.compile(
-            r'\.transform\.version\s*=\s*\\["\']([^"\']+)\\["\']'
-        )
     elif suffix in {".R", ".qmd", ".Rmd"}:
         track_pattern = re.compile(
             r'track\(\s*(?:transform\s*=\s*)?([\'"])([a-zA-Z0-9]{16})\1'
         )
         uid_pattern = None
-        stem_uid_pattern = None
-        version_pattern = None
     else:
         raise SystemExit(
             "Only .py, .ipynb, .R, .qmd, .Rmd files are supported for saving"
@@ -48,26 +32,12 @@ def parse_uid_from_code(
     uid_match = track_pattern.search(content)
     group_index = 1 if suffix == ".ipynb" else 2
     uid = uid_match.group(group_index) if uid_match else None
-    stem_uid = None
-    version = None
 
     if uid_pattern is not None and uid is None:
         uid_match = uid_pattern.search(content)
         uid = uid_match.group(1) if uid_match else None
-    if stem_uid_pattern is not None:
-        stem_uid_match = stem_uid_pattern.search(content)
-        stem_uid = stem_uid_match.group(1) if stem_uid_match else None
-    if version_pattern is not None:
-        version_match = version_pattern.search(content)
-        version = version_match.group(1) if version_match else None
-
-    if uid is None and (stem_uid is None or version is None):
-        target = "script" if suffix in {".py", ".R"} else "notebook"
-        raise SystemExit(
-            f"Cannot infer transform uid. Did you run `ln.track()` in your {target}?"
-        )
 
-    return uid, stem_uid, version
+    return uid
 
 
 def save_from_filepath_cli(
@@ -76,6 +46,8 @@ def save_from_filepath_cli(
     description: str | None,
     registry: str | None,
 ) -> str | None:
+    import lamindb_setup as ln_setup
+
     if not isinstance(filepath, Path):
         filepath = Path(filepath)
 
@@ -94,14 +66,23 @@ def save_from_filepath_cli(
         "R": set([".R", ".qmd", ".Rmd"]),
     }
 
-    if (
-        filepath.suffix in {".qmd", ".Rmd"}
-        and not filepath.with_suffix(".html").exists()
-    ):
-        raise SystemExit(
-            f"Please export your {filepath.suffix} file as an html file here"
-            f" {filepath.with_suffix('.html')}"
-        )
+    if filepath.suffix in {".qmd", ".Rmd"}:
+        if not (
+            filepath.with_suffix(".html").exists()
+            or filepath.with_suffix(".nb.html").exists()
+        ):
+            raise SystemExit(
+                f"Please export your {filepath.suffix} file as an html file here"
+                f" {filepath.with_suffix('.html')}"
+            )
+        if (
+            filepath.with_suffix(".html").exists()
+            and filepath.with_suffix(".nb.html").exists()
+        ):
+            raise SystemExit(
+                f'Please delete one of\n - {filepath.with_suffix(".html")}\n -'
+                f' {filepath.with_suffix(".nb.html")}'
+            )
 
     if registry is None:
         registry = (
@@ -128,9 +109,9 @@ def save_from_filepath_cli(
     elif registry == "transform":
         with open(filepath) as file:
             content = file.read()
-        uid, stem_uid, version = parse_uid_from_code(content, filepath.suffix)
-        logger.important(f"mapped '{filepath}' on uid '{uid}'")
+        uid = parse_uid_from_code(content, filepath.suffix)
         if uid is not None:
+            logger.important(f"mapped '{filepath}' on uid '{uid}'")
             transform = ln.Transform.filter(uid=uid).one_or_none()
             if transform is None:
                 logger.error(
@@ -139,10 +120,17 @@ def save_from_filepath_cli(
                 )
                 return "not-tracked-in-transform-registry"
         else:
-            transform = ln.Transform.get(uid__startswith=stem_uid, version=version)
+            transform = ln.Transform.filter(key=filepath.name).one_or_none()
+            if transform is None:
+                transform = ln.Transform(
+                    name=filepath.name,
+                    key=filepath.name,
+                    type="script" if filepath.suffix in {".R", ".py"} else "notebook",
+                ).save()
+                logger.important(f"created Transform('{transform.uid}')")
         # latest run of this transform by user
         run = ln.Run.filter(transform=transform).order_by("-started_at").first()
-        if run.created_by.id != ln_setup.settings.user.id:
+        if run is not None and run.created_by.id != ln_setup.settings.user.id:
             response = input(
                 "You are trying to save a transform created by another user: Source"
                 " and report files will be tagged with *your* user id. Proceed?"
@@ -156,16 +144,6 @@ def save_from_filepath_cli(
             filepath=filepath,
             from_cli=True,
         )
-        if filepath.suffix in {".qmd", ".Rmd"}:
-            report_file = ln.Artifact(
-                filepath.with_suffix(".html"),  # validated at the top that this exists
-                description=f"Report of run {run.uid}",
-                visibility=0,  # hidden file
-                run=False,
-            )
-            report_file.save(upload=True, print_progress=False)
-            run.report = report_file
-            run.save()
         return return_code
     else:
         raise SystemExit("Allowed values for '--registry' are: 'artifact', 'transform'")

{lamin_cli-0.21.4 → lamin_cli-1.0a1}/tests/scripts/run-track-and-finish.py

@@ -1,7 +1,7 @@
 import lamindb as ln
 
-ln.context.name = "My good script 2"
-ln.track("VFYCIuaw2GsX0000")
+# purposefully do not pass uid
+ln.track()
 
 
 if __name__ == "__main__":

{lamin_cli-0.21.4 → lamin_cli-1.0a1}/tests/test_load.py

@@ -1,4 +1,5 @@
 from lamin_cli._load import decompose_url
+from pathlib import Path
 import subprocess
 
 
@@ -15,26 +16,50 @@ def test_decompose_url():
         assert uid == "1GCKs8zLtkc85zKv"
 
 
-def test_get_transform():
+def test_load_transform():
+    import lamindb_setup as ln_setup
+
+    print(ln_setup.settings.instance.slug)
     result = subprocess.run(
         "lamin load"
-        " 'https://lamin.ai/laminlabs/arrayloader-benchmarks/transform/1GCKs8zLtkc85zKv'"
+        " 'https://lamin.ai/laminlabs/lamin-dev/transform/VFYCIuaw2GsX0000'"
         " --with-env",  # noqa
         shell=True,
         capture_output=True,
     )
+    print(result.stdout.decode())
+    print(result.stderr.decode())
     assert result.returncode == 0
 
+    print(ln_setup.settings.instance.slug)
+
+    path1 = Path("run-track-and-finish.py")
+    path2 = Path("run-track-and-finish__requirements.txt")
+    assert path1.exists()
+    assert path2.exists()
+
+    # below will fail because it will say "these files already exist"
+    result = subprocess.run(
+        "lamin load transform --uid VFYCIuaw2GsX --with-env",
+        shell=True,
+        capture_output=True,
+    )
+    assert result.returncode == 1
+    path1.unlink()
+    path2.unlink()
+
     # partial uid
     result = subprocess.run(
-        "lamin load transform --uid 1GCKs8zLtkc85z --with-env",
+        "lamin load transform --uid VFYCIuaw2GsX --with-env",
         shell=True,
         capture_output=True,
     )
     assert result.returncode == 0
+    path1.unlink()
+    path2.unlink()
 
 
-def test_get_artifact():
+def test_load_artifact():
     result = subprocess.run(
         "lamin load"
         " 'https://lamin.ai/laminlabs/lamin-site-assets/artifact/e2G7k9EVul4JbfsEYAy5'",  # noqa

{lamin_cli-0.21.4 → lamin_cli-1.0a1}/tests/test_migrate.py

@@ -35,6 +35,6 @@ def test_migrate_deploy():
 
 # def test_migrate_squash():
 #     exit_status = os.system(
-#         "yes | lamin migrate squash --package-name lnschema_core --end-number 0023"
+#         "yes | lamin migrate squash --package-name lamindb --end-number 0023"
 #     )
 #     assert exit_status == 0

{lamin_cli-0.21.4 → lamin_cli-1.0a1}/tests/test_parse_uid_from_code.py

@@ -1,4 +1,3 @@
-import pytest
 from lamin_cli._save import parse_uid_from_code
 
 
@@ -33,13 +32,12 @@ def test_python_track_pattern():
 
     # Test valid cases
     for content, expected_uid in valid_cases:
-        uid, _, _ = parse_uid_from_code(content, ".py")
+        uid = parse_uid_from_code(content, ".py")
         assert uid == expected_uid, f"Failed for valid content: {content}"
 
     # Test invalid cases
     for content in invalid_cases:
-        with pytest.raises(SystemExit):
-            uid, _, _ = parse_uid_from_code(content, ".py")
+        assert parse_uid_from_code(content, ".py") is None
 
 
 def test_jupyter_track_pattern():
@@ -70,14 +68,12 @@ def test_jupyter_track_pattern():
 
     # Test valid cases
     for content, expected_uid in valid_cases:
-        uid, _, _ = parse_uid_from_code(content, ".ipynb")
+        uid = parse_uid_from_code(content, ".ipynb")
         assert uid == expected_uid, f"Failed for valid content: {content}"
 
     # Test invalid cases
     for content in invalid_cases:
-        print(content)
-        with pytest.raises(SystemExit):
-            uid, _, _ = parse_uid_from_code(content, ".py")
+        assert parse_uid_from_code(content, ".py") is None
 
 
 def test_edge_cases():
@@ -99,8 +95,7 @@ def test_edge_cases():
     ]
 
     for content, expected_uid, suffix in test_cases:
-        print(content)
-        uid, _, _ = parse_uid_from_code(content, suffix)
+        uid = parse_uid_from_code(content, suffix)
         assert uid == expected_uid, f"Failed for content: {content}"
 
 
@@ -116,7 +111,7 @@ def test_r_track_pattern():
     # Test valid cases across all R-related suffixes
     for suffix in suffixes:
         for content, expected_uid in valid_cases:
-            uid, _, _ = parse_uid_from_code(content, suffix)
+            uid = parse_uid_from_code(content, suffix)
             assert (
                 uid == expected_uid
             ), f"Failed for valid content with {suffix}: {content}"

{lamin_cli-0.21.4 → lamin_cli-1.0a1}/tests/test_save_files.py

@@ -1,4 +1,5 @@
 import subprocess
+import lamindb_setup as ln_setup
 from pathlib import Path
 
 test_file = Path(__file__).parent.parent.resolve() / ".gitignore"
@@ -21,6 +22,8 @@ def test_save_file():
     )
     assert result.returncode == 1
 
+    print(ln_setup.settings.instance.slug)
+
     result = subprocess.run(
         f"lamin save {filepath} --key mytest",
         shell=True,

{lamin_cli-0.21.4 → lamin_cli-1.0a1}/tests/test_save_notebooks.py

@@ -20,11 +20,7 @@ def test_save_not_initialized():
         capture_output=True,
         env=env,
     )
-    assert result.returncode == 1
-    assert (
-        "Cannot infer transform uid. Did you run `ln.track()` in your notebook?"
-        in result.stderr.decode()
-    )
+    assert result.returncode == 0
 
 
 def test_save_non_consecutive():
@@ -87,7 +83,7 @@ def test_save_consecutive():
     transform = ln.Transform.filter(uid="hlsFXswrJjtt0000").one_or_none()
     assert transform is not None
     assert transform.latest_run.report is None
-    assert transform._source_code_artifact is None
+    assert transform.source_code is None
     assert transform.latest_run.environment is None
 
     # and save again
@@ -107,7 +103,7 @@ def test_save_consecutive():
     assert (
         transform.source_code
         == """# %% [markdown]
-# # transform.name
+#
 
 # %%
 import lamindb as ln
@@ -119,7 +115,7 @@ ln.track("hlsFXswrJjtt0000")
 print("my consecutive cell")
 """
     )
-    assert transform.hash == "OwVL-0-_gmk8heR3zV7BkA"
+    assert transform.hash == "ik5Dilxs2RmwOGydohFolQ"
     # below is the test that we can use if store the run repot as `.ipynb`
     # and not as html as we do right now
     assert transform.latest_run.report.suffix == ".html"
@@ -133,7 +129,6 @@ print("my consecutive cell")
     # }
     # testing for the hash of the report makes no sense because it contains timestamps
     assert transform.latest_run.environment.path.exists()
-    assert transform._source_code_artifact is None
 
     # edit the notebook
     nb = read_notebook(notebook_path)
@@ -167,9 +162,8 @@ print("my consecutive cell")
     transform = ln.Transform.get("hlsFXswrJjtt0000")
     assert transform.latest_run.report.path.exists()
     assert transform.latest_run.report.path == transform.latest_run.report.path
-    assert transform.hash == "BhQpym0JfeypqhVMPlQ0ng"
+    assert transform.hash == "Jv0_TrZfzM-0erbp1FGdrQ"
     assert transform.latest_run.environment.path.exists()
-    assert transform._source_code_artifact is None
 
     # get the the source code via command line
     result = subprocess.run(

{lamin_cli-0.21.4 → lamin_cli-1.0a1}/tests/test_save_scripts.py

@@ -8,7 +8,23 @@ from lamindb_setup import settings
 scripts_dir = Path(__file__).parent.resolve() / "scripts"
 
 
-def test_run_save_cache():
+def test_save_without_uid():
+    env = os.environ
+    env["LAMIN_TESTING"] = "true"
+    filepath = scripts_dir / "run-track-and-finish.py"
+
+    # attempt to save the script without it yet being run
+    result = subprocess.run(
+        f"lamin save {filepath}",
+        shell=True,
+        capture_output=True,
+    )
+    # print(result.stdout.decode())
+    assert result.returncode == 0
+    assert "created Transform" in result.stdout.decode()
+
+
+def test_run_save_cache_with_git_and_uid():
     env = os.environ
     env["LAMIN_TESTING"] = "true"
     filepath = scripts_dir / "run-track-and-finish-sync-git.py"
@@ -39,7 +55,6 @@ def test_run_save_cache():
     transform = ln.Transform.get("m5uCHTTpJnjQ")
     assert transform.hash == "MoIciBQ0lpVPCKQGofPX6g"
     assert transform.latest_run.environment.path.exists()
-    assert transform._source_code_artifact is None
 
     # you can rerun the same script
     result = subprocess.run(
@@ -54,7 +69,6 @@ def test_run_save_cache():
     assert "loaded Transform" in result.stdout.decode()
     assert "m5uCHTTp" in result.stdout.decode()
     assert "started Run" in result.stdout.decode()
-    assert "source code is already saved" in result.stdout.decode()
 
     # you can re-save the script
     result = subprocess.run(
@@ -66,7 +80,6 @@ def test_run_save_cache():
     # print(result.stdout.decode())
     # print(result.stderr.decode())
     assert result.returncode == 0
-    assert "source code is already saved" in result.stdout.decode()
     assert "run.environment is already saved" in result.stdout.decode()
 
     # edit the script
@@ -105,7 +118,7 @@ def test_run_save_cache():
     # print(result.stdout.decode())
     # print(result.stderr.decode())
     assert result.returncode == 1
-    assert "Source code changed, bump revision by setting" in result.stderr.decode()
+    assert "✗ source code changed, run:" in result.stderr.decode()
 
     # update the uid
     content = filepath.read_text()
@@ -204,7 +217,6 @@ def test_run_save_with_params():
     print(result.stdout.decode())
     print(result.stderr.decode())
     assert result.returncode == 0
-    assert "source code is already saved" in result.stdout.decode()
     assert (
         "run-track-with-params.py' on uid 'JjRF4mACd9m00000'" in result.stdout.decode()
     )

lamin_cli-0.21.4/lamin_cli/__init__.py

@@ -1,3 +0,0 @@
-"""Lamin CLI."""
-
-__version__ = "0.21.4"