lamin_cli 1.3.0__tar.gz → 1.4.1__tar.gz

{lamin_cli-1.3.0 → lamin_cli-1.4.1}/.pre-commit-config.yaml

@@ -31,7 +31,7 @@ repos:
               tests
           )
   - repo: https://github.com/pre-commit/mirrors-mypy
-    rev: v1.14.1
+    rev: v1.15.0
     hooks:
       - id: mypy
         exclude: |

{lamin_cli-1.3.0 → lamin_cli-1.4.1}/PKG-INFO

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

lamin_cli-1.4.1/lamin_cli/__init__.py

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

{lamin_cli-1.3.0 → lamin_cli-1.4.1}/lamin_cli/__main__.py

@@ -2,11 +2,13 @@ from __future__ import annotations
 
 import inspect
 import os
+import shutil
 import sys
 import warnings
 from collections import OrderedDict
 from functools import wraps
 from importlib.metadata import PackageNotFoundError, version
+from pathlib import Path
 from typing import TYPE_CHECKING
 
 from lamindb_setup._init_instance import (
@@ -307,21 +309,28 @@ def get(entity: str, uid: str | None = None, key: str | None = None):
 
 
 @main.command()
-@click.argument("path", type=click.Path(exists=True, dir_okay=True, file_okay=True))
-@click.option("--key", type=str, default=None)
-@click.option("--description", type=str, default=None)
-@click.option("--stem-uid", type=str, default=None)
-@click.option("--registry", type=str, default=None)
-def save(path: str, key: str, description: str, stem_uid: str, registry: str):
+@click.argument("path", type=str)
+@click.option("--key", type=str, default=None, help="The key of the artifact or transform.")
+@click.option("--description", type=str, default=None, help="A description of the artifact or transform.")
+@click.option("--stem-uid", type=str, default=None, help="The stem uid of the artifact or transform.")
+@click.option("--project", type=str, default=None, help="A valid project name or uid.")
+@click.option("--registry", type=str, default=None, help="Either 'artifact' or 'transform'. If not passed, chooses based on path suffix.")
+def save(path: str, key: str, description: str, stem_uid: str, project: str, registry: str):
     """Save a file or folder.
 
-    Defaults to saving `.py`, `.ipynb`, `.R`, `.Rmd`, and `.qmd` as {class}`~lamindb.Transform` and
-    other file types and folders as {class}`~lamindb.Artifact`. You can save a `.py` or `.ipynb` file as
+    Example: Given a valid project name "my_project".
+
+    ```
+    lamin save my_table.csv --key my_tables/my_table.csv --project my_project
+    ```
+
+    Note: Defaults to saving `.py`, `.ipynb`, `.R`, `.Rmd`, and `.qmd` as {class}`~lamindb.Transform` and
+    other file types and folders as {class}`~lamindb.Artifact`. You can enforce saving a file as
     an {class}`~lamindb.Artifact` by passing `--registry artifact`.
     """
-    from lamin_cli._save import save_from_filepath_cli
+    from lamin_cli._save import save_from_path_cli
 
-    if save_from_filepath_cli(path, key, description, stem_uid, registry) is not None:
+    if save_from_path_cli(path, key, description, stem_uid, project, registry) is not None:
         sys.exit(1)
 
 
@@ -343,9 +352,6 @@ def run(filepath: str, project: str, image_url: str, packages: str, cpu: int, gp
     lamin run my_script.py --project my_project
     ```
     """
-    import shutil
-    from pathlib import Path
-
     from lamin_cli.compute.modal import Runner
 
     default_mount_dir = Path('./modal_mount_dir')
@@ -354,7 +360,7 @@ def run(filepath: str, project: str, image_url: str, packages: str, cpu: int, gp
 
     shutil.copy(filepath, default_mount_dir)
 
-    filepath_in_mount_dir = Path(default_mount_dir) / Path(filepath).name
+    filepath_in_mount_dir = default_mount_dir / Path(filepath).name
 
     package_list = []
     if packages:

{lamin_cli-1.3.0 → lamin_cli-1.4.1}/lamin_cli/_load.py

@@ -78,7 +78,9 @@ def load(
                     )
         if bump_revision:
             uid = transform.uid
-            if uid in new_content:
+            if (
+                uid in new_content
+            ):  # this only hits if it has the full uid, not for the stem uid
                 new_uid = f"{uid[:-4]}{increment_base62(uid[-4:])}"
                 new_content = new_content.replace(uid, new_uid)
                 logger.important(f"updated uid: {uid} → {new_uid}")

lamin_cli-1.4.1/lamin_cli/_save.py

@@ -0,0 +1,239 @@
+from __future__ import annotations
+
+import re
+import sys
+from typing import TYPE_CHECKING
+
+import click
+from lamin_utils import logger
+
+if TYPE_CHECKING:
+    from pathlib import Path
+
+
+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]{12,16})\1'
+        )
+        uid_pattern = re.compile(r'\.context\.uid\s*=\s*["\']([^"\']+)["\']')
+    elif suffix == ".ipynb":
+        track_pattern = re.compile(
+            r'ln\.track\(\s*(?:transform\s*=\s*)?(?:\\"|\')([a-zA-Z0-9]{12,16})(?:\\"|\')'
+        )
+        # backward compat
+        uid_pattern = re.compile(r'\.context\.uid\s*=\s*\\["\']([^"\']+)\\["\']')
+    elif suffix in {".R", ".qmd", ".Rmd"}:
+        track_pattern = re.compile(
+            r'track\(\s*(?:transform\s*=\s*)?([\'"])([a-zA-Z0-9]{12,16})\1'
+        )
+        uid_pattern = None
+    else:
+        raise SystemExit(
+            "Only .py, .ipynb, .R, .qmd, .Rmd files are supported for saving"
+            " transforms."
+        )
+
+    # Search for matches in the entire file content
+    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
+
+    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
+
+    return uid
+
+
+def save_from_path_cli(
+    path: Path | str,
+    key: str | None,
+    description: str | None,
+    stem_uid: str | None,
+    project: str | None,
+    registry: str | None,
+) -> str | None:
+    import lamindb_setup as ln_setup
+    from lamindb_setup.core.upath import LocalPathClasses, UPath, create_path
+
+    # this will be gone once we get rid of lamin load or enable loading multiple
+    # instances sequentially
+    auto_connect_state = ln_setup.settings.auto_connect
+    ln_setup.settings.auto_connect = True
+
+    import lamindb as ln
+
+    if not ln.setup.core.django.IS_SETUP:
+        sys.exit(-1)
+    from lamindb._finish import save_context_core
+
+    ln_setup.settings.auto_connect = auto_connect_state
+
+    # this allows to have the correct treatment of credentials in case of cloud paths
+    path = create_path(path)
+    # isinstance is needed to cast the type of path to UPath
+    # to avoid mypy erors
+    assert isinstance(path, UPath)
+    if not path.exists():
+        raise click.BadParameter(f"Path {path} does not exist", param_hint="path")
+
+    if registry is None:
+        suffixes_transform = {
+            "py": {".py", ".ipynb"},
+            "R": {".R", ".qmd", ".Rmd"},
+        }
+        registry = (
+            "transform"
+            if path.suffix in suffixes_transform["py"].union(suffixes_transform["R"])
+            else "artifact"
+        )
+
+    if project is not None:
+        project_record = ln.Project.filter(
+            ln.Q(name=project) | ln.Q(uid=project)
+        ).one_or_none()
+        if project_record is None:
+            raise ln.errors.InvalidArgument(
+                f"Project '{project}' not found, either create it with `ln.Project(name='...').save()` or fix typos."
+            )
+
+    is_cloud_path = not isinstance(path, LocalPathClasses)
+
+    if registry == "artifact":
+        ln.settings.creation.artifact_silence_missing_run_warning = True
+        revises = None
+        if stem_uid is not None:
+            revises = (
+                ln.Artifact.filter(uid__startswith=stem_uid)
+                .order_by("-created_at")
+                .first()
+            )
+            if revises is None:
+                raise ln.errors.InvalidArgument("The stem uid is not found.")
+
+        if is_cloud_path:
+            if key is not None:
+                logger.error("Do not pass --key for cloud paths")
+                return "key-with-cloud-path"
+        elif key is None and description is None:
+            logger.error("Please pass a key or description via --key or --description")
+            return "missing-key-or-description"
+
+        artifact = ln.Artifact(
+            path, key=key, description=description, revises=revises
+        ).save()
+        logger.important(f"saved: {artifact}")
+        logger.important(f"storage path: {artifact.path}")
+        if ln_setup.settings.storage.type == "s3":
+            logger.important(f"storage url: {artifact.path.to_url()}")
+        if project is not None:
+            artifact.projects.add(project_record)
+            logger.important(f"labeled with project: {project_record.name}")
+        if ln_setup.settings.instance.is_remote:
+            slug = ln_setup.settings.instance.slug
+            logger.important(f"go to: https://lamin.ai/{slug}/artifact/{artifact.uid}")
+        return None
+
+    if registry == "transform":
+        if is_cloud_path:
+            logger.error("Can not register a transform from a cloud path")
+            return "transform-with-cloud-path"
+
+        if path.suffix in {".qmd", ".Rmd"}:
+            html_file_exists = path.with_suffix(".html").exists()
+            nb_html_file_exists = path.with_suffix(".nb.html").exists()
+
+            if not html_file_exists and not nb_html_file_exists:
+                logger.error(
+                    f"Please export your {path.suffix} file as an html file here"
+                    f" {path.with_suffix('.html')}"
+                )
+                return "export-qmd-Rmd-as-html"
+            elif html_file_exists and nb_html_file_exists:
+                logger.error(
+                    f"Please delete one of\n - {path.with_suffix('.html')}\n -"
+                    f" {path.with_suffix('.nb.html')}"
+                )
+                return "delete-html-or-nb-html"
+
+        with path.open() as file:
+            content = file.read()
+        uid = parse_uid_from_code(content, path.suffix)
+
+        if uid is not None:
+            logger.important(f"mapped '{path.name}' on uid '{uid}'")
+            if len(uid) == 16:
+                # is full uid
+                transform = ln.Transform.filter(uid=uid).one_or_none()
+            else:
+                # is stem uid
+                if stem_uid is not None:
+                    assert stem_uid == uid, (
+                        "passed stem uid and parsed stem uid do not match"
+                    )
+                else:
+                    stem_uid = uid
+                transform = (
+                    ln.Transform.filter(uid__startswith=uid)
+                    .order_by("-created_at")
+                    .first()
+                )
+                if transform is None:
+                    uid = f"{stem_uid}0000"
+        else:
+            # TODO: account for folders and hash equivalence as we do in ln.track()
+            transform = ln.Transform.filter(key=path.name, is_latest=True).one_or_none()
+        revises = None
+        if stem_uid is not None:
+            revises = (
+                ln.Transform.filter(uid__startswith=stem_uid)
+                .order_by("-created_at")
+                .first()
+            )
+            if revises is None:
+                raise ln.errors.InvalidArgument("The stem uid is not found.")
+        if transform is None:
+            if path.suffix == ".ipynb":
+                from nbproject.dev import read_notebook
+                from nbproject.dev._meta_live import get_title
+
+                nb = read_notebook(path)
+                description = get_title(nb)
+            else:
+                description = None
+            transform = ln.Transform(
+                uid=uid,
+                description=description,
+                key=path.name,
+                type="script" if path.suffix in {".R", ".py"} else "notebook",
+                revises=revises,
+            ).save()
+            logger.important(f"created Transform('{transform.uid}')")
+        if project is not None:
+            transform.projects.add(project_record)
+            logger.important(f"labeled with project: {project_record.name}")
+        # latest run of this transform by user
+        run = ln.Run.filter(transform=transform).order_by("-started_at").first()
+        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?"
+                " (y/n)"
+            )
+            if response != "y":
+                return "aborted-save-notebook-created-by-different-user"
+        if run is None and transform.key.endswith(".ipynb"):
+            run = ln.Run(transform=transform).save()
+            logger.important(
+                f"found no run, creating Run('{run.uid}') to display the html"
+            )
+        return_code = save_context_core(
+            run=run,
+            transform=transform,
+            filepath=path,
+            from_cli=True,
+        )
+        return return_code
+    else:
+        raise SystemExit("Allowed values for '--registry' are: 'artifact', 'transform'")

{lamin_cli-1.3.0 → lamin_cli-1.4.1}/tests/core/conftest.py

@@ -7,13 +7,13 @@ from lamin_utils import logger
 
 def pytest_sessionstart(session: pytest.Session):
     ln.setup.init(
-        storage="./default_storage_ci",
-        name="laminci-unit-tests",
+        storage="./default_storage_cli",
+        name="lamin-cli-unit-tests",
     )
     ln.setup.settings.auto_connect = True
 
 
 def pytest_sessionfinish(session: pytest.Session):
     logger.set_verbosity(1)
-    shutil.rmtree("./default_storage_ci")
-    ln.setup.delete("laminci-unit-tests", force=True)
+    shutil.rmtree("./default_storage_cli")
+    ln.setup.delete("lamin-cli-unit-tests", force=True)

{lamin_cli-1.3.0 → lamin_cli-1.4.1}/tests/core/test_migrate.py

@@ -5,9 +5,9 @@ import os
 # import lamindb_setup as ln_setup
 
 
-def test_migrate_create():
-    exit_status = os.system("lamin migrate create")
-    assert exit_status == 0
+# def test_migrate_create():
+#     exit_status = os.system("lamin migrate create")
+#     assert exit_status == 0
 
 
 def test_migrate_deploy():

{lamin_cli-1.3.0 → lamin_cli-1.4.1}/tests/core/test_save_files.py

@@ -1,12 +1,13 @@
 import subprocess
 from pathlib import Path
 
+import lamindb as ln
 import lamindb_setup as ln_setup
 
 test_file = Path(__file__).parent.parent.parent.resolve() / ".gitignore"
 
 
-def test_save_file():
+def test_save_local_file():
     filepath = test_file
 
     # neither key nor description
@@ -23,10 +24,10 @@ def test_save_file():
     )
     assert result.returncode == 1
 
-    print(ln_setup.settings.instance.slug)
+    ln.Project(name="test_project").save()
 
     result = subprocess.run(
-        f"lamin save {filepath} --key mytest",
+        f"lamin save {filepath} --key mytest --project test_project",
         shell=True,
         capture_output=True,
     )
@@ -34,6 +35,7 @@ def test_save_file():
     print(result.stderr.decode())
     assert "key='mytest'" in result.stdout.decode()
     assert "storage path:" in result.stdout.decode()
+    assert "labeled with project: test_project" in result.stdout.decode()
     assert result.returncode == 0
 
     # test passing the registry and saving the same file
@@ -62,3 +64,19 @@ def test_save_file():
         in result.stderr.decode()
     )
     assert result.returncode == 1
+
+
+def test_save_cloud_file():
+    # should be no key for cloud paths
+    result = subprocess.run(
+        "lamin save s3://cellxgene-data-public/cell-census/2024-07-01/h5ads/fe1a73ab-a203-45fd-84e9-0f7fd19efcbd.h5ad --key wrongkey.h5ad",
+        shell=True,
+        check=False,
+    )
+    assert result.returncode == 1
+
+    result = subprocess.run(
+        "lamin save s3://cellxgene-data-public/cell-census/2024-07-01/h5ads/fe1a73ab-a203-45fd-84e9-0f7fd19efcbd.h5ad",
+        shell=True,
+        check=True,
+    )

{lamin_cli-1.3.0 → lamin_cli-1.4.1}/tests/core/test_save_notebooks.py

@@ -54,7 +54,7 @@ def test_save_non_consecutive():
     assert process.returncode == 0
 
 
-def test_save_consecutive():
+def test_save_consecutive_user_passes_uid():
     notebook_path = Path(
         f"{notebook_dir}with-title-and-initialized-consecutive.ipynb"
     ).resolve()
@@ -73,14 +73,47 @@ def test_save_consecutive():
         capture_output=True,
         env=env,
     )
-    assert result.returncode == 1
-    assert "Did not find uid 'hlsFXswrJjtt0000'" in result.stdout.decode()
+    assert result.returncode == 0
+    assert "created Transform('hlsFXswrJjtt0000')" in result.stdout.decode()
+    assert "found no run, creating" in result.stdout.decode()
 
     # now, let's re-run this notebook so that `ln.track()` is actually run
+    # this mimics the interactive execution in an editor
+    with pytest.raises(CellExecutionError) as error:
+        nbproject_test.execute_notebooks(notebook_path)
+    assert (
+        're-running notebook with already-saved source code, please update the `uid` argument in `track()` to "hlsFXswrJjtt0001"'
+        in error.exconly()
+    )
+
+    # because nbconvert is recognized as non-interactive execution, the execution works out
+    result = subprocess.run(
+        f"jupyter nbconvert --to notebook --inplace --execute {notebook_path}",
+        shell=True,
+        capture_output=True,
+        env=env,
+    )
+    assert result.returncode == 0
+    assert (
+        "loaded Transform('hlsFXswrJjtt0000'), started new Run"
+        in notebook_path.read_text()
+    )
+
+    # now let's simulate the interactive use case and use nbproject_test again
+    # use the stem uid instead and it will bump the version
+    notebook_path.write_text(
+        notebook_path.read_text().replace("hlsFXswrJjtt0000", "hlsFXswrJjtt")
+    )
+    assert r"ln.track(\"hlsFXswrJjtt\")" in notebook_path.read_text()
+
     nbproject_test.execute_notebooks(notebook_path, print_outputs=True)
+    assert (
+        "created Transform('hlsFXswrJjtt0001'), started new"
+        in notebook_path.read_text()
+    )
 
-    # now, there is a transform record, but we're missing all artifacts
-    transform = ln.Transform.filter(uid="hlsFXswrJjtt0000").one_or_none()
+    # now, there is a transform record, but we're missing all artifacts because ln.finish() wasn't called
+    transform = ln.Transform.filter(uid="hlsFXswrJjtt0001").one_or_none()
     assert transform is not None
     assert transform.latest_run.report is None
     assert transform.source_code is None
@@ -98,7 +131,7 @@ def test_save_consecutive():
     assert result.returncode == 0
 
     # now, we have the associated artifacts
-    transform = ln.Transform.filter(uid="hlsFXswrJjtt0000").one_or_none()
+    transform = ln.Transform.filter(uid="hlsFXswrJjtt0001").one_or_none()
     assert transform is not None
     assert (
         transform.source_code
@@ -109,13 +142,14 @@ def test_save_consecutive():
 import lamindb as ln
 
 # %%
-ln.track("hlsFXswrJjtt0000")
+# pass full uid, will be updated to stem uid during tests
+ln.track("hlsFXswrJjtt")
 
 # %%
 print("my consecutive cell")
 """
     )
-    assert transform.hash == "ik5Dilxs2RmwOGydohFolQ"
+    assert transform.hash == "OQ8V3hVrEJcxK0aOOwpl4g"
     # 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"
@@ -137,12 +171,6 @@ print("my consecutive cell")
     nb.cells.append(new_cell)  # duplicate last cell
     write_notebook(nb, notebook_path)
 
-    # attempt re-running - it fails
-    with pytest.raises(CellExecutionError) as error:
-        nbproject_test.execute_notebooks(notebook_path, print_outputs=True)
-    # print(error.exconly())
-    assert "UpdateContext" in error.exconly()
-
     # attempt re-saving - it works but the user needs to confirm overwriting
     # source code and run report
     process = subprocess.Popen(
@@ -159,16 +187,16 @@ print("my consecutive cell")
     assert "You are about to overwrite an existing report" in stdout
     assert process.returncode == 0
     # the source code is overwritten with the edits, reflected in a new hash
-    transform = ln.Transform.get("hlsFXswrJjtt0000")
+    transform = ln.Transform.get("hlsFXswrJjtt0001")
     assert transform.latest_run.report.path.exists()
     assert transform.latest_run.report.path == transform.latest_run.report.path
-    assert transform.hash == "Jv0_TrZfzM-0erbp1FGdrQ"
+    assert transform.hash == "Ya5xuSTL7HVbE8MRogXiAQ"
     assert transform.latest_run.environment.path.exists()
 
     # get the the source code via command line
     result = subprocess.run(
         "yes | lamin load"
-        f" https://lamin.ai/{ln.setup.settings.user.handle}/laminci-unit-tests/transform/hlsFXswrJjtt0000",
+        f" https://lamin.ai/{ln.setup.settings.user.handle}/lamin-cli-unit-tests/transform/hlsFXswrJjtt0001",
         shell=True,
         capture_output=True,
     )
@@ -185,6 +213,74 @@ print("my consecutive cell")
     os.system(f"cp {notebook_path} {new_path}")
 
     # upon re-running it, the notebook name is updated
-    nbproject_test.execute_notebooks(new_path, print_outputs=True)
+    result = subprocess.run(
+        f"jupyter nbconvert --to notebook --inplace --execute {new_path}",
+        shell=True,
+        capture_output=True,
+        env=env,
+    )
+    print(result.stdout.decode())
+    assert result.returncode == 0
     transform = ln.Transform.get("hlsFXswrJjtt0001")
     assert "new_name.ipynb" in transform.key
+
+    # edit the notebook
+    nb = read_notebook(new_path)
+    nb.cells[-1]["source"] = ["ln.finish()"]
+    write_notebook(nb, new_path)
+
+    # run omitting the `--inplace` flag
+    result = subprocess.run(
+        f"jupyter nbconvert --to notebook --execute {new_path}",
+        shell=True,
+        capture_output=True,
+    )
+    print(result.stdout.decode())
+    assert (
+        "Please execute notebook 'nbconvert' by passing option '--inplace'."
+        in result.stderr.decode()
+    )
+    assert result.returncode == 1
+
+    result = subprocess.run(
+        f"jupyter nbconvert --to notebook --inplace --execute {new_path}",
+        shell=True,
+        capture_output=True,
+    )
+    assert result.returncode == 0
+    transform = ln.Transform.get("hlsFXswrJjtt")
+    assert "new_name.ipynb" in transform.key
+    assert (
+        transform.source_code
+        == """# %% [markdown]
+#
+
+# %%
+import lamindb as ln
+
+# %%
+# pass full uid, will be updated to stem uid during tests
+ln.track("hlsFXswrJjtt")
+
+# %%
+print("my consecutive cell")
+
+# %%
+ln.finish()
+"""
+    )
+    assert transform.latest_run.report is None
+    assert transform.latest_run.environment.path.exists()
+    result = subprocess.run(
+        f"lamin save {new_path}",
+        shell=True,
+        capture_output=True,
+    )
+    assert result.returncode == 0
+    assert transform.latest_run.report.path.exists()
+    assert (
+        "to save the notebook html, run: lamin save"
+        in transform.latest_run.report.path.read_text()
+    )
+    # for manual inspection
+    # os.system(f"cp {transform.latest_run.report.path} ./my_report.html")

{lamin_cli-1.3.0 → lamin_cli-1.4.1}/tests/core/test_save_r_code.py

@@ -55,7 +55,7 @@ def test_run_save_cache():
     # print(result.stdout.decode())
     # print(result.stderr.decode())
     assert result.returncode == 1
-    assert "Please export your" in result.stderr.decode()
+    assert "Please export your" in result.stdout.decode()
 
     filepath.with_suffix(".html").write_text("dummy html")
 

{lamin_cli-1.3.0 → lamin_cli-1.4.1}/tests/core/test_save_scripts.py

@@ -13,15 +13,18 @@ def test_save_without_uid():
     env["LAMIN_TESTING"] = "true"
     filepath = scripts_dir / "run-track-and-finish.py"
 
+    ln.Project(name="test_project").save()
+
     # attempt to save the script without it yet being run
     result = subprocess.run(
-        f"lamin save {filepath}",
+        f"lamin save {filepath} --project test_project",
         shell=True,
         capture_output=True,
     )
     # print(result.stdout.decode())
     assert result.returncode == 0
     assert "created Transform" in result.stdout.decode()
+    assert "labeled with project: test_project" in result.stdout.decode()
 
 
 def test_run_save_cache_with_git_and_uid():
@@ -35,9 +38,12 @@ def test_run_save_cache_with_git_and_uid():
         shell=True,
         capture_output=True,
     )
-    # print(result.stdout.decode())
-    assert result.returncode == 1
-    assert "Did you run `ln.track()`?" in result.stdout.decode()
+    assert result.returncode == 0
+    assert (
+        "mapped 'run-track-and-finish-sync-git.py' on uid 'm5uCHTTpJnjQ0000'"
+        in result.stdout.decode()
+    )
+    assert "created Transform('m5uCHTTpJnjQ0000')" in result.stdout.decode()
 
     # run the script
     result = subprocess.run(
@@ -48,7 +54,7 @@ def test_run_save_cache_with_git_and_uid():
     print(result.stdout.decode())
     print(result.stderr.decode())
     assert result.returncode == 0
-    assert "created Transform" in result.stdout.decode()
+    assert "loaded Transform" in result.stdout.decode()
     assert "m5uCHTTp" in result.stdout.decode()
     assert "started new Run" in result.stdout.decode()
 
@@ -178,10 +184,10 @@ if __name__ == "__main__":
     assert result.returncode == 1
     assert "already works on this draft" in result.stderr.decode()
 
-    # try to get the the source code via command line
+    # try to get the source code via command line
     result = subprocess.run(
         "yes | lamin load"
-        f" https://lamin.ai/{settings.user.handle}/laminci-unit-tests/transform/m5uCHTTpJnjQ0000",
+        f" https://lamin.ai/{settings.user.handle}/lamin-cli-unit-tests/transform/m5uCHTTpJnjQ0000",
         shell=True,
         capture_output=True,
     )

lamin_cli-1.4.1/tests/notebooks/with-title-and-initialized-consecutive.ipynb

@@ -0,0 +1,55 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "c4ea5bc1",
+   "metadata": {},
+   "source": [
+    "# My test notebook (consecutive)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "3ac1c25a",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import lamindb as ln"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "44bfcdec",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# pass full uid, will be updated to stem uid during tests\n",
+    "ln.track(\"hlsFXswrJjtt0000\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "c2c32e5a",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "print(\"my consecutive cell\")"
+   ]
+  }
+ ],
+ "metadata": {
+  "jupytext": {
+   "cell_metadata_filter": "-all",
+   "main_language": "python",
+   "notebook_metadata_filter": "-all"
+  },
+  "language_info": {
+   "name": "python"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

lamin_cli-1.3.0/lamin_cli/__init__.py

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

lamin_cli-1.3.0/lamin_cli/_save.py

@@ -1,185 +0,0 @@
-from __future__ import annotations
-
-import re
-import sys
-from pathlib import Path
-
-from lamin_utils import logger
-
-
-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'
-        )
-        uid_pattern = re.compile(r'\.context\.uid\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*\\["\']([^"\']+)\\["\']')
-    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
-    else:
-        raise SystemExit(
-            "Only .py, .ipynb, .R, .qmd, .Rmd files are supported for saving"
-            " transforms."
-        )
-
-    # Search for matches in the entire file content
-    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
-
-    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
-
-    return uid
-
-
-def save_from_filepath_cli(
-    filepath: str | Path,
-    key: str | None,
-    description: str | None,
-    stem_uid: str | None,
-    registry: str | None,
-) -> str | None:
-    import lamindb_setup as ln_setup
-
-    if not isinstance(filepath, Path):
-        filepath = Path(filepath)
-
-    # this will be gone once we get rid of lamin load or enable loading multiple
-    # instances sequentially
-    auto_connect_state = ln_setup.settings.auto_connect
-    ln_setup.settings.auto_connect = True
-
-    import lamindb as ln
-
-    if not ln.setup.core.django.IS_SETUP:
-        sys.exit(-1)
-    from lamindb._finish import save_context_core
-
-    ln_setup.settings.auto_connect = auto_connect_state
-
-    suffixes_transform = {
-        "py": {".py", ".ipynb"},
-        "R": {".R", ".qmd", ".Rmd"},
-    }
-
-    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 = (
-            "transform"
-            if filepath.suffix
-            in suffixes_transform["py"].union(suffixes_transform["R"])
-            else "artifact"
-        )
-
-    if registry == "artifact":
-        ln.settings.creation.artifact_silence_missing_run_warning = True
-        revises = None
-        if stem_uid is not None:
-            revises = (
-                ln.Artifact.filter(uid__startswith=stem_uid)
-                .order_by("-created_at")
-                .first()
-            )
-            if revises is None:
-                raise ln.errors.InvalidArgument("The stem uid is not found.")
-        elif key is None and description is None:
-            logger.error("Please pass a key or description via --key or --description")
-            return "missing-key-or-description"
-        artifact = ln.Artifact(
-            filepath, key=key, description=description, revises=revises
-        ).save()
-        logger.important(f"saved: {artifact}")
-        logger.important(f"storage path: {artifact.path}")
-        if ln_setup.settings.storage.type == "s3":
-            logger.important(f"storage url: {artifact.path.to_url()}")
-        if ln_setup.settings.instance.is_remote:
-            slug = ln_setup.settings.instance.slug
-            logger.important(f"go to: https://lamin.ai/{slug}/artifact/{artifact.uid}")
-        return None
-    elif registry == "transform":
-        with open(filepath) as file:
-            content = file.read()
-        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(
-                    f"Did not find uid '{uid}'"
-                    " in Transform registry. Did you run `ln.track()`?"
-                )
-                return "not-tracked-in-transform-registry"
-        else:
-            revises = None
-            if stem_uid is not None:
-                revises = (
-                    ln.Transform.filter(uid__startswith=stem_uid)
-                    .order_by("-created_at")
-                    .first()
-                )
-                if revises is None:
-                    raise ln.errors.InvalidArgument("The stem uid is not found.")
-            # TODO: build in the logic that queries for relative file paths
-            # we have in Context; add tests for multiple versions
-            transform = ln.Transform.filter(
-                key=filepath.name, is_latest=True
-            ).one_or_none()
-            if transform is None:
-                transform = ln.Transform(
-                    description=filepath.name,
-                    key=filepath.name,
-                    type="script" if filepath.suffix in {".R", ".py"} else "notebook",
-                    revises=revises,
-                ).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 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?"
-                " (y/n)"
-            )
-            if response != "y":
-                return "aborted-save-notebook-created-by-different-user"
-        if run is None and transform.key.endswith(".ipynb"):
-            run = ln.Run(transform=transform).save()
-            logger.important(
-                f"found no run, creating Run('{run.uid}') to display the html"
-            )
-        return_code = save_context_core(
-            run=run,
-            transform=transform,
-            filepath=filepath,
-            from_cli=True,
-        )
-        return return_code
-    else:
-        raise SystemExit("Allowed values for '--registry' are: 'artifact', 'transform'")

lamin_cli-1.3.0/tests/notebooks/with-title-and-initialized-consecutive.ipynb

@@ -1,191 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# My test notebook (consecutive)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 1,
-   "metadata": {
-    "execution": {
-     "iopub.execute_input": "2024-04-30T02:45:28.590279Z",
-     "iopub.status.busy": "2024-04-30T02:45:28.590128Z",
-     "iopub.status.idle": "2024-04-30T02:45:29.921019Z",
-     "shell.execute_reply": "2024-04-30T02:45:29.920739Z"
-    }
-   },
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "💡 connected lamindb: testuser1/laminci-unit-tests\n"
-     ]
-    }
-   ],
-   "source": [
-    "import lamindb as ln"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 2,
-   "metadata": {
-    "execution": {
-     "iopub.execute_input": "2024-04-30T02:45:29.923093Z",
-     "iopub.status.busy": "2024-04-30T02:45:29.922808Z",
-     "iopub.status.idle": "2024-04-30T02:45:32.189053Z",
-     "shell.execute_reply": "2024-04-30T02:45:32.188627Z"
-    }
-   },
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "💡 notebook imports: lamindb==0.71.0\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "💡 saved: Transform(uid='hlsFXswrJjtt5zKv', name='My test notebook (consecutive)', key='with-title-and-initialized-consecutive', version='1', type='notebook', updated_at=2024-04-30 02:45:31 UTC, created_by_id=1)\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "💡 saved: Run(uid='oX11QZyYk6dhucek9jNg', transform_id=1, created_by_id=1)\n"
-     ]
-    }
-   ],
-   "source": [
-    "ln.track(\"hlsFXswrJjtt0000\")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 3,
-   "metadata": {
-    "execution": {
-     "iopub.execute_input": "2024-04-30T02:45:32.191144Z",
-     "iopub.status.busy": "2024-04-30T02:45:32.191016Z",
-     "iopub.status.idle": "2024-04-30T02:45:32.193262Z",
-     "shell.execute_reply": "2024-04-30T02:45:32.192907Z"
-    }
-   },
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "my consecutive cell\n"
-     ]
-    }
-   ],
-   "source": [
-    "print(\"my consecutive cell\")"
-   ]
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "py39",
-   "language": "python",
-   "name": "python3"
-  },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 3
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.10.13"
-  },
-  "widgets": {
-   "application/vnd.jupyter.widget-state+json": {
-    "state": {
-     "31729cb39d074e8fb483120775f53731": {
-      "model_module": "ipylab",
-      "model_module_version": "^1.0.0",
-      "model_name": "SessionManagerModel",
-      "state": {
-       "_model_module": "ipylab",
-       "_model_module_version": "^1.0.0",
-       "_model_name": "SessionManagerModel",
-       "_view_count": null,
-       "_view_module": null,
-       "_view_module_version": "",
-       "_view_name": null,
-       "current_session": {},
-       "sessions": []
-      }
-     },
-     "6939d8a17fbb46b8877f987b20b56757": {
-      "model_module": "ipylab",
-      "model_module_version": "^1.0.0",
-      "model_name": "CommandRegistryModel",
-      "state": {
-       "_command_list": [],
-       "_commands": [],
-       "_model_module": "ipylab",
-       "_model_module_version": "^1.0.0",
-       "_model_name": "CommandRegistryModel",
-       "_view_count": null,
-       "_view_module": null,
-       "_view_module_version": "",
-       "_view_name": null
-      }
-     },
-     "82c3ccb5d1114b968e80e1605d528742": {
-      "model_module": "ipylab",
-      "model_module_version": "^1.0.0",
-      "model_name": "JupyterFrontEndModel",
-      "state": {
-       "_model_module": "ipylab",
-       "_model_module_version": "^1.0.0",
-       "_model_name": "JupyterFrontEndModel",
-       "_view_count": null,
-       "_view_module": null,
-       "_view_module_version": "",
-       "_view_name": null,
-       "commands": "IPY_MODEL_6939d8a17fbb46b8877f987b20b56757",
-       "sessions": "IPY_MODEL_31729cb39d074e8fb483120775f53731",
-       "shell": "IPY_MODEL_9f239e52e3794df9b2c06052072cad24",
-       "version": ""
-      }
-     },
-     "9f239e52e3794df9b2c06052072cad24": {
-      "model_module": "ipylab",
-      "model_module_version": "^1.0.0",
-      "model_name": "ShellModel",
-      "state": {
-       "_model_module": "ipylab",
-       "_model_module_version": "^1.0.0",
-       "_model_name": "ShellModel",
-       "_view_count": null,
-       "_view_module": null,
-       "_view_module_version": "",
-       "_view_name": null,
-       "_widgets": []
-      }
-     }
-    },
-    "version_major": 2,
-    "version_minor": 0
-   }
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 2
-}