lamindb_setup 0.71.2__tar.gz → 0.71.4__tar.gz

{lamindb_setup-0.71.2 → lamindb_setup-0.71.4}/.github/workflows/build.yml

@@ -61,7 +61,7 @@ jobs:
           repository: laminlabs/laminapp-ui
           token: ${{ secrets.GH_TOKEN_DEPLOY_LAMINAPP }}
           path: laminhub
-          ref: 11b0e5065d6f1a05484e1ef8ab8413f3c65bfa5a
+          ref: main
       - uses: actions/cache@v3
         with:
           path: ~/.cache/pre-commit
@@ -130,7 +130,7 @@ jobs:
           repository: laminlabs/laminapp-ui
           token: ${{ secrets.GH_TOKEN_DEPLOY_LAMINAPP }}
           path: laminhub
-          ref: 11b0e5065d6f1a05484e1ef8ab8413f3c65bfa5a
+          ref: main
       - name: Set env file for local test of edge functions
         run: |
           touch .env.local

{lamindb_setup-0.71.2 → lamindb_setup-0.71.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: lamindb_setup
-Version: 0.71.2
+Version: 0.71.4
 Summary: Setup & configure LaminDB.
 Author-email: Lamin Labs <laminlabs@gmail.com>
 Description-Content-Type: text/markdown

{lamindb_setup-0.71.2 → lamindb_setup-0.71.4}/docs/changelog.md

@@ -3,6 +3,13 @@
 <!-- prettier-ignore -->
 Name | PR | Developer | Date | Version
 --- | --- | --- | --- | ---
+⚡️ Speed-up file hash | [761](https://github.com/laminlabs/lamindb-setup/pull/761) | [Koncopd](https://github.com/Koncopd) | 2024-05-11 | 0.71.4
+♻️ Account for public storage locations | [758](https://github.com/laminlabs/lamindb-setup/pull/758) | [falexwolf](https://github.com/falexwolf) | 2024-05-10 |
+♻️ Make init_instance_hub idempotent | [757](https://github.com/laminlabs/lamindb-setup/pull/757) | [falexwolf](https://github.com/falexwolf) | 2024-05-09 |
+♻️ Refactor delete & connect | [756](https://github.com/laminlabs/lamindb-setup/pull/756) | [falexwolf](https://github.com/falexwolf) | 2024-05-09 |
+🔥 Remove laminapp-admin logic | [755](https://github.com/laminlabs/lamindb-setup/pull/755) | [falexwolf](https://github.com/falexwolf) | 2024-05-08 |
+♻️ Better treatment of current_user_id | [754](https://github.com/laminlabs/lamindb-setup/pull/754) | [falexwolf](https://github.com/falexwolf) | 2024-05-06 | 0.71.2
+💚 Fix tests | [753](https://github.com/laminlabs/lamindb-setup/pull/753) | [fredericenard](https://github.com/fredericenard) | 2024-05-06 |
 ♻️ Actually use local db | [751](https://github.com/laminlabs/lamindb-setup/pull/751) | [falexwolf](https://github.com/falexwolf) | 2024-05-06 | 0.71.2
 ✏️ Restore view_tree py3.9 compatibility | [750](https://github.com/laminlabs/lamindb-setup/pull/750) | [sunnyosun](https://github.com/sunnyosun) | 2024-05-06 |
 💚 Pin laminapp-ui | [749](https://github.com/laminlabs/lamindb-setup/pull/749) | [falexwolf](https://github.com/falexwolf) | 2024-05-06 |

{lamindb_setup-0.71.2 → lamindb_setup-0.71.4}/docs/hub-cloud/03-add-managed-storage.ipynb

@@ -255,7 +255,8 @@
     "# root.fs contains the underlying fsspec filesystem\n",
     "assert (\n",
     "    ln_setup.settings.storage.root.fs.cache_regions  # set by lamindb to True for s3 by default\n",
-    ")"
+    ")\n",
+    "assert ln_setup.settings.storage._instance_id is not None"
    ]
   },
   {
@@ -287,6 +288,26 @@
     "assert not ln_setup.settings.storage.root.fs.cache_regions"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "id": "015b8f36",
+   "metadata": {},
+   "source": [
+    "Cloud storage with mere read access:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "4ef50cab",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "with pytest.raises(ValueError) as error:\n",
+    "    set_managed_storage(\"gs://rxrx1-europe-west4/images/test/HEPG2-08\")\n",
+    "assert error.exconly().startswith(\"ValueError: Cannot manage storage without write access\")"
+   ]
+  },
   {
    "cell_type": "markdown",
    "id": "83a2ee6b",
@@ -302,16 +323,14 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "from laminhub_rest.core.collaborator._add_collaborator import add_collaborator\n",
+    "from laminhub_rest.core.instance.collaborator import InstanceCollaboratorHandler\n",
     "from lamindb_setup.core._hub_client import connect_hub_with_auth\n",
     "\n",
     "admin_hub = connect_hub_with_auth()\n",
-    "add_collaborator(\n",
+    "InstanceCollaboratorHandler(admin_hub).add_by_slug(\n",
+    "    \"testuser1/test-add-managed-storage\",\n",
     "    \"testuser2\",\n",
-    "    \"testuser1\",\n",
-    "    \"test-add-managed-storage\",\n",
-    "    \"write\",\n",
-    "    admin_hub,\n",
+    "    \"write\"\n",
     ")\n",
     "admin_hub.auth.close()"
    ]

{lamindb_setup-0.71.2 → lamindb_setup-0.71.4}/lamindb_setup/__init__.py

@@ -34,7 +34,7 @@ Modules & settings:
 
 """
 
-__version__ = "0.71.2"  # denote a release candidate for 0.1.0 with 0.1rc1
+__version__ = "0.71.4"  # denote a release candidate for 0.1.0 with 0.1rc1
 
 import sys
 from os import name as _os_name

{lamindb_setup-0.71.2 → lamindb_setup-0.71.4}/lamindb_setup/_connect_instance.py

@@ -55,7 +55,10 @@ def check_db_dsn_equal_up_to_credentials(db_dsn_hub, db_dsn_local):
 
 
 def update_db_using_local(
-    hub_instance_result: dict[str, str], settings_file: Path, db: str | None = None
+    hub_instance_result: dict[str, str],
+    settings_file: Path,
+    db: str | None = None,
+    raise_permission_error=True,
 ) -> str | None:
     db_updated = None
     # check if postgres
@@ -77,7 +80,11 @@ def update_db_using_local(
                 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":
+                if (
+                    db_dsn_hub.db.user == "none"
+                    and db_dsn_hub.db.password == "none"
+                    and raise_permission_error
+                ):
                     raise PermissionError(
                         "No database access, please ask your admin to provide you with"
                         " a DB URL and pass it via --db <db_url>"
@@ -101,6 +108,65 @@ def update_db_using_local(
     return db_updated
 
 
+def _connect_instance(
+    owner: str,
+    name: str,
+    *,
+    db: str | None = None,
+    raise_permission_error: bool = True,
+) -> InstanceSettings:
+    settings_file = instance_settings_file(name, owner)
+    make_hub_request = True
+    if settings_file.exists():
+        isettings = load_instance_settings(settings_file)
+        # skip hub request for a purely local instance
+        make_hub_request = isettings.is_remote
+    if make_hub_request:
+        # the following will return a string if the instance does not exist
+        # on the hub
+        hub_result = load_instance_from_hub(owner=owner, name=name)
+        # if hub_result is not a string, it means it made a request
+        # that successfully returned metadata
+        if not isinstance(hub_result, str):
+            instance_result, storage_result = hub_result
+            db_updated = update_db_using_local(
+                instance_result,
+                settings_file,
+                db=db,
+                raise_permission_error=raise_permission_error,
+            )
+            ssettings = StorageSettings(
+                root=storage_result["root"],
+                region=storage_result["region"],
+                uid=storage_result["lnid"],
+                uuid=UUID(storage_result["id"]),
+                instance_id=UUID(instance_result["id"]),
+            )
+            isettings = InstanceSettings(
+                id=UUID(instance_result["id"]),
+                owner=owner,
+                name=name,
+                storage=ssettings,
+                db=db_updated,
+                schema=instance_result["schema_str"],
+                git_repo=instance_result["git_repo"],
+                keep_artifacts_local=bool(instance_result["keep_artifacts_local"]),
+                is_on_hub=True,
+            )
+            check_whether_migrations_in_sync(instance_result["lamindb_version"])
+        else:
+            message = INSTANCE_NOT_FOUND_MESSAGE.format(
+                owner=owner, name=name, hub_result=hub_result
+            )
+            if settings_file.exists():
+                isettings = load_instance_settings(settings_file)
+                if isettings.is_remote:
+                    raise InstanceNotFoundError(message)
+            else:
+                raise InstanceNotFoundError(message)
+    return isettings
+
+
 @unlock_cloud_sqlite_upon_exception(ignore_prev_locker=True)
 def connect(
     slug: str,
@@ -134,71 +200,22 @@ def connect(
         elif settings._instance_exists and f"{owner}/{name}" != settings.instance.slug:
             close_instance(mute=True)
 
-        settings_file = instance_settings_file(name, owner)
-
-        make_hub_request = True
-        if settings_file.exists():
-            isettings = load_instance_settings(settings_file)
-            # mimic instance_result from hub
-            instance_result = {"id": isettings._id.hex}
-            # skip hub request for a purely local instance
-            make_hub_request = isettings.is_remote
-
-        if make_hub_request:
-            # the following will return a string if the instance does not exist
-            # on the hub
-            hub_result = load_instance_from_hub(owner=owner, name=name)
-            # if hub_result is not a string, it means it made a request
-            # that successfully returned metadata
-            if not isinstance(hub_result, str):
-                instance_result, storage_result = hub_result
-                db_updated = update_db_using_local(
-                    instance_result, settings_file, db=db
-                )
-                ssettings = StorageSettings(
-                    root=storage_result["root"],
-                    region=storage_result["region"],
-                    uid=storage_result["lnid"],
-                    uuid=UUID(storage_result["id"]),
-                    instance_id=UUID(instance_result["id"]),
-                )
-                isettings = InstanceSettings(
-                    id=UUID(instance_result["id"]),
-                    owner=owner,
-                    name=name,
-                    storage=ssettings,
-                    db=db_updated,
-                    schema=instance_result["schema_str"],
-                    git_repo=instance_result["git_repo"],
-                    keep_artifacts_local=bool(instance_result["keep_artifacts_local"]),
-                    is_on_hub=True,
-                )
-                check_whether_migrations_in_sync(instance_result["lamindb_version"])
+        try:
+            isettings = _connect_instance(owner, name, db=db)
+        except InstanceNotFoundError as e:
+            if _raise_not_found_error:
+                raise e
             else:
-                message = INSTANCE_NOT_FOUND_MESSAGE.format(
-                    owner=owner, name=name, hub_result=hub_result
-                )
-                if settings_file.exists():
-                    isettings = load_instance_settings(settings_file)
-                    if isettings.is_remote:
-                        if _raise_not_found_error:
-                            raise InstanceNotFoundError(message)
-                        return "instance-not-found"
-
-                else:
-                    if _raise_not_found_error:
-                        raise InstanceNotFoundError(message)
-                    return "instance-not-found"
-
+                return "instance-not-found"
+        if isinstance(isettings, str):
+            return isettings
         if storage is not None:
             update_isettings_with_storage(isettings, storage)
         isettings._persist()
         if _test:
             return None
         silence_loggers()
-        check, msg = isettings._load_db(
-            do_not_lock_for_laminapp_admin=True
-        )  # this also updates local SQLite
+        check, msg = isettings._load_db()
         if not check:
             local_db = (
                 isettings._is_cloud_sqlite and isettings._sqlite_file_local.exists()
@@ -216,7 +233,7 @@ def connect(
                     f"instance exists with id {isettings._id.hex}, but database is not"
                     " loadable: re-initializing"
                 )
-                return "instance-corrupted-or-deleted", instance_result
+                return "instance-corrupted-or-deleted"
         # this is for testing purposes only
         if _TEST_FAILED_LOAD:
             raise RuntimeError("Technical testing error.")

{lamindb_setup-0.71.2 → lamindb_setup-0.71.4}/lamindb_setup/_delete.py

@@ -1,29 +1,23 @@
 from __future__ import annotations
 
 import shutil
-from typing import TYPE_CHECKING, Optional
+from typing import TYPE_CHECKING
 from uuid import UUID
 
 from lamin_utils import logger
 
-from ._connect_instance import (
-    INSTANCE_NOT_FOUND_MESSAGE,
-    InstanceNotFoundError,
-    get_owner_name_from_identifier,
-)
-from .core._hub_core import connect_instance as load_instance_from_hub
+from ._connect_instance import _connect_instance, get_owner_name_from_identifier
 from .core._hub_core import delete_instance as delete_instance_on_hub
 from .core._hub_core import get_storage_records_for_instance
 from .core._settings import settings
-from .core._settings_instance import InstanceSettings
-from .core._settings_load import load_instance_settings
 from .core._settings_storage import StorageSettings
-from .core._settings_store import instance_settings_file
 from .core.upath import HOSTED_BUCKETS, check_storage_is_empty
 
 if TYPE_CHECKING:
     from pathlib import Path
 
+    from .core._settings_instance import InstanceSettings
+
 
 def delete_cache(cache_dir: Path):
     if cache_dir is not None and cache_dir.exists():
@@ -67,42 +61,8 @@ def delete(slug: str, force: bool = False, require_empty: bool = True) -> int |
         force: Whether to skip the confirmation prompt.
         require_empty: Whether to check if the instance is empty before deleting.
     """
-    instance_owner, instance_name = get_owner_name_from_identifier(slug)
-    if settings._instance_exists and settings.instance.name == instance_name:
-        isettings = settings.instance
-    else:
-        settings_file = instance_settings_file(instance_name, instance_owner)
-        if not settings_file.exists():
-            hub_result = load_instance_from_hub(
-                owner=instance_owner, name=instance_name
-            )
-            if isinstance(hub_result, str):
-                message = INSTANCE_NOT_FOUND_MESSAGE.format(
-                    owner=instance_owner,
-                    name=instance_name,
-                    hub_result=hub_result,
-                )
-                raise InstanceNotFoundError(message)
-            instance_result, storage_result = hub_result
-            ssettings = StorageSettings(
-                root=storage_result["root"],
-                region=storage_result["region"],
-                uid=storage_result["lnid"],
-                uuid=UUID(storage_result["id"]),
-            )
-            isettings = InstanceSettings(
-                id=UUID(instance_result["id"]),
-                owner=instance_owner,
-                name=instance_name,
-                storage=ssettings,
-                keep_artifacts_local=bool(instance_result["keep_artifacts_local"]),
-                db=instance_result["db"] if "db" in instance_result else None,
-                schema=instance_result["schema_str"],
-                git_repo=instance_result["git_repo"],
-                is_on_hub=True,
-            )
-        else:
-            isettings = load_instance_settings(settings_file)
+    owner, name = get_owner_name_from_identifier(slug)
+    isettings = _connect_instance(owner, name, raise_permission_error=False)
     if isettings.dialect != "sqlite":
         logger.warning(
             f"delete() does not yet affect your Postgres database at {isettings.db}"

{lamindb_setup-0.71.2 → lamindb_setup-0.71.4}/lamindb_setup/_init_instance.py

@@ -44,15 +44,17 @@ def register_storage_in_instance(ssettings: StorageSettings):
 
     from .core.hashing import hash_and_encode_as_b62
 
-    assert ssettings._instance_id is not None
-
+    if ssettings._instance_id is not None:
+        instance_uid = hash_and_encode_as_b62(ssettings._instance_id.hex)[:12]
+    else:
+        instance_uid = None
     # how do we ensure that this function is only called passing
     # the managing instance?
     defaults = {
         "root": ssettings.root_as_str,
         "type": ssettings.type,
         "region": ssettings.region,
-        "instance_uid": hash_and_encode_as_b62(ssettings._instance_id.hex)[:12],
+        "instance_uid": instance_uid,
         "created_by_id": current_user_id(),
     }
     if ssettings._uid is not None:
@@ -67,20 +69,19 @@ def register_storage_in_instance(ssettings: StorageSettings):
 def register_user(usettings):
     from lnschema_core.models import User
 
-    if usettings.handle != "laminapp-admin":
-        try:
-            # need to have try except because of integer primary key migration
-            user, created = User.objects.update_or_create(
-                uid=usettings.uid,
-                defaults={
-                    "handle": usettings.handle,
-                    "name": usettings.name,
-                },
-            )
-        # for users with only read access, except via ProgrammingError
-        # ProgrammingError: permission denied for table lnschema_core_user
-        except (OperationalError, FieldError, ProgrammingError):
-            pass
+    try:
+        # need to have try except because of integer primary key migration
+        user, created = User.objects.update_or_create(
+            uid=usettings.uid,
+            defaults={
+                "handle": usettings.handle,
+                "name": usettings.name,
+            },
+        )
+    # for users with only read access, except via ProgrammingError
+    # ProgrammingError: permission denied for table lnschema_core_user
+    except (OperationalError, FieldError, ProgrammingError):
+        pass
 
 
 def register_user_and_storage_in_instance(isettings: InstanceSettings, usettings):

{lamindb_setup-0.71.2 → lamindb_setup-0.71.4}/lamindb_setup/_set_managed_storage.py

@@ -31,6 +31,10 @@ def set_managed_storage(root: UPathStr, **fs_kwargs):
     ssettings = init_storage(
         root=root, instance_id=settings.instance._id, register_hub=True
     )
+    if ssettings._instance_id is None:
+        raise ValueError(
+            f"Cannot manage storage without write access: {ssettings.root}"
+        )
     settings.instance._storage = ssettings
     settings.instance._persist()  # this also updates the settings object
     register_storage_in_instance(ssettings)

{lamindb_setup-0.71.2 → lamindb_setup-0.71.4}/lamindb_setup/core/_hub_core.py

@@ -284,9 +284,11 @@ def _init_instance(isettings: InstanceSettings, client: Client) -> None:
     # as then init_instance is no longer idempotent
     try:
         client.table("instance").insert(fields, returning="minimal").execute()
-    except APIError as e:
-        logger.warning("instance likely already exists")
-        raise e
+    except APIError:
+        logger.warning(
+            f"instance already existed at: https://lamin.ai/{isettings.owner}/{isettings.name}"
+        )
+        return None
     client.table("storage").update(
         {"instance_id": isettings._id.hex, "is_default": True}
     ).eq("id", isettings.storage._uuid.hex).execute()  # type: ignore

{lamindb_setup-0.71.2 → lamindb_setup-0.71.4}/lamindb_setup/core/_settings_instance.py

@@ -42,7 +42,7 @@ class InstanceSettings:
         db: str | None = None,  # DB URI
         schema: str | None = None,  # comma-separated string of schema names
         git_repo: str | None = None,  # a git repo URL
-        is_on_hub: bool = False,  # initialized from hub
+        is_on_hub: bool | None = None,  # initialized from hub
     ):
         from ._hub_utils import validate_db_arg
 
@@ -406,9 +406,7 @@ class InstanceSettings:
 
         setup_django(self, init=True)
 
-    def _load_db(
-        self, do_not_lock_for_laminapp_admin: bool = False
-    ) -> tuple[bool, str]:
+    def _load_db(self) -> tuple[bool, str]:
         # 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():
@@ -423,15 +421,8 @@ class InstanceSettings:
 
         from .django import setup_django
 
-        # lock in all cases except if do_not_lock_for_laminapp_admin is True and
-        # user is `laminapp-admin`
-        # value doesn't matter if not a cloud sqlite instance
-        lock_cloud_sqlite = self._is_cloud_sqlite and (
-            not do_not_lock_for_laminapp_admin
-            or settings.user.handle != "laminapp-admin"
-        )
         # we need the local sqlite to setup django
-        self._update_local_sqlite_file(lock_cloud_sqlite=lock_cloud_sqlite)
+        self._update_local_sqlite_file(lock_cloud_sqlite=self._is_cloud_sqlite)
         # setting up django also performs a check for migrations & prints them
         # as warnings
         # this should fail, e.g., if the db is not reachable

{lamindb_setup-0.71.2 → lamindb_setup-0.71.4}/lamindb_setup/core/_settings_storage.py

@@ -113,11 +113,20 @@ def init_storage(
     )
     # the below might update the uid with one that's already taken on the hub
     if ssettings.type_is_cloud or register_hub:
+        from ._hub_core import delete_storage_record
         from ._hub_core import init_storage as init_storage_hub
 
         init_storage_hub(ssettings)
     # below comes last only if everything else was successful
-    mark_storage_root(ssettings.root, ssettings.uid)  # type: ignore
+    try:
+        mark_storage_root(ssettings.root, ssettings.uid)  # type: ignore
+    except Exception:
+        logger.important(
+            f"due to lack of write access, LaminDB won't manage storage location: {ssettings.root}"
+        )
+        if ssettings._uuid is not None:
+            delete_storage_record(ssettings._uuid)  # type: ignore
+        ssettings._instance_id = None
     return ssettings
 
 

{lamindb_setup-0.71.2 → lamindb_setup-0.71.4}/lamindb_setup/core/_settings_user.py

@@ -46,10 +46,6 @@ class UserSettings:
     @property
     def id(self):
         """Integer id valid in current intance."""
-        # do NOT use the function below because this
-        # doesn't error - it needs to be this way to have
-        # a user id available in migrations
-        # from lnschema_core.users import current_user_id
-        from lnschema_core.models import User
+        from lnschema_core.users import current_user_id
 
-        return User.objects.get(uid=self.uid).id
+        return current_user_id()

{lamindb_setup-0.71.2 → lamindb_setup-0.71.4}/lamindb_setup/core/django.py

@@ -4,7 +4,6 @@ from __future__ import annotations
 import builtins
 import os
 from pathlib import Path
-import shutil
 import time
 from lamin_utils import logger
 from ._settings_store import current_instance_settings_file
@@ -12,6 +11,7 @@ from ._settings_instance import InstanceSettings
 
 IS_RUN_FROM_IPYTHON = getattr(builtins, "__IPYTHON__", False)
 IS_SETUP = False
+IS_MIGRATING = False
 CONN_MAX_AGE = 299
 
 
@@ -101,7 +101,10 @@ def setup_django(
         call_command("migrate", verbosity=2)
         isettings._update_cloud_sqlite_file(unlock_cloud_sqlite=False)
     elif init:
+        global IS_MIGRATING
+        IS_MIGRATING = True
         call_command("migrate", verbosity=0)
+        IS_MIGRATING = False
 
     global IS_SETUP
     IS_SETUP = True

{lamindb_setup-0.71.2 → lamindb_setup-0.71.4}/lamindb_setup/core/hashing.py

@@ -40,11 +40,11 @@ def hash_set(s: set[str]) -> str:
     return to_b64_str(hashlib.md5(bstr).digest())[:20]
 
 
-def hash_md5s_from_dir(etags: list[str]) -> tuple[str, str]:
+def hash_md5s_from_dir(hashes: list[str]) -> tuple[str, str]:
     # need to sort below because we don't want the order of parsing the dir to
     # affect the hash
     digests = b"".join(
-        hashlib.md5(etag.encode("utf-8")).digest() for etag in sorted(etags)
+        hashlib.md5(hash.encode("utf-8")).digest() for hash in sorted(hashes)
     )
     digest = hashlib.md5(digests).digest()
     return to_b64_str(digest)[:22], "md5-d"
@@ -59,24 +59,27 @@ def hash_code(file_path: UPathStr):
     return hashlib.sha1(blob)
 
 
-def hash_file(file_path: Path, chunk_size=50 * 1024 * 1024) -> tuple[str, str]:
-    chunks = []
+def hash_file(
+    file_path: Path,
+    file_size: int | None = None,
+    chunk_size: int | None = 50 * 1024 * 1024,
+) -> tuple[str, str]:
     with open(file_path, "rb") as fp:
-        # read first chunk
-        chunks = [fp.read(chunk_size)]
-        # try reading the 2nd chunk
-        data = fp.read(chunk_size)
-        if data:
-            # go to end of file
+        if file_size is None:
+            fp.seek(0, 2)
+            file_size = fp.tell()
+            fp.seek(0, 0)
+        if chunk_size is None:
+            chunk_size = file_size
+        first_chunk = fp.read(chunk_size)
+        if file_size <= chunk_size:
+            digest = hashlib.md5(first_chunk).digest()
+            hash_type = "md5"
+        else:
             fp.seek(-chunk_size, 2)
-            # read last chunk
-            data = fp.read(chunk_size)
-            chunks.append(data)
-    if len(chunks) == 1:
-        digest = hashlib.md5(chunks[0]).digest()
-        hash_type = "md5"
-    else:
-        digests = b"".join(hashlib.sha1(chunk).digest() for chunk in chunks)
-        digest = hashlib.sha1(digests).digest()
-        hash_type = "sha1-fl"  # sha1 first last chunk
+            last_chunk = fp.read(chunk_size)
+            digest = hashlib.sha1(
+                hashlib.sha1(first_chunk).digest() + hashlib.sha1(last_chunk).digest()
+            ).digest()
+            hash_type = "sha1-fl"
     return to_b64_str(digest)[:22], hash_type

{lamindb_setup-0.71.2 → lamindb_setup-0.71.4}/tests/hub-cloud/test_connect_instance.py

@@ -7,8 +7,7 @@ import pytest
 from lamindb_setup._connect_instance import InstanceNotFoundError
 from lamindb_setup.core._hub_client import connect_hub_with_auth
 from lamindb_setup.core._hub_crud import update_instance
-from laminhub_rest.core.collaborator._add_collaborator import add_collaborator
-from laminhub_rest.core.collaborator._delete_collaborator import delete_collaborator
+from laminhub_rest.core.instance.collaborator import InstanceCollaboratorHandler
 from postgrest.exceptions import APIError
 
 # @pytest.fixture
@@ -24,15 +23,16 @@ def test_connect_after_revoked_access():
     if os.getenv("LAMIN_ENV") == "prod":
         ln_setup.login("testuser1@lamin.ai")
         admin_hub = connect_hub_with_auth()
+        collaborator_handler = InstanceCollaboratorHandler(admin_hub)
         try:
             # if a previous test run failed, this will
             # error with a violation of a unique constraint
-            add_collaborator(
+            collaborator_handler.add_by_slug(
+                "laminlabs/static-test-instance-private-sqlite",
                 "testuser2",
-                "laminlabs",
-                "static-test-instance-private-sqlite",
                 "write",
-                admin_hub,
+                "default",
+                skip_insert_user_table=True,
             )
         except APIError:
             pass
@@ -44,11 +44,8 @@ def test_connect_after_revoked_access():
             ln_setup.settings.instance.storage.root_as_str
             == "s3://lamindb-setup-private-bucket"
         )
-        delete_collaborator(
-            "laminlabs",
-            "static-test-instance-private-sqlite",
-            ln_setup.settings.user._uuid,
-            admin_hub,
+        collaborator_handler.delete_by_slug(
+            "laminlabs/static-test-instance-private-sqlite", "testuser2"
         )
         # make the instance private
         with pytest.raises(InstanceNotFoundError):

{lamindb_setup-0.71.2 → lamindb_setup-0.71.4}/tests/hub-local/conftest.py

@@ -6,7 +6,7 @@ from lamin_utils import logger
 from laminhub_rest.dev._setup_local_hub import setup_local_hub
 
 pytest_plugins = [
-    "laminhub_rest.test.fixtures.user",
+    "laminhub_rest.core.account.user.test.fixtures",
     "laminhub_rest.test.fixtures.run_id",
 ]
 

{lamindb_setup-0.71.2 → lamindb_setup-0.71.4}/tests/hub-local/test_all.py

@@ -34,7 +34,7 @@ from lamindb_setup.core._settings_save import save_user_settings
 from lamindb_setup.core._settings_storage import base62
 from lamindb_setup.core._settings_storage import init_storage as init_storage_base
 from lamindb_setup.core._settings_user import UserSettings
-from laminhub_rest.core.collaborator._add_collaborator import add_collaborator_by_ids
+from laminhub_rest.core.instance.collaborator import InstanceCollaboratorHandler
 from postgrest.exceptions import APIError
 
 
@@ -196,11 +196,11 @@ def test_db_user(
     )
     assert db_collaborator is None
     # now add testreader1 as a collaborator
-    add_collaborator_by_ids(
+    InstanceCollaboratorHandler(admin_client).add(
         account_id=reader_settings._uuid,
         instance_id=instance_id,
         role="read",
-        supabase_client=admin_client,
+        skip_insert_user_table=True,
     )
     # check that this was successful and can be read by the reader
     db_collaborator = select_collaborator(

{lamindb_setup-0.71.2 → lamindb_setup-0.71.4}/tests/hub-prod/conftest.py

@@ -1,5 +1,4 @@
 import os
-from typing import TYPE_CHECKING
 from uuid import UUID
 
 import lamindb_setup
@@ -10,6 +9,7 @@ from lamin_utils import logger
 def pytest_sessionstart(session: pytest.Session):
     lamindb_instance_id = UUID("e1a2d3ab762e4592af5a1e53f288284e")
     os.environ["LAMINDB_INSTANCE_ID_INIT"] = lamindb_instance_id.hex
+    assert lamindb_setup.settings.user.handle == "testuser2"
     lamindb_setup.init(
         storage="./default_storage",
         schema="bionty",
@@ -21,4 +21,4 @@ def pytest_sessionstart(session: pytest.Session):
 
 def pytest_sessionfinish(session: pytest.Session):
     logger.set_verbosity(1)
-    lamindb_setup.delete("lamindb-setup-unit-tests", force=True)
+    lamindb_setup.delete("testuser2/lamindb-setup-unit-tests", force=True)