lamin_cli 0.17.6__py2.py3-none-any.whl → 0.17.7__py2.py3-none-any.whl

lamin_cli/__init__.py

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

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/_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/_migration.py

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

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/_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.dist-info → lamin_cli-0.17.7.dist-info}/METADATA

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

lamin_cli-0.17.7.dist-info/RECORD

@@ -0,0 +1,12 @@
+lamin_cli/__init__.py,sha256=7lQuTta1nc-cmxhBP-lwuNItIDyamNoyfWWvnzL1HWg,41
+lamin_cli/__main__.py,sha256=_7d8PPnNKWdBHF-5jVCHKIqF6HkeXpvTJz3yNcvvnsc,9706
+lamin_cli/_cache.py,sha256=6LrrWNrdZzH_BrohQ2n24xLFhUQ5EFan1bnzqMX_mIg,812
+lamin_cli/_load.py,sha256=Ow34O5wK8i3Zg1q6K-bQXrCaanWf8GoeeXZTCWWZXJQ,4464
+lamin_cli/_migration.py,sha256=xTbad6aDUwuK0QvWCmDW3f8-xaqwisS-Cqf-LbD1WRI,1071
+lamin_cli/_save.py,sha256=KpGB1ZeKyE0Of0PkCX8j2UPtj4FQPS5wwKIYUFkTeio,4962
+lamin_cli/_settings.py,sha256=iS37mcQUHKRWxi2sHnAojEI6sWk3w232qwG-GeY2_Qc,1141
+lamin_cli-0.17.7.dist-info/entry_points.txt,sha256=Qms85i9cZPlu-U7RnVZhFsF7vJ9gaLZUFkCjcGcXTpg,49
+lamin_cli-0.17.7.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+lamin_cli-0.17.7.dist-info/WHEEL,sha256=Sgu64hAMa6g5FdzHxXv9Xdse9yxpGGMeagVtPMWpJQY,99
+lamin_cli-0.17.7.dist-info/METADATA,sha256=YjKsY2CBMUlg7EArBS9zzWB6h44Fyul1Vl68ma2bZ5I,336
+lamin_cli-0.17.7.dist-info/RECORD,,

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)

lamin_cli-0.17.6.dist-info/RECORD

@@ -1,11 +0,0 @@
-lamin_cli/__init__.py,sha256=NsLSTY60JMWUwHA302KuRXtvwrdZXYfftnkxK5L7Ntw,41
-lamin_cli/__main__.py,sha256=sJXjBotegrk_xl5gY0-z_2dZhi8TKbC4RabVvD9LS8A,9121
-lamin_cli/_cache.py,sha256=6LrrWNrdZzH_BrohQ2n24xLFhUQ5EFan1bnzqMX_mIg,812
-lamin_cli/_get.py,sha256=2LVNPxpjE0Gz-xIm6Sf9uwHLND66XpE5dg0Phu3Kgmc,3254
-lamin_cli/_migration.py,sha256=dULOvbpJ4VBiXuxPAM8jFGnBkh7pQGqE5eP-UC6uxWc,1055
-lamin_cli/_save.py,sha256=Ze_ztLSzib12-xvwM6QL2Z6UAN33n-DFrJDZg-t7nDU,4795
-lamin_cli-0.17.6.dist-info/entry_points.txt,sha256=Qms85i9cZPlu-U7RnVZhFsF7vJ9gaLZUFkCjcGcXTpg,49
-lamin_cli-0.17.6.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-lamin_cli-0.17.6.dist-info/WHEEL,sha256=Sgu64hAMa6g5FdzHxXv9Xdse9yxpGGMeagVtPMWpJQY,99
-lamin_cli-0.17.6.dist-info/METADATA,sha256=8mmKSv7wuqXP4MSOf3DvnPqGt-IAUpHRmWLNJAGzPvM,336
-lamin_cli-0.17.6.dist-info/RECORD,,