lamindb_setup 0.76.8__tar.gz → 0.77.0__tar.gz

{lamindb_setup-0.76.8 → lamindb_setup-0.77.0}/.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.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: lamindb_setup
-Version: 0.76.8
+Version: 0.77.0
 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.0}/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.0/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.0}/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.0}/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.0}/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.0}/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.0"  # 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
@@ -51,12 +51,11 @@ 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

{lamindb_setup-0.76.8 → lamindb_setup-0.77.0}/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.76.8 → lamindb_setup-0.77.0}/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")

{lamindb_setup-0.76.8 → lamindb_setup-0.77.0}/lamindb_setup/core/_hub_client.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import json
 import os
 from urllib.request import urlretrieve
 
@@ -78,7 +79,7 @@ def connect_hub_with_auth(
 
         if renew_token:
             settings.user.access_token = get_access_token(
-                settings.user.email, settings.user.password
+                settings.user.email, settings.user.password, settings.user.api_key
             )
         access_token = settings.user.access_token
     hub.postgrest.auth(access_token)
@@ -87,9 +88,17 @@ def connect_hub_with_auth(
 
 
 # runs ~0.5s
-def get_access_token(email: str | None = None, password: str | None = None):
+def get_access_token(
+    email: str | None = None, password: str | None = None, api_key: str | None = None
+):
     hub = connect_hub()
     try:
+        if api_key is not None:
+            auth_response = hub.functions.invoke(
+                "create-jwt",
+                invoke_options={"body": {"api_key": api_key}},
+            )
+            return json.loads(auth_response)["accessToken"]
         auth_response = hub.auth.sign_in_with_password(
             {
                 "email": email,

{lamindb_setup-0.76.8 → lamindb_setup-0.77.0}/lamindb_setup/core/_hub_core.py

@@ -436,10 +436,11 @@ def _sign_in_hub(email: str, password: str, handle: str | None, client: Client):
     )
     data = client.table("account").select("*").eq("id", auth.user.id).execute().data
     if data:  # sync data from hub to local cache in case it was updated on the hub
-        user_uuid = UUID(data[0]["id"])
-        user_id = data[0]["lnid"]
-        user_handle = data[0]["handle"]
-        user_name = data[0]["name"]
+        user = data[0]
+        user_uuid = UUID(user["id"])
+        user_id = user["lnid"]
+        user_handle = user["handle"]
+        user_name = user["name"]
         if handle is not None and handle != user_handle:
             logger.warning(
                 f"using account handle {user_handle} (cached handle was {handle})"
@@ -458,7 +459,7 @@ def _sign_in_hub(email: str, password: str, handle: str | None, client: Client):
 
 def sign_in_hub(
     email: str, password: str, handle: str | None = None
-) -> Exception | tuple[UUID, str, str, str, str]:
+) -> Exception | str | tuple[UUID, str, str, str, str]:
     try:
         result = call_with_fallback(
             _sign_in_hub, email=email, password=password, handle=handle
@@ -471,3 +472,53 @@ def sign_in_hub(
         )
         return exception
     return result
+
+
+def _sign_in_hub_api_key(api_key: str, client: Client):
+    response = client.functions.invoke(
+        "create-jwt",
+        invoke_options={"body": {"api_key": api_key}},
+    )
+    access_token = json.loads(response)["accessToken"]
+    # probably need more info here to avoid additional queries
+    # like handle, uid etc
+    account_id = client.auth._decode_jwt(access_token)["sub"]
+    client.postgrest.auth(access_token)
+    # normally public.account.id is equal to auth.user.id
+    data = client.table("account").select("*").eq("id", account_id).execute().data
+    if data:
+        user = data[0]
+        user_uuid = UUID(user["id"])
+        user_id = user["lnid"]
+        user_handle = user["handle"]
+        user_name = user["name"]
+    else:
+        logger.error("Invalid API key.")
+        return "invalid-api-key"
+    return (user_uuid, user_id, user_handle, user_name, access_token)
+
+
+def sign_in_hub_api_key(
+    api_key: str,
+) -> Exception | str | tuple[UUID, str, str, str, str]:
+    try:
+        result = call_with_fallback(_sign_in_hub_api_key, api_key=api_key)
+    except Exception as exception:
+        logger.error(exception)
+        logger.error("Could not login. Probably your API key is wrong.")
+        return exception
+    return result
+
+
+def _create_api_key(body: dict, client: Client) -> str:
+    response = client.functions.invoke(
+        "create-api-key",
+        invoke_options={"body": body},
+    )
+    api_key = json.loads(response)["apiKey"]
+    return api_key
+
+
+def create_api_key(body: dict) -> str:
+    api_key = call_with_fallback_auth(_create_api_key, body=body)
+    return api_key

{lamindb_setup-0.76.8 → lamindb_setup-0.77.0}/lamindb_setup/core/_settings_load.py

@@ -71,30 +71,35 @@ def load_user_settings(user_settings_file: Path):
     return settings
 
 
+def _null_to_value(field, value=None):
+    return field if field != "null" else value
+
+
 def setup_instance_from_store(store: InstanceSettingsStore) -> InstanceSettings:
     ssettings = StorageSettings(
         root=store.storage_root,
-        region=store.storage_region if store.storage_region != "null" else None,
+        region=_null_to_value(store.storage_region),
     )
     return InstanceSettings(
         id=UUID(store.id),
         owner=store.owner,
         name=store.name,
         storage=ssettings,
-        db=store.db if store.db != "null" else None,  # type: ignore
-        schema=store.schema_str if store.schema_str != "null" else None,
-        git_repo=store.git_repo if store.git_repo != "null" else None,
+        db=_null_to_value(store.db),
+        schema=_null_to_value(store.schema_str),
+        git_repo=_null_to_value(store.git_repo),
         keep_artifacts_local=store.keep_artifacts_local,  # type: ignore
     )
 
 
 def setup_user_from_store(store: UserSettingsStore) -> UserSettings:
     settings = UserSettings()
-    settings.email = store.email
-    settings.password = store.password if store.password != "null" else None
+    settings.email = _null_to_value(store.email)
+    settings.password = _null_to_value(store.password)
     settings.access_token = store.access_token
+    settings.api_key = _null_to_value(store.api_key)
     settings.uid = store.uid
-    settings.handle = store.handle if store.handle != "null" else "anonymous"
-    settings.name = store.name if store.name != "null" else None
+    settings.handle = _null_to_value(store.handle, value="anonymous")
+    settings.name = _null_to_value(store.name)
     settings._uuid = UUID(store.uuid) if store.uuid != "null" else None
     return settings

{lamindb_setup-0.76.8 → lamindb_setup-0.77.0}/lamindb_setup/core/_settings_store.py

@@ -65,6 +65,7 @@ class UserSettingsStore(BaseSettings):
     email: str
     password: str
     access_token: str
+    api_key: Optional[str] = None
     uid: str
     uuid: str
     handle: str

{lamindb_setup-0.76.8 → lamindb_setup-0.77.0}/lamindb_setup/core/_settings_user.py

@@ -21,8 +21,10 @@ class UserSettings:
 
     handle: str = "anonymous"
     """Unique handle."""
-    email: str = None  # type: ignore
+    email: str | None = None
     """User email."""
+    api_key: str | None = None
+    """Beta API key."""
     password: str | None = None
     """API key or legacy password."""
     access_token: str | None = None

{lamindb_setup-0.76.8 → lamindb_setup-0.77.0}/noxfile.py

@@ -27,7 +27,7 @@ def lint(session: nox.Session) -> None:
     ["hub-local", "hub-prod", "hub-cloud", "storage", "docs"],
 )
 def install(session: nox.Session, group: str) -> None:
-    no_deps_packages = "git+https://github.com/laminlabs/lnschema-core git+https://github.com/laminlabs/wetlab lamin-cli"
+    no_deps_packages = "git+https://github.com/laminlabs/lnschema-core git+https://github.com/laminlabs/wetlab git+https://github.com/laminlabs/lamin-cli"
     schema_deps = f"""uv pip install --system git+https://github.com/laminlabs/bionty git+https://github.com/laminlabs/lamindb@main
 uv pip install --system --no-deps {no_deps_packages}
 """

{lamindb_setup-0.76.8 → lamindb_setup-0.77.0}/tests/hub-cloud/test_connect_instance.py

@@ -18,6 +18,15 @@ from postgrest.exceptions import APIError
 #     ln_setup.delete("load_remote_instance", force=True)
 
 
+# do not call hub if the owner is set to anonymous
+def test_connect_anonymous_owned_instance_from_hub():
+    with pytest.raises(InstanceNotFoundError) as error:
+        ln_setup.connect("anonymous/random-instance-not-exists")
+    assert error.exconly().endswith(
+        "It is not possible to load an anonymous-owned instance from the hub"
+    )
+
+
 def test_connect_after_revoked_access():
     # can't currently test this on staging as I'm missing the accounts
     if os.getenv("LAMIN_ENV") == "prod":

lamindb_setup-0.77.0/tests/hub-cloud/test_login.py

@@ -0,0 +1,67 @@
+from __future__ import annotations
+
+import json
+import os
+from datetime import datetime, timedelta, timezone
+
+import lamindb_setup as ln_setup
+import pytest
+from lamindb_setup.core._hub_client import connect_hub_with_auth
+from lamindb_setup.core._hub_core import create_api_key
+from supafunc.errors import FunctionsHttpError
+
+
+def test_login():
+    ln_setup.login("testuser1")
+    assert ln_setup.settings.user.email == "testuser1@lamin.ai"
+    assert ln_setup.settings.user.uid == "DzTjkKse"
+    assert ln_setup.settings.user.handle == "testuser1"
+
+    import jwt
+
+    access_token_payload = jwt.decode(
+        ln_setup.settings.user.access_token,
+        algorithms="HS256",
+        options={"verify_signature": False},
+    )
+    assert access_token_payload["email"] == "testuser1@lamin.ai"
+
+
+def test_login_api_key():
+    ln_setup.login("testuser1")
+    # obtain API key
+    expires_at = (datetime.now(tz=timezone.utc) + timedelta(days=1)).strftime(
+        "%Y-%m-%d"
+    )
+    api_key = create_api_key(
+        {"expires_at": expires_at, "description": "test_login_api_key"}
+    )
+
+    ln_setup.logout()
+    assert ln_setup.settings.user.handle == "anonymous"
+
+    with pytest.raises(FunctionsHttpError):
+        ln_setup.login(api_key="invalid-key")
+
+    with pytest.raises(ValueError):
+        ln_setup.login(user=None, api_key=None)
+
+    os.environ["LAMIN_API_KEY"] = api_key
+    ln_setup.login()
+    assert ln_setup.settings.user.handle == "testuser1"
+    assert ln_setup.settings.user.api_key == api_key
+
+    ln_setup.logout()
+
+    ln_setup.login(api_key=api_key)
+    assert ln_setup.settings.user.handle == "testuser1"
+    assert ln_setup.settings.user.api_key == api_key
+
+    # clean up
+    # here checks also refreshing access token with api_key
+    hub = connect_hub_with_auth(renew_token=True)
+    hub.table("api_key").delete().eq("description", "test_login_api_key").execute()
+    hub.auth.sign_out({"scope": "local"})
+
+    # login back with email to populate all fields
+    ln_setup.login("testuser1@lamin.ai")

lamindb_setup-0.76.8/tests/hub-cloud/test_login.py

@@ -1,19 +0,0 @@
-from __future__ import annotations
-
-import lamindb_setup as ln_setup
-
-
-def test_login():
-    ln_setup.login("testuser1")
-    assert ln_setup.settings.user.email == "testuser1@lamin.ai"
-    assert ln_setup.settings.user.uid == "DzTjkKse"
-    assert ln_setup.settings.user.handle == "testuser1"
-
-    import jwt
-
-    access_token_payload = jwt.decode(
-        ln_setup.settings.user.access_token,
-        algorithms="HS256",
-        options={"verify_signature": False},
-    )
-    assert access_token_payload["email"] == "testuser1@lamin.ai"