lamindb_setup 1.4.1__py3-none-any.whl → 1.5.0__py3-none-any.whl

lamindb_setup/__init__.py

@@ -12,7 +12,7 @@ Basic operations:
    login
    logout
    init
-   close
+   disconnect
    delete
 
 Instance operations:
@@ -33,7 +33,7 @@ Modules & settings:
 
 """
 
-__version__ = "1.4.1"  # denote a release candidate for 0.1.0 with 0.1rc1
+__version__ = "1.5.0"  # denote a release candidate for 0.1.0 with 0.1rc1
 
 import os
 
@@ -41,9 +41,9 @@ from packaging import version as packaging_version
 
 from . import core
 from ._check_setup import _check_instance_setup
-from ._close import close
 from ._connect_instance import connect, load
 from ._delete import delete
+from ._disconnect import disconnect
 from ._django import django
 from ._entry_points import call_registered_entry_points as _call_registered_entry_points
 from ._init_instance import init
@@ -100,3 +100,6 @@ _TESTING = _is_CI_environment()
 _call_registered_entry_points("lamindb_setup.on_import")
 
 settings.__doc__ = """Global :class:`~lamindb.setup.core.SetupSettings`."""
+
+
+close = disconnect  # backward compatibility

lamindb_setup/_cache.py

@@ -8,16 +8,16 @@ from .core._settings_save import save_system_storage_settings
 
 
 def clear_cache_dir():
-    from lamindb_setup import close, settings
+    from lamindb_setup import disconnect, settings
 
     try:
         if settings.instance._is_cloud_sqlite:
             logger.warning(
-                "Closing the current instance to update the cloud sqlite database."
+                "Disconnecting the current instance to update the cloud sqlite database."
             )
-            close()
+            disconnect()
     except SystemExit as e:
-        if str(e) != "No instance is loaded! Call `lamin init` or `lamin connect`":
+        if str(e) != "No instance connected! Call `lamin connect` or `lamin init`":
             raise e
 
     cache_dir = settings.cache_dir

lamindb_setup/_check_setup.py

@@ -163,5 +163,14 @@ def _check_instance_setup(from_module: str | None = None) -> bool:
         return django_lamin.IS_SETUP
     else:
         if from_module is not None and settings.auto_connect:
-            logger.warning(InstanceNotSetupError.default_message)
+            # the below enables users to auto-connect to an instance
+            # simply by setting an environment variable, bypassing the
+            # need of calling connect() manually
+            if os.environ.get("LAMIN_CURRENT_INSTANCE") is not None:
+                from ._connect_instance import connect
+
+                connect(_write_settings=False, _reload_lamindb=False)
+                return django_lamin.IS_SETUP
+            else:
+                logger.warning(InstanceNotSetupError.default_message)
         return False

lamindb_setup/_connect_instance.py

@@ -8,7 +8,7 @@ from uuid import UUID
 from lamin_utils import logger
 
 from ._check_setup import _check_instance_setup, _get_current_instance_settings
-from ._close import close as close_instance
+from ._disconnect import disconnect
 from ._init_instance import (
     MESSAGE_CANNOT_SWITCH_DEFAULT_INSTANCE,
     CannotSwitchDefaultInstance,
@@ -192,8 +192,8 @@ def connect(instance: str | None = None, **kwargs) -> str | tuple | None:
     """Connect to an instance.
 
     Args:
-        instance: `None` or an instance identifier (URL, slug `account/name`, or `name` if the instance is local or in your account).
-            If `None`, it will connect to the instance that was connected via the CLI.
+        instance: Pass a slug (`account/name`) or URL (`https://lamin.ai/account/name`).
+            If `None`, looks for an environment variable `LAMIN_CURRENT_INSTANCE` to get the instance identifier. If it doesn't find this variable, it connects to the instance that was connected with `lamin connect` through the CLI.
     """
     # validate kwargs
     valid_kwargs = {
@@ -219,12 +219,14 @@ def connect(instance: str | None = None, **kwargs) -> str | tuple | None:
     _user: UserSettings | None = kwargs.get("_user", None)
     if _user is not None:
         access_token = _user.access_token
+    if instance is None:
+        instance = os.environ.get("LAMIN_CURRENT_INSTANCE")
 
     try:
         if instance is None:
             isettings_or_none = _get_current_instance_settings()
             if isettings_or_none is None:
-                raise SystemExit(
+                raise ValueError(
                     "No instance was connected through the CLI, pass a value to `instance` or connect via the CLI."
                 )
             isettings = isettings_or_none
@@ -246,7 +248,7 @@ def connect(instance: str | None = None, **kwargs) -> str | tuple | None:
                 and settings._instance_exists
                 and f"{owner}/{name}" != settings.instance.slug
             ):
-                close_instance(mute=True)
+                disconnect(mute=True)
 
             try:
                 isettings = _connect_instance(
@@ -299,17 +301,6 @@ def connect(instance: str | None = None, **kwargs) -> str | tuple | None:
         if _TEST_FAILED_LOAD:
             raise RuntimeError("Technical testing error.")
 
-        # below is for backfilling the instance_uid value
-        # we'll enable it once more people migrated to 0.71.0
-        # ssettings_record = isettings.storage.record
-        # if ssettings_record.instance_uid is None:
-        #     ssettings_record.instance_uid = isettings.uid
-        #     # try saving if not read-only access
-        #     try:
-        #         ssettings_record.save()
-        #     # raised by django when the access is denied
-        #     except ProgrammingError:
-        #         pass
         load_from_isettings(isettings, user=_user, write_settings=_write_settings)
         if _reload_lamindb:
             importlib.reload(importlib.import_module("lamindb"))

lamindb_setup/{_close.py → _disconnect.py}

@@ -7,8 +7,8 @@ from .core._settings_store import current_instance_settings_file
 from .core.cloud_sqlite_locker import clear_locker
 
 
-def close(mute: bool = False) -> None:
-    """Close existing instance.
+def disconnect(mute: bool = False) -> None:
+    """Disconnect an instance.
 
     Returns `None` if succeeds, otherwise an exception is raised.
     """
@@ -26,7 +26,7 @@ def close(mute: bool = False) -> None:
         current_instance_settings_file().unlink()
         clear_locker()
         if not mute:
-            logger.success(f"closed instance: {instance}")
+            logger.success(f"disconnected instance: {instance}")
     else:
         if not mute:
             logger.info("no instance loaded")

lamindb_setup/_init_instance.py

@@ -11,7 +11,7 @@ from django.core.exceptions import FieldError
 from django.db.utils import OperationalError, ProgrammingError
 from lamin_utils import logger
 
-from ._close import close as close_instance
+from ._disconnect import disconnect
 from ._silence_loggers import silence_loggers
 from .core import InstanceSettings
 from .core._docs import doc_args
@@ -262,7 +262,7 @@ def init(
         if _check_instance_setup() and not _test:
             raise CannotSwitchDefaultInstance(MESSAGE_CANNOT_SWITCH_DEFAULT_INSTANCE)
         elif _write_settings:
-            close_instance(mute=True)
+            disconnect(mute=True)
         from .core._hub_core import init_instance_hub
 
         name_str, instance_id, instance_state, _ = validate_init_args(

lamindb_setup/_setup_user.py

@@ -8,16 +8,14 @@ from lamin_utils import logger
 from ._check_setup import _check_instance_setup
 from ._init_instance import register_user
 from .core._settings import settings
-from .core._settings_load import load_or_create_user_settings, load_user_settings
+from .core._settings_load import load_user_settings
 from .core._settings_save import save_user_settings
 from .core._settings_store import (
     current_user_settings_file,
     user_settings_file_email,
     user_settings_file_handle,
 )
-
-if TYPE_CHECKING:
-    from lamindb_setup.core._settings_save import UserSettings
+from .core._settings_user import UserSettings
 
 
 def load_user(email: str | None = None, handle: str | None = None) -> UserSettings:
@@ -30,15 +28,12 @@ def load_user(email: str | None = None, handle: str | None = None) -> UserSettin
         save_user_settings(user_settings)  # needed to save to current_user.env
         assert user_settings.email is not None or user_settings.api_key is not None
     else:
-        user_settings = load_or_create_user_settings()
         if email is None:
             raise SystemExit(
                 "✗ Use your email for your first login in a compute environment. "
                 "After that, you can use your handle."
             )
-        user_settings.email = email
-        user_settings.handle = handle
-        save_user_settings(user_settings)
+        user_settings = UserSettings(handle=handle, email=email, uid="null")  # type: ignore
 
     from .core._settings import settings
 
@@ -49,7 +44,7 @@ def load_user(email: str | None = None, handle: str | None = None) -> UserSettin
 
 def login(
     user: str | None = None, *, api_key: str | None = None, key: str | None = None
-) -> None:
+) -> UserSettings:
     """Log in user.
 
     Args:
@@ -84,7 +79,7 @@ def login(
         elif user_settings.email is None:
             raise SystemExit(f"✗ No stored user email, please call: lamin login {user}")
     else:
-        user_settings = load_or_create_user_settings()
+        user_settings = UserSettings(handle="temporary", uid="null")
 
     from .core._hub_core import sign_in_hub, sign_in_hub_api_key
 
@@ -104,14 +99,12 @@ def login(
         raise SystemExit(f"✗ Unsuccessful login: {response}.")
     else:
         user_uuid, user_id, user_handle, user_name, access_token = response
+
     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 {user_handle} (uid: {user_id})")
+    else:  # legacy flow
         logger.success(f"logged in with email {user_settings.email} (uid: {user_id})")
+
     user_settings.uid = user_id
     user_settings.handle = user_handle
     user_settings.name = user_name
@@ -124,14 +117,17 @@ def login(
         register_user(user_settings)
 
     settings._user_settings = None
-    return None
+    return user_settings
 
 
 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")
+    if os.environ.get("LAMIN_API_KEY") is not None:
+        logger.warning(
+            "LAMIN_API_KEY is still set in your environment and will automatically log you in"
+        )

lamindb_setup/core/_aws_options.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import logging
 import os
 import time
 
@@ -38,7 +39,19 @@ PUBLIC_BUCKETS: tuple[str] = ("cellxgene-data-public",)
 LAMIN_ENDPOINTS: tuple[str | None] = (None,)
 
 
+class NoTracebackFilter(logging.Filter):
+    def filter(self, record):
+        record.exc_info = None  # Remove traceback info from the log record.
+        return True
+
+
 class AWSOptionsManager:
+    # suppress giant traceback logs from aiobotocore when failing to refresh sso etc
+    @staticmethod
+    def _suppress_aiobotocore_traceback_logging():
+        logger = logging.getLogger("aiobotocore.credentials")
+        logger.addFilter(NoTracebackFilter())
+
     def __init__(self):
         self._credentials_cache = {}
 
@@ -48,6 +61,9 @@ class AWSOptionsManager:
         fs = S3FileSystem(
             cache_regions=True, use_listings_cache=True, version_aware=False
         )
+
+        self._suppress_aiobotocore_traceback_logging()
+
         try:
             fs.connect()
             self.anon: bool = fs.session._credentials is None

lamindb_setup/core/_hub_core.py

@@ -34,13 +34,12 @@ from ._hub_utils import (
     LaminDsnModel,
 )
 from ._settings import settings
+from ._settings_instance import InstanceSettings
 from ._settings_storage import StorageSettings, base62
 
 if TYPE_CHECKING:
     from supabase import Client  # type: ignore
 
-    from ._settings_instance import InstanceSettings
-
 
 def delete_storage_record(storage_uuid: UUID, access_token: str | None = None) -> None:
     return call_with_fallback_auth(
@@ -439,11 +438,25 @@ def _access_aws(*, storage_root: str, client: Client) -> dict[str, dict]:
     return storage_root_info
 
 
-def access_db(isettings: InstanceSettings, access_token: str | None = None) -> str:
+def access_db(
+    instance: InstanceSettings | dict, access_token: str | None = None
+) -> str:
+    instance_id: UUID
+    instance_slug: str
+    instance_api_url: str | None
+    if isinstance(instance, InstanceSettings):
+        instance_id = instance._id
+        instance_slug = instance.slug
+        instance_api_url = instance._api_url
+    else:
+        instance_id = UUID(instance["id"])
+        instance_slug = instance["owner"] + "/" + instance["name"]
+        instance_api_url = instance["api_url"]
+
     if access_token is None:
         if settings.user.handle == "anonymous":
             raise RuntimeError(
-                f"Can only get fine-grained access to {isettings.slug} if authenticated."
+                f"Can only get fine-grained access to {instance_slug} if authenticated."
             )
         else:
             access_token = settings.user.access_token
@@ -451,20 +464,19 @@ def access_db(isettings: InstanceSettings, access_token: str | None = None) -> s
     else:
         renew_token = False
     # local is used in tests
-    url = f"/access_v2/instances/{isettings._id}/db_token"
+    url = f"/access_v2/instances/{instance_id}/db_token"
     if os.environ.get("LAMIN_ENV", "prod") != "local":
-        api_url = isettings._api_url
-        if api_url is None:
+        if instance_api_url is None:
             raise RuntimeError(
-                f"Can only get fine-grained access to {isettings.slug} if api_url is present."
+                f"Can only get fine-grained access to {instance_slug} if api_url is present."
             )
-        url = api_url + url
+        url = instance_api_url + url
 
     response = request_get_auth(url, access_token, renew_token)  # type: ignore
     response_json = response.json()
     if response.status_code != 200:
         raise PermissionError(
-            f"Fine-grained access to {isettings.slug} failed: {response_json}"
+            f"Fine-grained access to {instance_slug} failed: {response_json}"
         )
     if "token" not in response_json:
         raise RuntimeError("The response of access_db does not contain a db token.")

lamindb_setup/core/_settings.py

@@ -114,10 +114,13 @@ class SetupSettings:
             and self._user_settings_env != get_env_name()
         )
         if self._user_settings is None or env_changed:
-            self._user_settings = load_or_create_user_settings()
+            # only uses LAMIN_API_KEY if there is no current_user.env
+            self._user_settings = load_or_create_user_settings(
+                api_key=os.environ.get("LAMIN_API_KEY")
+            )
             self._user_settings_env = get_env_name()
             if self._user_settings and self._user_settings.uid is None:
-                raise RuntimeError("Need to login, first: lamin login <email>")
+                raise RuntimeError("Need to login, first: lamin login")
         return self._user_settings  # type: ignore
 
     @property

lamindb_setup/core/_settings_instance.py

@@ -286,7 +286,7 @@ class InstanceSettings:
         The core schema contained in lamindb is not included in this set.
         """
         if self._schema_str is None:
-            return {}  # type: ignore
+            return set()
         else:
             return {module for module in self._schema_str.split(",") if module != ""}
 

lamindb_setup/core/_settings_load.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import os
 from typing import TYPE_CHECKING
 from uuid import UUID, uuid4
 
@@ -40,7 +41,7 @@ def load_instance_settings(instance_settings_file: Path | None = None):
     if instance_settings_file is None:
         instance_settings_file = current_instance_settings_file()
     if not instance_settings_file.exists():
-        raise SystemExit("No instance is loaded! Call `lamin init` or `lamin connect`")
+        raise SystemExit("No instance connected! Call `lamin connect` or `lamin init`")
     try:
         settings_store = InstanceSettingsStore(_env_file=instance_settings_file)
     except (ValidationError, TypeError) as error:
@@ -55,11 +56,21 @@ def load_instance_settings(instance_settings_file: Path | None = None):
     return isettings
 
 
-def load_or_create_user_settings() -> UserSettings:
-    """Return current user settings."""
+def load_or_create_user_settings(api_key: str | None = None) -> UserSettings:
+    """Return current user settings.
+
+    Args:
+        api_key: if provided and there is no current user,
+            perform login and return the user settings.
+    """
     current_user_settings = current_user_settings_file()
     if not current_user_settings.exists():
-        logger.warning("using anonymous user (to identify, call: lamin login)")
+        if api_key is not None:
+            from lamindb_setup._setup_user import login
+
+            return login(api_key=api_key)
+        else:
+            logger.warning("using anonymous user (to identify, call: lamin login)")
         usettings = UserSettings(handle="anonymous", uid="00000000")
         from ._settings_save import save_user_settings
 

lamindb_setup/core/django.py

@@ -14,29 +14,101 @@ IS_MIGRATING = False
 CONN_MAX_AGE = 299
 
 
-def set_db_token(token: str | None, connection_name: str = "default"):
-    # None to reset
-    from django.db import connections
-    from django.db.backends.base.base import BaseDatabaseWrapper
+# a class to manage jwt in dbs
+class DBTokenManager:
+    def __init__(self, debug: bool = False):
+        from django.db.transaction import Atomic
 
-    connection = connections[connection_name]
-    assert connection.vendor == "postgresql"
+        self.debug = debug
+        self.original_atomic_enter = Atomic.__enter__
 
-    if token is not None:
+        self.tokens: dict[str, str] = {}
 
-        def connect(self):
-            BaseDatabaseWrapper.connect(self)
-            # now the connection should be set
-            # Use a psycopg cursor directly, bypassing Django's utilities.
-            with self.connection.cursor() as cursor:
-                cursor.execute("SELECT set_token(%s, false);", (token,))
-    else:
-        connect = BaseDatabaseWrapper.connect
+    def get_connection(self, connection_name: str):
+        from django.db import connections
 
-    connection.connect = connect.__get__(connection, connection.__class__)
-    # execute this to initially set or reset the token
-    connection.close()
-    connection.connect()
+        connection = connections[connection_name]
+        assert connection.vendor == "postgresql"
+
+        return connection
+
+    def set(self, token: str, connection_name: str = "default"):
+        from django.db.transaction import Atomic
+
+        # no adapt in psycopg3
+        from psycopg2.extensions import adapt
+
+        connection = self.get_connection(connection_name)
+
+        # escape correctly to avoid wrangling with params
+        set_token_query = (
+            f"SELECT set_token({adapt(token).getquoted().decode()}, true); "
+        )
+
+        def set_token_wrapper(execute, sql, params, many, context):
+            not_in_atomic_block = (
+                context is None
+                or "connection" not in context
+                or not context["connection"].in_atomic_block
+            )
+            # ignore atomic blocks
+            if not_in_atomic_block:
+                sql = set_token_query + sql
+            elif self.debug:
+                print("--in atomic block--")
+
+            if self.debug:
+                print(sql)
+            result = execute(sql, params, many, context)
+            # this ensures that psycopg3 in the current env doesn't break this wrapper
+            # psycopg3 returns a cursor
+            # psycopg3 fetching differs from psycopg2, it returns the output of all sql statements
+            # not only the last one as psycopg2 does. So we shift the cursor from set_token
+            if (
+                not_in_atomic_block
+                and result is not None
+                and hasattr(result, "nextset")
+            ):
+                if self.debug:
+                    print("(shift cursor)")
+                result.nextset()
+            return result
+
+        connection.execute_wrappers.append(set_token_wrapper)
+
+        # ensure we set the token only once for an outer atomic block
+        def __enter__(atomic):
+            self.original_atomic_enter(atomic)
+            is_same_connection = (
+                "default" if atomic.using is None else atomic.using
+            ) == connection_name
+            if is_same_connection and len(connection.atomic_blocks) == 1:
+                # use raw psycopg2 connection here
+                # atomic block ensures connection
+                if self.debug:
+                    print("(set transaction token)")
+                connection.connection.cursor().execute(set_token_query)
+
+        Atomic.__enter__ = __enter__
+
+        self.tokens[connection_name] = token
+
+    def reset(self, connection_name: str = "default"):
+        from django.db.transaction import Atomic
+
+        connection = self.get_connection(connection_name)
+
+        connection.execute_wrappers = [
+            w
+            for w in connection.execute_wrappers
+            if getattr(w, "__name__", None) != "set_token_wrapper"
+        ]
+        Atomic.__enter__ = self.original_atomic_enter
+
+        self.tokens.pop(connection_name, None)
+
+
+db_token_manager = DBTokenManager()
 
 
 def close_if_health_check_failed(self) -> None:
@@ -128,7 +200,8 @@ def setup_django(
         if isettings._fine_grained_access and isettings._db_permissions == "jwt":
             from ._hub_core import access_db
 
-            set_db_token(access_db(isettings))
+            db_token = access_db(isettings)
+            db_token_manager.set(db_token)  # sets for the default connection
 
     if configure_only:
         return None

{lamindb_setup-1.4.1.dist-info → lamindb_setup-1.5.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: lamindb_setup
-Version: 1.4.1
+Version: 1.5.0
 Summary: Setup & configure LaminDB.
 Author-email: Lamin Labs <open-source@lamin.ai>
 Requires-Python: >=3.10
@@ -21,7 +21,7 @@ Requires-Dist: psutil
 Requires-Dist: packaging
 Requires-Dist: urllib3<2 ; extra == "aws"
 Requires-Dist: aiobotocore[boto3]>=2.5.4,<3.0.0 ; extra == "aws"
-Requires-Dist: s3fs>=2023.12.2,<=2025.2.0,!=2024.10.0 ; extra == "aws"
+Requires-Dist: s3fs>=2023.12.2,<=2025.3.2,!=2024.10.0 ; extra == "aws"
 Requires-Dist: line_profiler ; extra == "dev"
 Requires-Dist: psycopg2-binary ; extra == "dev"
 Requires-Dist: python-dotenv ; extra == "dev"
@@ -32,7 +32,7 @@ Requires-Dist: pytest-xdist ; extra == "dev"
 Requires-Dist: nbproject-test>=0.4.3 ; extra == "dev"
 Requires-Dist: pandas ; extra == "dev"
 Requires-Dist: django-schema-graph ; extra == "erdiagram"
-Requires-Dist: gcsfs>=2023.12.2,<=2025.2.0 ; extra == "gcp"
+Requires-Dist: gcsfs>=2023.12.2,<=2025.3.2 ; extra == "gcp"
 Project-URL: Home, https://github.com/laminlabs/lamindb-setup
 Provides-Extra: aws
 Provides-Extra: dev

{lamindb_setup-1.4.1.dist-info → lamindb_setup-1.5.0.dist-info}/RECORD

@@ -1,47 +1,47 @@
-lamindb_setup/__init__.py,sha256=is_IPUSgYwCBU2vA_ly7eIalvGfszfaTs7uB3cZ2gLU,2692
-lamindb_setup/_cache.py,sha256=aszT-zk3S5dTLKp5g1W-S_FPh2E5YVCALwWSGPJLWBM,1493
+lamindb_setup/__init__.py,sha256=Qu5sZWgns9oPEIp_JS4KIkLv99Q91pvZPnnEOLJq8ng,2754
+lamindb_setup/_cache.py,sha256=ixasm_9pUFy-ztbhbqJRVP88uTbFclL60MwUUvZhMFs,1509
 lamindb_setup/_check.py,sha256=28PcG8Kp6OpjSLSi1r2boL2Ryeh6xkaCL87HFbjs6GA,129
-lamindb_setup/_check_setup.py,sha256=d1GS1Csy2G9AysfjoyVcNVY0lhHiWSwSLpfgdIQf35s,5477
-lamindb_setup/_close.py,sha256=SFfOO0OjYR3krvya66kK8RRQa7lPH8MnzUtE33yZ6sQ,1082
-lamindb_setup/_connect_instance.py,sha256=lo0EV_PA8YNlerxfPLG0u-YdmyKLAqbIIhTfzmwNDlI,18352
+lamindb_setup/_check_setup.py,sha256=uveV6CGiwm9M5OMe3lxfAMDs5SU7j1EogJsQB03ZaRw,5928
+lamindb_setup/_connect_instance.py,sha256=qqB-ene_OLTgqd-M7ke9_gT6u81gzNy_Gx5K7FMUaag,18007
 lamindb_setup/_delete.py,sha256=2KnZOqd5Kgr45XzjiDE9der35LODDUajZD6_hcurGtQ,5676
+lamindb_setup/_disconnect.py,sha256=p6tRLhixU4CuSxMKqzGTr-ovKmTRlZ8aID5dWQxOsg8,1092
 lamindb_setup/_django.py,sha256=uIQflpkp8l3axyPaKURlk3kacgpElVP5KOKmFxYSMGk,1454
 lamindb_setup/_entry_points.py,sha256=sKwXPX9xjOotoAjvgkU5LBwjjHLWVkh0ZGdiSsrch9k,522
 lamindb_setup/_exportdb.py,sha256=QLjoH4dEwqa01A12naKaDPglCCzl2_VLKWFfJRE_uSg,2113
 lamindb_setup/_importdb.py,sha256=fKv9ev5OOj_-bmzC8XZ1GxOcjIjI486yrHSHDWQrJeI,1874
-lamindb_setup/_init_instance.py,sha256=5BVHDM3qOe5_HsJGb14NqudGdCG3MjP05rcmercn9wg,14762
+lamindb_setup/_init_instance.py,sha256=5RBv2X18SfnIrciHljaoVsFF25te2P7KwHx0Ww87HLw,14750
 lamindb_setup/_migrate.py,sha256=ya-15sc91i4JmEWI4j00T2892x8hdy2fSW-qz4IdxLs,9739
 lamindb_setup/_register_instance.py,sha256=X7ZGlCVOZKq4zTpi3bxML4jzo6hgN9UYmdTxxf6JLmc,1205
 lamindb_setup/_schema.py,sha256=b3uzhhWpV5mQtDwhMINc2MabGCnGLESy51ito3yl6Wc,679
 lamindb_setup/_schema_metadata.py,sha256=cDkNHyFTFZq879UGY6i-rJEXfeBN59AN3Wz86caKnYI,14358
 lamindb_setup/_set_managed_storage.py,sha256=qC3ACD_PWG-MrzcS3fQpjDEOuxAaJBgPqCU_bDvqtXo,2043
-lamindb_setup/_setup_user.py,sha256=-g7Xj6510BDyM8kuqAsVBZFwehlhBa_uWBSV1rPeuM8,4586
+lamindb_setup/_setup_user.py,sha256=8BSGsW5jfmB4FlkhMt5osYXBbVCdOQeAVATb-oAYxa0,4495
 lamindb_setup/_silence_loggers.py,sha256=AKF_YcHvX32eGXdsYK8MJlxEaZ-Uo2f6QDRzjKFCtws,1568
 lamindb_setup/core/__init__.py,sha256=BxIVMX5HQq8oZ1OuY_saUEJz5Tdd7gaCPngxVu5iou4,417
-lamindb_setup/core/_aws_options.py,sha256=Umxu_1AYd-0LJUElZxowvE9vNA7Z8kh_63g3pp1gfd8,7243
+lamindb_setup/core/_aws_options.py,sha256=BLLAtasJp7T0quMG7KgH8PmfHAn62izBwA7bYFwLV88,7748
 lamindb_setup/core/_aws_storage.py,sha256=nEjeUv4xUVpoV0Lx-zjjmyb9w804bDyaeiM-OqbfwM0,1799
 lamindb_setup/core/_deprecated.py,sha256=HN7iUBdEgahw5e4NHCd1VJooUfieNb6GRzS5x8jU-q8,2549
 lamindb_setup/core/_docs.py,sha256=3k-YY-oVaJd_9UIY-LfBg_u8raKOCNfkZQPA73KsUhs,276
 lamindb_setup/core/_hub_client.py,sha256=XJ9V0th11zcx87tDTDVtYf5YjnEC06_jiSRHcnbFseg,7510
-lamindb_setup/core/_hub_core.py,sha256=FCFvnQsPWUYLJ_GFsuQ8rINQ7Rqth71pDfNJHRjPY_0,21344
+lamindb_setup/core/_hub_core.py,sha256=G5P7sZjH-2ZrWvmfQgJSB1Kw1JP01t070S4eX62mlwc,21738
 lamindb_setup/core/_hub_crud.py,sha256=IAuPZes1am8OFwtcf5jSRQPGG1eKwVTEsp9Li-uq0cQ,5377
 lamindb_setup/core/_hub_utils.py,sha256=6dyDGyzYFgVfR_lE3VN3CP1jGp98gxPtr-T91PAP05U,2687
 lamindb_setup/core/_private_django_api.py,sha256=By63l3vIEtK1pq246FhHq3tslxsaTJGKm5VakYluWp4,2656
-lamindb_setup/core/_settings.py,sha256=eslFO84vb5uRRfJ3r_uu4O8677l8lU5BbpZJMSAYw6A,8244
-lamindb_setup/core/_settings_instance.py,sha256=iUoLJj_bl8axs4fiNA5jgLjIEvrMaJBzz-PUDWXmUwg,19395
-lamindb_setup/core/_settings_load.py,sha256=BaII7qH3hKbttHHtB5YECoz0c2SnxL_IcUEMZhuqHCo,4342
+lamindb_setup/core/_settings.py,sha256=zkogVBqRly37pyDOReVDV019hR3oY2POImobDjs8CM8,8375
+lamindb_setup/core/_settings_instance.py,sha256=ftHAFFbg_0iThuywuQM37RIiCQnMEOc1dftTig1_DZo,19382
+lamindb_setup/core/_settings_load.py,sha256=adVwwEiwglrNNpZFgoP-EENZkzxZvKOzUr3z204pe94,4658
 lamindb_setup/core/_settings_save.py,sha256=P04ZnWFSN4Qq_QFWXNvJDs4yxrY9CjQBol_BDku_JEw,3227
 lamindb_setup/core/_settings_storage.py,sha256=op31t12T_fCfTG8OSfnXnIxB9VCQPg8Oo2cnZHVap8Y,14203
 lamindb_setup/core/_settings_store.py,sha256=zyybc6fJXJcFNTjBrgtgbPhriInuhpmQKNoGmy8ScFA,2298
 lamindb_setup/core/_settings_user.py,sha256=lWqV3HmZCsEq2UsU_iVNW0p9ddsNg7-B6xOaMNH1aw0,1475
 lamindb_setup/core/_setup_bionty_sources.py,sha256=ox3X-SHiHa2lNPSWjwZhINypbLacX6kGwH6hVVrSFZc,1505
 lamindb_setup/core/cloud_sqlite_locker.py,sha256=i6TrT7HG0lqliPvZTlsZ_uplPaqhPBbabyfeR32SkA8,7107
-lamindb_setup/core/django.py,sha256=2qIt3t9Ra_24aKU7q1r30JY87TM_rT6Cvh8rNPlqRc8,4876
+lamindb_setup/core/django.py,sha256=TMPRnZyFxD_BoKHJUw88aHqUNU_Dikyqg42GPNXBG-g,7414
 lamindb_setup/core/exceptions.py,sha256=4NpLUNUIfXYVTFX2FvLZF8RW34exk2Vn2X3G4YhnTRg,276
 lamindb_setup/core/hashing.py,sha256=M3Q1-ywnqh4Uy5zojbQfLju19HU0ySp8Oi7FGIJXfFI,3667
 lamindb_setup/core/types.py,sha256=zJii2le38BJUmsNVvzDrbzGYr0yaeb-9Rw9IKmsBr3k,523
 lamindb_setup/core/upath.py,sha256=bjKlQZFe-azlZZZ_VjH9bzfh93G6b88b_IE6E6Dg7cY,33662
-lamindb_setup-1.4.1.dist-info/LICENSE,sha256=UOZ1F5fFDe3XXvG4oNnkL1-Ecun7zpHzRxjp-XsMeAo,11324
-lamindb_setup-1.4.1.dist-info/WHEEL,sha256=CpUCUxeHQbRN5UGRQHYRJorO5Af-Qy_fHMctcQ8DSGI,82
-lamindb_setup-1.4.1.dist-info/METADATA,sha256=F41PXuW4grUyG6yLr9g-uCSTPb9SPK0AKhI6aCmm2_8,1790
-lamindb_setup-1.4.1.dist-info/RECORD,,
+lamindb_setup-1.5.0.dist-info/LICENSE,sha256=UOZ1F5fFDe3XXvG4oNnkL1-Ecun7zpHzRxjp-XsMeAo,11324
+lamindb_setup-1.5.0.dist-info/WHEEL,sha256=CpUCUxeHQbRN5UGRQHYRJorO5Af-Qy_fHMctcQ8DSGI,82
+lamindb_setup-1.5.0.dist-info/METADATA,sha256=aFRhOpjfw5V8ES2LSKpz691L1HOfeFC2zVaP7yvI72I,1790
+lamindb_setup-1.5.0.dist-info/RECORD,,