lamindb_setup 1.4.1__tar.gz → 1.5.0__tar.gz

{lamindb_setup-1.4.1 → lamindb_setup-1.5.0}/PKG-INFO

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

{lamindb_setup-1.4.1 → lamindb_setup-1.5.0}/docs/hub-prod/test-connect-anonymously-set-token.ipynb

@@ -15,8 +15,8 @@
    "source": [
     "import pytest\n",
     "import lamindb_setup as ln_setup\n",
-    "from lamindb_setup.core.django import set_db_token\n",
-    "from psycopg2.errors import UndefinedFunction"
+    "from lamindb_setup.core.django import db_token_manager\n",
+    "from django.db.utils import ProgrammingError"
    ]
   },
   {
@@ -55,10 +55,16 @@
    "source": [
     "# this just tests that the function is setup properly\n",
     "# the actual functionality is tested in lamindb\n",
-    "set_db_token(None)\n",
     "# set_token sql function is not defined\n",
-    "with pytest.raises(UndefinedFunction):\n",
-    "    set_db_token(\"test\")"
+    "db_token_manager.debug = True\n",
+    "db_token_manager.set(\"test\")\n",
+    "\n",
+    "with pytest.raises(ProgrammingError):\n",
+    "    ln_setup.settings.storage.record  # makes a db query through django\n",
+    "\n",
+    "db_token_manager.reset()  # turn off token\n",
+    "\n",
+    "ln_setup.settings.storage.record"
    ]
   },
   {

{lamindb_setup-1.4.1 → lamindb_setup-1.5.0}/lamindb_setup/__init__.py

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

{lamindb_setup-1.4.1 → lamindb_setup-1.5.0}/lamindb_setup/_cache.py

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

{lamindb_setup-1.4.1 → lamindb_setup-1.5.0}/lamindb_setup/_check_setup.py

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

{lamindb_setup-1.4.1 → lamindb_setup-1.5.0}/lamindb_setup/_connect_instance.py

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

lamindb_setup-1.4.1/lamindb_setup/_close.py → lamindb_setup-1.5.0/lamindb_setup/_disconnect.py

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

{lamindb_setup-1.4.1 → lamindb_setup-1.5.0}/lamindb_setup/_init_instance.py

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

{lamindb_setup-1.4.1 → lamindb_setup-1.5.0}/lamindb_setup/_setup_user.py

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

{lamindb_setup-1.4.1 → lamindb_setup-1.5.0}/lamindb_setup/core/_aws_options.py

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

{lamindb_setup-1.4.1 → lamindb_setup-1.5.0}/lamindb_setup/core/_hub_core.py

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

{lamindb_setup-1.4.1 → lamindb_setup-1.5.0}/lamindb_setup/core/_settings.py

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

{lamindb_setup-1.4.1 → lamindb_setup-1.5.0}/lamindb_setup/core/_settings_instance.py

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

{lamindb_setup-1.4.1 → lamindb_setup-1.5.0}/lamindb_setup/core/_settings_load.py

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

{lamindb_setup-1.4.1 → lamindb_setup-1.5.0}/lamindb_setup/core/django.py

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

{lamindb_setup-1.4.1 → lamindb_setup-1.5.0}/noxfile.py

@@ -33,7 +33,9 @@ uv pip install --system git+https://github.com/laminlabs/bionty
 """
     if group == "hub-cloud":
         cmds = (
-            modules_deps + "uv pip install --system ./laminhub/rest-hub line_profiler"
+            modules_deps
+            + "uv pip install --system sentry_sdk line_profiler wheel==0.45.1 flit"
+            + "\nuv pip install --system ./laminhub/rest-hub --no-build-isolation"
         )
     elif group == "docs":
         cmds = """uv pip install --system git+https://github.com/laminlabs/lamindb"""
@@ -52,9 +54,10 @@ uv pip install --system git+https://github.com/laminlabs/bionty
 
     # above downgrades django, I don't understand why, try this
     if group == "hub-local":
-        cmds += (
-            "\nuv pip install --system -e ./laminhub/rest-hub line_profiler sentry_sdk"
-        )
+        cmds += "\nuv pip install --system sentry_sdk line_profiler wheel==0.45.1 flit"
+        cmds += "\nuv pip install --system -e ./laminhub/rest-hub --no-build-isolation"
+        # check that just installing psycopg (psycopg3) doesn't break fine-grained access
+        cmds += "\nuv pip install --system psycopg[binary]"
 
     run(session, "uv pip install --system pandera")  # needed to import lamindb
     [run(session, line) for line in cmds.splitlines()]

{lamindb_setup-1.4.1 → lamindb_setup-1.5.0}/pyproject.toml

@@ -34,10 +34,10 @@ aws = [
     "urllib3<2", # for botocore, TODO: check that really required
     "aiobotocore[boto3]>=2.5.4,<3.0.0",
     # exclude 2024.10.0 due to https://github.com/fsspec/s3fs/pull/910
-    "s3fs>=2023.12.2,<=2025.2.0,!=2024.10.0"
+    "s3fs>=2023.12.2,<=2025.3.2,!=2024.10.0"
 ]
 gcp = [
-    "gcsfs>=2023.12.2,<=2025.2.0"
+    "gcsfs>=2023.12.2,<=2025.3.2"
 ]
 erdiagram = [
     "django-schema-graph",

{lamindb_setup-1.4.1 → lamindb_setup-1.5.0}/tests/hub-cloud/test_connect_instance.py

@@ -12,11 +12,11 @@ from postgrest.exceptions import APIError
 
 
 def test_connect_pass_none():
-    with pytest.raises(SystemExit) as err:
+    with pytest.raises(ValueError) as err:
         ln_setup.connect(_test=True)
     assert (
         err.exconly()
-        == "SystemExit: No instance was connected through the CLI, pass a value to `instance` or connect via the CLI."
+        == "ValueError: No instance was connected through the CLI, pass a value to `instance` or connect via the CLI."
     )
 
 

{lamindb_setup-1.4.1 → lamindb_setup-1.5.0}/tests/hub-local/conftest.py

@@ -19,6 +19,7 @@ pytest_plugins = [
 
 def pytest_configure():
     os.environ["LAMIN_ENV"] = "local"
+    os.environ["LAMIN_CLOUD_VERSION"] = "0.1"
     remove_lamin_local_settings()
     supabase_resources.start_local()
     supabase_resources.reset_local()

lamindb_setup-1.5.0/tests/hub-local/scripts/script-connect-fine-grained-access.py

@@ -0,0 +1,41 @@
+import os
+
+import lamindb_setup as ln_setup
+import pytest
+from django.db import transaction
+from lamindb_setup.core._hub_core import access_db
+from lamindb_setup.core.django import db_token_manager
+
+assert os.environ["LAMIN_ENV"] == "local"
+
+ln_setup.connect("instance_access_v2")
+
+isettings = ln_setup.settings.instance
+
+assert isettings._fine_grained_access
+assert isettings._db_permissions == "jwt"
+assert isettings._api_url is not None
+
+# test querying
+db_token_manager.debug = True
+
+storage_record = isettings.storage.record
+
+isettings.storage._record = None
+with transaction.atomic():
+    assert isettings.storage.record.id == storage_record.id
+
+# check calling access_db with a dict
+instance_dict = {
+    "owner": isettings.owner,
+    "name": isettings.name,
+    "id": isettings._id.hex,
+    "api_url": isettings._api_url,
+}
+access_db(instance_dict)
+# check calling access_db with anonymous user
+ln_setup.settings.user.handle = "anonymous"
+with pytest.raises(RuntimeError):
+    access_db(isettings)
+# check with providing access_token explicitly
+access_db(isettings, ln_setup.settings.user.access_token)

{lamindb_setup-1.4.1 → lamindb_setup-1.5.0}/tests/hub-local/test_all.py

@@ -14,7 +14,6 @@ from lamindb_setup.core._hub_client import (
 )
 from lamindb_setup.core._hub_core import (
     _connect_instance_hub,
-    access_db,
     connect_instance_hub,
     init_instance_hub,
     init_storage_hub,
@@ -309,9 +308,9 @@ def test_connect_instance_hub(create_myinstance, create_testadmin1_session):
     assert instance["name"] == create_myinstance["name"]
     assert instance["db"] == expected_dsn
 
-    # add db_server from seed_local_test
+    # add resource_db_server from seed_local_test
     admin_client.table("instance").update(
-        {"db_server_id": "e36c7069-2129-4c78-b2c6-323e2354b741"}
+        {"resource_db_server_id": "e36c7069-2129-4c78-b2c6-323e2354b741"}
     ).eq("id", instance["id"]).execute()
 
     instance, _ = connect_instance_hub(owner=owner, name=name)
@@ -391,8 +390,18 @@ def test_init_storage_incorrect_protocol():
     assert "Protocol incorrect-protocol is not supported" in error.exconly()
 
 
-def test_fine_grained_access(create_instance_fine_grained_access):
+def test_fine_grained_access(
+    create_testadmin1_session, create_instance_fine_grained_access
+):
+    admin_client, testadmin1 = create_testadmin1_session
     instance = create_instance_fine_grained_access
+    # check api_url is set up correctly through the new tables
+    instance_record = select_instance_by_name(
+        account_id=testadmin1._uuid,
+        name=instance.name,
+        client=admin_client,
+    )
+    assert instance_record["resource_db_server_id"] is not None
 
     isettings_file = instance_settings_file(
         instance.name, ln_setup.settings.user.handle

{lamindb_setup-1.4.1 → lamindb_setup-1.5.0}/tests/storage/test_storage_access.py

@@ -58,4 +58,4 @@ def test_connect_instance_with_public_storage():
     )
     client.auth.sign_out()
     assert ln_setup.settings.instance._id == UUID(instance["id"])
-    ln_setup.close()
+    ln_setup.disconnect()

lamindb_setup-1.4.1/tests/hub-local/scripts/script-connect-fine-grained-access.py

@@ -1,19 +0,0 @@
-import os
-
-import lamindb_setup as ln_setup
-import pytest
-from lamindb_setup.core._hub_core import access_db
-
-assert os.environ["LAMIN_ENV"] == "local"
-
-ln_setup.connect("instance_access_v2")
-
-assert ln_setup.settings.instance._fine_grained_access
-assert ln_setup.settings.instance._db_permissions == "jwt"
-
-# check calling access_db with anonymous user
-ln_setup.settings.user.handle = "anonymous"
-with pytest.raises(RuntimeError):
-    access_db(ln_setup.settings.instance)
-# check with providing access_token explicitly
-access_db(ln_setup.settings.instance, ln_setup.settings.user.access_token)