lamin_cli 0.14.0__tar.gz → 0.16.0__tar.gz

lamin_cli-0.16.0/.github/workflows/doc-changes.yml

@@ -0,0 +1,23 @@
+name: doc-changes
+
+on:
+  pull_request_target:
+    branches:
+      - main
+    types:
+      - closed
+
+jobs:
+  latest-changes:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.11"
+      - run: pip install "laminci[doc-changes]@git+https://x-access-token:${{ secrets.LAMIN_BUILD_DOCS }}@github.com/laminlabs/laminci"
+      - run: laminci doc-changes
+        env:
+          repo_token: ${{ secrets.GITHUB_TOKEN }}
+          docs_token: ${{ secrets.LAMIN_BUILD_DOCS }}
+          changelog_file: lamin-docs/docs/changelog/soon/lamindb.md

{lamin_cli-0.14.0 → lamin_cli-0.16.0}/.pre-commit-config.yaml

@@ -23,7 +23,7 @@ repos:
           - flake8-typing-imports==1.10.0
         language_version: python3
         args:
-          - --max-line-length=88
+          - --max-line-length=120
           - --ignore=E203,W503,BLK100,TYP001
         exclude: |
           (?x)(

{lamin_cli-0.14.0 → lamin_cli-0.16.0}/PKG-INFO

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

lamin_cli-0.16.0/lamin_cli/__init__.py

@@ -0,0 +1,3 @@
+"""Lamin CLI."""
+
+__version__ = "0.16.0"

{lamin_cli-0.14.0 → lamin_cli-0.16.0}/lamin_cli/__main__.py

@@ -1,16 +1,73 @@
 from __future__ import annotations
 import os
 import sys
+from collections import OrderedDict
+import inspect
 from importlib.metadata import PackageNotFoundError, version
-from typing import Optional
+from typing import Optional, Mapping
 
 # https://github.com/ewels/rich-click/issues/19
 # Otherwise rich-click takes over the formatting.
 if os.environ.get("NO_RICH"):
     import click as click
+
+    class OrderedGroup(click.Group):
+        """Overwrites list_commands to return commands in order of definition."""
+
+        def __init__(
+            self,
+            name: Optional[str] = None,
+            commands: Optional[Mapping[str, click.Command]] = None,
+            **kwargs,
+        ):
+            super(OrderedGroup, self).__init__(name, commands, **kwargs)
+            self.commands = commands or OrderedDict()
+
+        def list_commands(self, ctx: click.Context) -> Mapping[str, click.Command]:
+            return self.commands
+
+    lamin_group_decorator = click.group(cls=OrderedGroup)
+
 else:
     import rich_click as click
 
+    COMMAND_GROUPS = {
+        "lamin": [
+            {
+                "name": "Main commands",
+                "commands": [
+                    "login",
+                    "init",
+                    "load",
+                    "info",
+                    "close",
+                    "delete",
+                    "logout",
+                ],
+            },
+            {
+                "name": "Data commands",
+                "commands": ["get", "save"],
+            },
+            {
+                "name": "Configuration commands",
+                "commands": ["register", "cache", "set"],
+            },
+            {
+                "name": "Schema commands",
+                "commands": ["migrate", "schema"],
+            },
+        ]
+    }
+
+    lamin_group_decorator = click.rich_config(
+        help_config=click.RichHelpConfiguration(
+            command_groups=COMMAND_GROUPS,
+            style_commands_table_column_width_ratio=(1, 13),
+        )
+    )(click.group())
+
+
 from click import Command, Context
 from lamindb_setup._silence_loggers import silence_loggers
 
@@ -23,7 +80,7 @@ except PackageNotFoundError:
     lamindb_version = "lamindb installation not found"
 
 
-@click.group()
+@lamin_group_decorator
 @click.version_option(version=lamindb_version, prog_name="lamindb")
 def main():
     """Configure LaminDB and perform simple actions."""
@@ -31,11 +88,17 @@ def main():
 
 
 @main.command()
-def info():
-    """Show user & instance info."""
-    import lamindb_setup
+@click.argument("user", type=str)
+@click.option("--key", type=str, default=None, help="API key")
+@click.option("--password", type=str, default=None, help="legacy password")
+def login(user: str, key: Optional[str], password: Optional[str]):
+    """Login using a user email address or handle.
 
-    print(lamindb_setup.settings)
+    Examples: `lamin login marge` or `lamin login marge@acme.com`
+    """
+    from lamindb_setup._setup_user import login
+
+    return login(user, key=key, password=password)
 
 
 # fmt: off
@@ -52,25 +115,6 @@ def init(storage: str, db: Optional[str], schema: Optional[str], name: Optional[
     return init_(storage=storage, db=db, schema=schema, name=name)
 
 
-@main.command()
-@click.argument("user", type=str)
-@click.option("--key", type=str, default=None, help="API key")
-@click.option("--password", type=str, default=None, help="legacy password")
-def login(user: str, key: Optional[str], password: Optional[str]):
-    """Login using an email or user handle."""
-    from lamindb_setup._setup_user import login
-
-    return login(user, key=key, password=password)
-
-
-@main.command()
-def logout():
-    """Logout."""
-    from lamindb_setup._setup_user import logout
-
-    return logout()
-
-
 # fmt: off
 @main.command()
 @click.argument("identifier", type=str, default=None)
@@ -78,12 +122,10 @@ def logout():
 @click.option("--storage", type=str, default=None, help="Update storage while loading.")
 # fmt: on
 def load(identifier: str, db: Optional[str], storage: Optional[str]):
-    """Auto-connect to a lamindb instance.
-
-    Identifier can be slug (account_handle/instance_name) or url
-    (https://lamin.ai/account_handle/instance_name).
+    """Load an instance for auto-connection.
 
-    If the owner is the current user the instance_name suffices.
+    `IDENTIFIER` is either a slug (`account/instance`) or a `URL`
+    (`https://lamin.ai/account/instance`).
     """
     from lamindb_setup import settings, connect
 
@@ -91,53 +133,52 @@ def load(identifier: str, db: Optional[str], storage: Optional[str]):
     return connect(slug=identifier, db=db, storage=storage)
 
 
-# fmt: off
 @main.command()
-@click.argument("instance", type=str, default=None)
-@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 instance."""
-    from lamindb_setup._delete import delete
-
-    return delete(instance, force=force)
-
-
-@main.command(name="set")
-@click.argument("setting", type=click.Choice(["auto-connect"], case_sensitive=False))
-@click.argument("value", type=click.BOOL)
-def set_(setting: str, value: bool):
-    """Update settings."""
-    from lamindb_setup import settings
+def info():
+    """Show user, settings & instance info."""
+    import lamindb_setup
 
-    if setting == "auto-connect":
-        settings.auto_connect = value
+    print(lamindb_setup.settings)
 
 
 @main.command()
 def close():
-    """Close existing instance."""
+    """Close an existing instance.
+
+    Is the opposite of loading an instance.
+    """
     from lamindb_setup._close import close as close_
 
     return close_()
 
 
+# fmt: off
 @main.command()
-def register():
-    """Register an instance on the hub."""
-    from lamindb_setup._register_instance import register as register_
+@click.argument("instance", type=str, default=None)
+@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."""
+    from lamindb_setup._delete import delete
 
-    return register_()
+    return delete(instance, force=force)
 
 
 @main.command()
-@click.argument("action", type=click.Choice(["view"]))
-def schema(action: str):
-    """View schema."""
-    from lamindb_setup._schema import view
+def logout():
+    """Logout."""
+    from lamindb_setup._setup_user import logout
 
-    if action == "view":
-        return view()
+    return logout()
+
+
+@main.command()
+@click.argument("url", type=str)
+def get(url: str):
+    """Get an object from a lamin.ai URL."""
+    from lamin_cli._get import get
+
+    return get(url)
 
 
 @main.command()
@@ -155,21 +196,53 @@ def save(filepath: str, key: str, description: str):
 
 
 @main.command()
-@click.argument("url", type=str)
-def get(url: str):
-    """Get an object from a lamin.ai URL."""
-    from lamin_cli._get import get
+def register():
+    """Register an instance on the hub."""
+    from lamindb_setup._register_instance import register as register_
 
-    return get(url)
+    return register_()
 
 
 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)
 
 
+@main.command()
+@click.argument("action", type=click.Choice(["view"]))
+def schema(action: str):
+    """View schema."""
+    from lamindb_setup._schema import view
+
+    if action == "view":
+        return view()
+
+
 # https://stackoverflow.com/questions/57810659/automatically-generate-all-help-documentation-for-click-commands
+# https://claude.ai/chat/73c28487-bec3-4073-8110-50d1a2dd6b84
 def _generate_help():
-    out: dict[str, str] = {}
+    out: dict[str, dict[str, str | None]] = {}
 
     def recursive_help(
         cmd: Command, parent: Optional[Context] = None, name: tuple[str, ...] = ()
@@ -177,7 +250,16 @@ def _generate_help():
         ctx = click.Context(cmd, info_name=cmd.name, parent=parent)
         assert cmd.name
         name = (*name, cmd.name)
-        out[" ".join(name)] = cmd.get_help(ctx)
+        command_name = " ".join(name)
+
+        docstring = inspect.getdoc(cmd.callback)
+        usage = cmd.get_help(ctx).split("\n")[0]
+        options = cmd.get_help(ctx).split("Options:")[1]
+        out[command_name] = {
+            "help": usage + "\n\nOptions:" + options,
+            "docstring": docstring,
+        }
+
         for sub in getattr(cmd, "commands", {}).values():
             recursive_help(sub, ctx, name=name)
 

{lamin_cli-0.14.0 → lamin_cli-0.16.0}/lamin_cli/_get.py

@@ -32,10 +32,10 @@ def get(url: str):
 
     if entity == "transform":
         transform = ln.Transform.get(uid)
-        filepath_cache = transform.source_code.cache()
+        filepath_cache = transform._source_code_artifact.cache()
         target_filename = transform.key
-        if not target_filename.endswith(transform.source_code.suffix):
-            target_filename += transform.source_code.suffix
+        if not target_filename.endswith(transform._source_code_artifact.suffix):
+            target_filename += transform._source_code_artifact.suffix
         filepath_cache.rename(target_filename)
         logger.success(f"cached source code of transform {uid} as {target_filename}")
     elif entity == "artifact":

{lamin_cli-0.14.0 → lamin_cli-0.16.0}/tests/scripts/run-track-and-finish-sync-git.py

@@ -3,6 +3,8 @@ import lamindb as ln
 ln.settings.sync_git_repo = "https://github.com/laminlabs/lamin-cli"
 ln.settings.transform.stem_uid = "m5uCHTTpJnjQ"
 ln.settings.transform.version = "1"
+ln.settings.transform.name = "My good script"
+
 
 if __name__ == "__main__":
     # we're using new_run here to mock the notebook situation

{lamin_cli-0.14.0 → lamin_cli-0.16.0}/tests/scripts/run-track-and-finish.py

@@ -2,6 +2,7 @@ import lamindb as ln
 
 ln.settings.transform.stem_uid = "VFYCIuaw2GsX"
 ln.settings.transform.version = "1"
+ln.settings.transform.name = "My good script 2"
 
 if __name__ == "__main__":
     # we're using new_run here to mock the notebook situation

{lamin_cli-0.14.0 → lamin_cli-0.16.0}/tests/test_migrate.py

@@ -15,7 +15,7 @@ def test_migrate_deploy():
     import lamindb as ln
 
     instance_slug = ln.setup.settings.instance.slug
-    exit_status = os.system("lamin load laminlabs/static-test-instance-private-sqlite")
+    exit_status = os.system("lamin load testuser1/static-test-instance-private-sqlite")
     assert exit_status == 0
     exit_status = os.system("lamin migrate deploy")
     assert exit_status == 0

{lamin_cli-0.14.0 → lamin_cli-0.16.0}/tests/test_save_notebooks.py

@@ -81,8 +81,8 @@ def test_save_consecutive():
     # now, there is a transform record, but we're missing all artifacts
     transform = ln.Transform.filter(uid="hlsFXswrJjtt5zKv").one_or_none()
     assert transform is not None
-    assert transform.latest_report is None
-    assert transform.source_code is None
+    assert transform.latest_run.report is None
+    assert transform._source_code_artifact is None
     assert transform.latest_run.environment is None
 
     # and save again
@@ -97,11 +97,11 @@ def test_save_consecutive():
     # now, we have the associated artifacts
     transform = ln.Transform.filter(uid="hlsFXswrJjtt5zKv").one_or_none()
     assert transform is not None
-    assert transform.latest_report.path.exists()
-    assert transform.latest_run.report.path == transform.latest_report.path
-    assert transform.source_code.hash == "5nc_HMjPvT9n26OWrjq6uQ"
+    assert transform.latest_run.report.path.exists()
+    assert transform.latest_run.report.path == transform.latest_run.report.path
+    assert transform._source_code_artifact.hash == "5nc_HMjPvT9n26OWrjq6uQ"
     assert transform.latest_run.environment.path.exists()
-    assert transform.source_code.path.exists()
+    assert transform._source_code_artifact.path.exists()
 
     # now, assume the user modifies the notebook
     nb = read_notebook(notebook_path)
@@ -128,11 +128,11 @@ def test_save_consecutive():
     assert result.returncode == 0
     # the source code is overwritten with the edits, reflected in a new hash
     transform = ln.Transform.get("hlsFXswrJjtt5zKv")
-    assert transform.latest_report.path.exists()
-    assert transform.latest_run.report.path == transform.latest_report.path
-    assert transform.source_code.hash == "ocLybD0Hv_L3NhhXgTyQcw"
+    assert transform.latest_run.report.path.exists()
+    assert transform.latest_run.report.path == transform.latest_run.report.path
+    assert transform._source_code_artifact.hash == "ocLybD0Hv_L3NhhXgTyQcw"
     assert transform.latest_run.environment.path.exists()
-    assert transform.source_code.path.exists()
+    assert transform._source_code_artifact.path.exists()
 
     # get the the source code via command line
     result = subprocess.run(

{lamin_cli-0.14.0 → lamin_cli-0.16.0}/tests/test_save_scripts.py

@@ -37,9 +37,9 @@ def test_run_save_cache():
     assert "saved: Run" in result.stdout.decode()
 
     transform = ln.Transform.get("m5uCHTTpJnjQ")
-    assert transform.source_code.hash == "-QN2dVdC8T3xWG8vBl-wew"
+    assert transform._source_code_artifact.hash == "T1zmmTJyeEpBxjaHcHcZdg"
     assert transform.latest_run.environment.path.exists()
-    assert transform.source_code.path.exists()
+    assert transform._source_code_artifact.path.exists()
 
     # you can rerun the same script
     result = subprocess.run(

lamin_cli-0.14.0/lamin_cli/__init__.py

@@ -1,3 +0,0 @@
-"""Lamin CLI."""
-
-__version__ = "0.14.0"