lamindb_setup 1.10.0__py3-none-any.whl → 1.10.2__py3-none-any.whl

lamindb_setup/__init__.py

@@ -35,7 +35,7 @@ Modules & settings:
 
 """
 
-__version__ = "1.10.0"  # denote a release candidate for 0.1.0 with 0.1rc1
+__version__ = "1.10.2"  # denote a release candidate for 0.1.0 with 0.1rc1
 
 import os
 

lamindb_setup/_connect_instance.py

@@ -3,6 +3,7 @@ from __future__ import annotations
 import importlib
 import os
 import sys
+import types
 from typing import TYPE_CHECKING, Any
 from uuid import UUID
 
@@ -24,6 +25,7 @@ from .core._settings_load import load_instance_settings
 from .core._settings_storage import StorageSettings
 from .core._settings_store import instance_settings_file, settings_dir
 from .core.cloud_sqlite_locker import unlock_cloud_sqlite_upon_exception
+from .core.django import reset_django
 from .errors import CannotSwitchDefaultInstance
 
 if TYPE_CHECKING:
@@ -101,6 +103,7 @@ def _connect_instance(
     *,
     db: str | None = None,
     raise_permission_error: bool = True,
+    use_root_db_user: bool = False,
     access_token: str | None = None,
 ) -> InstanceSettings:
     settings_file = instance_settings_file(name, owner)
@@ -120,7 +123,10 @@ def _connect_instance(
         # do not call hub if the user is anonymous
         if owner != "anonymous":
             hub_result = connect_instance_hub(
-                owner=owner, name=name, access_token=access_token
+                owner=owner,
+                name=name,
+                access_token=access_token,
+                use_root_db_user=use_root_db_user,
             )
         else:
             hub_result = "anonymous-user"
@@ -155,7 +161,9 @@ def _connect_instance(
                 schema_id=None
                 if (schema_id := instance_result["schema_id"]) is None
                 else UUID(schema_id),
-                fine_grained_access=instance_result.get("fine_grained_access", False),
+                fine_grained_access=bool(
+                    instance_result["fine_grained_access"]
+                ),  # can be None
                 db_permissions=instance_result.get("db_permissions", None),
             )
         else:
@@ -177,22 +185,26 @@ def _connect_instance(
 def reset_django_module_variables():
     # This function updates all module-level references to Django classes
     # But it will fail to update function level references
+    # This is not a problem unless for the function that calls ln.connect() itself
     # So, if a user has
+    #
     # def my_function():
     #     import lamindb as ln
-    #     ...
+    #     ln.connect(...)
     #
-    # Then it will **not** work and the `ln` variable will become stale and hold a reference
+    # Then it will **not** work and the `ln` variable becomes stale and hold a reference
     # to the old classes
-    # There doesn't seem to be an easy way to fix this problem
-
-    import types
+    # 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.important_hint("resetting django module variables")
 
+    # django.apps needs to be a local import to refresh variables
     from django.apps import apps
 
     app_names = {app.name for app in apps.get_app_configs()}
-
-    for name, module in sys.modules.items():
+    # always copy before iterations over sys.modules
+    # see https://docs.python.org/3/library/sys.html#sys.modules
+    for name, module in sys.modules.copy().items():
         if (
             module is not None
             and (not name.startswith("__") or name == "__main__")
@@ -230,12 +242,11 @@ def reset_django_module_variables():
                 continue
 
 
-def _connect_cli(instance: str) -> None:
+def _connect_cli(instance: str, use_root_db_user: bool = False) -> None:
     from lamindb_setup import settings as settings_
 
-    settings_.auto_connect = True
     owner, name = get_owner_name_from_identifier(instance)
-    isettings = _connect_instance(owner, name)
+    isettings = _connect_instance(owner, name, use_root_db_user=use_root_db_user)
     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
@@ -262,6 +273,7 @@ def connect(instance: str | None = None, **kwargs: Any) -> str | tuple | None:
     """
     # validate kwargs
     valid_kwargs = {
+        "use_root_db_user",
         "_db",
         "_write_settings",
         "_raise_not_found_error",
@@ -274,6 +286,7 @@ def connect(instance: str | None = None, **kwargs: Any) -> str | tuple | None:
             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)
     _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)
@@ -289,12 +302,18 @@ def connect(instance: str | None = None, **kwargs: Any) -> str | tuple | None:
 
     try:
         if instance is None:
-            isettings_or_none = _get_current_instance_settings()
-            if isettings_or_none is None:
-                raise ValueError(
-                    "No instance was connected through the CLI, pass a value to `instance` or connect via the CLI."
-                )
-            isettings = isettings_or_none
+            if settings._instance_exists:
+                isettings = settings.instance
+            else:
+                isettings_or_none = _get_current_instance_settings()
+                if isettings_or_none is None:
+                    raise ValueError(
+                        "No instance was connected through the CLI, pass a value to `instance` or connect via the CLI."
+                    )
+                isettings = isettings_or_none
+            if use_root_db_user:
+                reset_django()
+                owner, name = isettings.owner, isettings.name
             if _db is not None and isettings.dialect == "postgresql":
                 isettings._db = _db
         else:
@@ -310,14 +329,13 @@ def connect(instance: str | None = None, **kwargs: Any) -> str | tuple | None:
                     # 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:
-                    from lamindb_setup.core.django import reset_django
-
                     if (
                         settings._instance_exists
                         and settings.instance.slug != "none/none"
@@ -328,11 +346,6 @@ def connect(instance: str | None = None, **kwargs: Any) -> str | tuple | None:
                             raise CannotSwitchDefaultInstance(
                                 "Cannot switch default instance while `ln.track()` is live: call `ln.finish()`"
                             )
-                        else:
-                            logger.important_hint(
-                                "switching the default lamindb instance might produce unexpected side effects with function-scoped imports: "
-                                "please import lamindb at the module level instead of inside functions"
-                            )
                     reset_django()
             elif (
                 _write_settings
@@ -341,9 +354,14 @@ def connect(instance: str | None = None, **kwargs: Any) -> str | tuple | None:
             ):
                 disconnect(mute=True)
 
+        if instance is not None or use_root_db_user:
             try:
                 isettings = _connect_instance(
-                    owner, name, db=_db, access_token=access_token
+                    owner,
+                    name,
+                    db=_db,
+                    access_token=access_token,
+                    use_root_db_user=use_root_db_user,
                 )
             except InstanceNotFoundError as e:
                 if _raise_not_found_error:

lamindb_setup/_migrate.py

@@ -93,17 +93,13 @@ class migrate:
     @disable_auto_connect
     def create(cls) -> None:
         """Create a migration."""
-        if _check_instance_setup():
-            raise RuntimeError("Restart Python session to create migration or use CLI!")
         setup_django(settings.instance, create_migrations=True)
 
     @classmethod
     def deploy(cls, package_name: str | None = None, number: int | None = None) -> None:
         """Deploy a migration."""
-        from ._schema_metadata import update_schema_in_hub
-
-        if _check_instance_setup():
-            raise RuntimeError("Restart Python session to migrate or use CLI!")
+        from lamindb_setup._connect_instance import connect
+        from lamindb_setup._schema_metadata import update_schema_in_hub
         from lamindb_setup.core._hub_client import call_with_fallback_auth
         from lamindb_setup.core._hub_crud import (
             select_collaborator,
@@ -117,12 +113,17 @@ class migrate:
                 select_collaborator,
                 instance_id=settings.instance._id,
                 account_id=settings.user._uuid,
+                fine_grained_access=settings.instance._fine_grained_access,
             )
             if collaborator is None or collaborator["role"] != "admin":
                 raise SystemExit(
                     "❌ Only admins can deploy migrations, please ensure that you're an"
                     f" admin: https://lamin.ai/{settings.instance.slug}/settings"
                 )
+            # ensure we connect with the root user
+            if "root" not in settings.instance.db:
+                connect(use_root_db_user=True)
+                assert "root" in (instance_db := settings.instance.db), instance_db
             # we need lamindb to be installed, otherwise we can't populate the version
             # information in the hub
             import lamindb
@@ -139,7 +140,6 @@ class migrate:
         # this populates the hub
         if settings.instance.is_on_hub:
             logger.important(f"updating lamindb version in hub: {lamindb.__version__}")
-            # TODO: integrate update of instance table within update_schema_in_hub & below
             if settings.instance.dialect != "sqlite":
                 update_schema_in_hub()
             call_with_fallback_auth(

lamindb_setup/core/_deprecated.py

@@ -51,7 +51,7 @@ def deprecated(new_name: str):
             warnings.warn(
                 f"Use {new_name} instead of {func.__name__}, "
                 f"{func.__name__} will be removed in the future.",
-                category=FutureWarning,
+                category=DeprecationWarning,
                 stacklevel=2,
             )
             return func(*args, **kwargs)

lamindb_setup/core/_hub_core.py

@@ -424,6 +424,7 @@ def _init_instance_hub(
 def _connect_instance_hub(
     owner: str,  # account_handle
     name: str,  # instance_name
+    use_root_db_user: bool,
     client: Client,
 ) -> tuple[dict, dict] | str:
     response = client.functions.invoke(
@@ -475,17 +476,29 @@ def _connect_instance_hub(
 
     if instance["db_scheme"] is not None:
         db_user_name, db_user_password = None, None
-        if "db_user_name" in instance and "db_user_password" in instance:
+        if (
+            "db_user_name" in instance
+            and "db_user_password" in instance
+            and not use_root_db_user
+        ):
             db_user_name, db_user_password = (
                 instance["db_user_name"],
                 instance["db_user_password"],
             )
         else:
-            db_user = select_db_user_by_instance(instance["id"], client)
+            if use_root_db_user:
+                fine_grained_access = False
+            else:
+                fine_grained_access = bool(
+                    instance["fine_grained_access"]
+                )  # can be None
+            db_user = select_db_user_by_instance(
+                instance["id"], fine_grained_access, client
+            )
             if db_user is not None:
                 db_user_name, db_user_password = (
-                    db_user["db_user_name"],
-                    db_user["db_user_password"],
+                    db_user["name" if fine_grained_access else "db_user_name"],
+                    db_user["password" if fine_grained_access else "db_user_password"],
                 )
         db_dsn = LaminDsn.build(
             scheme=instance["db_scheme"],
@@ -505,15 +518,25 @@ def connect_instance_hub(
     owner: str,  # account_handle
     name: str,  # instance_name
     access_token: str | None = None,
+    use_root_db_user: bool = False,
 ) -> tuple[dict, dict] | str:
     from ._settings import settings
 
     if settings.user.handle != "anonymous" or access_token is not None:
         return call_with_fallback_auth(
-            _connect_instance_hub, owner=owner, name=name, access_token=access_token
+            _connect_instance_hub,
+            owner=owner,
+            name=name,
+            use_root_db_user=use_root_db_user,
+            access_token=access_token,
         )
     else:
-        return call_with_fallback(_connect_instance_hub, owner=owner, name=name)
+        return call_with_fallback(
+            _connect_instance_hub,
+            owner=owner,
+            name=name,
+            use_root_db_user=use_root_db_user,
+        )
 
 
 def access_aws(storage_root: str, access_token: str | None = None) -> dict[str, dict]:
@@ -570,7 +593,7 @@ def access_db(
     if isinstance(instance, InstanceSettings):
         instance_id = instance._id
         instance_slug = instance.slug
-        instance_api_url = instance._api_url
+        instance_api_url = instance.api_url
     else:
         instance_id = UUID(instance["id"])
         instance_slug = instance["owner"] + "/" + instance["name"]

lamindb_setup/core/_hub_crud.py

@@ -137,10 +137,12 @@ def update_instance(instance_id: str, instance_fields: dict, client: Client):
 def select_collaborator(
     instance_id: str,
     account_id: str,
+    fine_grained_access: bool,
     client: Client,
 ):
+    table = "access_instance" if fine_grained_access else "account_instance"
     data = (
-        client.table("account_instance")
+        client.table(table)
         .select("*")
         .eq("instance_id", instance_id)
         .eq("account_id", account_id)
@@ -180,35 +182,53 @@ def insert_db_user(
     db_user_name: str,
     db_user_password: str,
     instance_id: UUID,
+    fine_grained_access: bool,
     client: Client,
 ) -> None:
-    fields = (
-        {
-            "id": uuid4().hex,
-            "instance_id": instance_id.hex,
-            "name": name,
-            "db_user_name": db_user_name,
-            "db_user_password": db_user_password,
-        },
-    )
-    data = client.table("db_user").insert(fields).execute().data
+    fields = {"instance_id": instance_id.hex}
+    if fine_grained_access:
+        table = "access_db_user"
+        fields.update(
+            {
+                "name": db_user_name,
+                "password": db_user_password,
+                "type": name,
+            }
+        )
+    else:
+        table = "db_user"
+        fields.update(
+            {
+                "id": uuid4().hex,
+                "name": name,
+                "db_user_name": db_user_name,
+                "db_user_password": db_user_password,
+            }
+        )
+
+    data = client.table(table).insert(fields).execute().data
     return data[0]
 
 
-def select_db_user_by_instance(instance_id: str, client: Client):
+def select_db_user_by_instance(
+    instance_id: str, fine_grained_access: bool, client: Client
+):
     """Get db_user for which client has permission."""
-    data = (
-        client.table("db_user")
-        .select("*")
-        .eq("instance_id", instance_id)
-        .execute()
-        .data
-    )
+    if fine_grained_access:
+        table = "access_db_user"
+        type_name = "type"
+        type_priority = "jwt"
+    else:
+        table = "db_user"
+        type_name = "name"
+        type_priority = "write"
+
+    data = client.table(table).select("*").eq("instance_id", instance_id).execute().data
     if len(data) == 0:
         return None
     elif len(data) > 1:
         for item in data:
-            if item["name"] == "write":
+            if item[type_name] == type_priority:
                 return item
         logger.warning("found multiple db credentials, using the first one")
     return data[0]

lamindb_setup/core/_settings.py

@@ -79,24 +79,15 @@ class SetupSettings:
     def auto_connect(self) -> bool:
         """Auto-connect to current instance upon `import lamindb`.
 
-        Upon installing `lamindb`, this setting is `False`.
-
-        Upon calling `lamin init` or `lamin connect` on the CLI, this setting is switched to `True`.
-
-        `ln.connect()` doesn't change the value of this setting.
-
-        You can manually change this setting
-
-        - in Python: `ln.setup.settings.auto_connect = True/False`
-        - via the CLI: `lamin settings set auto-connect true/false`
+        This setting is always `True` and will be removed in a future version.
         """
         return True
 
     @auto_connect.setter
     def auto_connect(self, value: bool) -> None:
-        # logger.warning(
-        #     "setting auto_connect to `False` no longer has an effect and the setting will likely be removed in the future; since lamindb 1.7, auto_connect `True` no longer clashes with connecting in a Python session",
-        # )
+        logger.warning(
+            "setting auto_connect to `False` no longer has an effect and the setting will likely be removed in the future",
+        )
         if value:
             self._auto_connect_path.touch()
         else:
@@ -324,7 +315,6 @@ class SetupSettings:
         else:
             repr += "Current instance: None"
         repr += "\nConfig:\n"
-        repr += f" - auto-connect in Python: {self.auto_connect}\n"
         repr += f" - private Django API: {self.private_django_api}\n"
         repr += "Local directories:\n"
         repr += f" - cache: {self.cache_dir.as_posix()}\n"

lamindb_setup/core/_settings_instance.py

@@ -5,6 +5,7 @@ import shutil
 from pathlib import Path
 from typing import TYPE_CHECKING, Literal
 
+from django.db import connection
 from django.db.utils import ProgrammingError
 from lamin_utils import logger
 
@@ -343,6 +344,37 @@ class InstanceSettings:
         """
         return self._git_repo
 
+    @property
+    def api_url(self) -> str | None:
+        """URL for REST API.
+
+        Use this URL for API calls related to this instance.
+        """
+        return self._api_url
+
+    @property
+    def available_spaces(self) -> dict | None:
+        """Available spaces with roles for instances fine-grained permissions.
+
+        Returns a dictionary with roles as keys and lists of available spaces
+        as values if this instance has fine-grained permissions and the current user
+        is a collaborator, `None` otherwise.
+        """
+        if self._db_permissions != "jwt":
+            return None
+
+        from lamindb.models import Space
+
+        spaces: dict = {"admin": [], "write": [], "read": []}
+        with connection.cursor() as cur:
+            cur.execute("SELECT * FROM check_access() WHERE type = 'space'")
+            rows = cur.fetchall()
+        for row in rows:
+            spaces[row[1]].append(row[0])
+        return {
+            k: Space.filter(id__in=v).to_list() if v else [] for k, v in spaces.items()
+        }
+
     @property
     def _id(self) -> UUID:
         """The internal instance id."""

lamindb_setup/core/django.py

@@ -273,13 +273,9 @@ def setup_django(
         isettings._local_storage = isettings._search_local_root()
 
 
-# THIS IS NOT SAFE
-# especially if lamindb is imported already
-# django.setup fails if called for the second time
-# reset_django() allows to call setup again,
-# needed to connect to a different instance in the same process if connected already
-# there could be problems if models are already imported from lamindb or other modules
-# these 'old' models can have any number of problems
+# these needs to be followed by
+# setup_django()
+# reset_django_module_variables()
 def reset_django():
     from django.conf import settings
     from django.apps import apps

{lamindb_setup-1.10.0.dist-info → lamindb_setup-1.10.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: lamindb_setup
-Version: 1.10.0
+Version: 1.10.2
 Summary: Setup & configure LaminDB.
 Author-email: Lamin Labs <open-source@lamin.ai>
 Requires-Python: >=3.10
@@ -27,7 +27,7 @@ Requires-Dist: psycopg2-binary ; extra == "dev"
 Requires-Dist: python-dotenv ; extra == "dev"
 Requires-Dist: nox ; extra == "dev"
 Requires-Dist: pytest>=6.0 ; extra == "dev"
-Requires-Dist: pytest-cov ; extra == "dev"
+Requires-Dist: pytest-cov<7.0.0 ; extra == "dev"
 Requires-Dist: pytest-xdist ; extra == "dev"
 Requires-Dist: nbproject-test>=0.4.3 ; extra == "dev"
 Requires-Dist: pandas ; extra == "dev"

{lamindb_setup-1.10.0.dist-info → lamindb_setup-1.10.2.dist-info}/RECORD

@@ -1,8 +1,8 @@
-lamindb_setup/__init__.py,sha256=3mcObwaFgQm5wWQp4KSOie5bNf-F8wcGjWh6v6hFYWw,2783
+lamindb_setup/__init__.py,sha256=X3c4WiIMGBIUrnNgq0NYa6vEZbdSPENtF4bbr2kHuwc,2783
 lamindb_setup/_cache.py,sha256=pGvDNVHGx4HWr_6w5ajqEJOdysmaGc6F221qFnXkT-k,2747
 lamindb_setup/_check.py,sha256=28PcG8Kp6OpjSLSi1r2boL2Ryeh6xkaCL87HFbjs6GA,129
 lamindb_setup/_check_setup.py,sha256=ToKMxsUq8dQBQh8baOrNVlSb1iC8h4zTg5dV8wMu0W4,6760
-lamindb_setup/_connect_instance.py,sha256=wC66-SrdQx4Qeei_-zzEJPYL2RFZGihd8ErfOfEzt1c,16666
+lamindb_setup/_connect_instance.py,sha256=6pgE_8Kv8ZVytXzN6Qp5ZlOtMtqE93cIdSkdA3Ey8ko,17545
 lamindb_setup/_delete.py,sha256=4kS-_nQrV5xMvZE3BGCNEEGCboyGmqqDMXlckF0GxSk,5780
 lamindb_setup/_disconnect.py,sha256=FT8EpCm5XXDdhDH7QtAnkO3KPatq2HqT9VXGNjgJDbk,1232
 lamindb_setup/_django.py,sha256=uIQflpkp8l3axyPaKURlk3kacgpElVP5KOKmFxYSMGk,1454
@@ -10,7 +10,7 @@ lamindb_setup/_entry_points.py,sha256=sKwXPX9xjOotoAjvgkU5LBwjjHLWVkh0ZGdiSsrch9
 lamindb_setup/_exportdb.py,sha256=QLjoH4dEwqa01A12naKaDPglCCzl2_VLKWFfJRE_uSg,2113
 lamindb_setup/_importdb.py,sha256=fKv9ev5OOj_-bmzC8XZ1GxOcjIjI486yrHSHDWQrJeI,1874
 lamindb_setup/_init_instance.py,sha256=0DhUGJ6FERxVg30F4XhCfsXaIy3AP1UecQzyjEm-FLw,14965
-lamindb_setup/_migrate.py,sha256=W-F5vSSs4pB68TdX6k97vMV-VOPgqcf6VOejHjbrQA8,10326
+lamindb_setup/_migrate.py,sha256=oaqFcONqclTBXjxr4OWCJkSIH08nmC69xgVzdRq0N8U,10375
 lamindb_setup/_register_instance.py,sha256=RdUZxZWHLdbvdNZWpF8e0UWROb_T0cStWbzc5yUw34I,1047
 lamindb_setup/_schema.py,sha256=b3uzhhWpV5mQtDwhMINc2MabGCnGLESy51ito3yl6Wc,679
 lamindb_setup/_schema_metadata.py,sha256=yMSuLZc-7iWUV7tETNuKmcDeMW0wtUr5ypKxsKC-m7k,14898
@@ -23,15 +23,15 @@ lamindb_setup/types.py,sha256=XlXLb4nmbc68uBj5Hp3xpDRezYGJIBZv6jAAqqN0p10,614
 lamindb_setup/core/__init__.py,sha256=5M4A6CVHBO_T5Rr9MeLaPW3WTk4-y00cgRYEgUJVU5U,410
 lamindb_setup/core/_aws_options.py,sha256=UbwnaEX2KcZBDOa2W2NbH62cNrKJQ78Hrn7zcszhQvU,8092
 lamindb_setup/core/_aws_storage.py,sha256=ofPTHXvF97I9eUCHxj5RPpUUqAcNV0VsPWpyKMcshOI,2030
-lamindb_setup/core/_deprecated.py,sha256=HN7iUBdEgahw5e4NHCd1VJooUfieNb6GRzS5x8jU-q8,2549
+lamindb_setup/core/_deprecated.py,sha256=M3vpM4fZPOncxY2qsXQAPeaEph28xWdv7tYaueaUyAA,2554
 lamindb_setup/core/_docs.py,sha256=3k-YY-oVaJd_9UIY-LfBg_u8raKOCNfkZQPA73KsUhs,276
 lamindb_setup/core/_hub_client.py,sha256=Pl3sEG2rasdJp4Rh5HNY0VsPVls-nfY0OxD5QzrYF9A,8678
-lamindb_setup/core/_hub_core.py,sha256=hYjtUaBEcUA5Etn4aPVDX3oSksdwr-8UL7gplIFriVc,25814
-lamindb_setup/core/_hub_crud.py,sha256=Jz0d8wFKM1Pv9B9byyUJPlCIMkIzk56Jd-c3Awpm9Xw,5730
+lamindb_setup/core/_hub_core.py,sha256=r1tpfDjzgv7phESjq_dqYk23fyvm1M4KaVI-snP3NLA,26477
+lamindb_setup/core/_hub_crud.py,sha256=j6516H82kLjFUNPqFGUINbDw9YbofMgjxadGzYb0OS4,6362
 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=CzOdAABbNHR5sWfPG90SZCpiDaHJw1NI3_JurQUtwV8,13811
-lamindb_setup/core/_settings_instance.py,sha256=_zIfY-6lOBPu6ttE-MgOE5ebHhn1JE47dBUt0A73BUE,22241
+lamindb_setup/core/_settings.py,sha256=Xsn4Z-Z-gGM6q89f0SiWMaSDhIbTurwEwJLRsz6vspM,13312
+lamindb_setup/core/_settings_instance.py,sha256=P2O2RWOSx2OUuU2nJBaD8FV6EIZYvUGGqTeVabIBKsA,23325
 lamindb_setup/core/_settings_load.py,sha256=j20cy3J56ZBHLDfB2A8oKjekNetMNsy0_W3eWD36pWI,5161
 lamindb_setup/core/_settings_save.py,sha256=XZx-vow7BT6y3JpRBB2UOJp2vwc7jOGea4wSgOPqjPU,3262
 lamindb_setup/core/_settings_storage.py,sha256=pyU25hP5rQYjVe0tFPR8P6TzAYzu1NpT-PIbXoxfV18,15348
@@ -39,12 +39,12 @@ lamindb_setup/core/_settings_store.py,sha256=QmeWIGdIyq7UmjfHiEB_0xRD8hY-8-ZR2Wn
 lamindb_setup/core/_settings_user.py,sha256=gFfyMf-738onbh1Mf4wsmLlenQJPtjQfpUgKnOlqc2o,1453
 lamindb_setup/core/_setup_bionty_sources.py,sha256=ox3X-SHiHa2lNPSWjwZhINypbLacX6kGwH6hVVrSFZc,1505
 lamindb_setup/core/cloud_sqlite_locker.py,sha256=H_CTUCjURFXwD1cCtV_Jn0_60iztZTkaesLLXIBgIxc,7204
-lamindb_setup/core/django.py,sha256=Pi2HkvH0F9edziov8gmq4bEES9vYi9e0cHd-R19ocmA,10771
+lamindb_setup/core/django.py,sha256=Er0ikZmWHx5rPkzbuWLNkq2XTL9yTcEL16iX1yz9R60,10470
 lamindb_setup/core/exceptions.py,sha256=qjMzqy_uzPA7mCOdnoWnS_fdA6OWbdZGftz-YYplrY0,84
 lamindb_setup/core/hashing.py,sha256=Y8Uc5uSGTfU6L2R_gb5w8DdHhGRog7RnkK-e9FEMjPY,3680
 lamindb_setup/core/types.py,sha256=T7NwspfRHgIIpYsXDcApks8jkOlGeGRW-YbVLB7jNIo,67
 lamindb_setup/core/upath.py,sha256=-Wxct7lYOLVzUGv3ynqq0zLcRSAGWbvs-NqrZL0Aqy4,35579
-lamindb_setup-1.10.0.dist-info/LICENSE,sha256=UOZ1F5fFDe3XXvG4oNnkL1-Ecun7zpHzRxjp-XsMeAo,11324
-lamindb_setup-1.10.0.dist-info/WHEEL,sha256=CpUCUxeHQbRN5UGRQHYRJorO5Af-Qy_fHMctcQ8DSGI,82
-lamindb_setup-1.10.0.dist-info/METADATA,sha256=jvFAWDjQWtaIldISegSqxJcgy87atWPfbgVMTMC_JXg,1798
-lamindb_setup-1.10.0.dist-info/RECORD,,
+lamindb_setup-1.10.2.dist-info/LICENSE,sha256=UOZ1F5fFDe3XXvG4oNnkL1-Ecun7zpHzRxjp-XsMeAo,11324
+lamindb_setup-1.10.2.dist-info/WHEEL,sha256=CpUCUxeHQbRN5UGRQHYRJorO5Af-Qy_fHMctcQ8DSGI,82
+lamindb_setup-1.10.2.dist-info/METADATA,sha256=B90EP2olTts5waIXLN5nLvIBqWnhY_FxeoMX9yLOnwk,1804
+lamindb_setup-1.10.2.dist-info/RECORD,,