lamindb_setup 0.81.4__py3-none-any.whl → 1.0a1__py3-none-any.whl

lamindb_setup/__init__.py

@@ -33,7 +33,7 @@ Modules & settings:
 
 """
 
-__version__ = "0.81.4"  # denote a release candidate for 0.1.0 with 0.1rc1
+__version__ = "1.0a1"  # denote a release candidate for 0.1.0 with 0.1rc1
 
 import os as _os
 import sys as _sys
@@ -51,7 +51,36 @@ from ._register_instance import register
 from ._setup_user import login, logout
 from .core._settings import settings
 
-_TESTING = _os.getenv("LAMIN_TESTING") is not None
+
+def _is_CI_environment() -> bool:
+    ci_env_vars = [
+        "LAMIN_TESTING",  # Set by our nox configurations
+        "CI",  # Commonly set by many CI systems
+        "TRAVIS",  # Travis CI
+        "GITHUB_ACTIONS",  # GitHub Actions
+        "GITLAB_CI",  # GitLab CI/CD
+        "CIRCLECI",  # CircleCI
+        "JENKINS_URL",  # Jenkins
+        "TEAMCITY_VERSION",  # TeamCity
+        "BUILDKITE",  # Buildkite
+        "BITBUCKET_BUILD_NUMBER",  # Bitbucket Pipelines
+        "APPVEYOR",  # AppVeyor
+        "AZURE_HTTP_USER_AGENT",  # Azure Pipelines
+        "BUDDY",  # Buddy
+        "DRONE",  # Drone CI
+        "HUDSON_URL",  # Hudson
+        "CF_BUILD_ID",  # Codefresh
+        "WERCKER",  # Wercker
+        "NOW_BUILDER",  # ZEIT Now
+        "TASKCLUSTER_ROOT_URL",  # TaskCluster
+        "SEMAPHORE",  # Semaphore CI
+        "BUILD_ID",  # Generic build environments
+    ]
+    return any(env_var in _os.environ for env_var in ci_env_vars)
+
+
+_TESTING = _is_CI_environment()
+
 
 # hide the supabase error in a thread on windows
 if _os.name == "nt":

lamindb_setup/_check_setup.py

@@ -27,6 +27,7 @@ If you used the CLI to set up lamindb in a notebook, restart the Python session.
 
 
 CURRENT_ISETTINGS: InstanceSettings | None = None
+IS_LOADING: bool = False
 
 
 def _get_current_instance_settings() -> InstanceSettings | None:
@@ -54,16 +55,11 @@ def _get_current_instance_settings() -> InstanceSettings | None:
 
 # we make this a private function because in all the places it's used,
 # users should not see it
-def _check_instance_setup(
-    from_lamindb: bool = False, from_module: str | None = None
-) -> bool:
-    reload_module = from_lamindb or from_module is not None
-    from ._init_instance import get_schema_module_name, reload_schema_modules
-
+def _check_instance_setup(from_module: str | None = None) -> bool:
     if django.IS_SETUP:
         # reload logic here because module might not yet have been imported
         # upon first setup
-        if from_module is not None:
+        if from_module is not None and from_module != "lamindb":
             il.reload(il.import_module(from_module))
         return True
     silence_loggers()
@@ -75,18 +71,21 @@ def _check_instance_setup(
         return True
     isettings = _get_current_instance_settings()
     if isettings is not None:
-        if reload_module and settings.auto_connect:
-            if not django.IS_SETUP:
+        if (
+            from_module is not None
+            and settings.auto_connect
+            and not django.IS_SETUP
+            and not IS_LOADING
+        ):
+            if not from_module == "lamindb":
+                import lamindb
+
+                il.reload(il.import_module(from_module))
+            else:
                 django.setup_django(isettings)
-                if from_module is not None:
-                    # this only reloads `from_module`
-                    il.reload(il.import_module(from_module))
-                else:
-                    # this bulk reloads all schema modules
-                    reload_schema_modules(isettings)
                 logger.important(f"connected lamindb: {isettings.slug}")
         return django.IS_SETUP
     else:
-        if reload_module and settings.auto_connect:
+        if from_module is not None and settings.auto_connect:
             logger.warning(InstanceNotSetupError.default_message)
         return False

lamindb_setup/_connect_instance.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
+import importlib
 import os
-import sys
 from typing import TYPE_CHECKING
 from uuid import UUID
 
@@ -198,6 +198,7 @@ def connect(slug: str, **kwargs) -> str | tuple | None:
         "_db",
         "_write_settings",
         "_raise_not_found_error",
+        "_reload_lamindb",
         "_test",
         "_user",
     }
@@ -210,6 +211,7 @@ def connect(slug: str, **kwargs) -> str | tuple | None:
     _db: str | None = kwargs.get("_db", None)
     _write_settings: bool = kwargs.get("_write_settings", True)
     _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)
 
     access_token: str | None = None
@@ -257,6 +259,14 @@ def connect(slug: str, **kwargs) -> str | tuple | None:
         if _test:
             return None
         silence_loggers()
+        # migrate away from lnschema-core
+        no_lnschema_core_file = (
+            settings_dir / f"no_lnschema_core-{isettings.slug.replace('/', '--')}"
+        )
+        if not no_lnschema_core_file.exists():
+            migrate_lnschema_core(
+                isettings, no_lnschema_core_file, write_file=_write_settings
+            )
         check, msg = isettings._load_db()
         if not check:
             local_db = (
@@ -292,21 +302,14 @@ def connect(slug: str, **kwargs) -> str | tuple | None:
         #     except ProgrammingError:
         #         pass
         load_from_isettings(isettings, user=_user, write_settings=_write_settings)
+        if _reload_lamindb:
+            importlib.reload(importlib.import_module("lamindb"))
     except Exception as e:
         if isettings is not None:
             if _write_settings:
                 isettings._get_settings_file().unlink(missing_ok=True)  # type: ignore
             settings._instance_settings = None
         raise e
-    # rename lnschema_bionty to bionty for sql tables
-    if "bionty" in isettings.schema:
-        no_lnschema_bionty_file = (
-            settings_dir / f"no_lnschema_bionty-{isettings.slug.replace('/', '')}"
-        )
-        if not no_lnschema_bionty_file.exists():
-            migrate_lnschema_bionty(
-                isettings, no_lnschema_bionty_file, write_file=_write_settings
-            )
     return None
 
 
@@ -322,13 +325,10 @@ def load(slug: str) -> str | tuple | None:
     return result
 
 
-def migrate_lnschema_bionty(
-    isettings: InstanceSettings, no_lnschema_bionty_file: Path, write_file: bool = True
+def migrate_lnschema_core(
+    isettings: InstanceSettings, no_lnschema_core_file: Path, write_file: bool = True
 ):
-    """Migrate lnschema_bionty tables to bionty tables if bionty_source doesn't exist.
-
-    :param db_uri: str, database URI (e.g., 'sqlite:///path/to/db.sqlite' or 'postgresql://user:password@host:port/dbname')
-    """
+    """Migrate lnschema_core tables to lamindb tables."""
     from urllib.parse import urlparse
 
     parsed_uri = urlparse(isettings.db)
@@ -348,60 +348,62 @@ def migrate_lnschema_bionty(
     cur = conn.cursor()
 
     try:
-        # check if bionty_source table exists
         if db_type == "sqlite":
             cur.execute(
-                "SELECT name FROM sqlite_master WHERE type='table' AND name='bionty_source'"
+                "SELECT name FROM sqlite_master WHERE type='table' AND name='lamindb_user'"
             )
             migrated = cur.fetchone() is not None
 
             # tables that need to be renamed
             cur.execute(
-                "SELECT name FROM sqlite_master WHERE type='table' AND name LIKE 'lnschema_bionty_%'"
+                "SELECT name FROM sqlite_master WHERE type='table' AND name LIKE 'lnschema_core_%'"
             )
             tables_to_rename = [
-                row[0][len("lnschema_bionty_") :] for row in cur.fetchall()
+                row[0][len("lnschema_core_") :] for row in cur.fetchall()
             ]
         else:  # postgres
             cur.execute(
-                "SELECT EXISTS (SELECT FROM information_schema.tables WHERE table_name = 'bionty_source')"
+                "SELECT EXISTS (SELECT FROM information_schema.tables WHERE table_name = 'lamindb_user')"
             )
             migrated = cur.fetchone()[0]
 
             # tables that need to be renamed
             cur.execute(
-                "SELECT table_name FROM information_schema.tables WHERE table_name LIKE 'lnschema_bionty_%'"
+                "SELECT table_name FROM information_schema.tables WHERE table_name LIKE 'lnschema_core_%'"
             )
             tables_to_rename = [
-                row[0][len("lnschema_bionty_") :] for row in cur.fetchall()
+                row[0][len("lnschema_core_") :] for row in cur.fetchall()
             ]
 
         if migrated:
             if write_file:
-                no_lnschema_bionty_file.touch(exist_ok=True)
+                no_lnschema_core_file.touch(exist_ok=True)
         else:
             try:
-                # rename tables only if bionty_source doesn't exist and there are tables to rename
+                response = input(
+                    f"Do you want to migrate to lamindb 0.78 (integrate lnschema_core into lamindb)? (y/n) -- Will rename {tables_to_rename}"
+                )
+                if response != "y":
+                    print("Aborted.")
+                    quit()
                 for table in tables_to_rename:
                     if db_type == "sqlite":
                         cur.execute(
-                            f"ALTER TABLE lnschema_bionty_{table} RENAME TO bionty_{table}"
+                            f"ALTER TABLE lnschema_core_{table} RENAME TO lamindb_{table}"
                         )
                     else:  # postgres
                         cur.execute(
-                            f"ALTER TABLE lnschema_bionty_{table} RENAME TO bionty_{table};"
+                            f"ALTER TABLE lnschema_core_{table} RENAME TO lamindb_{table};"
                         )
 
-                # update django_migrations table
                 cur.execute(
-                    "UPDATE django_migrations SET app = 'bionty' WHERE app = 'lnschema_bionty'"
+                    "UPDATE django_migrations SET app = 'lamindb' WHERE app = 'lnschema_core'"
                 )
-
-                logger.warning(
-                    "Please uninstall lnschema-bionty via `pip uninstall lnschema-bionty`!"
+                print(
+                    "Renaming tables finished.\nNow, *please* call: lamin migrate deploy"
                 )
                 if write_file:
-                    no_lnschema_bionty_file.touch(exist_ok=True)
+                    no_lnschema_core_file.touch(exist_ok=True)
             except Exception:
                 # read-only users can't rename tables
                 pass

lamindb_setup/_delete.py

@@ -99,7 +99,7 @@ def delete(slug: str, force: bool = False, require_empty: bool = True) -> int |
             )
         require_empty = True
     # first the default storage
-    n_objects = check_storage_is_empty(
+    n_files = check_storage_is_empty(
         isettings.storage.root,
         raise_error=require_empty,
         account_for_sqlite_file=isettings.dialect == "sqlite",
@@ -132,7 +132,7 @@ def delete(slug: str, force: bool = False, require_empty: bool = True) -> int |
         delete_instance_on_hub(isettings._id, require_empty=False)
     delete_by_isettings(isettings)
     # if .lndb file was delete, then we might count -1
-    if n_objects <= 0 and isettings.storage.type == "local":
+    if n_files <= 0 and isettings.storage.type == "local":
         # dir is only empty after sqlite file was delete via delete_by_isettings
         if (isettings.storage.root / ".lamindb").exists():
             (isettings.storage.root / ".lamindb").rmdir()

lamindb_setup/_django.py

@@ -5,24 +5,24 @@ from .core.django import setup_django
 
 
 def django(command: str, package_name: str | None = None, **kwargs):
-    r"""Manage migrations.
+    r"""Call Django commands.
 
     Examples:
 
     Reset auto-incrementing primary integer ids after a database import:
 
     >>> import lamindb as ln
-    >>> ln.setup.django("sqlsequencereset", "lnschema_core")
+    >>> ln.setup.django("sqlsequencereset", "lamindb")
     BEGIN;
-    SELECT setval(pg_get_serial_sequence('"lnschema_core_user"','id'), coalesce(max("id"), 1), max("id") IS NOT null) FROM "lnschema_core_user";  # noqa
-    SELECT setval(pg_get_serial_sequence('"lnschema_core_storage"','id'), coalesce(max("id"), 1), max("id") IS NOT null) FROM "lnschema_core_storage";  # noqa
+    SELECT setval(pg_get_serial_sequence('"lamindb_user"','id'), coalesce(max("id"), 1), max("id") IS NOT null) FROM "lamindb_user";  # noqa
+    SELECT setval(pg_get_serial_sequence('"lamindb_storage"','id'), coalesce(max("id"), 1), max("id") IS NOT null) FROM "lamindb_storage";  # noqa
     COMMIT;
 
     You can then run the SQL output that you'll see like so:
 
     >>> sql = \"\"\"BEGIN;
-        SELECT setval(pg_get_serial_sequence('"lnschema_core_user"','id'), coalesce(max("id"), 1), max("id") IS NOT null) FROM "lnschema_core_user";  # noqa
-        SELECT setval(pg_get_serial_sequence('"lnschema_core_storage"','id'), coalesce(max("id"), 1), max("id") IS NOT null) FROM "lnschema_core_storage";  # noqa
+        SELECT setval(pg_get_serial_sequence('"lamindb_user"','id'), coalesce(max("id"), 1), max("id") IS NOT null) FROM "lamindb_user";  # noqa
+        SELECT setval(pg_get_serial_sequence('"lamindb_storage"','id'), coalesce(max("id"), 1), max("id") IS NOT null) FROM "lamindb_storage";  # noqa
         COMMIT;\"\"\"
     >>> from django.db import connection
     >>> with connection.cursor() as cursor:

lamindb_setup/_exportdb.py

@@ -4,7 +4,7 @@ from importlib import import_module
 from pathlib import Path
 
 MODELS = {
-    "core": {
+    "lamindb": {
         "Collection": False,
         "Artifact": False,
         "Transform": False,

lamindb_setup/_init_instance.py

@@ -2,7 +2,6 @@ from __future__ import annotations
 
 import importlib
 import os
-import sys
 import uuid
 from typing import TYPE_CHECKING, Literal
 from uuid import UUID
@@ -29,6 +28,8 @@ if TYPE_CHECKING:
 def get_schema_module_name(schema_name, raise_import_error: bool = True) -> str | None:
     import importlib.util
 
+    if schema_name == "core":
+        return "lamindb"
     name_attempts = [f"lnschema_{schema_name.replace('-', '_')}", schema_name]
     for name in name_attempts:
         module_spec = importlib.util.find_spec(name)
@@ -42,8 +43,8 @@ def get_schema_module_name(schema_name, raise_import_error: bool = True) -> str
 
 
 def register_storage_in_instance(ssettings: StorageSettings):
-    from lnschema_core.models import Storage
-    from lnschema_core.users import current_user_id
+    from lamindb.base.users import current_user_id
+    from lamindb.models import Storage
 
     from .core.hashing import hash_and_encode_as_b62
 
@@ -71,7 +72,7 @@ def register_storage_in_instance(ssettings: StorageSettings):
 
 
 def register_user(usettings):
-    from lnschema_core.models import User
+    from lamindb.models import User
 
     try:
         # need to have try except because of integer primary key migration
@@ -99,35 +100,6 @@ def register_user_and_storage_in_instance(isettings: InstanceSettings, usettings
         logger.warning(f"instance seems not set up ({error})")
 
 
-def reload_schema_modules(isettings: InstanceSettings, include_core: bool = True):
-    schema_names = ["core"] if include_core else []
-    # schema_names += list(isettings.schema)
-    schema_module_names = [get_schema_module_name(n) for n in schema_names]
-
-    for schema_module_name in schema_module_names:
-        if schema_module_name in sys.modules:
-            schema_module = importlib.import_module(schema_module_name)
-            importlib.reload(schema_module)
-
-
-def reload_lamindb_itself(isettings) -> bool:
-    reloaded = False
-    if "lamindb" in sys.modules:
-        import lamindb
-
-        importlib.reload(lamindb)
-        reloaded = True
-    return reloaded
-
-
-def reload_lamindb(isettings: InstanceSettings):
-    log_message = settings.auto_connect
-    if not reload_lamindb_itself(isettings):
-        log_message = True
-    if log_message:
-        logger.important(f"connected lamindb: {isettings.slug}")
-
-
 ERROR_SQLITE_CACHE = """
 Your cached local SQLite file exists, while your cloud SQLite file ({}) doesn't.
 Either delete your cache ({}) or add it back to the cloud (if delete was accidental).
@@ -329,6 +301,8 @@ def init(
             update_schema_in_hub(access_token=access_token)
         if _write_settings:
             settings.auto_connect = True
+        importlib.reload(importlib.import_module("lamindb"))
+        logger.important(f"initialized lamindb: {isettings.slug}")
     except Exception as e:
         from ._delete import delete_by_isettings
         from .core._hub_core import delete_instance_record, delete_storage_record
@@ -338,16 +312,17 @@ def init(
                 delete_by_isettings(isettings)
             else:
                 settings._instance_settings = None
-            if (
-                user_handle != "anonymous" or access_token is not None
-            ) and isettings.is_on_hub:
-                delete_instance_record(isettings._id, access_token=access_token)
         if (
             ssettings is not None
             and (user_handle != "anonymous" or access_token is not None)
             and ssettings.is_on_hub
         ):
             delete_storage_record(ssettings._uuid, access_token=access_token)  # type: ignore
+        if isettings is not None:
+            if (
+                user_handle != "anonymous" or access_token is not None
+            ) and isettings.is_on_hub:
+                delete_instance_record(isettings._id, access_token=access_token)
         raise e
     return None
 
@@ -378,7 +353,6 @@ def load_from_isettings(
         if not isettings._get_settings_file().exists():
             register_user(user)
     isettings._persist(write_to_disk=write_settings)
-    reload_lamindb(isettings)
 
 
 def validate_sqlite_state(isettings: InstanceSettings) -> None:
@@ -414,7 +388,7 @@ def infer_instance_name(
         return str(db).split("/")[-1]
     if storage == "create-s3":
         raise ValueError("pass name to init if storage = 'create-s3'")
-    storage_path = UPath(storage)
+    storage_path = UPath(storage).resolve()
     # not sure if name is ever ""
     if storage_path.name != "":
         name = storage_path.name

lamindb_setup/_migrate.py

@@ -5,7 +5,7 @@ from django.db.migrations.loader import MigrationLoader
 from lamin_utils import logger
 from packaging import version
 
-from ._check_setup import _check_instance_setup
+from . import _check_setup
 from .core._settings import settings
 from .core.django import setup_django
 
@@ -64,16 +64,18 @@ class migrate:
     @classmethod
     def create(cls) -> None:
         """Create a migration."""
-        if _check_instance_setup():
+        if _check_setup._check_instance_setup():
             raise RuntimeError("Restart Python session to create migration or use CLI!")
+        _check_setup.IS_LOADING = True
         setup_django(settings.instance, create_migrations=True)
+        _check_setup.IS_LOADING = False
 
     @classmethod
     def deploy(cls) -> None:
         """Deploy a migration."""
         from ._schema_metadata import update_schema_in_hub
 
-        if _check_instance_setup():
+        if _check_setup._check_instance_setup():
             raise RuntimeError("Restart Python session to migrate or use CLI!")
         from lamindb_setup.core._hub_client import call_with_fallback_auth
         from lamindb_setup.core._hub_crud import (

lamindb_setup/_schema_metadata.py

@@ -232,7 +232,7 @@ class _ModelHandler:
         return related_fields
 
     def _get_field_metadata(self, model, field: Field):
-        from lnschema_core.models import LinkORM
+        from lamindb.models import LinkORM
 
         internal_type = field.get_internal_type()
         model_name = field.model._meta.model_name
@@ -273,14 +273,16 @@ class _ModelHandler:
             through = self._get_through(field)
 
         return FieldMetadata(
-            schema_name=schema_name,
+            schema_name=schema_name if schema_name != "lamindb" else "core",
             model_name=model_name,
             field_name=field_name,
             type=internal_type,
             is_link_table=issubclass(field.model, LinkORM),
             column_name=column,
             relation_type=relation_type,
-            related_schema_name=related_schema_name,
+            related_schema_name=related_schema_name
+            if related_schema_name != "lamindb"
+            else "core",
             related_model_name=related_model_name,
             related_field_name=related_field_name,
             through=through,
@@ -288,7 +290,7 @@ class _ModelHandler:
 
     @staticmethod
     def _get_through_many_to_many(field_or_rel: ManyToManyField | ManyToManyRel):
-        from lnschema_core.models import Registry
+        from lamindb.models import Registry
 
         if isinstance(field_or_rel, ManyToManyField):
             if field_or_rel.model != Registry:
@@ -365,7 +367,7 @@ class _SchemaHandler:
 
     def to_dict(self, include_django_objects: bool = True):
         return {
-            module_name: {
+            module_name if module_name != "lamindb" else "core": {
                 model_name: model.to_dict(include_django_objects)
                 for model_name, model in module.items()
             }
@@ -376,7 +378,7 @@ class _SchemaHandler:
         return self.to_dict(include_django_objects=False)
 
     def _get_modules_metadata(self):
-        from lnschema_core.models import Record, Registry
+        from lamindb.models import Record, Registry
 
         all_models = {
             module_name: {
@@ -401,6 +403,8 @@ class _SchemaHandler:
         module_set_info = []
         for module_name in self.included_modules:
             module = self._get_schema_module(module_name)
+            if module_name == "lamindb":
+                module_name = "core"
             module_set_info.append(
                 {"id": 0, "name": module_name, "version": module.__version__}
             )

lamindb_setup/core/_aws_credentials.py

@@ -3,6 +3,7 @@ from __future__ import annotations
 import os
 import time
 
+from lamin_utils import logger
 from upath.implementations.cloud import S3Path
 
 HOSTED_REGIONS = [
@@ -40,8 +41,15 @@ class AWSCredentialsManager:
 
         # this is cached so will be resued with the connection initialized
         fs = S3FileSystem(cache_regions=True)
-        fs.connect()
-        self.anon: bool = fs.session._credentials is None
+        try:
+            fs.connect()
+            self.anon: bool = fs.session._credentials is None
+        except Exception as e:
+            logger.warning(
+                f"There is a problem with your default AWS Credentials: {e}\n"
+                "`anon` mode will be used for all non-managed buckets."
+            )
+            self.anon = True
         self.anon_public: bool | None = None
         if not self.anon:
             try:

lamindb_setup/core/_hub_core.py

@@ -233,11 +233,11 @@ def _delete_instance(
     )
     if require_empty:
         for storage_record in storage_records:
+            root_string: str = storage_record["root"]  # type: ignore
             account_for_sqlite_file = (
                 instance_with_storage["db_scheme"] is None
-                and instance_with_storage["storage"]["root"] == storage_record["root"]
+                and instance_with_storage["storage"]["root"] == root_string
             )
-            root_string = storage_record["root"]
             # gate storage and instance deletion on empty storage location for
             # normally auth.get_session() doesn't have access_token
             # so this block is useless i think (Sergei)

lamindb_setup/core/_hub_crud.py

@@ -144,17 +144,14 @@ def select_collaborator(
 def select_default_storage_by_instance_id(
     instance_id: str, client: Client
 ) -> dict | None:
-    try:
-        data = (
-            client.table("storage")
-            .select("*")
-            .eq("instance_id", instance_id)
-            .eq("is_default", True)
-            .execute()
-            .data
-        )
-    except Exception:
-        return None
+    data = (
+        client.table("storage")
+        .select("*")
+        .eq("instance_id", instance_id)
+        .eq("is_default", True)
+        .execute()
+        .data
+    )
     if len(data) == 0:
         return None
     return data[0]

lamindb_setup/core/_settings.py

@@ -164,7 +164,7 @@ class SetupSettings:
 
     @property
     def paths(self) -> type[SetupPaths]:
-        """Convert cloud paths to lamidb local paths.
+        """Convert cloud paths to lamindb local paths.
 
         Use `settings.paths.cloud_to_local_no_update`
         or `settings.paths.cloud_to_local`.
@@ -179,7 +179,7 @@ class SetupSettings:
         repr = self.user.__repr__()
         repr += f"\nAuto-connect in Python: {self.auto_connect}\n"
         repr += f"Private Django API: {self.private_django_api}\n"
-        repr += f"Cache directory: {self.cache_dir}\n"
+        repr += f"Cache directory: {self.cache_dir.as_posix()}\n"
         if self._instance_exists:
             repr += self.instance.__repr__()
         else:

lamindb_setup/core/_settings_instance.py

@@ -121,7 +121,7 @@ class InstanceSettings:
     def _search_local_root(
         self, local_root: str | None = None, mute_warning: bool = False
     ) -> StorageSettings | None:
-        from lnschema_core.models import Storage
+        from lamindb.models import Storage
 
         if local_root is not None:
             local_records = Storage.objects.filter(root=local_root)
@@ -358,7 +358,7 @@ class InstanceSettings:
             sqlite_filepath = self.storage.cloud_to_local(
                 self._sqlite_file, error_no_origin=False
             )
-            return f"sqlite:///{sqlite_filepath}"
+            return f"sqlite:///{sqlite_filepath.as_posix()}"
         else:
             return self._db
 
@@ -457,11 +457,24 @@ class InstanceSettings:
         settings._instance_settings = self
 
     def _init_db(self):
+        from lamindb_setup import _check_setup
+
         from .django import setup_django
 
+        _check_setup.IS_LOADING = True
         setup_django(self, init=True)
+        _check_setup.IS_LOADING = False
+
+        from lamindb.models import Space
+
+        Space.objects.get_or_create(
+            name="All",
+            description="Every team & user with access to the instance has access.",
+        )
 
     def _load_db(self) -> tuple[bool, str]:
+        from lamindb_setup import _check_setup
+
         # Is the database available and initialized as LaminDB?
         # returns a tuple of status code and message
         if self.dialect == "sqlite" and not self._sqlite_file.exists():
@@ -472,7 +485,6 @@ class InstanceSettings:
                     f" {legacy_file} to {self._sqlite_file}"
                 )
             return False, f"SQLite file {self._sqlite_file} does not exist"
-        from lamindb_setup import settings  # to check user
 
         from .django import setup_django
 
@@ -481,5 +493,7 @@ class InstanceSettings:
         # setting up django also performs a check for migrations & prints them
         # as warnings
         # this should fail, e.g., if the db is not reachable
+        _check_setup.IS_LOADING = True
         setup_django(self)
+        _check_setup.IS_LOADING = False
         return True, ""

lamindb_setup/core/_settings_storage.py

@@ -230,7 +230,7 @@ class StorageSettings:
         """Storage record in the current instance."""
         if self._record is None:
             # dynamic import because of import order
-            from lnschema_core.models import Storage
+            from lamindb.models import Storage
 
             from ._settings import settings
 

lamindb_setup/core/_settings_user.py

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

lamindb_setup/core/django.py

@@ -5,10 +5,8 @@ import builtins
 import os
 from pathlib import Path
 import time
-from lamin_utils import logger
-from ._settings_store import current_instance_settings_file
 from ._settings_instance import InstanceSettings
-import sys
+
 
 IS_RUN_FROM_IPYTHON = getattr(builtins, "__IPYTHON__", False)
 IS_SETUP = False

lamindb_setup/core/hashing.py

@@ -12,6 +12,7 @@ from __future__ import annotations
 
 import base64
 import hashlib
+import json
 from concurrent.futures import ThreadPoolExecutor
 from typing import TYPE_CHECKING
 
@@ -40,11 +41,21 @@ def b16_to_b64(s: str):
     return to_b64_str(base64.b16decode(s.strip('"'), casefold=True))
 
 
+def hash_string(string: str) -> str:
+    # as we're truncating (not here) at 22 b64, we choose md5 over sha512
+    return to_b64_str(hashlib.md5(string.encode("utf-8")).digest())
+
+
 # a lot to read about this: lamin-notes/2022/hashing
 def hash_set(s: set[str]) -> str:
-    bstr = ":".join(sorted(s)).encode("utf-8")
-    # as we're truncating at 22 b64, we choose md5 over sha512
-    return to_b64_str(hashlib.md5(bstr).digest())[:HASH_LENGTH]
+    join_s = ":".join(sorted(s))
+    return hash_string(join_s)[:HASH_LENGTH]
+
+
+def hash_dict(d: dict) -> str:
+    return to_b64_str(hashlib.md5(json.dumps(d, sort_keys=True).encode()).digest())[
+        :HASH_LENGTH
+    ]
 
 
 def hash_from_hashes_list(hashes: Iterable[str]) -> str:
@@ -111,6 +122,6 @@ def hash_dir(path: Path):
     hashes, sizes = zip(*hashes_sizes)
 
     hash, hash_type = hash_from_hashes_list(hashes), "md5-d"
-    n_objects = len(hashes)
+    n_files = len(hashes)
     size = sum(sizes)
-    return size, hash, hash_type, n_objects
+    return size, hash, hash_type, n_files

lamindb_setup/core/upath.py

@@ -12,14 +12,15 @@ from itertools import islice
 from pathlib import Path, PosixPath, PurePosixPath, WindowsPath
 from typing import TYPE_CHECKING, Any, Literal
 
+import click
 import fsspec
 from lamin_utils import logger
 from upath import UPath
-from upath.implementations.cloud import CloudPath, S3Path  # keep CloudPath!
+from upath.implementations.cloud import CloudPath  # keep CloudPath!
 from upath.implementations.local import LocalPath
 
 from ._aws_credentials import HOSTED_BUCKETS, get_aws_credentials_manager
-from .hashing import HASH_LENGTH, b16_to_b64, hash_from_hashes_list
+from .hashing import HASH_LENGTH, b16_to_b64, hash_from_hashes_list, hash_string
 
 if TYPE_CHECKING:
     from .types import UPathStr
@@ -192,12 +193,15 @@ class ProgressCallback(fsspec.callbacks.Callback):
     def update_relative_value(self, inc=1):
         if inc != 0:
             self.value += inc
-        # this is specific to http filesystem
-        # for some reason the last update is 0 always
-        # here 100% is forced manually in this case
-        elif self.value >= 0.999:
-            self.value = self.size
-        self.call()
+            self.call()
+        else:
+            # this is specific to http filesystem
+            # for some reason the last update is 0 always
+            # sometimes the reported result is less that 100%
+            # here 100% is forced manually in this case
+            if self.value < 1.0 and self.value >= 0.999:
+                self.value = self.size
+                self.call()
 
     def branch(self, path_1, path_2, kwargs):
         if self.adjust_size:
@@ -264,7 +268,17 @@ def download_to(self, local_path: UPathStr, print_progress: bool = True, **kwarg
         )
         kwargs["callback"] = callback
 
-    self.fs.download(str(self), str(local_path), **kwargs)
+    cloud_path_str = str(self)
+    local_path_str = str(local_path)
+    # needed due to https://github.com/fsspec/filesystem_spec/issues/1766
+    # otherwise fsspec calls fs._ls_real where it reads the body and parses links
+    # so the file is downloaded 2 times
+    # upath doesn't call fs.ls to infer type, so it is safe to call
+    if self.protocol in {"http", "https"} and self.stat().as_info()["type"] == "file":
+        self.fs.use_listings_cache = True
+        self.fs.dircache[cloud_path_str] = []
+
+    self.fs.download(cloud_path_str, local_path_str, **kwargs)
 
 
 def upload_from(
@@ -312,8 +326,7 @@ def upload_from(
         destination = self.as_posix()
 
     # the below lines are to avoid s3fs triggering create_bucket in upload if
-    # dirs are present it allows to avoid permission error
-    # would be easier to just
+    # dirs are present, it allows to avoid the permission error
     if self.protocol == "s3" and local_path_is_dir and create_folder:
         bucket = self.drive
         if bucket not in self.fs.dircache:
@@ -505,7 +518,7 @@ def compute_file_tree(
         skip_suffixes_tuple = ()
     else:
         skip_suffixes_tuple = tuple(skip_suffixes)  # type: ignore
-    n_objects = 0
+    n_files = 0
     n_directories = 0
 
     # by default only including registered files
@@ -518,7 +531,7 @@ def compute_file_tree(
         include_paths = set()
 
     def inner(dir_path: Path, prefix: str = "", level: int = -1):
-        nonlocal n_objects, n_directories, suffixes
+        nonlocal n_files, n_directories, suffixes
         if level == 0:
             return
         stripped_dir_path = dir_path.as_posix().rstrip("/")
@@ -551,7 +564,7 @@ def compute_file_tree(
                 suffix = extract_suffix_from_path(child_path)
                 suffixes.add(suffix)
                 n_files_per_dir_and_type[suffix] += 1
-                n_objects += 1
+                n_files += 1
                 if n_files_per_dir_and_type[suffix] == n_max_files_per_dir_and_type:
                     yield prefix + "..."
                 elif n_files_per_dir_and_type[suffix] > n_max_files_per_dir_and_type:
@@ -564,15 +577,15 @@ def compute_file_tree(
     for line in islice(iterator, n_max_files):
         folder_tree += f"\n{line}"
     if next(iterator, None):
-        folder_tree += f"\n... only showing {n_max_files} out of {n_objects} files"
+        folder_tree += f"\n... only showing {n_max_files} out of {n_files} files"
     directory_info = "directory" if n_directories == 1 else "directories"
     display_suffixes = ", ".join([f"{suffix!r}" for suffix in suffixes])
-    suffix_message = f" with suffixes {display_suffixes}" if n_objects > 0 else ""
+    suffix_message = f" with suffixes {display_suffixes}" if n_files > 0 else ""
     message = (
         f"{n_directories} sub-{directory_info} &"
-        f" {n_objects} files{suffix_message}\n{path.resolve()}{folder_tree}"
+        f" {n_files} files{suffix_message}\n{path.resolve()}{folder_tree}"
     )
-    return message, n_objects
+    return message, n_files
 
 
 # adapted from: https://stackoverflow.com/questions/9727673
@@ -726,12 +739,26 @@ warnings.filterwarnings(
 )
 
 
-def create_path(path: UPath, access_token: str | None = None) -> UPath:
-    path = UPath(path)
-    # test whether we have an AWS S3 path
-    if not isinstance(path, S3Path):
-        return path
-    return get_aws_credentials_manager().enrich_path(path, access_token)
+def create_path(path: UPathStr, access_token: str | None = None) -> UPath:
+    upath = UPath(path)
+
+    if upath.protocol == "s3":
+        # add managed credentials and other options for AWS s3 paths
+        return get_aws_credentials_manager().enrich_path(upath, access_token)
+
+    if upath.protocol in {"http", "https"}:
+        # this is needed because by default aiohttp drops a connection after 5 min
+        # so it is impossible to download large files
+        client_kwargs = upath.storage_options.get("client_kwargs", {})
+        if "timeout" not in client_kwargs:
+            from aiohttp import ClientTimeout
+
+            client_kwargs = {
+                **client_kwargs,
+                "timeout": ClientTimeout(sock_connect=30, sock_read=30),
+            }
+            return UPath(upath, client_kwargs=client_kwargs)
+    return upath
 
 
 def get_stat_file_cloud(stat: dict) -> tuple[int, str | None, str | None]:
@@ -749,20 +776,26 @@ def get_stat_file_cloud(stat: dict) -> tuple[int, str | None, str | None]:
     # s3
     # StorageClass is checked to be sure that it is indeed s3
     # because http also has ETag
-    elif "ETag" in stat and "StorageClass" in stat:
+    elif "ETag" in stat:
         etag = stat["ETag"]
-        # small files
-        if "-" not in etag:
-            # only store hash for non-multipart uploads
-            # we can't rapidly validate multi-part uploaded files client-side
-            # we can add more logic later down-the-road
-            hash = b16_to_b64(etag)
-            hash_type = "md5"
+        if "mimetype" in stat:
+            # http
+            hash = hash_string(etag.strip('"'))
+            hash_type = "md5-etag"
         else:
-            stripped_etag, suffix = etag.split("-")
-            suffix = suffix.strip('"')
-            hash = b16_to_b64(stripped_etag)
-            hash_type = f"md5-{suffix}"  # this is the S3 chunk-hashing strategy
+            # s3
+            # small files
+            if "-" not in etag:
+                # only store hash for non-multipart uploads
+                # we can't rapidly validate multi-part uploaded files client-side
+                # we can add more logic later down-the-road
+                hash = b16_to_b64(etag)
+                hash_type = "md5"
+            else:
+                stripped_etag, suffix = etag.split("-")
+                suffix = suffix.strip('"')
+                hash = b16_to_b64(stripped_etag)
+                hash_type = f"md5-{suffix}"  # this is the S3 chunk-hashing strategy
     if hash is not None:
         hash = hash[:HASH_LENGTH]
     return size, hash, hash_type
@@ -787,17 +820,18 @@ def get_stat_dir_cloud(path: UPath) -> tuple[int, str | None, str | None, int]:
         if compute_list_hash:
             hashes.append(object[accessor].strip('"='))
     size = sum(sizes)
-    n_objects = len(sizes)
+    n_files = len(sizes)
     if compute_list_hash:
         hash, hash_type = hash_from_hashes_list(hashes), "md5-d"
-    return size, hash, hash_type, n_objects
+    return size, hash, hash_type, n_files
 
 
-class InstanceNotEmpty(Exception):
-    pass
+class InstanceNotEmpty(click.ClickException):
+    def show(self, file=None):
+        pass
 
 
-# is as fast as boto3: https://lamin.ai/laminlabs/lamindata/transform/krGp3hT1f78N5zKv
+# is as fast as boto3: https://lamin.ai/laminlabs/lamin-site-assets/transform/krGp3hT1f78N5zKv
 def check_storage_is_empty(
     root: UPathStr, *, raise_error: bool = True, account_for_sqlite_file: bool = False
 ) -> int:
@@ -820,20 +854,20 @@ def check_storage_is_empty(
             root_string += "/"
         directory_string = root_string + ".lamindb"
     objects = root_upath.fs.find(directory_string)
-    n_objects = len(objects)
-    n_diff = n_objects - n_offset_objects
+    n_files = len(objects)
+    n_diff = n_files - n_offset_objects
     ask_for_deletion = (
         "delete them prior to deleting the instance"
         if raise_error
         else "consider deleting them"
     )
     message = (
-        f"Storage '{directory_string}' contains {n_objects - n_offset_objects} objects"
+        f"Storage '{directory_string}' contains {n_files - n_offset_objects} objects"
         f" - {ask_for_deletion}"
     )
     if n_diff > 0:
         if raise_error:
-            raise InstanceNotEmpty(message)
+            raise InstanceNotEmpty(message) from None
         else:
             logger.warning(message)
     return n_diff

{lamindb_setup-0.81.4.dist-info → lamindb_setup-1.0a1.dist-info}/METADATA

@@ -1,20 +1,19 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.3
 Name: lamindb_setup
-Version: 0.81.4
+Version: 1.0a1
 Summary: Setup & configure LaminDB.
 Author-email: Lamin Labs <open-source@lamin.ai>
 Requires-Python: >=3.9
 Description-Content-Type: text/markdown
-Requires-Dist: lnschema_core>=0.51.0
 Requires-Dist: lamin_utils>=0.3.3
-Requires-Dist: django>4.2,<5.3.0
+Requires-Dist: django>=5,<5.2
 Requires-Dist: dj_database_url>=1.3.0,<3.0.0
 Requires-Dist: pydantic-settings
 Requires-Dist: appdirs<2.0.0
 Requires-Dist: requests
 Requires-Dist: universal_pathlib==0.2.5
 Requires-Dist: botocore<2.0.0
-Requires-Dist: supabase>=2.8.1,<=2.10.0
+Requires-Dist: supabase>=2.8.1,<=2.11.0
 Requires-Dist: psutil
 Requires-Dist: urllib3<2 ; extra == "aws"
 Requires-Dist: aiobotocore[boto3]>=2.5.4,<3.0.0 ; extra == "aws"

{lamindb_setup-0.81.4.dist-info → lamindb_setup-1.0a1.dist-info}/RECORD

@@ -1,47 +1,47 @@
-lamindb_setup/__init__.py,sha256=41Rm-lDXIF3ir0Xsj-vpB0EZO5SmkipsRc5pmUzBEvk,1714
+lamindb_setup/__init__.py,sha256=k7P3AZb2980R0v07EyB8b-cVODo3vHm5kzBOn5fYj_4,2646
 lamindb_setup/_cache.py,sha256=1XnM-V_KprbjpgPY7Bg3FYn53Iz_2_fEgcMOaSdKKbg,1332
 lamindb_setup/_check.py,sha256=28PcG8Kp6OpjSLSi1r2boL2Ryeh6xkaCL87HFbjs6GA,129
-lamindb_setup/_check_setup.py,sha256=6cSfpmVOSgU7YiVHfJpBTGTQ7rrnwunt1pJT_jkgNM8,3196
+lamindb_setup/_check_setup.py,sha256=FQA-wrLJgsBMmK5zJv3-2528CWhS-kwe4vOOXJ06yCM,3023
 lamindb_setup/_close.py,sha256=cXNwK7QTTyNFt2XTpLnO3KHljJ7ShOcISk95np_dltE,1239
-lamindb_setup/_connect_instance.py,sha256=ClSM1zQAqVmNBapmB7H3dzmnWdn1dkpr_y5HAsF74XU,16070
-lamindb_setup/_delete.py,sha256=yjLIegM2Lh6sWRSTTybI17wK_kA4_pF_k3iVUkkgEAE,5681
-lamindb_setup/_django.py,sha256=DWUTjjVhEViX0S-zIkeqQgKovWqVgWMl4Y0ANwlA3Pw,1505
+lamindb_setup/_connect_instance.py,sha256=YU54loNCweRy-lqfqd2i2Us6xxwftkUPlmCjiGWJ_wI,16109
+lamindb_setup/_delete.py,sha256=Mip5M9tCxyfsjzdcPCl6x9CQ0TkYTqKNNWDIcJ-KVMo,5677
+lamindb_setup/_django.py,sha256=uIQflpkp8l3axyPaKURlk3kacgpElVP5KOKmFxYSMGk,1454
 lamindb_setup/_entry_points.py,sha256=Hs2oJQOCTaGUdWn-1mufM6qUZr9W_EJ_Oc3f0_Vc0Yw,616
-lamindb_setup/_exportdb.py,sha256=43g77-tH-vAlTn8ig1mMD9-KXLKvxUeDLaq0gVu3l-c,2114
+lamindb_setup/_exportdb.py,sha256=VjaeTsYgnhicbQUN05Ae0Au8lFKPAIeii7flOBcaMk4,2117
 lamindb_setup/_importdb.py,sha256=yYYShzUajTsR-cTW4CZ-UNDWZY2uE5PAgNbp-wn8Ogc,1874
-lamindb_setup/_init_instance.py,sha256=zJbkP22h4Yif_VNooL06FFoHqH1EU45CqiLwF8FUaKs,14368
-lamindb_setup/_migrate.py,sha256=x_b4k4XRfLSD-EEFMc324yK6DIK7goW33wUytbIWlNs,8917
+lamindb_setup/_init_instance.py,sha256=OFoaF_wadtxD_ICLq9uPLHP-IWTqGeu8Ea57F-CqgJ4,13617
+lamindb_setup/_migrate.py,sha256=bIW6TkgU93rTdnNAKWcyMgjTF0ypc_dzqsJG2lo_4Iw,9001
 lamindb_setup/_register_instance.py,sha256=alQuYp2f8Ct8xvRC1gt8p_HZ0tqCd3gZD3kiPBLPpsI,1269
 lamindb_setup/_schema.py,sha256=b3uzhhWpV5mQtDwhMINc2MabGCnGLESy51ito3yl6Wc,679
-lamindb_setup/_schema_metadata.py,sha256=49wDLbhRhatDeADjHOPfQURt65lf_OZ7lob1ZiAT_ac,13773
+lamindb_setup/_schema_metadata.py,sha256=2uO6uwWScjwggK44z_UgYAuxL66BdKfy-ad8V4ebwxI,13985
 lamindb_setup/_set_managed_storage.py,sha256=4tDxXQMt8Gw028uY3vIQxZQ7qBNXhQMc8saarNK_Z-s,2043
 lamindb_setup/_setup_user.py,sha256=-g7Xj6510BDyM8kuqAsVBZFwehlhBa_uWBSV1rPeuM8,4586
 lamindb_setup/_silence_loggers.py,sha256=AKF_YcHvX32eGXdsYK8MJlxEaZ-Uo2f6QDRzjKFCtws,1568
 lamindb_setup/core/__init__.py,sha256=BxIVMX5HQq8oZ1OuY_saUEJz5Tdd7gaCPngxVu5iou4,417
-lamindb_setup/core/_aws_credentials.py,sha256=E8yanKOq-idaIz5y9D9SazHaYJKX69VLK3pn7jl82do,5815
+lamindb_setup/core/_aws_credentials.py,sha256=_wBWC10MGx3PW9UXGhsVNlq7YvCER3RhfRgAdlxEjNM,6120
 lamindb_setup/core/_aws_storage.py,sha256=nEjeUv4xUVpoV0Lx-zjjmyb9w804bDyaeiM-OqbfwM0,1799
 lamindb_setup/core/_deprecated.py,sha256=3qxUI1dnDlSeR0BYrv7ucjqRBEojbqotPgpShXs4KF8,2520
 lamindb_setup/core/_docs.py,sha256=3k-YY-oVaJd_9UIY-LfBg_u8raKOCNfkZQPA73KsUhs,276
 lamindb_setup/core/_hub_client.py,sha256=cN19XbZmvLCxL_GKdOcKbedNRL7kR47vmLmA--NMv-U,6306
-lamindb_setup/core/_hub_core.py,sha256=cZfEDFq2z0cHjyPqwg7K5K3vw9C2nDHnbIHmmAjVbeM,19997
-lamindb_setup/core/_hub_crud.py,sha256=ro4dvZ0EaHs7_QwJH6BoKl69Wc9HEPDkIc9BFyO_DMg,5460
+lamindb_setup/core/_hub_core.py,sha256=qVGGsWVfP6GK9UzmEz1kuR_B8wFkgTstMJJoMHeUF0c,20007
+lamindb_setup/core/_hub_crud.py,sha256=IAuPZes1am8OFwtcf5jSRQPGG1eKwVTEsp9Li-uq0cQ,5377
 lamindb_setup/core/_hub_utils.py,sha256=08NwQsb53-tXa_pr-f0tPTN0FeeVf_i1p3dEbEWD0F4,3016
 lamindb_setup/core/_private_django_api.py,sha256=KIn43HOhiRjkbTbddyJqv-WNTTa1bAizbM1tWXoXPBg,2869
-lamindb_setup/core/_settings.py,sha256=NYrSGtAw68mlQJgzBnV-DECi-RUBn32eeosyYCBtW3I,8232
-lamindb_setup/core/_settings_instance.py,sha256=ajcq9zRNE598tTqyMkMqaEOubVfFeE998DPtbgyzK3A,18801
+lamindb_setup/core/_settings.py,sha256=eslFO84vb5uRRfJ3r_uu4O8677l8lU5BbpZJMSAYw6A,8244
+lamindb_setup/core/_settings_instance.py,sha256=gUbffwhsp_SygjU0P1bohXnRejAQ2sDTjctSg4-O94A,19199
 lamindb_setup/core/_settings_load.py,sha256=5OpghcbkrK9KBM_0Iu-61FTI76UbOpPkkJpUittXS-w,4098
 lamindb_setup/core/_settings_save.py,sha256=rxGxgaK5i9exKqSJERQQyY1WZio20meoQJoYXlVW-1w,3138
-lamindb_setup/core/_settings_storage.py,sha256=FOTyi89BZ48a8elCQ91C4B6oMO4tBnva4J6Tk40N9Ww,12249
+lamindb_setup/core/_settings_storage.py,sha256=dPIvbA6PkdjM8gsX6zxtH7VNMc4vhkuEO4luVMZY7RQ,12243
 lamindb_setup/core/_settings_store.py,sha256=WcsgOmgnu9gztcrhp-N4OONNZyxICHV8M0HdJllTaEo,2219
-lamindb_setup/core/_settings_user.py,sha256=iz0MqFLKXqm8LYx_CHmr02_oNvYWFLIxKkJLdpS5W08,1476
+lamindb_setup/core/_settings_user.py,sha256=lWqV3HmZCsEq2UsU_iVNW0p9ddsNg7-B6xOaMNH1aw0,1475
 lamindb_setup/core/_setup_bionty_sources.py,sha256=jZOPXpipW_5IjMO-bLMk-_wVwk7-5MLd72K2rnqqy7U,4001
 lamindb_setup/core/cloud_sqlite_locker.py,sha256=i6TrT7HG0lqliPvZTlsZ_uplPaqhPBbabyfeR32SkA8,7107
-lamindb_setup/core/django.py,sha256=E4U9nUlV2kHd-G5v6iSdFGAAWixlQDxOFwMwOMG9xfw,3864
+lamindb_setup/core/django.py,sha256=bJme5D9KHmo98S9dLzFktdS2rZ0Aoj4EdkirniirB1I,3763
 lamindb_setup/core/exceptions.py,sha256=4NpLUNUIfXYVTFX2FvLZF8RW34exk2Vn2X3G4YhnTRg,276
-lamindb_setup/core/hashing.py,sha256=26dtak7XgmrWa_D1zuDyxObRQcriMtnc1yEigkKASmM,3142
+lamindb_setup/core/hashing.py,sha256=2kZy_7NQB1WoUK8SBrhFX90lBpTkBr1V9tf7FS9Fe2Q,3380
 lamindb_setup/core/types.py,sha256=zJii2le38BJUmsNVvzDrbzGYr0yaeb-9Rw9IKmsBr3k,523
-lamindb_setup/core/upath.py,sha256=X5Jjm50-br1Qq3eRlO6U4ykidptc2QzoQtq-ilaPt4Q,29602
-lamindb_setup-0.81.4.dist-info/LICENSE,sha256=UOZ1F5fFDe3XXvG4oNnkL1-Ecun7zpHzRxjp-XsMeAo,11324
-lamindb_setup-0.81.4.dist-info/WHEEL,sha256=EZbGkh7Ie4PoZfRQ8I0ZuP9VklN_TvcZ6DSE5Uar4z4,81
-lamindb_setup-0.81.4.dist-info/METADATA,sha256=xstSHpwOECuKUylOziRLHFHtafUtglGT1CQA0lUGscs,1730
-lamindb_setup-0.81.4.dist-info/RECORD,,
+lamindb_setup/core/upath.py,sha256=UqfZcSIEflje2393osJ0tleizGKip5N1VJtXXVFUH7U,31061
+lamindb_setup-1.0a1.dist-info/LICENSE,sha256=UOZ1F5fFDe3XXvG4oNnkL1-Ecun7zpHzRxjp-XsMeAo,11324
+lamindb_setup-1.0a1.dist-info/WHEEL,sha256=CpUCUxeHQbRN5UGRQHYRJorO5Af-Qy_fHMctcQ8DSGI,82
+lamindb_setup-1.0a1.dist-info/METADATA,sha256=YRknY51lYN64_4Nm-ytu8YmaeVvcD4B2XLCutFPNkNo,1689
+lamindb_setup-1.0a1.dist-info/RECORD,,

{lamindb_setup-0.81.4.dist-info → lamindb_setup-1.0a1.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: flit 3.9.0
+Generator: flit 3.10.1
 Root-Is-Purelib: true
 Tag: py3-none-any