lamindb_setup 0.76.8__tar.gz → 0.77.1__tar.gz

{lamindb_setup-0.76.8 → lamindb_setup-0.77.1}/.github/workflows/build.yml

@@ -19,7 +19,7 @@ jobs:
         with:
           python-version: "3.10" # run one job on 3.9
           cache: "pip"
-      - uses: aws-actions/configure-aws-credentials@v2
+      - uses: aws-actions/configure-aws-credentials@v4
         with:
           aws-access-key-id: ${{ secrets.AWS_ACCESS_KEY_ID }}
           aws-secret-access-key: ${{ secrets.AWS_SECRET_ACCESS_KEY }}
@@ -45,7 +45,7 @@ jobs:
             python-version: "3.10" # test on 3.9
     timeout-minutes: 7
     steps:
-      - uses: aws-actions/configure-aws-credentials@v2
+      - uses: aws-actions/configure-aws-credentials@v4
         with:
           aws-access-key-id: ${{ secrets.AWS_ACCESS_KEY_ID }}
           aws-secret-access-key: ${{ secrets.AWS_SECRET_ACCESS_KEY }}
@@ -62,12 +62,12 @@ jobs:
           token: ${{ secrets.GH_TOKEN_DEPLOY_LAMINAPP }}
           path: laminhub
           ref: main
-      - uses: actions/cache@v3
+      - uses: actions/cache@v4
         with:
           path: ~/.cache/pre-commit
           key: pre-commit-${{ runner.os }}-${{ hashFiles('.pre-commit-config.yaml') }}
       - id: cache-postgres
-        uses: actions/cache@v3
+        uses: actions/cache@v4
         with:
           path: ~/postgres.tar
           key: cache-postgres-0
@@ -118,7 +118,7 @@ jobs:
     runs-on: ubuntu-latest
     timeout-minutes: 6
     steps:
-      - uses: aws-actions/configure-aws-credentials@v2
+      - uses: aws-actions/configure-aws-credentials@v4
         with:
           aws-access-key-id: ${{ secrets.AWS_ACCESS_KEY_ID }}
           aws-secret-access-key: ${{ secrets.AWS_SECRET_ACCESS_KEY }}
@@ -144,7 +144,7 @@ jobs:
       - run: pip install "laminci@git+https://x-access-token:${{ secrets.LAMIN_BUILD_DOCS }}@github.com/laminlabs/laminci"
       - run: nox -s "install(group='hub-local')"
       - id: cache-supabase
-        uses: actions/cache@v3
+        uses: actions/cache@v4
         with:
           path: /var/lib/docker
           key: cache-supabase
@@ -183,7 +183,7 @@ jobs:
     needs: hub-cloud
     runs-on: ubuntu-latest
     steps:
-      - uses: aws-actions/configure-aws-credentials@v2
+      - uses: aws-actions/configure-aws-credentials@v4
         with:
           aws-access-key-id: ${{ secrets.AWS_ACCESS_KEY_ID }}
           aws-secret-access-key: ${{ secrets.AWS_SECRET_ACCESS_KEY }}

{lamindb_setup-0.76.8 → lamindb_setup-0.77.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: lamindb_setup
-Version: 0.76.8
+Version: 0.77.1
 Summary: Setup & configure LaminDB.
 Author-email: Lamin Labs <open-source@lamin.ai>
 Description-Content-Type: text/markdown

{lamindb_setup-0.76.8 → lamindb_setup-0.77.1}/docs/hub-cloud/07-keep-artifacts-local.ipynb

@@ -16,22 +16,26 @@
     "# this shouldn't run in a notebook, but in the unit tests\n",
     "# currently still limited because of inability to load multiple instances\n",
     "\n",
+    "import os\n",
     "import pytest\n",
     "import lamindb_setup as ln_setup\n",
-    "from pathlib import Path\n",
+    "from upath import UPath\n",
+    "\n",
+    "name = f\"keep-artifacts-local-setup-{os.environ['LAMIN_ENV']}\"\n",
+    "storage = (UPath(\"s3://lamindb-ci\") / name).as_posix()\n",
     "\n",
     "ln_setup.login(\"testuser1\")\n",
-    "ln_setup.init(storage=\"s3://lamindb-ci/keep-artifacts-local-setup\")\n",
+    "ln_setup.init(storage=storage)\n",
     "\n",
-    "assert ln_setup.settings.instance.name == \"keep-artifacts-local-setup\"\n",
+    "assert ln_setup.settings.instance.name == name\n",
     "assert ln_setup.settings.instance.storage.type_is_cloud\n",
     "assert (\n",
     "    ln_setup.settings.instance.storage.root_as_str\n",
-    "    == \"s3://lamindb-ci/keep-artifacts-local-setup\"\n",
+    "    == storage\n",
     ")\n",
     "assert (\n",
     "    ln_setup.settings.instance._sqlite_file.as_posix()\n",
-    "    == f\"s3://lamindb-ci/keep-artifacts-local-setup/{ln_setup.settings.instance._id.hex}.lndb\"  # noqa\n",
+    "    == f\"{storage}/{ln_setup.settings.instance._id.hex}.lndb\"  # noqa\n",
     ")"
    ]
   },
@@ -68,12 +72,12 @@
     "\n",
     "assert (\n",
     "    ln_setup.settings.instance.storage_local.root.as_posix()\n",
-    "    == Path(\"./my_storage_local\").resolve().as_posix()\n",
+    "    == UPath(\"./my_storage_local\").resolve().as_posix()\n",
     ")\n",
     "assert (ln_setup.settings.instance.storage_local.root / \".lamindb/_is_initialized\").read_text() == ln_setup.settings.instance.storage_local.uid\n",
     "assert ln_setup.settings.instance.storage_local is not None\n",
     "# the remote storage location is still in the regular slot\n",
-    "assert ln_setup.settings.instance.storage.root.as_posix() == \"s3://lamindb-ci/keep-artifacts-local-setup\""
+    "assert ln_setup.settings.instance.storage.root.as_posix() == storage"
    ]
   },
   {
@@ -100,7 +104,7 @@
    "source": [
     "assert (\n",
     "    ln_setup.settings.instance.storage_local.root.as_posix()\n",
-    "    == Path(\"./my_storage_local2\").resolve().as_posix()\n",
+    "    == UPath(\"./my_storage_local2\").resolve().as_posix()\n",
     ")\n",
     "assert (ln_setup.settings.instance.storage_local.root / \".lamindb/_is_initialized\").read_text() == ln_setup.settings.instance.storage_local.uid"
    ]
@@ -170,7 +174,7 @@
    "outputs": [],
    "source": [
     "with pytest.raises(ln_setup.core.upath.InstanceNotEmpty):\n",
-    "    ln_setup.delete(\"keep-artifacts-local-setup\", force=True)"
+    "    ln_setup.delete(name, force=True)"
    ]
   },
   {
@@ -188,13 +192,13 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "ln_setup.delete(\"keep-artifacts-local-setup\", force=True)"
+    "ln_setup.delete(name, force=True)"
    ]
   }
  ],
  "metadata": {
   "kernelspec": {
-   "display_name": "py310",
+   "display_name": "Python 3 (ipykernel)",
    "language": "python",
    "name": "python3"
   },
@@ -208,7 +212,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.10.13"
+   "version": "3.9.17"
   }
  },
  "nbformat": 4,

lamindb_setup-0.77.1/docs/hub-prod/test-init-load-local-anonymously.ipynb

@@ -0,0 +1,140 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "c4107648",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import lamindb_setup as ln_setup"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "8587fb8e",
+   "metadata": {},
+   "source": [
+    "Check current user."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "66c361b1",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "ln_setup.login(\"testuser2\")\n",
+    "assert ln_setup.settings.user.handle == \"testuser2\""
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "c6cc67f2",
+   "metadata": {},
+   "source": [
+    "logout and check that the user info was updated."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "7a572ee2",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "ln_setup.logout()\n",
+    "assert ln_setup.settings.user.handle == \"anonymous\""
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "4b8b119f",
+   "metadata": {},
+   "source": [
+    "Init a local instance anonymously."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "f8663b52",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!lamin close\n",
+    "!lamin init --storage ./test-anonymous-init --schema bionty"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "a9f53d46",
+   "metadata": {},
+   "source": [
+    "Load the instance and check."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "1bb37c25",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "ln_setup.load(\"test-anonymous-init\")\n",
+    "assert ln_setup.settings.instance.name == \"test-anonymous-init\"\n",
+    "assert ln_setup.settings.instance.owner == \"anonymous\""
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "9c19ede8",
+   "metadata": {},
+   "source": [
+    "Clean up."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "b37256df",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "ln_setup.delete(\"test-anonymous-init\", force=True)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "c1eea364",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "ln_setup.login(\"testuser2\")"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.9.17"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

{lamindb_setup-0.76.8 → lamindb_setup-0.77.1}/docs/hub-prod/test-insufficient-user-info.ipynb

@@ -1,7 +1,6 @@
 {
  "cells": [
   {
-   "attachments": {},
    "cell_type": "markdown",
    "metadata": {},
    "source": [
@@ -33,7 +32,6 @@
    ]
   },
   {
-   "attachments": {},
    "cell_type": "markdown",
    "metadata": {},
    "source": [
@@ -46,16 +44,15 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "with pytest.raises(TypeError):\n",
+    "with pytest.raises(ValueError):\n",
     "    ln_setup.login()"
    ]
   },
   {
-   "attachments": {},
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "If we add an email or handle it looks up the password from the stored env file (`lamin login testuser1@lamin.ai`):"
+    "If we add an email or handle it looks up credentials from the stored env file (`lamin login testuser1@lamin.ai`):"
    ]
   },
   {
@@ -68,7 +65,6 @@
    ]
   },
   {
-   "attachments": {},
    "cell_type": "markdown",
    "metadata": {},
    "source": [
@@ -89,7 +85,6 @@
    ]
   },
   {
-   "attachments": {},
    "cell_type": "markdown",
    "metadata": {},
    "source": [
@@ -102,16 +97,15 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "with pytest.raises(RuntimeError):\n",
-    "    ln_setup.login(\"testuser1\", password=\"dummy\")"
+    "with pytest.raises(SystemExit):\n",
+    "    ln_setup.login(\"testuser1\", key=\"dummy\")"
    ]
   },
   {
-   "attachments": {},
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "If we try to login without password, this will error:"
+    "If we try to login without key, this will error:"
    ]
   },
   {
@@ -120,16 +114,15 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "with pytest.raises(RuntimeError):\n",
+    "with pytest.raises(SystemExit):\n",
     "    ln_setup.login(\"testuser1@lamin.ai\")"
    ]
   },
   {
-   "attachments": {},
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "If we try login with a wrong password, this will error:"
+    "If we try login with a wrong key, this will error:"
    ]
   },
   {
@@ -186,7 +179,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.10.13"
+   "version": "3.9.17"
   },
   "nbproject": {
    "id": "vLOmzd6d4Jow",

{lamindb_setup-0.76.8 → lamindb_setup-0.77.1}/docs/hub-prod/test-sqlite-lock.ipynb

@@ -11,24 +11,24 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "89b7057a",
+   "id": "69eeefee",
    "metadata": {},
    "outputs": [],
    "source": [
-    "!lamin login testuser2"
+    "import pytest\n",
+    "import lamindb_setup as ln_setup\n",
+    "from lamindb_setup.core.cloud_sqlite_locker import Locker, InstanceLockedException\n",
+    "from lamindb_setup.core.upath import UPath"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "69eeefee",
+   "id": "5605dfcd",
    "metadata": {},
    "outputs": [],
    "source": [
-    "import pytest\n",
-    "import lamindb_setup as ln_setup\n",
-    "from lamindb_setup.core.cloud_sqlite_locker import Locker, InstanceLockedException\n",
-    "from lamindb_setup.core.upath import UPath"
+    "ln_setup.login(\"testuser2\")"
    ]
   },
   {

{lamindb_setup-0.76.8 → lamindb_setup-0.77.1}/docs/notebooks.md

@@ -17,6 +17,7 @@ hub-prod/test-empty-init
 hub-prod/test-import-schema
 hub-prod/test-invalid-schema
 hub-prod/test-insufficient-user-info
+hub-prod/test-init-load-local-anonymously
 hub-prod/test-connect-anonymously
 hub-prod/test-sqlite-lock
 hub-prod/test-cloud-sync

{lamindb_setup-0.76.8 → lamindb_setup-0.77.1}/lamindb_setup/__init__.py

@@ -34,10 +34,10 @@ Modules & settings:
 
 """
 
-__version__ = "0.76.8"  # denote a release candidate for 0.1.0 with 0.1rc1
+__version__ = "0.77.1"  # denote a release candidate for 0.1.0 with 0.1rc1
 
-import sys
-from os import name as _os_name
+import os as _os
+import sys as _sys
 
 from . import core
 from ._check_setup import _check_instance_setup
@@ -45,18 +45,18 @@ from ._close import close
 from ._connect_instance import connect, load
 from ._delete import delete
 from ._django import django
+from ._entry_points import call_registered_entry_points as _call_registered_entry_points
 from ._init_instance import init
 from ._migrate import migrate
 from ._register_instance import register
 from ._setup_user import login, logout
 from .core._settings import settings
 
-dev = core  # backward compat
-_TESTING = False  # used in lamindb tests
+_TESTING = _os.getenv("LAMIN_TESTING") is not None
 
 # hide the supabase error in a thread on windows
-if _os_name == "nt":
-    if sys.version_info.minor > 7:
+if _os.name == "nt":
+    if _sys.version_info.minor > 7:
         import threading
 
         _original_excepthook = threading.excepthook
@@ -69,4 +69,7 @@ if _os_name == "nt":
 
         threading.excepthook = _except_hook
 
+# provide a way for other packages to run custom code on import
+_call_registered_entry_points("lamindb_setup.on_import")
+
 settings.__doc__ = """Global :class:`~lamindb.setup.core.SetupSettings`."""

{lamindb_setup-0.76.8 → lamindb_setup-0.77.1}/lamindb_setup/_connect_instance.py

@@ -124,7 +124,11 @@ def _connect_instance(
     if make_hub_request:
         # the following will return a string if the instance does not exist
         # on the hub
-        hub_result = load_instance_from_hub(owner=owner, name=name)
+        # do not call hub if the user is anonymous
+        if owner != "anonymous":
+            hub_result = load_instance_from_hub(owner=owner, name=name)
+        else:
+            hub_result = "anonymous-user"
         # if hub_result is not a string, it means it made a request
         # that successfully returned metadata
         if not isinstance(hub_result, str):
@@ -155,9 +159,12 @@ def _connect_instance(
             )
             check_whether_migrations_in_sync(instance_result["lamindb_version"])
         else:
-            message = INSTANCE_NOT_FOUND_MESSAGE.format(
-                owner=owner, name=name, hub_result=hub_result
-            )
+            if hub_result != "anonymous-user":
+                message = INSTANCE_NOT_FOUND_MESSAGE.format(
+                    owner=owner, name=name, hub_result=hub_result
+                )
+            else:
+                message = "It is not possible to load an anonymous-owned instance from the hub"
             if settings_file.exists():
                 isettings = load_instance_settings(settings_file)
                 if isettings.is_remote:

lamindb_setup-0.77.1/lamindb_setup/_entry_points.py

@@ -0,0 +1,22 @@
+import sys
+import warnings
+from importlib.metadata import entry_points
+
+
+def call_registered_entry_points(group, **kwargs):
+    """load and call entry points registered under group."""
+    if sys.version_info >= (3, 10):
+        eps = entry_points(group=group)
+    else:
+        eps = entry_points().get(group, [])
+
+    for ep in eps:
+        func = ep.load()
+        try:
+            func(**kwargs)
+        except BaseException as e:
+            warnings.warn(
+                f"Error loading entry point of group {group!r}: {ep} -> {e}",
+                RuntimeWarning,
+                stacklevel=2,
+            )

{lamindb_setup-0.76.8 → lamindb_setup-0.77.1}/lamindb_setup/_setup_user.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
-from typing import Optional, Union
+import os
+from typing import TYPE_CHECKING, Optional, Union
 
 from lamin_utils import logger
 
@@ -15,8 +16,11 @@ from .core._settings_store import (
     user_settings_file_handle,
 )
 
+if TYPE_CHECKING:
+    from lamindb_setup.core._settings_save import UserSettings
 
-def load_user(email: str | None = None, handle: str | None = None) -> str | None:
+
+def load_user(email: str | None = None, handle: str | None = None) -> UserSettings:
     if email is not None:
         settings_file = user_settings_file_email(email)
     if handle is not None:
@@ -28,8 +32,8 @@ def load_user(email: str | None = None, handle: str | None = None) -> str | None
     else:
         user_settings = load_or_create_user_settings()
         if email is None:
-            raise RuntimeError(
-                "Use your email for your first login in a compute environment. "
+            raise SystemExit(
+                "✗ Use your email for your first login in a compute environment. "
                 "After that, you can use your handle."
             )
         user_settings.email = email
@@ -40,59 +44,68 @@ def load_user(email: str | None = None, handle: str | None = None) -> str | None
 
     settings._user_settings = None  # this is to refresh a settings instance
 
-    return None
+    return user_settings
 
 
 def login(
-    user: str,
-    *,
-    key: str | None = None,
-    password: str | None = None,  # for backward compat
+    user: str | None = None, *, key: str | None = None, api_key: str | None = None
 ) -> None:
     """Log in user.
 
     Args:
         user: handle or email
-        key: API key or legacy passward
-        password: Backward compat, will be removed
+        key: API key
+        api_key: Beta API key
     """
-    if "@" in user:
-        email, handle = user, None
+    if user is None and api_key is None:
+        if "LAMIN_API_KEY" in os.environ:
+            api_key = os.environ["LAMIN_API_KEY"]
+        else:
+            raise ValueError("Both `user` and `api_key` should not be `None`.")
+
+    if api_key is None:
+        if "@" in user:  # type: ignore
+            email, handle = user, None
+        else:
+            email, handle = None, user
+        user_settings = load_user(email, handle)
+
+        if key is not None:
+            # within UserSettings, we still call it "password" for a while
+            user_settings.password = key
+
+        if user_settings.email is None:
+            raise SystemExit(f"✗ No stored user email, please call: lamin login {user}")
+
+        if user_settings.password is None:
+            raise SystemExit(
+                "✗ No stored API key, please call: lamin login <your-email> --key <API-key>"
+            )
     else:
-        email, handle = None, user
-    load_user(email, handle)
-
-    user_settings = load_or_create_user_settings()
-
-    if password is not None:
-        logger.warning(
-            "please use --key instead of --password, "
-            "passwords are deprecated and replaced with API keys"
-        )
-        key = password
-
-    if key is not None:
-        # within UserSettings, we still call it "password" for a while
-        user_settings.password = key
+        user_settings = load_or_create_user_settings()
 
-    if user_settings.email is None:
-        raise RuntimeError("No stored user email, please call: lamin login {user}")
+    from .core._hub_core import sign_in_hub, sign_in_hub_api_key
 
-    if user_settings.password is None:
-        raise RuntimeError(
-            "No stored API key, please call: lamin login <your-email> --key <API-key>"
+    if api_key is None:
+        response = sign_in_hub(
+            user_settings.email,  # type: ignore
+            user_settings.password,  # type: ignore
+            user_settings.handle,
         )
+    else:
+        response = sign_in_hub_api_key(api_key)
 
-    from .core._hub_core import sign_in_hub
-
-    response = sign_in_hub(
-        user_settings.email, user_settings.password, user_settings.handle
-    )
     if isinstance(response, Exception):
         raise response
+    elif isinstance(response, str):
+        raise SystemExit(f"✗ Unsuccessful login: {response}.")
     else:
         user_uuid, user_id, user_handle, user_name, access_token = response
-    if handle is None:
+    if api_key is not None:
+        logger.success(
+            f"logged in with API key (handle: {user_handle}, uid: {user_id})"
+        )
+    elif handle is None:
         logger.success(f"logged in with handle {user_handle} (uid: {user_id})")
     else:
         logger.success(f"logged in with email {user_settings.email} (uid: {user_id})")
@@ -101,6 +114,7 @@ def login(
     user_settings.name = user_name
     user_settings._uuid = user_uuid
     user_settings.access_token = access_token
+    user_settings.api_key = api_key
     save_user_settings(user_settings)
 
     if settings._instance_exists and _check_instance_setup():
@@ -113,6 +127,8 @@ def login(
 def logout():
     if current_user_settings_file().exists():
         current_user_settings_file().unlink()
+        # update user info
+        settings._user_settings = None
         logger.success("logged out")
     else:
         logger.important("already logged out")