lamin_cli 0.17.3__py2.py3-none-any.whl → 0.17.4__py2.py3-none-any.whl

lamin_cli/_get.py

@@ -1,82 +1,82 @@
-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)
+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/_migration.py

@@ -1,48 +1,48 @@
-from __future__ import annotations
-import os
-from typing import Optional
-
-if os.environ.get("NO_RICH"):
-    import click as click
-else:
-    import rich_click as click
-
-
-@click.group()
-def migrate():
-    """Manage migrations."""
-
-
-@migrate.command("create")
-def create():
-    """Create a new migration."""
-    from lamindb_setup._migrate import migrate
-
-    return migrate.create()
-
-
-@migrate.command("deploy")
-def deploy():
-    """Deploy migrations."""
-    from lamindb_setup._migrate import migrate
-
-    return migrate.deploy()
-
-
-@migrate.command("squash")
-@click.option("--package-name", type=str, default=None)
-@click.option("--end-number", type=str, default=None)
-@click.option("--start-number", type=str, default=None)
-def squash(
-    package_name: Optional[str],
-    end_number: Optional[str],
-    start_number: Optional[str],
-):
-    """Squash migrations."""
-    from lamindb_setup._migrate import migrate
-
-    return migrate.squash(
-        package_name=package_name,
-        migration_nr=end_number,
-        start_migration_nr=start_number,
-    )
+from __future__ import annotations
+import os
+from typing import Optional
+
+if os.environ.get("NO_RICH"):
+    import click as click
+else:
+    import rich_click as click
+
+
+@click.group()
+def migrate():
+    """Manage migrations."""
+
+
+@migrate.command("create")
+def create():
+    """Create a new migration."""
+    from lamindb_setup._migrate import migrate
+
+    return migrate.create()
+
+
+@migrate.command("deploy")
+def deploy():
+    """Deploy migrations."""
+    from lamindb_setup._migrate import migrate
+
+    return migrate.deploy()
+
+
+@migrate.command("squash")
+@click.option("--package-name", type=str, default=None)
+@click.option("--end-number", type=str, default=None)
+@click.option("--start-number", type=str, default=None)
+def squash(
+    package_name: Optional[str],
+    end_number: Optional[str],
+    start_number: Optional[str],
+):
+    """Squash migrations."""
+    from lamindb_setup._migrate import migrate
+
+    return migrate.squash(
+        package_name=package_name,
+        migration_nr=end_number,
+        start_migration_nr=start_number,
+    )

lamin_cli/_save.py

@@ -1,111 +1,111 @@
-from __future__ import annotations
-from pathlib import Path
-from typing import Optional, Union
-import lamindb_setup as ln_setup
-from lamin_utils import logger
-import re
-
-
-def get_stem_uid_and_version_from_file(
-    file_path: Path,
-) -> 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":
-        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":
-        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*\\["\']([^"\']+)\\["\']'
-        )
-    else:
-        raise ValueError("Only .py and .ipynb files are supported.")
-
-    # Search for matches in the entire file content
-    uid_match = uid_pattern.search(content)
-    stem_uid_match = stem_uid_pattern.search(content)
-    version_match = version_pattern.search(content)
-
-    # Extract values if matches are found
-    uid = uid_match.group(1) if uid_match else None
-    stem_uid = stem_uid_match.group(1) if stem_uid_match else None
-    version = version_match.group(1) if version_match else None
-
-    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"
-            " into the notebook"
-        )
-    return uid, stem_uid, version
-
-
-def save_from_filepath_cli(
-    filepath: Union[str, Path], key: Optional[str], description: Optional[str]
-) -> Optional[str]:
-    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
-    from lamindb._finish import save_context_core
-
-    ln_setup.settings.auto_connect = auto_connect_state
-
-    if filepath.suffix not in {".py", ".ipynb"}:
-        if 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)
-        artifact.save()
-        slug = ln_setup.settings.instance.slug
-        logger.important(f"saved: {artifact}")
-        logger.important(f"storage path: {artifact.path}")
-        if ln_setup.settings.instance.is_remote:
-            logger.important(f"go to: https://lamin.ai/{slug}/artifact/{artifact.uid}")
-        if ln_setup.settings.storage.type == "s3":
-            logger.important(f"storage url: {artifact.path.to_url()}")
-        return None
-    else:
-        # consider notebooks & scripts a transform
-        uid, stem_uid, transform_version = get_stem_uid_and_version_from_file(filepath)
-        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()?"
-                )
-                return "not-tracked-in-transform-registry"
-        else:
-            transform = ln.Transform.get(
-                uid__startswith=stem_uid, version=transform_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:
-            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"
-        return save_context_core(
-            run=run,
-            transform=transform,
-            filepath=filepath,
-            from_cli=True,
-        )
+from __future__ import annotations
+from pathlib import Path
+from typing import Optional, Union
+import lamindb_setup as ln_setup
+from lamin_utils import logger
+import re
+
+
+def get_stem_uid_and_version_from_file(
+    file_path: Path,
+) -> 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":
+        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":
+        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*\\["\']([^"\']+)\\["\']'
+        )
+    else:
+        raise ValueError("Only .py and .ipynb files are supported.")
+
+    # Search for matches in the entire file content
+    uid_match = uid_pattern.search(content)
+    stem_uid_match = stem_uid_pattern.search(content)
+    version_match = version_pattern.search(content)
+
+    # Extract values if matches are found
+    uid = uid_match.group(1) if uid_match else None
+    stem_uid = stem_uid_match.group(1) if stem_uid_match else None
+    version = version_match.group(1) if version_match else None
+
+    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"
+            " into the notebook"
+        )
+    return uid, stem_uid, version
+
+
+def save_from_filepath_cli(
+    filepath: Union[str, Path], key: Optional[str], description: Optional[str]
+) -> Optional[str]:
+    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
+    from lamindb._finish import save_context_core
+
+    ln_setup.settings.auto_connect = auto_connect_state
+
+    if filepath.suffix not in {".py", ".ipynb"}:
+        if 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)
+        artifact.save()
+        slug = ln_setup.settings.instance.slug
+        logger.important(f"saved: {artifact}")
+        logger.important(f"storage path: {artifact.path}")
+        if ln_setup.settings.instance.is_remote:
+            logger.important(f"go to: https://lamin.ai/{slug}/artifact/{artifact.uid}")
+        if ln_setup.settings.storage.type == "s3":
+            logger.important(f"storage url: {artifact.path.to_url()}")
+        return None
+    else:
+        # consider notebooks & scripts a transform
+        uid, stem_uid, transform_version = get_stem_uid_and_version_from_file(filepath)
+        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()?"
+                )
+                return "not-tracked-in-transform-registry"
+        else:
+            transform = ln.Transform.get(
+                uid__startswith=stem_uid, version=transform_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:
+            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"
+        return save_context_core(
+            run=run,
+            transform=transform,
+            filepath=filepath,
+            from_cli=True,
+        )