lamindb_setup 1.11.0__tar.gz → 1.12.1__tar.gz

{lamindb_setup-1.11.0 → lamindb_setup-1.12.1}/.github/workflows/build.yml

@@ -15,7 +15,7 @@ jobs:
     timeout-minutes: 12
     steps:
       - uses: actions/checkout@v4
-      - uses: actions/setup-python@v5
+      - uses: actions/setup-python@v6
         with:
           python-version: "3.10"
           cache: "pip"
@@ -52,7 +52,7 @@ jobs:
           aws-secret-access-key: ${{ secrets.AWS_SECRET_ACCESS_KEY }}
           aws-region: eu-central-1
       - uses: actions/checkout@v4
-      - uses: actions/setup-python@v4
+      - uses: actions/setup-python@v6
         with:
           python-version: ${{ matrix.python-version }}
           cache: "pip"
@@ -97,7 +97,7 @@ jobs:
     timeout-minutes: 12
     steps:
       - uses: actions/checkout@v4
-      - uses: actions/setup-python@v5
+      - uses: actions/setup-python@v6
         with:
           python-version: "3.10"
           cache: "pip"
@@ -139,7 +139,7 @@ jobs:
           echo "AWS_ACCESS_KEY_ID_HOSTED_S3=${{ secrets.AWS_ACCESS_KEY_ID }}" >> .env.local
           echo "AWS_SECRET_ACCESS_KEY_HOSTED_S3=${{ secrets.AWS_SECRET_ACCESS_KEY }}" >> .env.local
         working-directory: laminhub/rest-hub/supabase
-      - uses: actions/setup-python@v4
+      - uses: actions/setup-python@v6
         with:
           python-version: "3.11" # we need to run everything for coverage on 3.11
           cache: "pip"
@@ -168,7 +168,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v4
-      - uses: actions/setup-python@v4
+      - uses: actions/setup-python@v6
         with:
           python-version: "3.11"
           cache: "pip"
@@ -205,7 +205,7 @@ jobs:
           ssh-key: ${{ secrets.READ_LNDOCS }}
           path: lndocs
           ref: main
-      - uses: actions/setup-python@v5
+      - uses: actions/setup-python@v6
         with:
           python-version: "3.10"
           cache: "pip"

{lamindb_setup-1.11.0 → lamindb_setup-1.12.1}/.gitignore

@@ -69,6 +69,9 @@ instance/
 # Scrapy stuff:
 .scrapy
 
+# Ruff
+.ruff_cache
+
 # Sphinx documentation
 docs/_build/
 

{lamindb_setup-1.11.0 → lamindb_setup-1.12.1}/.pre-commit-config.yaml

@@ -1,6 +1,6 @@
 repos:
   - repo: https://github.com/rbubley/mirrors-prettier
-    rev: v3.5.1
+    rev: v3.6.2
     hooks:
       - id: prettier
         exclude: |
@@ -17,13 +17,13 @@ repos:
               docs/notes/
           )
   - repo: https://github.com/astral-sh/ruff-pre-commit
-    rev: v0.8.6
+    rev: v0.14.0
     hooks:
-      - id: ruff
+      - id: ruff-check
         args: [--fix, --exit-non-zero-on-fix, --unsafe-fixes]
       - id: ruff-format
   - repo: https://github.com/pre-commit/pre-commit-hooks
-    rev: v4.5.0
+    rev: v6.0.0
     hooks:
       - id: detect-private-key
       - id: check-ast
@@ -37,7 +37,7 @@ repos:
       - id: trailing-whitespace
       - id: check-case-conflict
   - repo: https://github.com/pre-commit/mirrors-mypy
-    rev: v1.7.1
+    rev: v1.18.1
     hooks:
       - id: mypy
         exclude: |

{lamindb_setup-1.11.0 → lamindb_setup-1.12.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: lamindb_setup
-Version: 1.11.0
+Version: 1.12.1
 Summary: Setup & configure LaminDB.
 Author-email: Lamin Labs <open-source@lamin.ai>
 Requires-Python: >=3.10
@@ -10,10 +10,11 @@ Requires-Dist: django>=5.1,<5.2
 Requires-Dist: dj_database_url>=1.3.0,<3.0.0
 Requires-Dist: pydantic-settings
 Requires-Dist: platformdirs<5.0.0
+Requires-Dist: httpx_retries<1.0.0
 Requires-Dist: requests
 Requires-Dist: universal_pathlib==0.2.6
 Requires-Dist: botocore<2.0.0
-Requires-Dist: supabase>=2.8.1,<=2.15.0
+Requires-Dist: supabase>=2.8.1,<=2.16.0
 Requires-Dist: gotrue<=2.12.0
 Requires-Dist: storage3!=0.11.2; python_version < '3.11'
 Requires-Dist: pyjwt<3.0.0

{lamindb_setup-1.11.0 → lamindb_setup-1.12.1}/docs/hub-cloud/08-test-multi-session.ipynb

@@ -8,10 +8,14 @@
    ]
   },
   {
-   "cell_type": "markdown",
+   "cell_type": "code",
+   "execution_count": null,
    "metadata": {},
+   "outputs": [],
    "source": [
-    "This notebook is complemented by the `faq/setup.ipynb` notebook in lamindb."
+    "!lamin login testuser1\n",
+    "!lamin init --storage \"./testsetup-prepare\"\n",
+    "!lamin disconnect"
    ]
   },
   {
@@ -20,8 +24,16 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "!lamin login testuser1\n",
-    "!lamin init --storage \"./testsetup-prepare\""
+    "import lamindb_setup as ln_setup\n",
+    "import lamindb as ln\n",
+    "import pytest"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "If you try to use lamindb, it will raise an `CurrentInstanceNotConfigured` and ask you to `init` or `connect` an instance via the python API."
    ]
   },
   {
@@ -30,8 +42,8 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "import lamindb_setup as ln_setup\n",
-    "import pytest"
+    "with pytest.raises(ln.setup.errors.CurrentInstanceNotConfigured):\n",
+    "    ln.track()"
    ]
   },
   {
@@ -98,6 +110,71 @@
     "    User.objects.get(handle=\"testuser2\")"
    ]
   },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "ln.track()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Let us try connecting to another instance:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "with pytest.raises(ln.setup.errors.CannotSwitchDefaultInstance) as error:\n",
+    "    ln.connect(\"testsetup3\")\n",
+    "assert error.exconly().endswith(\n",
+    "    \"Cannot switch default instance while `ln.track()` is live: call `ln.finish()`\"\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Let us try to init another instance in the same Python session."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "with pytest.raises(ln.setup.errors.CannotSwitchDefaultInstance) as error:\n",
+    "    ln.setup.init(storage=\"./testsetup2\")\n",
+    "assert error.exconly().endswith(\n",
+    "    \"Cannot switch default instance while `ln.track()` is live: call `ln.finish()`\"\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Switch off `ln.track()`."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "ln.context._transform = None"
+   ]
+  },
   {
    "cell_type": "markdown",
    "metadata": {},

{lamindb_setup-1.11.0 → lamindb_setup-1.12.1}/lamindb_setup/__init__.py

@@ -35,9 +35,15 @@ Modules & settings:
 
 """
 
-__version__ = "1.11.0"  # denote a release candidate for 0.1.0 with 0.1rc1
+__version__ = "1.12.1"  # denote a release candidate for 0.1.0 with 0.1rc1
 
 import os
+import warnings
+
+# ignore for now, remove this after supabase upgrade in the deps
+warnings.filterwarnings("ignore", category=DeprecationWarning, module="supabase")
+warnings.filterwarnings("ignore", category=DeprecationWarning, module="supafunc")
+warnings.filterwarnings("ignore", category=DeprecationWarning, module="postgrest")
 
 from packaging import version as packaging_version
 

{lamindb_setup-1.11.0 → lamindb_setup-1.12.1}/lamindb_setup/_connect_instance.py

@@ -104,6 +104,7 @@ def _connect_instance(
     db: str | None = None,
     raise_permission_error: bool = True,
     use_root_db_user: bool = False,
+    use_proxy_db: bool = False,
     access_token: str | None = None,
 ) -> InstanceSettings:
     settings_file = instance_settings_file(name, owner)
@@ -118,8 +119,7 @@ def _connect_instance(
             if db is not None and isettings.dialect == "postgresql":
                 isettings._db = db
     if make_hub_request:
-        # the following will return a string if the instance does not exist
-        # on the hub
+        # the following will return a string if the instance does not exist on the hub
         # do not call hub if the user is anonymous
         if owner != "anonymous":
             hub_result = connect_instance_hub(
@@ -127,6 +127,7 @@ def _connect_instance(
                 name=name,
                 access_token=access_token,
                 use_root_db_user=use_root_db_user,
+                use_proxy_db=use_proxy_db,
             )
         else:
             hub_result = "anonymous-user"
@@ -161,10 +162,10 @@ def _connect_instance(
                 schema_id=None
                 if (schema_id := instance_result["schema_id"]) is None
                 else UUID(schema_id),
-                fine_grained_access=bool(
-                    instance_result["fine_grained_access"]
-                ),  # can be None
-                db_permissions=instance_result.get("db_permissions", None),
+                fine_grained_access=bool(instance_result["fine_grained_access"]),
+                db_permissions=instance_result.get("db_permissions", None)
+                if not use_root_db_user
+                else "write",
             )
         else:
             if hub_result != "anonymous-user":
@@ -192,8 +193,7 @@ def reset_django_module_variables():
     #     import lamindb as ln
     #     ln.connect(...)
     #
-    # Then it will **not** work and the `ln` variable becomes stale and hold a reference
-    # to the old classes
+    # Then it will **not** work and the `ln` variable becomes stale and hold a reference to the old classes
     # Other functions that dynamically import are no problem because the variables
     # are automatically refreshed when the function runs the next time after ln.connect() was called
     logger.debug("resetting django module variables")
@@ -242,11 +242,15 @@ def reset_django_module_variables():
                 continue
 
 
-def _connect_cli(instance: str, use_root_db_user: bool = False) -> None:
+def _connect_cli(
+    instance: str, use_root_db_user: bool = False, use_proxy_db: bool = False
+) -> None:
     from lamindb_setup import settings as settings_
 
     owner, name = get_owner_name_from_identifier(instance)
-    isettings = _connect_instance(owner, name, use_root_db_user=use_root_db_user)
+    isettings = _connect_instance(
+        owner, name, use_root_db_user=use_root_db_user, use_proxy_db=use_proxy_db
+    )
     isettings._persist(write_to_disk=True)
     if not isettings.is_on_hub or isettings._is_cloud_sqlite:
         # there are two reasons to call the full-blown connect
@@ -259,6 +263,36 @@ def _connect_cli(instance: str, use_root_db_user: bool = False) -> None:
     return None
 
 
+def validate_connection_state(
+    owner: str, name: str, use_root_db_user: bool = False
+) -> None:
+    from django.db import connection
+
+    if (
+        settings._instance_exists
+        and f"{owner}/{name}" == settings.instance.slug
+        # below is to ensure that if another process interferes
+        # we don't use the in-memory mock database
+        # could be made more specific by checking whether the django
+        # configured database is the same as the one in settings
+        and connection.settings_dict["NAME"] != ":memory:"
+        and not use_root_db_user  # always re-connect for root db user
+    ):
+        logger.important(
+            f"doing nothing, already connected lamindb: {settings.instance.slug}"
+        )
+        return None
+    else:
+        if settings._instance_exists and settings.instance.slug != "none/none":
+            import lamindb as ln
+
+            if ln.context.transform is not None:
+                raise CannotSwitchDefaultInstance(
+                    "Cannot switch default instance while `ln.track()` is live: call `ln.finish()`"
+                )
+        reset_django()
+
+
 @unlock_cloud_sqlite_upon_exception(ignore_prev_locker=True)
 def connect(instance: str | None = None, **kwargs: Any) -> str | tuple | None:
     """Connect to an instance.
@@ -274,6 +308,7 @@ def connect(instance: str | None = None, **kwargs: Any) -> str | tuple | None:
     # validate kwargs
     valid_kwargs = {
         "use_root_db_user",
+        "use_proxy_db",
         "_db",
         "_write_settings",
         "_raise_not_found_error",
@@ -284,15 +319,18 @@ def connect(instance: str | None = None, **kwargs: Any) -> str | tuple | None:
     for kwarg in kwargs:
         if kwarg not in valid_kwargs:
             raise TypeError(f"connect() got unexpected keyword argument '{kwarg}'")
-    isettings: InstanceSettings = None  # type: ignore
-    # _db is still needed because it is called in init
+
     use_root_db_user: bool = kwargs.get("use_root_db_user", False)
+    use_proxy_db = kwargs.get("use_proxy_db", False)
+    # _db is still needed because it is called in init
     _db: str | None = kwargs.get("_db", None)
     _write_settings: bool = kwargs.get("_write_settings", False)
     _raise_not_found_error: bool = kwargs.get("_raise_not_found_error", True)
     _reload_lamindb: bool = kwargs.get("_reload_lamindb", True)
     _test: bool = kwargs.get("_test", False)
 
+    isettings: InstanceSettings = None  # type: ignore
+
     access_token: str | None = None
     _user: UserSettings | None = kwargs.get("_user", None)
     if _user is not None:
@@ -317,36 +355,11 @@ def connect(instance: str | None = None, **kwargs: Any) -> str | tuple | None:
             if _db is not None and isettings.dialect == "postgresql":
                 isettings._db = _db
         else:
-            from django.db import connection
-
             owner, name = get_owner_name_from_identifier(instance)
             if _check_instance_setup() and not _test:
-                if (
-                    settings._instance_exists
-                    and f"{owner}/{name}" == settings.instance.slug
-                    # below is to ensure that if another process interferes
-                    # we don't use the in-memory mock database
-                    # could be made more specific by checking whether the django
-                    # configured database is the same as the one in settings
-                    and connection.settings_dict["NAME"] != ":memory:"
-                    and not use_root_db_user  # always re-connect for root db user
-                ):
-                    logger.important(
-                        f"doing nothing, already connected lamindb: {settings.instance.slug}"
-                    )
-                    return None
-                else:
-                    if (
-                        settings._instance_exists
-                        and settings.instance.slug != "none/none"
-                    ):
-                        import lamindb as ln
-
-                        if ln.context.transform is not None:
-                            raise CannotSwitchDefaultInstance(
-                                "Cannot switch default instance while `ln.track()` is live: call `ln.finish()`"
-                            )
-                    reset_django()
+                validate_connection_state(
+                    owner, name, use_root_db_user=use_root_db_user
+                )
             elif (
                 _write_settings
                 and settings._instance_exists
@@ -362,6 +375,7 @@ def connect(instance: str | None = None, **kwargs: Any) -> str | tuple | None:
                     db=_db,
                     access_token=access_token,
                     use_root_db_user=use_root_db_user,
+                    use_proxy_db=use_proxy_db,
                 )
             except InstanceNotFoundError as e:
                 if _raise_not_found_error:
@@ -416,7 +430,7 @@ def connect(instance: str | None = None, **kwargs: Any) -> str | tuple | None:
     return None
 
 
-def get_owner_name_from_identifier(identifier: str):
+def get_owner_name_from_identifier(identifier: str) -> tuple[str, str]:
     if "/" in identifier:
         if identifier.startswith("https://lamin.ai/"):
             identifier = identifier.replace("https://lamin.ai/", "")

{lamindb_setup-1.11.0 → lamindb_setup-1.12.1}/lamindb_setup/_delete.py

@@ -21,6 +21,8 @@ if TYPE_CHECKING:
 
 
 def delete_cache(isettings: InstanceSettings):
+    if isettings.storage is None:
+        return
     # avoid init of root
     root = isettings.storage._root_init
     if not isinstance(root, LocalPathClasses):
@@ -40,7 +42,7 @@ def delete_by_isettings(isettings: InstanceSettings) -> None:
     if settings_file.exists():
         settings_file.unlink()
     delete_cache(isettings)
-    if isettings.dialect == "sqlite":
+    if isettings.dialect == "sqlite" and isettings.storage is not None:
         try:
             if isettings._sqlite_file.exists():
                 isettings._sqlite_file.unlink()

{lamindb_setup-1.11.0 → lamindb_setup-1.12.1}/lamindb_setup/_init_instance.py

@@ -3,7 +3,6 @@ from __future__ import annotations
 import importlib
 import os
 import uuid
-from pathlib import Path
 from typing import TYPE_CHECKING, Literal
 from uuid import UUID
 
@@ -17,12 +16,13 @@ from ._silence_loggers import silence_loggers
 from .core import InstanceSettings
 from .core._docs import doc_args
 from .core._settings import settings
-from .core._settings_instance import check_is_instance_remote, is_local_db_url
+from .core._settings_instance import check_is_instance_remote
 from .core._settings_storage import StorageSettings, init_storage
 from .core.upath import UPath
 from .errors import CannotSwitchDefaultInstance
 
 if TYPE_CHECKING:
+    from lamindb.models import Storage
     from pydantic import PostgresDsn
 
     from .core._settings_user import UserSettings
@@ -50,7 +50,7 @@ def get_schema_module_name(module_name, raise_import_error: bool = True) -> str
     return None
 
 
-def register_storage_in_instance(ssettings: StorageSettings):
+def register_storage_in_instance(ssettings: StorageSettings) -> Storage:
     from lamindb.models import Storage
 
     # how do we ensure that this function is only called passing
@@ -70,7 +70,7 @@ def register_storage_in_instance(ssettings: StorageSettings):
     return storage
 
 
-def register_user(usettings: UserSettings, update_user: bool = True):
+def register_user(usettings: UserSettings, update_user: bool = True) -> None:
     from lamindb.models import User
 
     if not update_user and User.objects.filter(uid=usettings.uid).exists():
@@ -92,7 +92,9 @@ def register_user(usettings: UserSettings, update_user: bool = True):
         pass
 
 
-def register_initial_records(isettings: InstanceSettings, usettings: UserSettings):
+def register_initial_records(
+    isettings: InstanceSettings, usettings: UserSettings
+) -> None:
     """Register space, user & storage in DB."""
     from django.db.utils import OperationalError
     from lamindb.models import Branch, Space
@@ -246,6 +248,15 @@ def init(
     See Also:
         Init an instance for via the CLI, see `here <https://docs.lamin.ai/cli#init>`__.
     """
+    from ._check_setup import _check_instance_setup
+    from ._connect_instance import (
+        reset_django_module_variables,
+        validate_connection_state,
+    )
+    from .core._hub_core import init_instance_hub
+
+    silence_loggers()
+
     isettings = None
     ssettings = None
 
@@ -262,22 +273,6 @@ def init(
     access_token: str | None = None if _user is None else _user.access_token
 
     try:
-        silence_loggers()
-        from ._check_setup import _check_instance_setup
-
-        if _check_instance_setup() and not _test:
-            from lamindb_setup.core.django import reset_django
-
-            if settings._instance_exists:
-                raise CannotSwitchDefaultInstance(
-                    "Cannot init new instance after connecting to an existing instance."
-                )
-            reset_django()
-        elif _write_settings:
-            disconnect(mute=True)
-        from ._connect_instance import reset_django_module_variables
-        from .core._hub_core import init_instance_hub
-
         name_str, instance_id, instance_state, _ = validate_init_args(
             storage=storage,
             name=name,
@@ -289,6 +284,10 @@ def init(
         )
         if instance_state == "connected":
             return None
+        if _check_instance_setup() and not _test:
+            validate_connection_state(user_handle, name_str)
+        elif _write_settings:
+            disconnect(mute=True)
         isettings = InstanceSettings(
             id=instance_id,  # type: ignore
             owner=user_handle,
@@ -379,10 +378,8 @@ def load_from_isettings(
     else:
         # when loading, django is already set up
         #
-        # only register user if the instance is connected
-        # for the first time in an environment
-        # this is our best proxy for that the user might not
-        # yet be registered
+        # only register user if the instance is connected for the first time in an environment
+        # this is our best proxy for that the user might not yet be registered
         if not isettings._get_settings_file().exists():
             # do not try to update the user on fine grained access instances
             # this is blocked anyways, only select and insert are allowed

{lamindb_setup-1.11.0 → lamindb_setup-1.12.1}/lamindb_setup/_migrate.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-import requests  # type: ignore
+import httpx
 from django.db import connection
 from django.db.migrations.loader import MigrationLoader
 from lamin_utils import logger
@@ -146,7 +146,7 @@ class migrate:
                 logger.warning(
                     "clearing instance cache in hub; if this fails, re-run with latest lamindb version"
                 )
-                requests.delete(
+                httpx.delete(
                     f"{settings.instance.api_url}/cache/instances/{settings.instance._id.hex}",
                     headers={"Authorization": f"Bearer {settings.user.access_token}"},
                 )

{lamindb_setup-1.11.0 → lamindb_setup-1.12.1}/lamindb_setup/_schema_metadata.py

@@ -71,9 +71,9 @@ def _synchronize_schema(client: Client) -> tuple[bool, UUID, dict]:
         .eq("id", settings.instance._id.hex)
         .execute()
     )
-    assert (
-        len(instance_response.data) == 1
-    ), f"schema of instance {settings.instance._id.hex} could not be updated with schema {schema_uuid.hex}"
+    assert len(instance_response.data) == 1, (
+        f"schema of instance {settings.instance._id.hex} could not be updated with schema {schema_uuid.hex}"
+    )
 
     return is_new, schema_uuid, schema
 

{lamindb_setup-1.11.0 → lamindb_setup-1.12.1}/lamindb_setup/core/_aws_options.py

@@ -29,8 +29,7 @@ def _keep_trailing_slash(path_str: str) -> str:
 AWS_CREDENTIALS_EXPIRATION: int = 11 * 60 * 60  # refresh credentials after 11 hours
 
 
-# set anon=True for these buckets if credentials fail for a public bucket
-# to be expanded
+# set anon=True for these buckets if credentials fail for a public bucket to be expanded
 PUBLIC_BUCKETS: tuple[str, ...] = ("cellxgene-data-public", "bionty-assets")
 
 
@@ -155,8 +154,7 @@ class AWSOptionsManager:
                 # this option is needed for correct uploads to R2
                 path = UPath(path, fixed_upload_size=True)
             return path
-        # trailing slash is needed to avoid returning incorrect results
-        # with .startswith
+        # trailing slash is needed to avoid returning incorrect results with .startswith
         # for example s3://lamindata-eu should not receive cache for s3://lamindata
         path_str = _keep_trailing_slash(path.as_posix())
         root = self._find_root(path_str)

{lamindb_setup-1.11.0 → lamindb_setup-1.12.1}/lamindb_setup/core/_aws_storage.py

@@ -1,12 +1,11 @@
 from __future__ import annotations
 
+import httpx
 from lamin_utils import logger
 
 
 def get_location(ip="ipinfo.io"):
-    import requests  # type: ignore
-
-    response = requests.get(f"http://{ip}/json").json()
+    response = httpx.get(f"http://{ip}/json").json()
     loc = response["loc"].split(",")
     return {"latitude": float(loc[0]), "longitude": float(loc[1])}