lamin_cli 1.7.2__tar.gz → 1.8.1__tar.gz

{lamin_cli-1.7.2 → lamin_cli-1.8.1}/PKG-INFO

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

lamin_cli-1.8.1/lamin_cli/__init__.py

@@ -0,0 +1,18 @@
+"""Lamin CLI.
+
+This is the command line interface for interacting with LaminDB & LaminHub.
+
+The interface is defined in `__main__.py`. The root API here is used by LaminR to replicate the CLI functionality.
+"""
+
+__version__ = "1.8.1"
+
+from lamindb_setup import disconnect, logout
+from lamindb_setup._connect_instance import _connect_cli as connect
+from lamindb_setup._init_instance import init
+from lamindb_setup._setup_user import login
+
+from ._delete import delete
+from ._save import save
+
+__all__ = ["save", "init", "connect", "delete", "login", "disconnect"]

{lamin_cli-1.7.2 → lamin_cli-1.8.1}/lamin_cli/__main__.py

@@ -11,6 +11,7 @@ from importlib.metadata import PackageNotFoundError, version
 from pathlib import Path
 from typing import TYPE_CHECKING, Literal
 
+import lamindb_setup as ln_setup
 from lamin_utils import logger
 from lamindb_setup._init_instance import (
     DOC_DB,
@@ -19,6 +20,13 @@ from lamindb_setup._init_instance import (
     DOC_STORAGE_ARG,
 )
 
+from lamin_cli import connect as connect_
+from lamin_cli import disconnect as disconnect_
+from lamin_cli import init as init_
+from lamin_cli import login as login_
+from lamin_cli import logout as logout_
+from lamin_cli import save as save_
+
 from .urls import decompose_url
 
 if TYPE_CHECKING:
@@ -129,16 +137,12 @@ def login(user: str, key: str | None):
 
     See also: Login in a Python session via {func}`~lamindb.setup.login`.
     """
-    from lamindb_setup._setup_user import login as login_
-
     return login_(user, key=key)
 
 
 @main.command()
 def logout():
     """Log out of LaminHub."""
-    from lamindb_setup import logout as logout_
-
     return logout_()
 
 
@@ -170,8 +174,6 @@ def init(
 
     See also: Init in a Python session via {func}`~lamindb.setup.init`.
     """
-    from lamindb_setup._init_instance import init as init_
-
     return init_(storage=storage, db=db, modules=modules, name=name)
 
 
@@ -188,8 +190,7 @@ def connect(instance: str):
 
     See also: Connect in a Python session via {func}`~lamindb.connect`.
     """
-    from lamindb_setup._connect_instance import _connect_cli
-    return _connect_cli(instance)
+    return connect_(instance)
 
 
 @main.command()
@@ -198,8 +199,6 @@ def disconnect():
 
     See also: Disconnect in a Python session via {func}`~lamindb.setup.disconnect`.
     """
-    from lamindb_setup import disconnect as disconnect_
-
     return disconnect_()
 
 
@@ -211,18 +210,22 @@ def disconnect():
 def create(entity: Literal["branch"], name: str | None = None):
     """Create a record for an entity.
 
-    Currently only supports creating a branch.
+    Currently only supports creating branches and projects.
 
     ```
     lamin create branch --name my_branch
+    lamin create project --name my_project
     ```
     """
-    assert entity == "branch", "Currently only supports creating a branch."
-
-    from lamindb.models import Branch
+    from lamindb.models import Branch, Project
 
-    branch = Branch(name=name).save()
-    logger.important(f"created branch: {branch.name}")
+    if entity == "branch":
+        record = Branch(name=name).save()
+    elif entity == "project":
+        record = Project(name=name).save()
+    else:
+        raise NotImplementedError(f"Creating {entity} is not implemented.")
+    logger.important(f"created {entity}: {record.name}")
 
 
 # fmt: off
@@ -243,9 +246,9 @@ def list_(entity: Literal["branch"], name: str | None = None):
     from lamindb.models import Branch, Space
 
     if entity == "branch":
-        print(Branch.df())
+        print(Branch.to_dataframe())
     else:
-        print(Space.df())
+        print(Space.to_dataframe())
 
 
 # fmt: off
@@ -303,38 +306,9 @@ def delete(entity: str, name: str | None = None, uid: str | None = None, slug: s
     lamin delete instance --slug account/name
     ```
     """
-    from lamindb_setup import connect, delete
+    from lamin_cli._delete import delete as delete_
 
-    # 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()
-    elif entity == "artifact":
-        assert uid is not None, "You have to pass a uid for deleting an artifact."
-        from lamindb import Artifact
-
-        Artifact.get(uid).delete()
-    elif entity == "transform":
-        assert uid is not None, "You have to pass a uid for deleting an transform."
-        from lamindb import Transform
-
-        Transform.get(uid).delete()
-    elif entity == "collection":
-        assert uid is not None, "You have to pass a uid for deleting an collection."
-        from lamindb import Collection
-
-        Collection.get(uid).delete()
-    elif entity == "instance":
-        return delete(slug, force=force)
-    else:  # backwars compatibility
-        return delete(entity, force=force)
+    return delete_(entity=entity, name=name, uid=uid, slug=slug, force=force)
 
 
 @main.command()
@@ -350,9 +324,9 @@ def load(entity: str, uid: str | None = None, key: str | None = None, with_env:
     Pass a URL, `artifact`, or `transform`. For example:
 
     ```
-    lamin load https://lamin.ai/account/instance/artifact/e2G7k9EVul4JbfsEYAy5
+    lamin load https://lamin.ai/account/instance/artifact/e2G7k9EVul4JbfsE
     lamin load artifact --key mydatasets/mytable.parquet
-    lamin load artifact --uid e2G7k9EVul4JbfsEYAy5
+    lamin load artifact --uid e2G7k9EVul4JbfsE
     lamin load transform --key analysis.ipynb
     lamin load transform --uid Vul4JbfsEYAy5
     lamin load transform --uid Vul4JbfsEYAy5 --with-env
@@ -370,10 +344,6 @@ def load(entity: str, uid: str | None = None, key: str | None = None, with_env:
 
 
 def _describe(entity: str = "artifact", uid: str | None = None, key: str | None = None):
-    import lamindb_setup as ln_setup
-
-    from ._load import decompose_url
-
     if entity.startswith("https://") and "lamin" in entity:
         url = entity
         instance, entity, uid = decompose_url(url)
@@ -449,20 +419,20 @@ def save(path: str, key: str, description: str, stem_uid: str, project: str, spa
     other file types and folders as {class}`~lamindb.Artifact`. You can enforce saving a file as
     an {class}`~lamindb.Artifact` by passing `--registry artifact`.
     """
-    from lamin_cli import save as save_
-
     if save_(path=path, key=key, description=description, stem_uid=stem_uid, project=project, space=space, branch=branch, registry=registry) is not None:
         sys.exit(1)
 
 
 @main.command()
+@click.argument("entity", type=str, default=None, required=False)
 @click.option("--key", type=str, default=None, help="The key of an artifact or transform.")
 @click.option("--uid", type=str, default=None, help="The uid of an artifact or transform.")
 @click.option("--project", type=str, default=None, help="A valid project name or uid.")
 @click.option("--features", multiple=True, help="Feature annotations. Supports: feature=value, feature=val1,val2, or feature=\"val1\",\"val2\"")
-@click.option("--registry", type=str, default=None, help="Either 'artifact' or 'transform'. If not passed, chooses based on key suffix.")
-def annotate(key: str, uid: str, project: str, registry: str, features: tuple):
-    """Annotate an artifact or a transform.
+def annotate(entity: str | None, key: str, uid: str, project: str, features: tuple):
+    """Annotate an artifact or transform.
+
+    Entity is either 'artifact' or 'transform'. If not passed, chooses based on key suffix.
 
     You can annotate with projects and valid features & values. For example,
 
@@ -477,11 +447,17 @@ def annotate(key: str, uid: str, project: str, registry: str, features: tuple):
     from lamin_cli._annotate import _parse_features_list
     from lamin_cli._save import infer_registry_from_path
 
-    if registry is None:
+    # once we enable passing the URL as entity, then we don't need to throw this error
+    if not ln.setup.settings._instance_exists:
+        raise click.ClickException("Not connected to an instance. Please run: lamin connect account/name")
+
+    if entity is None:
         if key is not None:
             registry = infer_registry_from_path(key)
         else:
             registry = "artifact"
+    else:
+        registry = entity
     if registry == "artifact":
         model = ln.Artifact
     else:
@@ -491,7 +467,7 @@ def annotate(key: str, uid: str, project: str, registry: str, features: tuple):
     if key is not None:
         artifact = model.get(key=key)
     elif uid is not None:
-        artifact = model.get(uid=uid)
+        artifact = model.get(uid)  # do not use uid=uid, because then no truncated uids would work
     else:
         raise ln.errors.InvalidArgument("Either --key or --uid must be provided")
 

lamin_cli-1.8.1/lamin_cli/_delete.py

@@ -0,0 +1,43 @@
+from lamindb_setup import connect
+from lamindb_setup import delete as delete_instance
+
+from .urls import decompose_url
+
+
+def delete(
+    entity: str,
+    name: str | None = None,
+    uid: str | None = None,
+    slug: str | 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()
+    elif entity == "artifact":
+        assert uid is not None, "You have to pass a uid for deleting an artifact."
+        from lamindb import Artifact
+
+        Artifact.get(uid).delete()
+    elif entity == "transform":
+        assert uid is not None, "You have to pass a uid for deleting an transform."
+        from lamindb import Transform
+
+        Transform.get(uid).delete()
+    elif entity == "collection":
+        assert uid is not None, "You have to pass a uid for deleting an collection."
+        from lamindb import Collection
+
+        Collection.get(uid).delete()
+    elif entity == "instance":
+        return delete_instance(slug, force=force)
+    else:  # backwards compatibility
+        return delete_instance(entity, force=force)

{lamin_cli-1.7.2 → lamin_cli-1.8.1}/lamin_cli/_save.py

@@ -73,13 +73,13 @@ def parse_title_r_notebook(content: str) -> str | None:
 
 def save(
     path: Path | str,
-    key: str | None,
-    description: str | None,
-    stem_uid: str | None,
-    project: str | None,
-    space: str | None,
-    branch: str | None,
-    registry: str | None,
+    key: str | None = None,
+    description: str | None = None,
+    stem_uid: str | None = None,
+    project: str | None = None,
+    space: str | None = None,
+    branch: str | None = None,
+    registry: str | None = None,
 ) -> str | None:
     import lamindb as ln
     from lamindb._finish import save_context_core
@@ -104,12 +104,14 @@ def save(
             raise ln.errors.InvalidArgument(
                 f"Project '{project}' not found, either create it with `ln.Project(name='...').save()` or fix typos."
             )
+    space_record = None
     if space is not None:
         space_record = ln.Space.filter(ln.Q(name=space) | ln.Q(uid=space)).one_or_none()
         if space_record is None:
             raise ln.errors.InvalidArgument(
                 f"Space '{space}' not found, either create it on LaminHub or fix typos."
             )
+    branch_record = None
     if branch is not None:
         branch_record = ln.Branch.filter(
             ln.Q(name=branch) | ln.Q(uid=branch)
@@ -141,12 +143,14 @@ def save(
             logger.error("Please pass a key or description via --key or --description")
             return "missing-key-or-description"
 
-        artifact = ln.Artifact(path, key=key, description=description, revises=revises)
-        if space is not None:
-            artifact.space = space_record
-        if branch is not None:
-            artifact.branch = branch_record
-        artifact.save()
+        artifact = ln.Artifact(
+            path,
+            key=key,
+            description=description,
+            revises=revises,
+            branch=branch_record,
+            space=space_record,
+        ).save()
         logger.important(f"saved: {artifact}")
         logger.important(f"storage path: {artifact.path}")
         if artifact.storage.type == "s3":

lamin_cli-1.8.1/lamin_cli/_settings.py

@@ -0,0 +1,96 @@
+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:
+
+    - `work-dir` → {attr}`~lamindb.setup.core.SetupSettings.work_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 work-dir
+    lamin settings get branch
+    ```
+
+    Examples for setting the working directory:
+
+    ```
+    lamin settings set work-dir .  # set work-dir to current directory
+    lamin settings set work-dir ~/my-project  # set work-dir to ~/my-project
+    lamin settings set work-dir none  # unset work-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", "work-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 == "work-dir":
+        if value.lower() == "none":
+            value = None  # type: ignore[assignment]
+        settings_.work_dir = value
+
+
+@settings.command("get")
+@click.argument(
+    "setting",
+    type=click.Choice(
+        ["auto-connect", "private-django-api", "space", "branch", "work-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 == "work-dir":
+        value = settings_.work_dir
+        if value is None:
+            value = "None"
+    else:
+        value = getattr(settings_, setting.replace("-", "_"))
+    click.echo(value)

{lamin_cli-1.7.2 → lamin_cli-1.8.1}/tests/core/conftest.py

@@ -10,7 +10,6 @@ def pytest_sessionstart(session: pytest.Session):
         storage="./default_storage_cli",
         name="lamin-cli-unit-tests",
     )
-    ln.setup.settings.auto_connect = True
 
 
 def pytest_sessionfinish(session: pytest.Session):

lamin_cli-1.7.2/tests/core/test_create_switch_delete_list.py → lamin_cli-1.8.1/tests/core/test_create_switch_delete_list_settings.py

@@ -1,10 +1,16 @@
 import os
 import subprocess
+from pathlib import Path
 
 import lamindb as ln
 import lamindb_setup as ln_setup
 
 
+def test_create_project():
+    exit_status = os.system("lamin create project --name testproject")
+    assert exit_status == 0
+
+
 def test_branch():
     exit_status = os.system("lamin switch --branch archive")
     assert exit_status == 0
@@ -40,3 +46,38 @@ def test_space():
     exit_status = os.system("lamin switch --space all")
     assert exit_status == 0
     assert ln_setup.settings.space.uid == 12 * "a"
+
+
+def test_work_dir():
+    # default work-dir is None
+    result = subprocess.run(
+        "lamin settings get work-dir",
+        capture_output=True,
+        text=True,
+        shell=True,
+    )
+    assert result.stdout.strip() == "None"
+    assert ln_setup.settings.work_dir is None
+    # set work-dir to tmp_path
+    this_path = Path(__file__).resolve()
+    exit_status = os.system(f"lamin settings set work-dir {this_path.parent}")
+    assert exit_status == 0
+    result = subprocess.run(
+        "lamin settings get work-dir",
+        capture_output=True,
+        text=True,
+        shell=True,
+    )
+    assert result.stdout.strip() == str(this_path.parent)
+    assert ln_setup.settings.work_dir == this_path.parent
+    # unset work-dir
+    exit_status = os.system("lamin settings set work-dir none")
+    assert exit_status == 0
+    result = subprocess.run(
+        "lamin settings get work-dir",
+        capture_output=True,
+        text=True,
+        shell=True,
+    )
+    assert result.stdout.strip() == "None"
+    assert ln_setup.settings.work_dir is None

{lamin_cli-1.7.2 → lamin_cli-1.8.1}/tests/core/test_save_annotate_files.py

@@ -45,7 +45,8 @@ def test_save_and_annotate_local_file():
     assert artifact.branch == branch
     assert project in artifact.projects.all()
 
-    # test passing the registry and saving the same file
+    # test passing the registry and saving the same file on the main branch
+    # it should recognize the file on the contrib1 branch
     result = subprocess.run(
         f"lamin save {filepath} --key mytest --registry artifact",
         shell=True,

{lamin_cli-1.7.2 → lamin_cli-1.8.1}/tests/core/test_save_notebooks.py

@@ -94,10 +94,8 @@ def test_save_consecutive_user_passes_uid():
         env=env,
     )
     assert result.returncode == 0
-    assert (
-        "loaded Transform('hlsFXswrJjtt0000'), started new Run"
-        in notebook_path.read_text()
-    )
+    assert "loaded Transform('hlsFXswrJjtt0000'" in notebook_path.read_text()
+    assert "started new Run" in notebook_path.read_text()
 
     # now let's simulate the interactive use case and use nbproject_test again
     # use the stem uid instead and it will bump the version
@@ -107,10 +105,8 @@ def test_save_consecutive_user_passes_uid():
     assert r"ln.track(\"hlsFXswrJjtt\")" in notebook_path.read_text()
 
     nbproject_test.execute_notebooks(notebook_path, print_outputs=True)
-    assert (
-        "created Transform('hlsFXswrJjtt0001'), started new"
-        in notebook_path.read_text()
-    )
+    assert "created Transform('hlsFXswrJjtt0001'" in notebook_path.read_text()
+    assert "started new Run" in notebook_path.read_text()
 
     # now, there is a transform record, but we're missing all artifacts because ln.finish() wasn't called
     transform = ln.Transform.filter(uid="hlsFXswrJjtt0001").one_or_none()

lamin_cli-1.7.2/lamin_cli/__init__.py

@@ -1,12 +0,0 @@
-"""Lamin CLI.
-
-This is the command line interface for interacting with LaminDB & LaminHub.
-
-The interface is defined in `__main__.py`. The root API here is used by LaminR to replicate the CLI functionality.
-"""
-
-__version__ = "1.7.2"
-
-from ._save import save
-
-__all__ = ["save"]

lamin_cli-1.7.2/lamin_cli/_settings.py

@@ -1,62 +0,0 @@
-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
-
-
-@settings.command("get")
-@click.argument(
-    "setting",
-    type=click.Choice(
-        ["auto-connect", "private-django-api", "space", "branch"], 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()
-    else:
-        value = getattr(settings_, setting.replace("-", "_"))
-    click.echo(value)