lamin_cli 0.17.6__tar.gz → 0.17.8__tar.gz

{lamin_cli-0.17.6 → lamin_cli-0.17.8}/PKG-INFO

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

lamin_cli-0.17.8/lamin_cli/__init__.py

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

{lamin_cli-0.17.6 → lamin_cli-0.17.8}/lamin_cli/__main__.py

@@ -35,26 +35,28 @@ else:
     COMMAND_GROUPS = {
         "lamin": [
             {
-                "name": "Main commands",
+                "name": "Connect to an instance",
                 "commands": [
-                    "login",
-                    "init",
-                    "load",
+                    "connect",
+                    "disconnect",
                     "info",
-                    "delete",
+                    "init",
                 ],
             },
             {
-                "name": "Data commands",
-                "commands": ["get", "save"],
+                "name": "Read & write data",
+                "commands": ["load", "save", "get", "delete"],
             },
             {
-                "name": "Configuration commands",
-                "commands": ["cache", "set"],
+                "name": "Configure",
+                "commands": ["cache", "settings", "migrate"],
             },
             {
-                "name": "Schema migration",
-                "commands": ["migrate"],
+                "name": "Auth",
+                "commands": [
+                    "login",
+                    "logout",
+                ],
             },
         ]
     }
@@ -63,7 +65,7 @@ else:
         @click.rich_config(
             help_config=click.RichHelpConfiguration(
                 command_groups=COMMAND_GROUPS,
-                style_commands_table_column_width_ratio=(1, 13),
+                style_commands_table_column_width_ratio=(1, 10),
             )
         )
         @click.group()
@@ -77,6 +79,7 @@ else:
 from click import Command, Context
 from lamindb_setup._silence_loggers import silence_loggers
 
+from lamin_cli._settings import settings
 from lamin_cli._cache import cache
 from lamin_cli._migration import migrate
 
@@ -96,44 +99,34 @@ def main():
 @main.command()
 @click.argument("user", type=str, default=None, required=False)
 @click.option("--key", type=str, default=None, help="The API key.")
-@click.option("--logout", is_flag=True, help="Logout instead of logging in.")
-def login(user: str, key: Optional[str], logout: bool = False):
+def login(user: str, key: Optional[str]):
     """Log into LaminHub.
 
-    Upon logging in the first time, you need to pass your API key via:
-
-    ```
-    lamin login myemail@acme.com --key YOUR_API_KEY
-    ```
-
-    You'll find your API key on LaminHub in the top right corner under "Settings".
-
-    After this, you can either use `lamin login myhandle` or `lamin login myemail@acme.com`
+    `lamin login` prompts for your API key unless you set it via environment variable `LAMIN_API_KEY`.
 
-    You can also call this without arguments:
-
-    ```
-    lamin login
-    ```
+    You find your API key in your account settings on LaminHub (top right corner).
 
-    You will be prompted for your Beta API key unless you set an environment variable `LAMIN_API_KEY`.
+    After authenticating once, you can re-authenticate and switch between accounts via `lamin login myhandle`.
     """
-    if logout:
-        from lamindb_setup._setup_user import logout as logout_func
+    from lamindb_setup._setup_user import login as login_
 
-        return logout_func()
+    if user is None:
+        if "LAMIN_API_KEY" in os.environ:
+            api_key = os.environ["LAMIN_API_KEY"]
+        else:
+            api_key = input("Your API key: ")
     else:
-        from lamindb_setup._setup_user import login
+        api_key = None
 
-        if user is None:
-            if "LAMIN_API_KEY" in os.environ:
-                api_key = os.environ["LAMIN_API_KEY"]
-            else:
-                api_key = input("Your API key: ")
-        else:
-            api_key = None
+    return login_(user, key=key, api_key=api_key)
 
-        return login(user, key=key, api_key=api_key)
+
+@main.command()
+def logout():
+    """Log out of LaminHub."""
+    from lamindb_setup import logout as logout_
+
+    return logout_()
 
 
 # fmt: off
@@ -144,7 +137,7 @@ def login(user: str, key: Optional[str], logout: bool = False):
 @click.option("--name", type=str, default=None, help="The instance name.")
 # fmt: on
 def init(storage: str, db: Optional[str], schema: Optional[str], name: Optional[str]):
-    """Init a LaminDB instance."""
+    """Init an instance."""
     from lamindb_setup._init_instance import init as init_
 
     return init_(storage=storage, db=db, schema=schema, name=name)
@@ -152,26 +145,32 @@ def init(storage: str, db: Optional[str], schema: Optional[str], name: Optional[
 
 # fmt: off
 @main.command()
-@click.argument("instance", type=str, default=None, required=False)
-@click.option("--unload", is_flag=True, help="Unload the current instance.")
+@click.argument("instance", type=str)
 # fmt: on
-def load(instance: Optional[str], unload: bool):
-    """Load an instance for auto-connection.
+def connect(instance: str):
+    """Connect to an instance.
+
+    Pass a slug (`account/name`) or URL (`https://lamin.ai/account/name`).
 
-    Pass a slug (`account/name`) or URL
-    (`https://lamin.ai/account/name`).
+    `lamin connect` switches
+    {attr}`~lamindb.setup.core.SetupSettings.auto_connect` to `True` so that you
+    auto-connect in a Python session upon importing `lamindb`.
     """
-    if unload:
-        from lamindb_setup._close import close as close_
+    from lamindb_setup import settings as settings_, connect as connect_
 
-        return close_()
-    else:
-        if instance is None:
-            raise click.UsageError("INSTANCE is required when loading an instance.")
-        from lamindb_setup import settings, connect
+    settings_.auto_connect = True
+    return connect_(slug=instance)
 
-        settings.auto_connect = True
-        return connect(slug=instance)
+
+@main.command()
+def disconnect():
+    """Disconnect from an instance.
+
+    Is the opposite of connecting to an instance.
+    """
+    from lamindb_setup import close as close_
+
+    return close_()
 
 
 @main.command()
@@ -181,12 +180,12 @@ def info(schema: bool):
     if schema:
         from lamindb_setup._schema import view
 
-        print("Open in browser: http://127.0.0.1:8000/schema/")
+        click.echo("Open in browser: http://127.0.0.1:8000/schema/")
         return view()
     else:
-        import lamindb_setup
+        from lamindb_setup import settings as settings_
 
-        print(lamindb_setup.settings)
+        click.echo(settings_)
 
 
 # fmt: off
@@ -195,7 +194,10 @@ def info(schema: bool):
 @click.option("--force", is_flag=True, default=False, help="Do not ask for confirmation.")  # noqa: E501
 # fmt: on
 def delete(instance: str, force: bool = False):
-    """Delete an instance."""
+    """Delete an entity.
+
+    Currently only supports instance deletion.
+    """
     from lamindb_setup._delete import delete
 
     return delete(instance, force=force)
@@ -208,23 +210,52 @@ def delete(instance: str, force: bool = False):
 @click.option(
     "--with-env", is_flag=True, help="Also return the environment for a tranform."
 )
-def get(entity: str, uid: str = None, key: str = None, with_env: bool = False):
-    """Query an entity.
+def load(entity: str, uid: str = None, key: str = None, with_env: bool = False):
+    """Load a file or folder.
 
     Pass a URL, `artifact`, or `transform`. For example:
 
     ```
-    lamin get https://lamin.ai/account/instance/artifact/e2G7k9EVul4JbfsEYAy5
-    lamin get artifact --key mydatasets/mytable.parquet
-    lamin get artifact --uid e2G7k9EVul4JbfsEYAy5
-    lamin get transform --key analysis.ipynb
-    lamin get transform --uid Vul4JbfsEYAy5
-    lamin get transform --uid Vul4JbfsEYAy5 --with-env
+    lamin load https://lamin.ai/account/instance/artifact/e2G7k9EVul4JbfsEYAy5
+    lamin load artifact --key mydatasets/mytable.parquet
+    lamin load artifact --uid e2G7k9EVul4JbfsEYAy5
+    lamin load transform --key analysis.ipynb
+    lamin load transform --uid Vul4JbfsEYAy5
+    lamin load transform --uid Vul4JbfsEYAy5 --with-env
     ```
     """
-    from lamin_cli._get import get
+    is_slug = entity.count("/") == 1
+    if is_slug:
+        from lamindb_setup import settings as settings_, connect
+
+        # can decide whether we want to actually deprecate
+        # click.echo(
+        #     f"! please use: lamin connect {entity}"
+        # )
+        settings_.auto_connect = True
+        return connect(slug=entity)
+    else:
+        from lamin_cli._load import load as load_
 
-    return get(entity, uid=uid, key=key, with_env=with_env)
+        return load_(entity, uid=uid, key=key, with_env=with_env)
+
+
+@main.command()
+@click.argument("entity", type=str)
+@click.option("--uid", help="The uid for the entity.")
+@click.option("--key", help="The key for the entity.")
+@click.option(
+    "--with-env", is_flag=True, help="Also return the environment for a tranform."
+)
+def get(entity: str, uid: str = None, key: str = None, with_env: bool = False):
+    """Query metadata about an entity.
+
+    Currently only works for artifact & transform and behaves like `lamin load`.
+    """
+    from lamin_cli._load import load as load_
+
+    click.echo(f"! to load a file or folder, please use: lamin load {entity}")
+    return load_(entity, uid=uid, key=key, with_env=with_env)
 
 
 @main.command()
@@ -235,36 +266,22 @@ def get(entity: str, uid: str = None, key: str = None, with_env: bool = False):
 @click.option("--description", type=str, default=None)
 @click.option("--registry", type=str, default=None)
 def save(filepath: str, key: str, description: str, registry: str):
-    """Save file or folder."""
+    """Save a file or folder.
+
+    Defaults to saving `.py` and `.ipynb` as :class:`~lamindb.Transform` and
+    other file types and folders as :class:`~lamindb.Artifact`.
+
+    You can save a `.py` or `.ipynb` file as an :class:`~lamindb.Artifact` by
+    passing `--registry artifact`.
+    """
     from lamin_cli._save import save_from_filepath_cli
 
     if save_from_filepath_cli(filepath, key, description, registry) is not None:
         sys.exit(1)
 
 
+main.add_command(settings)
 main.add_command(cache)
-
-
-@main.command(name="set")
-@click.argument(
-    "setting",
-    type=click.Choice(["auto-connect", "private-django-api"], case_sensitive=False),
-)
-@click.argument("value", type=click.BOOL)
-def set_(setting: str, value: bool):
-    """Update settings.
-
-    - `auto-connect` → {attr}`~lamindb.setup.core.SetupSettings.auto_connect`
-    - `private-django-api` → {attr}`~lamindb.setup.core.SetupSettings.private_django_api`
-    """
-    from lamindb_setup import settings
-
-    if setting == "auto-connect":
-        settings.auto_connect = value
-    if setting == "private-django-api":
-        settings.private_django_api = value
-
-
 main.add_command(migrate)
 
 

lamin_cli-0.17.8/lamin_cli/_load.py

@@ -0,0 +1,110 @@
+from __future__ import annotations
+from typing import Tuple
+from lamin_utils import logger
+from pathlib import Path
+
+
+def decompose_url(url: str) -> Tuple[str, str, str]:
+    assert "transform" in url or "artifact" in url
+    for entity in ["transform", "artifact"]:
+        if entity in url:
+            break
+    uid = url.split(f"{entity}/")[1]
+    instance_slug = "/".join(url.split("/")[3:5])
+    return instance_slug, entity, uid
+
+
+def load(entity: str, uid: str = None, key: str = None, with_env: bool = False):
+    import lamindb_setup as ln_setup
+
+    if entity.startswith("https://") and "lamin" in entity:
+        url = entity
+        instance, entity, uid = decompose_url(url)
+    elif entity not in {"artifact", "transform"}:
+        raise SystemExit("Entity has to be a laminhub URL or 'artifact' or 'transform'")
+    else:
+        instance = ln_setup.settings.instance.slug
+
+    ln_setup.connect(instance)
+    from lnschema_core import models as ln
+
+    def script_to_notebook(
+        transform: ln.Transform, notebook_path: Path, bump_revision: bool = False
+    ) -> None:
+        import jupytext
+        from lamin_utils._base62 import increment_base62
+
+        py_content = transform.source_code.replace(
+            "# # transform.name", f"# # {transform.name}"
+        )
+        if bump_revision:
+            uid = transform.uid
+            new_uid = f"{uid[:-4]}{increment_base62(uid[-4:])}"
+            py_content = py_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 entity == "transform":
+        transform = (
+            ln.Transform.objects.get(uid=uid)
+            if uid is not None
+            # if below, we take is_latest=True as the criterion, we might get draft notebooks
+            # hence, we use source_code__isnull=False and order by created_at instead
+            else ln.Transform.objects.filter(key=key, source_code__isnull=False)
+            .order_by("-created_at")
+            .first()
+        )
+        target_filename = transform.key
+        if Path(target_filename).exists():
+            response = input(f"! {target_filename} 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
+            filepath_cache.rename(target_filename)
+        elif transform.source_code is not None:
+            if transform.key.endswith(".ipynb"):
+                script_to_notebook(transform, target_filename, bump_revision=True)
+            else:
+                Path(target_filename).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
+
+            ln.settings.track_run_inputs = False
+            if (
+                transform.latest_run is not None
+                and transform.latest_run.environment is not None
+            ):
+                filepath_env_cache = transform.latest_run.environment.cache()
+                target_env_filename = (
+                    ".".join(target_filename.split(".")[:-1]) + "__requirements.txt"
+                )
+                filepath_env_cache.rename(target_env_filename)
+                logger.important(target_env_filename)
+            else:
+                logger.warning("latest transform run with environment doesn't exist")
+        return target_filename
+    elif entity == "artifact":
+        import lamindb as ln
+
+        ln.settings.track_run_inputs = False
+        artifact = (
+            ln.Artifact.get(uid)
+            if uid is not None
+            else ln.Artifact.filter(key=key, source_code__isnull=False)
+            .order_by("-created_at")
+            .first()
+        )
+        cache_path = artifact.cache()
+        logger.important(f"artifact is here: {cache_path}")
+        return cache_path

{lamin_cli-0.17.6 → lamin_cli-0.17.8}/lamin_cli/_migration.py

@@ -10,7 +10,7 @@ else:
 
 @click.group()
 def migrate():
-    """Manage migrations."""
+    """Manage metadata schema migrations."""
 
 
 @migrate.command("create")

{lamin_cli-0.17.6 → lamin_cli-0.17.8}/lamin_cli/_save.py

@@ -6,20 +6,20 @@ from lamin_utils import logger
 import re
 
 
-def get_stem_uid_and_version_from_file(
-    file_path: Path,
+def parse_uid_from_code(
+    content: str, suffix: str
 ) -> tuple[str | None, str | None, str | None]:
-    # line-by-line matching might be faster, but let's go with this for now
-    with open(file_path) as file:
-        content = file.read()
-
-    if file_path.suffix == ".py":
+    if suffix == ".py":
+        track_pattern = re.compile(r'ln\.track\(\s*(?:uid\s*=\s*)?["\']([^"\']+)["\']')
         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 file_path.suffix == ".ipynb":
+    elif suffix == ".ipynb":
+        track_pattern = re.compile(
+            r'ln\.track\(\s*(?:uid\s*=\s*)?\\["\']([^"\']+)\\["\']'
+        )
         uid_pattern = re.compile(r'\.context\.uid\s*=\s*\\["\']([^"\']+)\\["\']')
         stem_uid_pattern = re.compile(
             r'\.transform\.stem_uid\s*=\s*\\["\']([^"\']+)\\["\']'
@@ -31,7 +31,10 @@ def get_stem_uid_and_version_from_file(
         raise ValueError("Only .py and .ipynb files are supported.")
 
     # Search for matches in the entire file content
-    uid_match = uid_pattern.search(content)
+    uid_match = track_pattern.search(content)
+    uid = uid_match.group(1) if uid_match else None
+    if uid is None:
+        uid_match = uid_pattern.search(content)
     stem_uid_match = stem_uid_pattern.search(content)
     version_match = version_pattern.search(content)
 
@@ -42,8 +45,8 @@ def get_stem_uid_and_version_from_file(
 
     if uid is None and (stem_uid is None or version is None):
         raise SystemExit(
-            "ln.context.uid isn't"
-            f" set in {file_path}\nCall ln.context.track() and copy/paste the output"
+            "Cannot infer transform uid."
+            "\nCall `ln.track()` and copy/paste the output"
             " into the notebook"
         )
     return uid, stem_uid, version
@@ -86,20 +89,20 @@ def save_from_filepath_cli(
             logger.important(f"go to: https://lamin.ai/{slug}/artifact/{artifact.uid}")
         return None
     elif registry == "transform":
-        # consider notebooks & scripts a transform
-        uid, stem_uid, transform_version = get_stem_uid_and_version_from_file(filepath)
+        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}'")
         if uid is not None:
             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.context.track()?"
+                    " in Transform registry. Did you run `ln.track()`?"
                 )
                 return "not-tracked-in-transform-registry"
         else:
-            transform = ln.Transform.get(
-                uid__startswith=stem_uid, version=transform_version
-            )
+            transform = ln.Transform.get(uid__startswith=stem_uid, version=version)
         # 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:

lamin_cli-0.17.8/lamin_cli/_settings.py

@@ -0,0 +1,41 @@
+from __future__ import annotations
+import os
+
+if os.environ.get("NO_RICH"):
+    import click as click
+else:
+    import rich_click as click
+
+
+@click.group(invoke_without_command=True)
+@click.pass_context
+def settings(ctx):
+    """Manage settings.
+
+    Call without subcommands and options to show settings.
+    """
+    if ctx.invoked_subcommand is None:
+        from lamindb_setup import settings as settings_
+
+        click.echo("Configure: see `lamin settings --help`")
+        click.echo(settings_)
+
+
+@settings.command("set")
+@click.argument(
+    "setting",
+    type=click.Choice(["auto-connect", "private-django-api"], case_sensitive=False),
+)
+@click.argument("value", type=click.BOOL)
+def set(setting: str, value: bool):
+    """Update settings.
+
+    - `auto-connect` → {attr}`~lamindb.setup.core.SetupSettings.auto_connect`
+    - `private-django-api` → {attr}`~lamindb.setup.core.SetupSettings.private_django_api`
+    """
+    from lamindb_setup import settings as settings_
+
+    if setting == "auto-connect":
+        settings_.auto_connect = value
+    if setting == "private-django-api":
+        settings_.private_django_api = value

{lamin_cli-0.17.6 → lamin_cli-0.17.8}/tests/notebooks/with-title-and-initialized-consecutive.ipynb

@@ -66,8 +66,7 @@
     }
    ],
    "source": [
-    "ln.context.uid = \"hlsFXswrJjtt0000\"\n",
-    "ln.context.track()"
+    "ln.track(\"hlsFXswrJjtt0000\")"
    ]
   },
   {

{lamin_cli-0.17.6 → lamin_cli-0.17.8}/tests/notebooks/with-title-and-initialized-non-consecutive.ipynb

@@ -67,7 +67,7 @@
       "source": [
         "ln.settings.transform.stem_uid = \"HDMGkxN9rgFA\"\n",
         "ln.settings.transform.version = \"1\"\n",
-        "ln.context.track()"
+        "ln.track()"
       ]
     }
   ],

{lamin_cli-0.17.6 → lamin_cli-0.17.8}/tests/scripts/run-track-and-finish-sync-git.py

@@ -1,15 +1,15 @@
 import lamindb as ln
 
 ln.settings.sync_git_repo = "https://github.com/laminlabs/lamin-cli"
-ln.context.uid = "m5uCHTTpJnjQ0000"
 ln.context.name = "My good script"
+ln.track("m5uCHTTpJnjQ0000")
 
 
 if __name__ == "__main__":
     # we're using new_run here to mock the notebook situation
     # and cover the look up of an existing run in the tests
     # new_run = True is trivial
-    ln.context.track(new_run=False)
+    ln.track(new_run=False)
 
     print("hello!")
 

{lamin_cli-0.17.6 → lamin_cli-0.17.8}/tests/scripts/run-track-and-finish.py

@@ -1,13 +1,14 @@
 import lamindb as ln
 
-ln.context.uid = "VFYCIuaw2GsX0000"
 ln.context.name = "My good script 2"
+ln.track("VFYCIuaw2GsX0000")
+
 
 if __name__ == "__main__":
     # we're using new_run here to mock the notebook situation
     # and cover the look up of an existing run in the tests
     # new_run = True is trivial
-    ln.context.track(new_run=False)
+    ln.track(new_run=False)
 
     print("hello!")
 

lamin_cli-0.17.8/tests/scripts/run-track-with-params.py

@@ -0,0 +1,21 @@
+import argparse
+import lamindb as ln
+
+if __name__ == "__main__":
+    p = argparse.ArgumentParser()
+    p.add_argument("--dataset-key", type=str)
+    p.add_argument("--downsample", action="store_true")
+    p.add_argument("--learning-rate", type=float)
+    args = p.parse_args()
+
+    params = {
+        "dataset_key": args.dataset_key,
+        "learning_rate": args.learning_rate,
+        "downsample": args.downsample,
+    }
+
+    ln.track("JjRF4mACd9m00000", params=params)
+
+    # actual code
+
+    ln.finish()

lamin_cli-0.17.6/tests/test_get.py → lamin_cli-0.17.8/tests/test_load.py

@@ -1,19 +1,23 @@
-from lamin_cli._get import decompose_url
+from lamin_cli._load import decompose_url
 import subprocess
 
 
 def test_decompose_url():
-    url = "https://lamin.ai/laminlabs/arrayloader-benchmarks/transform/1GCKs8zLtkc85zKv"  # noqa
-    result = decompose_url(url)
-    instance_slug, entity, uid = result
-    assert instance_slug == "laminlabs/arrayloader-benchmarks"
-    assert entity == "transform"
-    assert uid == "1GCKs8zLtkc85zKv"
+    urls = [
+        "https://lamin.ai/laminlabs/arrayloader-benchmarks/transform/1GCKs8zLtkc85zKv",  # noqa
+        "https://lamin.company.com/laminlabs/arrayloader-benchmarks/transform/1GCKs8zLtkc85zKv",  # noqa
+    ]
+    for url in urls:
+        result = decompose_url(url)
+        instance_slug, entity, uid = result
+        assert instance_slug == "laminlabs/arrayloader-benchmarks"
+        assert entity == "transform"
+        assert uid == "1GCKs8zLtkc85zKv"
 
 
 def test_get_transform():
     result = subprocess.run(
-        "lamin get"
+        "lamin load"
         " 'https://lamin.ai/laminlabs/arrayloader-benchmarks/transform/1GCKs8zLtkc85zKv'"
         " --with-env",  # noqa
         shell=True,
@@ -24,7 +28,7 @@ def test_get_transform():
 
 def test_get_artifact():
     result = subprocess.run(
-        "lamin get"
+        "lamin load"
         " 'https://lamin.ai/laminlabs/lamin-site-assets/artifact/e2G7k9EVul4JbfsEYAy5'",  # noqa
         shell=True,
         capture_output=True,

{lamin_cli-0.17.6 → lamin_cli-0.17.8}/tests/test_migrate.py

@@ -15,7 +15,9 @@ def test_migrate_deploy():
     import lamindb as ln
 
     instance_slug = ln.setup.settings.instance.slug
-    exit_status = os.system("lamin load testuser1/static-test-instance-private-sqlite")
+    exit_status = os.system(
+        "lamin connect testuser1/static-test-instance-private-sqlite"
+    )
     assert exit_status == 0
     exit_status = os.system("lamin migrate deploy")
     assert exit_status == 0
@@ -27,7 +29,7 @@ def test_migrate_deploy():
     # )
     # import lamindb
     # assert instance["lamindb_version"] == lamindb.__version__
-    exit_status = os.system(f"lamin load {instance_slug}")
+    exit_status = os.system(f"lamin connect {instance_slug}")
     assert exit_status == 0
 
 

{lamin_cli-0.17.6 → lamin_cli-0.17.8}/tests/test_save_notebooks.py

@@ -22,7 +22,7 @@ def test_save_not_initialized():
     )
     assert result.returncode == 1
     assert (
-        "Call ln.context.track() and copy/paste the output into the notebook"
+        "Call `ln.track()` and copy/paste the output into the notebook"
         in result.stderr.decode()
     )
 
@@ -70,7 +70,7 @@ def test_save_consecutive():
     transform = ln.Transform.filter(uid="hlsFXswrJjtt0000").one_or_none()
     assert transform is None
 
-    # let's try to save a notebook for which `ln.context.track()` was never run
+    # let's try to save a notebook for which `ln.track()` was never run
     result = subprocess.run(
         f"lamin save {notebook_path}",
         shell=True,
@@ -80,7 +80,7 @@ def test_save_consecutive():
     assert result.returncode == 1
     assert "Did not find uid 'hlsFXswrJjtt0000'" in result.stdout.decode()
 
-    # now, let's re-run this notebook so that ln.context.track() is actually run
+    # now, let's re-run this notebook so that `ln.track()` is actually run
     nbproject_test.execute_notebooks(notebook_path, print_outputs=True)
 
     # now, there is a transform record, but we're missing all artifacts
@@ -113,14 +113,13 @@ def test_save_consecutive():
 import lamindb as ln
 
 # %%
-ln.context.uid = "hlsFXswrJjtt0000"
-ln.context.track()
+ln.track("hlsFXswrJjtt0000")
 
 # %%
 print("my consecutive cell")
 """
     )
-    assert transform.hash == "fHpHnC_pScmOl3ZR8x5cTQ"
+    assert transform.hash == "OwVL-0-_gmk8heR3zV7BkA"
     # 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"
@@ -168,13 +167,13 @@ 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 == "b63gPnGqNWBE0G4G3pOghw"
+    assert transform.hash == "BhQpym0JfeypqhVMPlQ0ng"
     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 get"
+        "yes | lamin load"
         f" https://lamin.ai/{ln.setup.settings.user.handle}/laminci-unit-tests/transform/hlsFXswrJjtt0000",  # noqa
         shell=True,
         capture_output=True,

{lamin_cli-0.17.6 → lamin_cli-0.17.8}/tests/test_save_scripts.py

@@ -21,7 +21,7 @@ def test_run_save_cache():
     )
     # print(result.stdout.decode())
     assert result.returncode == 1
-    assert "Did you run ln.context.track()?" in result.stdout.decode()
+    assert "Did you run `ln.track()`?" in result.stdout.decode()
 
     # run the script
     result = subprocess.run(
@@ -33,11 +33,11 @@ def test_run_save_cache():
     # print(result.stderr.decode())
     assert result.returncode == 0
     assert "created Transform" in result.stdout.decode()
-    assert "m5uCHTTpJnjQ0000" in result.stdout.decode()
-    assert "created Run" in result.stdout.decode()
+    assert "m5uCHTTp" in result.stdout.decode()
+    assert "started new Run" in result.stdout.decode()
 
     transform = ln.Transform.get("m5uCHTTpJnjQ")
-    assert transform.hash == "Cwk0OPOyUH5nzTiU2ISlDQ"
+    assert transform.hash == "MoIciBQ0lpVPCKQGofPX6g"
     assert transform.latest_run.environment.path.exists()
     assert transform._source_code_artifact is None
 
@@ -52,8 +52,8 @@ def test_run_save_cache():
     # print(result.stderr.decode())
     assert result.returncode == 0
     assert "loaded Transform" in result.stdout.decode()
-    assert "m5uCHTTpJnjQ0000" in result.stdout.decode()
-    assert "loaded Run" 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
@@ -85,12 +85,13 @@ def test_run_save_cache():
     assert result.returncode == 1
     assert "Did not find blob hash" in result.stderr.decode()
 
-    # edit the script to remove the git integration
+    # edit the script to remove the git integration & ln.finish
     content = filepath.read_text()
     content_lines = content.split("\n")
     content_lines.remove(
         'ln.settings.sync_git_repo = "https://github.com/laminlabs/lamin-cli"'
     )
+    content_lines.remove("    ln.finish()")
     content = "\n".join(content_lines)
     filepath.write_text(content)
 
@@ -101,14 +102,51 @@ def test_run_save_cache():
         capture_output=True,
         env=env,
     )
-    print(result.stdout.decode())
-    print(result.stderr.decode())
+    # print(result.stdout.decode())
+    # print(result.stderr.decode())
     assert result.returncode == 1
     assert "Source code changed, bump revision by setting" in result.stderr.decode()
 
+    # update the uid
+    content = filepath.read_text()
+    filepath.write_text(content.replace("m5uCHTTpJnjQ0000", "m5uCHTTpJnjQ0001"))
+
+    # re-run the script that lacks ln.finish(), hence doesn't yet save source code
+    result = subprocess.run(
+        f"python {filepath}",
+        shell=True,
+        capture_output=True,
+        env=env,
+    )
+    # print(result.stdout.decode())
+    # print(result.stderr.decode())
+    assert result.returncode == 0
+    assert "created Transform(" in result.stdout.decode()
+    assert "started new Run(" in result.stdout.decode()
+
+    # login a different user
+    assert ln.setup.settings.user.handle != "testuser2"
+    result = subprocess.run(
+        "lamin login testuser2",
+        shell=True,
+        capture_output=True,
+        env=env,
+    )
+    # re-run the script through the second user
+    result = subprocess.run(
+        f"python {filepath}",
+        shell=True,
+        capture_output=True,
+        env=env,
+    )
+    # print(result.stdout.decode())
+    # print(result.stderr.decode())
+    assert result.returncode == 1
+    assert "already works on this draft" in result.stderr.decode()
+
     # try to get the the source code via command line
     result = subprocess.run(
-        "lamin get"
+        "yes | lamin load"
         f" https://lamin.ai/{settings.user.handle}/laminci-unit-tests/transform/m5uCHTTpJnjQ0000",  # noqa
         shell=True,
         capture_output=True,
@@ -117,7 +155,7 @@ def test_run_save_cache():
     assert result.returncode == 0
 
     result = subprocess.run(
-        f"lamin get transform --key {filepath.name}",  # noqa
+        f"yes | lamin load transform --key {filepath.name}",  # noqa
         shell=True,
         capture_output=True,
     )
@@ -125,9 +163,48 @@ def test_run_save_cache():
     assert result.returncode == 0
 
     result = subprocess.run(
-        f"lamin get transform --uid m5uCHTTpJnjQ0000",  # noqa
+        f"yes | lamin load transform --uid m5uCHTTpJnjQ0000",  # noqa
         shell=True,
         capture_output=True,
     )
     print(result.stderr.decode())
     assert result.returncode == 0
+
+
+def test_run_save_with_params():
+    env = os.environ
+    env["LAMIN_TESTING"] = "true"
+    filepath = scripts_dir / "run-track-with-params.py"
+
+    # define params
+    ln.Param(name="dataset_key", dtype="str").save()
+    ln.Param(name="learning_rate", dtype="float").save()
+    ln.Param(name="downsample", dtype="bool").save()
+
+    # run the script
+    result = subprocess.run(
+        f"python {filepath} --dataset-key mydata --learning-rate 0.01 --downsample",
+        shell=True,
+        capture_output=True,
+    )
+    print(result.stdout.decode())
+    print(result.stderr.decode())
+    assert result.returncode == 0
+    assert "created Transform" in result.stdout.decode()
+    assert "JjRF4mAC" in result.stdout.decode()
+    assert "started new Run" in result.stdout.decode()
+
+    # you can re-save the script
+    result = subprocess.run(
+        f"lamin save {filepath}",
+        shell=True,
+        capture_output=True,
+        env=env,
+    )
+    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.17.6/lamin_cli/__init__.py

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

lamin_cli-0.17.6/lamin_cli/_get.py

@@ -1,82 +0,0 @@
-from __future__ import annotations
-from typing import Tuple
-from lamin_utils import logger
-import lamindb_setup as ln_setup
-from pathlib import Path
-
-
-def decompose_url(url: str) -> Tuple[str, str, str]:
-    assert "transform" in url or "artifact" in url
-    for entity in ["transform", "artifact"]:
-        if entity in url:
-            break
-    uid = url.split(f"{entity}/")[1]
-    instance_slug = "/".join(url.replace("https://lamin.ai/", "").split("/")[:2])
-    return instance_slug, entity, uid
-
-
-def get(entity: str, uid: str = None, key: str = None, with_env: bool = False):
-    if entity.startswith("https://lamin.ai"):
-        url = entity
-        instance_slug, entity, uid = decompose_url(url)
-    elif entity not in {"artifact", "transform"}:
-        raise ValueError(
-            "entity has to be a URL starting with https://lamin.ai or 'artifact' or"
-            " 'transform'"
-        )
-    else:
-        instance_slug = None
-
-    if instance_slug is not None:
-        auto_connect = ln_setup.settings.auto_connect
-        # we don't want to auto-connect when importing lamindb
-        ln_setup.settings.auto_connect = False
-
-        import lamindb as ln
-        from lamindb._finish import script_to_notebook
-
-        ln_setup.settings.auto_connect = auto_connect
-        ln.connect(instance_slug)
-    else:
-        import lamindb as ln
-        from lamindb._finish import script_to_notebook
-
-    # below is to silence warnings about missing run inputs
-    ln.settings.track_run_inputs = False
-
-    if entity == "transform":
-        transform = (
-            ln.Transform.get(uid) if uid is not None else ln.Transform.get(key=key)
-        )
-        target_filename = transform.key
-        if transform._source_code_artifact_id is not None:
-            # backward compat
-            filepath_cache = transform._source_code_artifact.cache()
-            if not target_filename.endswith(transform._source_code_artifact.suffix):
-                target_filename += transform._source_code_artifact.suffix
-            filepath_cache.rename(target_filename)
-        elif transform.source_code is not None:
-            if transform.key.endswith(".ipynb"):
-                script_to_notebook(transform, target_filename)
-            else:
-                Path(target_filename).write_text(transform.source_code)
-        else:
-            raise ValueError("No source code available for this transform.")
-        logger.important(target_filename)
-        if with_env:
-            if (
-                transform.latest_run is not None
-                and transform.latest_run.environment is not None
-            ):
-                filepath_env_cache = transform.latest_run.environment.cache()
-                target_env_filename = (
-                    ".".join(target_filename.split(".")[:-1]) + "__requirements.txt"
-                )
-                filepath_env_cache.rename(target_env_filename)
-                logger.important(target_env_filename)
-            else:
-                logger.warning("latest transform run with environment doesn't exist")
-    elif entity == "artifact":
-        artifact = ln.Artifact.get(uid) if uid is not None else ln.Artifact.get(key=key)
-        cache_path = artifact.cache()
-        logger.important(cache_path)