lamindb_setup 1.5.1__py3-none-any.whl → 1.6.0__py3-none-any.whl

lamindb_setup/__init__.py

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

lamindb_setup/_connect_instance.py

@@ -67,10 +67,12 @@ def update_db_using_local(
     db_updated = None
     # check if postgres
     if hub_instance_result["db_scheme"] == "postgresql":
-        db_dsn_hub = LaminDsnModel(db=hub_instance_result["db"])
         if db is not None:
-            db_dsn_local = LaminDsnModel(db=db)
+            # use only the provided db if it is set
+            db_dsn_hub = LaminDsnModel(db=db)
+            db_dsn_local = db_dsn_hub
         else:
+            db_dsn_hub = LaminDsnModel(db=hub_instance_result["db"])
             # read directly from the environment
             if os.getenv("LAMINDB_INSTANCE_DB") is not None:
                 logger.important("loading db URL from env variable LAMINDB_INSTANCE_DB")
@@ -78,16 +80,15 @@ def update_db_using_local(
             # read from a cached settings file in case the hub result is only
             # read level or inexistent
             elif settings_file.exists() and (
-                db_dsn_hub.db.user is None
-                or (db_dsn_hub.db.user is not None and "read" in db_dsn_hub.db.user)
+                db_dsn_hub.db.user in {None, "none"} or "read" in db_dsn_hub.db.user  # type:ignore
             ):
                 isettings = load_instance_settings(settings_file)
                 db_dsn_local = LaminDsnModel(db=isettings.db)
             else:
                 # just take the default hub result and ensure there is actually a user
                 if (
-                    db_dsn_hub.db.user == "none"
-                    and db_dsn_hub.db.password == "none"
+                    db_dsn_hub.db.user in {None, "none"}
+                    and db_dsn_hub.db.password in {None, "none"}
                     and raise_permission_error
                 ):
                     raise PermissionError(
@@ -95,13 +96,13 @@ def update_db_using_local(
                         " a DB URL and pass it via --db <db_url>"
                     )
                 db_dsn_local = db_dsn_hub
-        if not check_db_dsn_equal_up_to_credentials(db_dsn_hub.db, db_dsn_local.db):
-            raise ValueError(
-                "The local differs from the hub database information:\n 1. did you"
-                " pass a wrong db URL with --db?\n 2. did your database get updated by"
-                " an admin?\nConsider deleting your cached database environment:\nrm"
-                f" {settings_file.as_posix()}"
-            )
+            if not check_db_dsn_equal_up_to_credentials(db_dsn_hub.db, db_dsn_local.db):
+                raise ValueError(
+                    "The local differs from the hub database information:\n"
+                    "did your database get updated by an admin?\n"
+                    "Consider deleting your cached database environment:\nrm"
+                    f" {settings_file.as_posix()}"
+                )
         db_updated = LaminDsn.build(
             scheme=db_dsn_hub.db.scheme,
             user=db_dsn_local.db.user,
@@ -345,11 +346,15 @@ def migrate_lnschema_core(
     if db_type == "sqlite":
         import sqlite3
 
+        # maybe also use LAMINDB_DJANGO_DATABASE_URL here?
         conn = sqlite3.connect(parsed_uri.path)
     elif db_type in ["postgresql", "postgres"]:
         import psycopg2
 
-        conn = psycopg2.connect(isettings.db)
+        # do not ignore LAMINDB_DJANGO_DATABASE_URL if it is set
+        conn = psycopg2.connect(
+            os.environ.get("LAMINDB_DJANGO_DATABASE_URL", isettings.db)
+        )
     else:
         raise ValueError("Unsupported database type. Use 'sqlite' or 'postgresql' URI.")
 

lamindb_setup/_init_instance.py

@@ -98,13 +98,31 @@ def register_user(usettings):
 def register_initial_records(isettings: InstanceSettings, usettings):
     """Register space, user & storage in DB."""
     from django.db.utils import OperationalError
-    from lamindb.models import Space
+    from lamindb.models import Branch, Space
 
     try:
         Space.objects.get_or_create(
+            uid="A",
             name="All",
             description="Every team & user with access to the instance has access.",
         )
+        Branch.objects.get_or_create(
+            id=-1,
+            uid="T",
+            name="Trash",
+            description="The trash.",
+        )
+        Branch.objects.get_or_create(
+            id=0,
+            uid="A",
+            name="Archive",
+            description="The archive.",
+        )
+        Branch.objects.get_or_create(
+            uid="M",
+            name="Main",
+            description="The main & default branch of the instance.",
+        )
         register_user(usettings)
         register_storage_in_instance(isettings.storage)
     except OperationalError as error:
@@ -206,7 +224,7 @@ class CannotSwitchDefaultInstance(SystemExit):
 MESSAGE_CANNOT_SWITCH_DEFAULT_INSTANCE = """
 You cannot write to different instances in the same Python session.
 
-Do you want to read from another instance via `Record.using()`? For example:
+Do you want to read from another instance via `SQLRecord.using()`? For example:
 
 ln.Artifact.using("laminlabs/cellxgene").filter()
 

lamindb_setup/_schema_metadata.py

@@ -150,6 +150,7 @@ class FieldMetadata(BaseModel):
     is_link_table: bool
     is_primary_key: bool
     is_editable: bool
+    max_length: int | None = None
     relation_type: RelationType | None = None
     related_field_name: str | None = None
     related_model_name: str | None = None
@@ -158,7 +159,7 @@ class FieldMetadata(BaseModel):
 
 class _ModelHandler:
     def __init__(self, model, module_name: str, included_modules: list[str]) -> None:
-        from lamindb.models import LinkORM
+        from lamindb.models import IsLink
 
         self.model = model
         self.class_name = model.__name__
@@ -167,7 +168,11 @@ class _ModelHandler:
         self.table_name = model._meta.db_table
         self.included_modules = included_modules
         self.fields = self._get_fields_metadata(self.model)
-        self.is_link_table = issubclass(model, LinkORM)
+        self.is_link_table = issubclass(model, IsLink)
+        self.name_field = model._name_field if hasattr(model, "_name_field") else None
+        self.ontology_id_field = (
+            model._ontology_id_field if hasattr(model, "_ontology_id_field") else None
+        )
 
     def to_dict(self, include_django_objects: bool = True):
         _dict = {
@@ -175,6 +180,8 @@ class _ModelHandler:
             "class_name": self.class_name,
             "table_name": self.table_name,
             "is_link_table": self.is_link_table,
+            "name_field": self.name_field,
+            "ontology_id_field": self.ontology_id_field,
         }
 
         for field_name in self.fields.keys():
@@ -238,23 +245,26 @@ class _ModelHandler:
         return related_fields
 
     def _get_field_metadata(self, model, field: Field):
-        from lamindb.models import LinkORM
+        from lamindb.models import IsLink
 
         internal_type = field.get_internal_type()
         model_name = field.model._meta.model_name
         relation_type = self._get_relation_type(model, field)
+
+        schema_name = field.model.__get_module_name__()
+
         if field.related_model is None:
-            schema_name = field.model.__get_module_name__()
             related_model_name = None
             related_schema_name = None
             related_field_name = None
             is_editable = field.editable
+            max_length = field.max_length
         else:
             related_model_name = field.related_model._meta.model_name
             related_schema_name = field.related_model.__get_module_name__()
-            schema_name = field.model.__get_module_name__()
             related_field_name = field.remote_field.name
             is_editable = False
+            max_length = None
 
         field_name = field.name
         is_primary_key = getattr(field, "primary_key", False)
@@ -286,9 +296,10 @@ class _ModelHandler:
             model_name=model_name,
             field_name=field_name,
             type=internal_type,
-            is_link_table=issubclass(field.model, LinkORM),
+            is_link_table=issubclass(field.model, IsLink),
             is_primary_key=is_primary_key,
             is_editable=is_editable,
+            max_length=max_length,
             column_name=column,
             relation_type=relation_type,
             related_schema_name=related_schema_name
@@ -389,7 +400,7 @@ class _SchemaHandler:
         return self.to_dict(include_django_objects=False)
 
     def _get_modules_metadata(self):
-        from lamindb.models import Record, Registry
+        from lamindb.models import Registry, SQLRecord
 
         all_models = {
             module_name: {
@@ -400,7 +411,7 @@ class _SchemaHandler:
                     module_name
                 ).models.__dict__.values()
                 if model.__class__ is Registry
-                and model is not Record
+                and model is not SQLRecord
                 and not model._meta.abstract
                 and model.__get_module_name__() == module_name
             }

lamindb_setup/core/_hub_core.py

@@ -36,6 +36,7 @@ from ._hub_utils import (
 from ._settings import settings
 from ._settings_instance import InstanceSettings
 from ._settings_storage import StorageSettings, base62
+from .hashing import hash_and_encode_as_b62
 
 if TYPE_CHECKING:
     from supabase import Client  # type: ignore
@@ -116,6 +117,28 @@ def _select_storage(
         return True
 
 
+def _select_storage_or_parent(path: str, client: Client) -> dict | None:
+    result = client.rpc("existing_root_or_child", {"_path": path}).execute().data
+    if result["root"] is None:
+        return None
+    result["uid"] = result.pop("lnid")
+    result["instance_uid"] = hash_and_encode_as_b62(
+        UUID(result.pop("instance_id")).hex
+    )[:12]
+    return result
+
+
+def select_storage_or_parent(path: str, access_token: str | None = None) -> dict | None:
+    if settings.user.handle != "anonymous" or access_token is not None:
+        return call_with_fallback_auth(
+            _select_storage_or_parent,
+            path=path,
+            access_token=access_token,
+        )
+    else:
+        return call_with_fallback(_select_storage_or_parent, path=path)
+
+
 def init_storage_hub(
     ssettings: StorageSettings,
     auto_populate_instance: bool = True,

lamindb_setup/core/_settings.py

@@ -5,6 +5,7 @@ import sys
 from typing import TYPE_CHECKING
 
 from appdirs import AppDirs
+from lamin_utils import logger
 
 from ._settings_load import (
     load_instance_settings,
@@ -162,7 +163,16 @@ class SetupSettings:
             self._cache_dir = cache_dir
         else:
             cache_dir = self._cache_dir
-        cache_dir.mkdir(parents=True, exist_ok=True)
+        try:
+            cache_dir.mkdir(parents=True, exist_ok=True)
+        # we don not want this to error
+        # beause no actual writing happens on just getting the cache dir
+        # in cloud_to_local_no_update for example
+        # so it should not fail on read-only systems
+        except Exception as e:
+            logger.warning(
+                f"Failed to create lamin cache directory at {cache_dir}: {e}"
+            )
         return cache_dir
 
     @property

lamindb_setup/core/_settings_store.py

@@ -2,6 +2,7 @@ import os
 from pathlib import Path
 from typing import Optional
 
+from lamin_utils import logger
 from pydantic_settings import BaseSettings, SettingsConfigDict
 
 if "LAMIN_SETTINGS_DIR" in os.environ:
@@ -12,7 +13,11 @@ else:
     # hence, let's take home/.lamin
     settings_dir = Path.home() / ".lamin"
 
-settings_dir.mkdir(parents=True, exist_ok=True)
+
+try:
+    settings_dir.mkdir(parents=True, exist_ok=True)
+except Exception as e:
+    logger.warning(f"Failed to create lamin settings directory at {settings_dir}: {e}")
 
 
 def get_settings_file_name_prefix():

lamindb_setup/core/_settings_user.py

@@ -47,7 +47,7 @@ class UserSettings:
 
     @property
     def id(self):
-        """Integer id valid in current intance."""
+        """Integer id valid in current instance."""
         from lamindb.base.users import current_user_id
 
         # there is no cache needed here because current_user_id()

lamindb_setup/core/django.py

@@ -3,6 +3,10 @@ from __future__ import annotations
 # flake8: noqa
 import builtins
 import os
+import sys
+import importlib as il
+import jwt
+import time
 from pathlib import Path
 import time
 from ._settings_instance import InstanceSettings
@@ -14,15 +18,47 @@ IS_MIGRATING = False
 CONN_MAX_AGE = 299
 
 
+# db token that refreshes on access if needed
+class DBToken:
+    def __init__(
+        self, instance: InstanceSettings | dict, access_token: str | None = None
+    ):
+        self.instance = instance
+        self.access_token = access_token
+        # initialized in token_query
+        self._token: str | None = None
+        self._token_query: str | None = None
+        self._expiration: float
+
+    def _refresh_token(self):
+        from ._hub_core import access_db
+        from psycopg2.extensions import adapt
+
+        self._token = access_db(self.instance, self.access_token)
+        self._token_query = (
+            f"SELECT set_token({adapt(self._token).getquoted().decode()}, true);"
+        )
+        self._expiration = jwt.decode(self._token, options={"verify_signature": False})[
+            "exp"
+        ]
+
+    @property
+    def token_query(self) -> str:
+        # refresh token if needed
+        if self._token is None or time.time() >= self._expiration:
+            self._refresh_token()
+
+        return self._token_query  # type: ignore
+
+
 # a class to manage jwt in dbs
 class DBTokenManager:
-    def __init__(self, debug: bool = False):
+    def __init__(self):
         from django.db.transaction import Atomic
 
-        self.debug = debug
         self.original_atomic_enter = Atomic.__enter__
 
-        self.tokens: dict[str, str] = {}
+        self.tokens: dict[str, DBToken] = {}
 
     def get_connection(self, connection_name: str):
         from django.db import connections
@@ -32,19 +68,11 @@ class DBTokenManager:
 
         return connection
 
-    def set(self, token: str, connection_name: str = "default"):
+    def set(self, token: DBToken, 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
@@ -53,12 +81,7 @@ class DBTokenManager:
             )
             # 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)
+                sql = token.token_query + sql
             result = execute(sql, params, many, context)
             # this ensures that psycopg3 in the current env doesn't break this wrapper
             # psycopg3 returns a cursor
@@ -69,30 +92,29 @@ class DBTokenManager:
                 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)
 
+        self.tokens[connection_name] = token
+
         # 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)
+            connection_name = "default" if atomic.using is None else atomic.using
+            if connection_name in self.tokens:
+                # here we don't use the connection from the closure
+                # because Atomic is a single class to manage transactions for all connections
+                connection = self.get_connection(connection_name)
+                if len(connection.atomic_blocks) == 1:
+                    token = self.tokens[connection_name]
+                    # use raw psycopg2 connection here
+                    # atomic block ensures connection
+                    connection.connection.cursor().execute(token.token_query)
 
         Atomic.__enter__ = __enter__
 
-        self.tokens[connection_name] = token
-
     def reset(self, connection_name: str = "default"):
         from django.db.transaction import Atomic
 
@@ -103,7 +125,6 @@ class DBTokenManager:
             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)
 
@@ -151,8 +172,7 @@ def setup_django(
 
         module_names = ["core"] + list(isettings.modules)
         raise_import_error = True if init else False
-        installed_apps = ["django.contrib.contenttypes"]
-        installed_apps += [
+        installed_apps = [
             package_name
             for name in module_names
             if (
@@ -198,9 +218,7 @@ def setup_django(
         BaseDatabaseWrapper.close_if_health_check_failed = close_if_health_check_failed
 
         if isettings._fine_grained_access and isettings._db_permissions == "jwt":
-            from ._hub_core import access_db
-
-            db_token = access_db(isettings)
+            db_token = DBToken(isettings)
             db_token_manager.set(db_token)  # sets for the default connection
 
     if configure_only:
@@ -225,3 +243,44 @@ def setup_django(
 
     if isettings.keep_artifacts_local:
         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
+def reset_django():
+    from django.conf import settings
+    from django.apps import apps
+    from django.db import connections
+
+    if not settings.configured:
+        return
+
+    connections.close_all()
+
+    if getattr(settings, "_wrapped", None) is not None:
+        settings._wrapped = None
+
+    app_names = {"django"} | {app.name for app in apps.get_app_configs()}
+
+    apps.app_configs.clear()
+    apps.apps_ready = apps.models_ready = apps.ready = apps.loading = False
+    apps.clear_cache()
+
+    # i suspect it is enough to just drop django and all the apps from sys.modules
+    # the code above is just a precaution
+    for module_name in list(sys.modules):
+        if module_name.partition(".")[0] in app_names:
+            del sys.modules[module_name]
+
+    il.invalidate_caches()
+
+    global db_token_manager
+    db_token_manager = DBTokenManager()
+
+    global IS_SETUP
+    IS_SETUP = False

lamindb_setup/core/upath.py

@@ -51,6 +51,21 @@ VALID_SIMPLE_SUFFIXES = {
     ".xml",
     ".qs",  # https://cran.r-project.org/web/packages/qs/vignettes/vignette.html
     ".rds",
+    ".pt",
+    ".pth",
+    ".ckpt",
+    ".state_dict",
+    ".keras",
+    ".pb",
+    ".pbtxt",
+    ".savedmodel",
+    ".pkl",
+    ".pickle",
+    ".bin",
+    ".safetensors",
+    ".model",
+    ".mlmodel",
+    ".mar",
     #
     # with readers (see below)
     #

{lamindb_setup-1.5.1.dist-info → lamindb_setup-1.6.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: lamindb_setup
-Version: 1.5.1
+Version: 1.6.0
 Summary: Setup & configure LaminDB.
 Author-email: Lamin Labs <open-source@lamin.ai>
 Requires-Python: >=3.10

{lamindb_setup-1.5.1.dist-info → lamindb_setup-1.6.0.dist-info}/RECORD

@@ -1,19 +1,19 @@
-lamindb_setup/__init__.py,sha256=6Pa6KiaXVM_X8ZbMROukN1R0ZALoVmJQgtEYG7deh70,2754
+lamindb_setup/__init__.py,sha256=vSYZ5n67C1AL8iuvzPXKwh2fwCyIbPYmLoKuByHGsA8,2754
 lamindb_setup/_cache.py,sha256=ixasm_9pUFy-ztbhbqJRVP88uTbFclL60MwUUvZhMFs,1509
 lamindb_setup/_check.py,sha256=28PcG8Kp6OpjSLSi1r2boL2Ryeh6xkaCL87HFbjs6GA,129
 lamindb_setup/_check_setup.py,sha256=uveV6CGiwm9M5OMe3lxfAMDs5SU7j1EogJsQB03ZaRw,5928
-lamindb_setup/_connect_instance.py,sha256=qqB-ene_OLTgqd-M7ke9_gT6u81gzNy_Gx5K7FMUaag,18007
+lamindb_setup/_connect_instance.py,sha256=Xx2d7GWBZ4qWhmk69ZAQNfehBlnAYejk9ojPL639VRA,18260
 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=5RBv2X18SfnIrciHljaoVsFF25te2P7KwHx0Ww87HLw,14750
+lamindb_setup/_init_instance.py,sha256=S5sk1nSMYe0Kxo_gpQygu0gBsIsAF1QIfLh_d5SeEF0,15253
 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/_schema_metadata.py,sha256=x4u15X_X-4dsS0Zot3mOwn_IWO0e7LL0Ip8vyUOffNQ,14758
 lamindb_setup/_set_managed_storage.py,sha256=qC3ACD_PWG-MrzcS3fQpjDEOuxAaJBgPqCU_bDvqtXo,2043
 lamindb_setup/_setup_user.py,sha256=8BSGsW5jfmB4FlkhMt5osYXBbVCdOQeAVATb-oAYxa0,4495
 lamindb_setup/_silence_loggers.py,sha256=AKF_YcHvX32eGXdsYK8MJlxEaZ-Uo2f6QDRzjKFCtws,1568
@@ -23,25 +23,25 @@ lamindb_setup/core/_aws_storage.py,sha256=nEjeUv4xUVpoV0Lx-zjjmyb9w804bDyaeiM-Oq
 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=G5P7sZjH-2ZrWvmfQgJSB1Kw1JP01t070S4eX62mlwc,21738
+lamindb_setup/core/_hub_core.py,sha256=_TYVAbYzjmY1pd7egsqhIEFd31ZAycxlY0RFuYk56PQ,22551
 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=zkogVBqRly37pyDOReVDV019hR3oY2POImobDjs8CM8,8375
+lamindb_setup/core/_settings.py,sha256=rpakpthAcvjOeAmldvZquml-7NJ8i44Hu_P8pJV_coo,8790
 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/_settings_store.py,sha256=Qe5tsTtQO9TJ5jqr-VgiDs6MOkFrxO6y0kYEVveCN-I,2450
+lamindb_setup/core/_settings_user.py,sha256=5hmnMu6fxrHAcwBEtIL0P9N8V4B0SjhzIdqFQ9o3Tsg,1476
 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=TMPRnZyFxD_BoKHJUw88aHqUNU_Dikyqg42GPNXBG-g,7414
+lamindb_setup/core/django.py,sha256=6nKn_sokPqXqWE9EdRvhNzS5tjsMo3IZSfHiwTN_HcI,9348
 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.5.1.dist-info/LICENSE,sha256=UOZ1F5fFDe3XXvG4oNnkL1-Ecun7zpHzRxjp-XsMeAo,11324
-lamindb_setup-1.5.1.dist-info/WHEEL,sha256=CpUCUxeHQbRN5UGRQHYRJorO5Af-Qy_fHMctcQ8DSGI,82
-lamindb_setup-1.5.1.dist-info/METADATA,sha256=a3z20S-iuXtoFo6eZyiVaytP1qu5Rdj-CNT09UgQEX4,1792
-lamindb_setup-1.5.1.dist-info/RECORD,,
+lamindb_setup/core/upath.py,sha256=U5CBiHVoEBEUi-YzYd0G8wMONkO-wcXQQ9htfDWbw-s,33876
+lamindb_setup-1.6.0.dist-info/LICENSE,sha256=UOZ1F5fFDe3XXvG4oNnkL1-Ecun7zpHzRxjp-XsMeAo,11324
+lamindb_setup-1.6.0.dist-info/WHEEL,sha256=CpUCUxeHQbRN5UGRQHYRJorO5Af-Qy_fHMctcQ8DSGI,82
+lamindb_setup-1.6.0.dist-info/METADATA,sha256=Zf2AdqY6BlftKrFrwOY5HaWY9WSXv4GjaRuFs5D_mBQ,1792
+lamindb_setup-1.6.0.dist-info/RECORD,,