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

lamin_cli/_settings.py

@@ -1,96 +1,154 @@
-from __future__ import annotations
-
-import os
-from pathlib import Path
-
-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:
-
-    ```
-    lamin settings
-    ```
-
-    Allows to get and set these settings:
-
-    - `dev-dir` → {attr}`~lamindb.setup.core.SetupSettings.dev_dir`
-    - `private-django-api` → {attr}`~lamindb.setup.core.SetupSettings.private_django_api`
-    - `branch` → current branch (use `lamin switch --branch` to change)
-    - `space` → current space (use `lamin switch --space` to change)
-
-    Examples for getting a setting:
-
-    ```
-    lamin settings get dev-dir
-    lamin settings get branch
-    ```
-
-    Examples for setting the working directory:
-
-    ```
-    lamin settings set dev-dir .  # set dev-dir to current directory
-    lamin settings set dev-dir ~/my-project  # set dev-dir to ~/my-project
-    lamin settings set dev-dir none  # unset dev-dir
-    ```
-    """
-    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", "dev-dir"], case_sensitive=False
-    ),
-)
-@click.argument("value")  # No explicit type - let Click handle it
-def set(setting: str, value: str):
-    """Set a setting."""
-    from lamindb_setup import settings as settings_
-
-    if setting == "auto-connect":
-        settings_.auto_connect = click.BOOL(value)
-    if setting == "private-django-api":
-        settings_.private_django_api = click.BOOL(value)
-    if setting == "dev-dir":
-        if value.lower() == "none":
-            value = None  # type: ignore[assignment]
-        settings_.dev_dir = value
-
-
-@settings.command("get")
-@click.argument(
-    "setting",
-    type=click.Choice(
-        ["auto-connect", "private-django-api", "space", "branch", "dev-dir"],
-        case_sensitive=False,
-    ),
-)
-def get(setting: str):
-    """Get a setting."""
-    from lamindb_setup import settings as settings_
-
-    if setting == "branch":
-        _, value = settings_._read_branch_idlike_name()
-    elif setting == "space":
-        _, value = settings_._read_space_idlike_name()
-    elif setting == "dev-dir":
-        value = settings_.dev_dir
-        if value is None:
-            value = "None"
-    else:
-        value = getattr(settings_, setting.replace("-", "_"))
-    click.echo(value)
+from __future__ import annotations
+
+import os
+from pathlib import Path
+
+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 development & cache directories, branch, and space settings.
+
+    Get or set a setting by name:
+
+    - `dev-dir` → development directory {attr}`~lamindb.setup.core.SetupSettings.dev_dir`
+    - `cache-dir` → cache directory {attr}`~lamindb.setup.core.SetupSettings.cache_dir`
+    - `branch` → branch {attr}`~lamindb.setup.core.SetupSettings.branch`
+    - `space` → space {attr}`~lamindb.setup.core.SetupSettings.space`
+
+    Display via [lamin info](https://docs.lamin.ai/cli#info)
+
+    Examples:
+
+    ```
+    # dev-dir
+    lamin settings dev-dir get
+    lamin settings dev-dir set .  # set to current directory
+    lamin settings dev-dir set ~/my-project
+    lamin settings dev-dir unset
+    # cache-dir
+    lamin settings cache-dir get
+    lamin settings cache-dir set /path/to/cache
+    lamin settings cache-dir clear
+    # branch
+    lamin settings branch get
+    lamin settings branch set main
+    # space
+    lamin settings space get
+    lamin settings space set all
+    ```
+
+    → Python/R alternative: {attr}`~lamindb.setup.core.SetupSettings.dev_dir`, {attr}`~lamindb.setup.core.SetupSettings.cache_dir`, {attr}`~lamindb.setup.core.SetupSettings.branch`, and {attr}`~lamindb.setup.core.SetupSettings.space`
+    """
+    if ctx.invoked_subcommand is None:
+        from lamindb_setup import settings as settings_
+
+        click.echo("Configure: see `lamin settings --help`")
+        click.echo(settings_)
+
+
+# -----------------------------------------------------------------------------
+# dev-dir group (pattern: lamin settings dev-dir get/set)
+# -----------------------------------------------------------------------------
+
+
+@click.group("dev-dir")
+def dev_dir_group():
+    """Get or set the development directory."""
+
+
+@dev_dir_group.command("get")
+def dev_dir_get():
+    """Show the current development directory."""
+    from lamindb_setup import settings as settings_
+
+    value = settings_.dev_dir
+    click.echo(value if value is not None else "None")
+
+
+@dev_dir_group.command("set")
+@click.argument("value", type=str)
+def dev_dir_set(value: str):
+    """Set the development directory."""
+    from lamindb_setup import settings as settings_
+
+    if value.lower() == "none":
+        value = None  # type: ignore[assignment]
+    settings_.dev_dir = value
+
+
+@dev_dir_group.command("unset")
+def dev_dir_unset():
+    """Unset the development directory."""
+    from lamindb_setup import settings as settings_
+
+    settings_.dev_dir = None
+
+
+settings.add_command(dev_dir_group)
+
+
+# -----------------------------------------------------------------------------
+# Legacy get/set (hidden, backward compatibility)
+# -----------------------------------------------------------------------------
+
+
+@settings.command("set", hidden=True)
+@click.argument(
+    "setting",
+    type=click.Choice(
+        ["auto-connect", "private-django-api", "dev-dir"], case_sensitive=False
+    ),
+)
+@click.argument("value")  # No explicit type - let Click handle it
+def set_legacy(setting: str, value: str):
+    """Set a setting (legacy). Use lamin settings <name> set <value> instead."""
+    from lamindb_setup import settings as settings_
+
+    if setting == "auto-connect":
+        settings_.auto_connect = click.BOOL(value)
+    if setting == "private-django-api":
+        settings_.private_django_api = click.BOOL(value)
+    if setting == "dev-dir":
+        if value.lower() == "none":
+            value = None  # type: ignore[assignment]
+        settings_.dev_dir = value
+
+
+@settings.command("get", hidden=True)
+@click.argument(
+    "setting",
+    type=click.Choice(
+        ["auto-connect", "private-django-api", "space", "branch", "dev-dir"],
+        case_sensitive=False,
+    ),
+)
+def get_legacy(setting: str):
+    """Get a setting (legacy). Use lamin settings <name> get instead."""
+    from lamindb_setup import settings as settings_
+
+    if setting == "branch":
+        _, value = settings_._read_branch_idlike_name()
+    elif setting == "space":
+        _, value = settings_._read_space_idlike_name()
+    elif setting == "dev-dir":
+        value = settings_.dev_dir
+        if value is None:
+            value = "None"
+    else:
+        value = getattr(settings_, setting.replace("-", "_"))
+    click.echo(value)
+
+
+# -----------------------------------------------------------------------------
+# cache-dir (already uses lamin settings cache-dir get/set/clear)
+# -----------------------------------------------------------------------------
+
+from lamin_cli._cache import cache
+
+settings.add_command(cache, "cache-dir")

lamin_cli/clone/_clone_verification.py

@@ -1,56 +1,56 @@
-from concurrent.futures import ThreadPoolExecutor
-
-from django.db import OperationalError, ProgrammingError
-from lamin_utils import logger
-
-
-def _count_instance_records() -> dict[str, int]:
-    """Count all records across SQLRecord registries in parallel.
-
-    Returns:
-        Dictionary mapping table names (format: "app_label.ModelName") to  their record counts.
-
-    Example:
-        >>> counts = _count_all_records()
-        >>> counts
-        {'lamindb.Artifact': 1523, 'lamindb.Collection': 42, 'bionty.Gene': 60000}
-    """
-    # Import here to ensure that models are loaded
-    from django.apps import apps
-    from lamindb.models import SQLRecord
-
-    def _count_model(model):
-        """Count records for a single model."""
-        table_name = f"{model._meta.app_label}.{model.__name__}"
-        try:
-            return (table_name, model.objects.count())
-        except (OperationalError, ProgrammingError) as e:
-            logger.warning(f"Could not count {table_name}: {e}")
-            return (table_name, 0)
-
-    models = [m for m in apps.get_models() if issubclass(m, SQLRecord)]
-
-    with ThreadPoolExecutor(max_workers=10) as executor:
-        results = executor.map(_count_model, models)
-
-    return dict(results)
-
-
-def _compare_record_counts(
-    original: dict[str, int], clone: dict[str, int]
-) -> dict[str, tuple[int, int]]:
-    """Compare record counts and return mismatches."""
-    mismatches = {}
-
-    all_tables = set(original.keys()) | set(clone.keys())
-
-    for table in all_tables:
-        orig_count = original.get(table, 0)
-        clone_count = clone.get(table, 0)
-
-        # we allow a difference of 1 because of tracking
-        # new records during the cloning process
-        if abs(clone_count - orig_count) > 1:
-            mismatches[table] = (orig_count, clone_count)
-
-    return mismatches
+from concurrent.futures import ThreadPoolExecutor
+
+from django.db import OperationalError, ProgrammingError
+from lamin_utils import logger
+
+
+def _count_instance_records() -> dict[str, int]:
+    """Count all records across SQLRecord registries in parallel.
+
+    Returns:
+        Dictionary mapping table names (format: "app_label.ModelName") to  their record counts.
+
+    Example:
+        >>> counts = _count_all_records()
+        >>> counts
+        {'lamindb.Artifact': 1523, 'lamindb.Collection': 42, 'bionty.Gene': 60000}
+    """
+    # Import here to ensure that models are loaded
+    from django.apps import apps
+    from lamindb.models import SQLRecord
+
+    def _count_model(model):
+        """Count records for a single model."""
+        table_name = f"{model._meta.app_label}.{model.__name__}"
+        try:
+            return (table_name, model.objects.count())
+        except (OperationalError, ProgrammingError) as e:
+            logger.warning(f"Could not count {table_name}: {e}")
+            return (table_name, 0)
+
+    models = [m for m in apps.get_models() if issubclass(m, SQLRecord)]
+
+    with ThreadPoolExecutor(max_workers=10) as executor:
+        results = executor.map(_count_model, models)
+
+    return dict(results)
+
+
+def _compare_record_counts(
+    original: dict[str, int], clone: dict[str, int]
+) -> dict[str, tuple[int, int]]:
+    """Compare record counts and return mismatches."""
+    mismatches = {}
+
+    all_tables = set(original.keys()) | set(clone.keys())
+
+    for table in all_tables:
+        orig_count = original.get(table, 0)
+        clone_count = clone.get(table, 0)
+
+        # we allow a difference of 1 because of tracking
+        # new records during the cloning process
+        if abs(clone_count - orig_count) > 1:
+            mismatches[table] = (orig_count, clone_count)
+
+    return mismatches

lamin_cli/clone/create_sqlite_clone_and_import_db.py

@@ -1,51 +1,53 @@
-import argparse
-import json
-import sys
-from pathlib import Path
-
-import lamindb_setup as ln_setup
-
-if __name__ == "__main__":
-    sys.path.insert(0, str(Path(__file__).parent.parent))
-
-    parser = argparse.ArgumentParser()
-    parser.add_argument("--instance-name", required=True)
-    parser.add_argument("--export-dir", required=True)
-    parser.add_argument("--modules", required=True)
-    parser.add_argument("--original-counts", required=True)
-    args = parser.parse_args()
-
-    instance_name = args.instance_name
-    export_dir = args.export_dir
-    modules_without_lamindb = {m for m in args.modules.split(",") if m}
-    modules_complete = modules_without_lamindb.copy()
-    modules_complete.add("lamindb")
-
-    ln_setup.init(
-        storage=f"{instance_name}-clone", modules=f"{','.join(modules_without_lamindb)}"
-    )
-
-    ln_setup.io.import_db(
-        module_names=list(modules_complete), input_dir=export_dir, if_exists="replace"
-    )
-
-    from django.db import connection
-
-    with connection.cursor() as cursor:
-        cursor.execute("PRAGMA wal_checkpoint(FULL)")
-
-    from lamin_cli.clone._clone_verification import (
-        _compare_record_counts,
-        _count_instance_records,
-    )
-
-    clone_counts = _count_instance_records()
-    original_counts = json.loads(args.original_counts)
-    mismatches = _compare_record_counts(original_counts, clone_counts)
-    if mismatches:
-        print(json.dumps(mismatches), file=sys.stderr)
-        sys.exit(1)
-
-    from django.db import connections
-
-    connections.close_all()
+import argparse
+import json
+import sys
+from pathlib import Path
+
+import lamindb_setup as ln_setup
+
+if __name__ == "__main__":
+    from lamindb_setup.io import import_db
+
+    sys.path.insert(0, str(Path(__file__).parent.parent))
+
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--instance-name", required=True)
+    parser.add_argument("--export-dir", required=True)
+    parser.add_argument("--modules", required=True)
+    parser.add_argument("--original-counts", required=True)
+    args = parser.parse_args()
+
+    instance_name = args.instance_name
+    export_dir = args.export_dir
+    modules_without_lamindb = {m for m in args.modules.split(",") if m}
+    modules_complete = modules_without_lamindb.copy()
+    modules_complete.add("lamindb")
+
+    ln_setup.init(
+        storage=f"{instance_name}-clone", modules=f"{','.join(modules_without_lamindb)}"
+    )
+
+    import_db(
+        module_names=list(modules_complete), input_dir=export_dir, if_exists="replace"
+    )
+
+    from django.db import connection
+
+    with connection.cursor() as cursor:
+        cursor.execute("PRAGMA wal_checkpoint(FULL)")
+
+    from lamin_cli.clone._clone_verification import (
+        _compare_record_counts,
+        _count_instance_records,
+    )
+
+    clone_counts = _count_instance_records()
+    original_counts = json.loads(args.original_counts)
+    mismatches = _compare_record_counts(original_counts, clone_counts)
+    if mismatches:
+        print(json.dumps(mismatches), file=sys.stderr)
+        sys.exit(1)
+
+    from django.db import connections
+
+    connections.close_all()