lamin_cli 1.12.0__py2.py3-none-any.whl → 1.12.1__py2.py3-none-any.whl

lamin_cli/_annotate.py

@@ -1,47 +1,47 @@
-def _parse_features_list(features_list: tuple) -> dict:
-    """Parse feature list into a dictionary.
-
-    Supports multiple formats:
-    - Quoted values: 'perturbation="DMSO","IFNG"' → {"perturbation": ["DMSO", "IFNG"]}
-    - Unquoted values: 'perturbation=IFNG,DMSO' → {"perturbation": ["IFNG", "DMSO"]}
-    - Single values: 'cell_line=HEK297' → {"cell_line": "HEK297"}
-    - Mixed: ('perturbation="DMSO","IFNG"', 'cell_line=HEK297', 'genes=TP53,BRCA1')
-    """
-    import re
-
-    import lamindb as ln
-
-    feature_dict = {}
-
-    for feature_assignment in features_list:
-        if "=" not in feature_assignment:
-            raise ln.errors.InvalidArgument(
-                f"Invalid feature assignment: '{feature_assignment}'. Expected format: 'feature=value' or 'feature=\"value1\",\"value2\"'"
-            )
-
-        feature_name, values_str = feature_assignment.split("=", 1)
-        feature_name = feature_name.strip()
-
-        # Parse quoted values using regex
-        # This will match quoted strings like "DMSO","IFNG" or single values like HEK297
-        quoted_values = re.findall(r'"([^"]*)"', values_str)
-
-        if quoted_values:
-            # If we found quoted values, use them
-            if len(quoted_values) == 1:
-                feature_dict[feature_name] = quoted_values[0]
-            else:
-                feature_dict[feature_name] = quoted_values
-        else:
-            # If no quoted values, treat as single unquoted value
-            # Remove any surrounding whitespace
-            value = values_str.strip()
-
-            # Handle comma-separated unquoted values
-            if "," in value:
-                values = [v.strip() for v in value.split(",")]
-                feature_dict[feature_name] = values
-            else:
-                feature_dict[feature_name] = value
-
-    return feature_dict
+def _parse_features_list(features_list: tuple) -> dict:
+    """Parse feature list into a dictionary.
+
+    Supports multiple formats:
+    - Quoted values: 'perturbation="DMSO","IFNG"' → {"perturbation": ["DMSO", "IFNG"]}
+    - Unquoted values: 'perturbation=IFNG,DMSO' → {"perturbation": ["IFNG", "DMSO"]}
+    - Single values: 'cell_line=HEK297' → {"cell_line": "HEK297"}
+    - Mixed: ('perturbation="DMSO","IFNG"', 'cell_line=HEK297', 'genes=TP53,BRCA1')
+    """
+    import re
+
+    import lamindb as ln
+
+    feature_dict = {}
+
+    for feature_assignment in features_list:
+        if "=" not in feature_assignment:
+            raise ln.errors.InvalidArgument(
+                f"Invalid feature assignment: '{feature_assignment}'. Expected format: 'feature=value' or 'feature=\"value1\",\"value2\"'"
+            )
+
+        feature_name, values_str = feature_assignment.split("=", 1)
+        feature_name = feature_name.strip()
+
+        # Parse quoted values using regex
+        # This will match quoted strings like "DMSO","IFNG" or single values like HEK297
+        quoted_values = re.findall(r'"([^"]*)"', values_str)
+
+        if quoted_values:
+            # If we found quoted values, use them
+            if len(quoted_values) == 1:
+                feature_dict[feature_name] = quoted_values[0]
+            else:
+                feature_dict[feature_name] = quoted_values
+        else:
+            # If no quoted values, treat as single unquoted value
+            # Remove any surrounding whitespace
+            value = values_str.strip()
+
+            # Handle comma-separated unquoted values
+            if "," in value:
+                values = [v.strip() for v in value.split(",")]
+                feature_dict[feature_name] = values
+            else:
+                feature_dict[feature_name] = value
+
+    return feature_dict

lamin_cli/_cache.py

@@ -1,41 +1,49 @@
-from __future__ import annotations
-
-import os
-
-if os.environ.get("NO_RICH"):
-    import click as click
-else:
-    import rich_click as click
-
-
-@click.group()
-def cache():
-    """Get, set, or clear the cache directory."""
-
-
-@cache.command("set")
-@click.argument(
-    "cache_dir",
-    type=click.Path(dir_okay=True, file_okay=False),
-)
-def set_cache(cache_dir: str):
-    """Set the cache directory."""
-    from lamindb_setup._cache import set_cache_dir
-
-    set_cache_dir(cache_dir)
-
-
-@cache.command("clear")
-def clear_cache():
-    """Clear the cache directory."""
-    from lamindb_setup._cache import clear_cache_dir
-
-    clear_cache_dir()
-
-
-@cache.command("get")
-def get_cache():
-    """Get the cache directory."""
-    from lamindb_setup._cache import get_cache_dir
-
-    click.echo(f"The cache directory is {get_cache_dir()}")
+from __future__ import annotations
+
+import os
+
+if os.environ.get("NO_RICH"):
+    import click as click
+else:
+    import rich_click as click
+
+
+@click.group()
+def cache():
+    """Get, set, reset, or clear the cache directory."""
+
+
+@cache.command("set")
+@click.argument(
+    "cache_dir",
+    type=click.Path(dir_okay=True, file_okay=False),
+)
+def set_cache(cache_dir: str):
+    """Set the path to the cache directory."""
+    from lamindb_setup._cache import set_cache_dir
+
+    set_cache_dir(cache_dir)
+
+
+@cache.command("reset")
+def reset_cache():
+    """Reset the cache directory to the default path."""
+    from lamindb_setup._cache import set_cache_dir
+
+    set_cache_dir(None)
+
+
+@cache.command("clear")
+def clear_cache():
+    """Clear contents of the cache directory."""
+    from lamindb_setup._cache import clear_cache_dir
+
+    clear_cache_dir()
+
+
+@cache.command("get")
+def get_cache():
+    """Get the path to the cache directory."""
+    from lamindb_setup._cache import get_cache_dir
+
+    click.echo(f"The cache directory is {get_cache_dir()}")

lamin_cli/_context.py

@@ -1,76 +1,76 @@
-import os
-import sys
-from pathlib import Path
-
-import click
-from lamin_utils import logger
-from lamindb_setup.core._settings_store import settings_dir
-
-
-def get_current_run_file() -> Path:
-    """Get the path to the file storing the current run UID."""
-    return settings_dir / "current_shell_run.txt"
-
-
-def is_interactive_shell() -> bool:
-    """Check if running in an interactive terminal."""
-    return sys.stdin.isatty() and sys.stdout.isatty() and os.isatty(0)
-
-
-def get_script_filename() -> Path:
-    """Try to get the filename of the calling shell script."""
-    import psutil
-
-    parent = psutil.Process(os.getppid())
-    cmdline = parent.cmdline()
-
-    # For shells like bash, sh, zsh
-    if parent.name() in ["bash", "sh", "zsh", "dash"]:
-        # cmdline is typically: ['/bin/bash', 'script.sh', ...]
-        if len(cmdline) > 1 and not cmdline[1].startswith("-"):
-            return Path(cmdline[1])
-    raise click.ClickException(
-        "Cannot determine script filename. Please run in an interactive shell."
-    )
-
-
-def track():
-    import lamindb as ln
-
-    if not ln.setup.settings._instance_exists:
-        raise click.ClickException(
-            "Not connected to an instance. Please run: lamin connect account/name"
-        )
-    path = get_script_filename()
-    source_code = path.read_text()
-    transform = ln.Transform(
-        key=path.name, source_code=source_code, type="script"
-    ).save()
-    run = ln.Run(transform=transform).save()
-    current_run_file = get_current_run_file()
-    current_run_file.parent.mkdir(parents=True, exist_ok=True)
-    current_run_file.write_text(run.uid)
-    logger.important(f"started tracking shell run: {run.uid}")
-
-
-def finish():
-    from datetime import datetime, timezone
-
-    import lamindb as ln
-
-    if not ln.setup.settings._instance_exists:
-        raise click.ClickException(
-            "Not connected to an instance. Please run: lamin connect account/name"
-        )
-
-    current_run_file = get_current_run_file()
-    if not current_run_file.exists():
-        raise click.ClickException(
-            "No active run to finish. Please run `lamin track` first."
-        )
-    run = ln.Run.get(uid=current_run_file.read_text().strip())
-    run._status_code = 0
-    run.finished_at = datetime.now(timezone.utc)
-    run.save()
-    current_run_file.unlink()
-    logger.important(f"finished tracking shell run: {run.uid}")
+import os
+import sys
+from pathlib import Path
+
+import click
+from lamin_utils import logger
+from lamindb_setup.core._settings_store import settings_dir
+
+
+def get_current_run_file() -> Path:
+    """Get the path to the file storing the current run UID."""
+    return settings_dir / "current_shell_run.txt"
+
+
+def is_interactive_shell() -> bool:
+    """Check if running in an interactive terminal."""
+    return sys.stdin.isatty() and sys.stdout.isatty() and os.isatty(0)
+
+
+def get_script_filename() -> Path:
+    """Try to get the filename of the calling shell script."""
+    import psutil
+
+    parent = psutil.Process(os.getppid())
+    cmdline = parent.cmdline()
+
+    # For shells like bash, sh, zsh
+    if parent.name() in ["bash", "sh", "zsh", "dash"]:
+        # cmdline is typically: ['/bin/bash', 'script.sh', ...]
+        if len(cmdline) > 1 and not cmdline[1].startswith("-"):
+            return Path(cmdline[1])
+    raise click.ClickException(
+        "Cannot determine script filename. Please run in an interactive shell."
+    )
+
+
+def track():
+    import lamindb as ln
+
+    if not ln.setup.settings._instance_exists:
+        raise click.ClickException(
+            "Not connected to an instance. Please run: lamin connect account/name"
+        )
+    path = get_script_filename()
+    source_code = path.read_text()
+    transform = ln.Transform(
+        key=path.name, source_code=source_code, type="script"
+    ).save()
+    run = ln.Run(transform=transform).save()
+    current_run_file = get_current_run_file()
+    current_run_file.parent.mkdir(parents=True, exist_ok=True)
+    current_run_file.write_text(run.uid)
+    logger.important(f"started tracking shell run: {run.uid}")
+
+
+def finish():
+    from datetime import datetime, timezone
+
+    import lamindb as ln
+
+    if not ln.setup.settings._instance_exists:
+        raise click.ClickException(
+            "Not connected to an instance. Please run: lamin connect account/name"
+        )
+
+    current_run_file = get_current_run_file()
+    if not current_run_file.exists():
+        raise click.ClickException(
+            "No active run to finish. Please run `lamin track` first."
+        )
+    run = ln.Run.get(uid=current_run_file.read_text().strip())
+    run._status_code = 0
+    run.finished_at = datetime.now(timezone.utc)
+    run.save()
+    current_run_file.unlink()
+    logger.important(f"finished tracking shell run: {run.uid}")

lamin_cli/_delete.py

@@ -1,85 +1,85 @@
-import click
-from lamindb_setup import connect
-from lamindb_setup import delete as delete_instance
-from lamindb_setup.errors import StorageNotEmpty
-
-from .urls import decompose_url
-
-
-def delete(
-    entity: str,
-    name: str | None = None,
-    uid: str | None = None,
-    key: str | None = None,
-    permanent: bool | None = None,
-    force: bool = False,
-):
-    # TODO: refactor to abstract getting and deleting across entities
-    if entity.startswith("https://") and "lamin" in entity:
-        url = entity
-        instance, entity, uid = decompose_url(url)
-        connect(instance)
-
-    if entity == "branch":
-        assert name is not None, "You have to pass a name for deleting a branch."
-        from lamindb import Branch
-
-        Branch.get(name=name).delete(permanent=permanent)
-    elif entity == "artifact":
-        assert uid is not None or key is not None, (
-            "You have to pass a uid or key for deleting an artifact."
-        )
-        from lamindb import Artifact
-
-        if key is not None:
-            record = Artifact.objects.filter(key=key).order_by("-created_at").first()
-            if record is None:
-                raise SystemExit(f"Artifact with key={key} does not exist.")
-        else:
-            record = Artifact.get(uid)
-        record.delete(permanent=permanent)
-    elif entity == "transform":
-        assert uid is not None or key is not None, (
-            "You have to pass a uid or key for deleting a transform."
-        )
-        from lamindb import Transform
-
-        if key is not None:
-            record = Transform.objects.filter(key=key).order_by("-created_at").first()
-            if record is None:
-                raise SystemExit(f"Transform with key={key} does not exist.")
-        else:
-            record = Transform.get(uid)
-        record.delete(permanent=permanent)
-    elif entity == "collection":
-        assert uid is not None or key is not None, (
-            "You have to pass a uid or key for deleting a collection."
-        )
-        from lamindb import Collection
-
-        if key is not None:
-            record = Collection.objects.filter(key=key).order_by("-created_at").first()
-            if record is None:
-                raise SystemExit(f"Collection with key={key} does not exist.")
-        else:
-            record = Collection.get(uid)
-        record.delete(permanent=permanent)
-    elif entity == "record":
-        assert uid is not None or name is not None, (
-            "You have to pass a uid or name for deleting a record."
-        )
-        from lamindb import Record
-
-        if name is not None:
-            record = Record.objects.get(name=name)
-            if record is None:
-                raise SystemExit(f"Record with name={name} does not exist.")
-        else:
-            record = Record.get(uid)
-        record.delete(permanent=permanent)
-    else:
-        # could introduce "db" as an entity
-        try:
-            return delete_instance(entity, force=force)
-        except StorageNotEmpty as e:
-            raise click.ClickException(str(e)) from e
+import click
+from lamindb_setup import connect
+from lamindb_setup import delete as delete_instance
+from lamindb_setup.errors import StorageNotEmpty
+
+from .urls import decompose_url
+
+
+def delete(
+    entity: str,
+    name: str | None = None,
+    uid: str | None = None,
+    key: str | None = None,
+    permanent: bool | None = None,
+    force: bool = False,
+):
+    # TODO: refactor to abstract getting and deleting across entities
+    if entity.startswith("https://") and "lamin" in entity:
+        url = entity
+        instance, entity, uid = decompose_url(url)
+        connect(instance)
+
+    if entity == "branch":
+        assert name is not None, "You have to pass a name for deleting a branch."
+        from lamindb import Branch
+
+        Branch.get(name=name).delete(permanent=permanent)
+    elif entity == "artifact":
+        assert uid is not None or key is not None, (
+            "You have to pass a uid or key for deleting an artifact."
+        )
+        from lamindb import Artifact
+
+        if key is not None:
+            record = Artifact.objects.filter(key=key).order_by("-created_at").first()
+            if record is None:
+                raise SystemExit(f"Artifact with key={key} does not exist.")
+        else:
+            record = Artifact.get(uid)
+        record.delete(permanent=permanent)
+    elif entity == "transform":
+        assert uid is not None or key is not None, (
+            "You have to pass a uid or key for deleting a transform."
+        )
+        from lamindb import Transform
+
+        if key is not None:
+            record = Transform.objects.filter(key=key).order_by("-created_at").first()
+            if record is None:
+                raise SystemExit(f"Transform with key={key} does not exist.")
+        else:
+            record = Transform.get(uid)
+        record.delete(permanent=permanent)
+    elif entity == "collection":
+        assert uid is not None or key is not None, (
+            "You have to pass a uid or key for deleting a collection."
+        )
+        from lamindb import Collection
+
+        if key is not None:
+            record = Collection.objects.filter(key=key).order_by("-created_at").first()
+            if record is None:
+                raise SystemExit(f"Collection with key={key} does not exist.")
+        else:
+            record = Collection.get(uid)
+        record.delete(permanent=permanent)
+    elif entity == "record":
+        assert uid is not None or name is not None, (
+            "You have to pass a uid or name for deleting a record."
+        )
+        from lamindb import Record
+
+        if name is not None:
+            record = Record.objects.get(name=name)
+            if record is None:
+                raise SystemExit(f"Record with name={name} does not exist.")
+        else:
+            record = Record.get(uid)
+        record.delete(permanent=permanent)
+    else:
+        # could introduce "db" as an entity
+        try:
+            return delete_instance(entity, force=force)
+        except StorageNotEmpty as e:
+            raise click.ClickException(str(e)) from e