lamindb_setup 1.3.0__tar.gz → 1.3.1__tar.gz

{lamindb_setup-1.3.0 → lamindb_setup-1.3.1}/PKG-INFO

@@ -1,12 +1,12 @@
 Metadata-Version: 2.3
 Name: lamindb_setup
-Version: 1.3.0
+Version: 1.3.1
 Summary: Setup & configure LaminDB.
 Author-email: Lamin Labs <open-source@lamin.ai>
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 Requires-Dist: lamin_utils>=0.3.3
-Requires-Dist: django>=5,<5.2
+Requires-Dist: django>=5.1,<5.2
 Requires-Dist: dj_database_url>=1.3.0,<3.0.0
 Requires-Dist: pydantic-settings
 Requires-Dist: appdirs<2.0.0

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

@@ -15,7 +15,7 @@
    "source": [
     "import pytest\n",
     "import lamindb_setup as ln_setup\n",
-    "from lamindb_setup.core.django import set_token\n",
+    "from lamindb_setup.core.django import set_db_token\n",
     "from psycopg2.errors import UndefinedFunction"
    ]
   },
@@ -55,10 +55,10 @@
    "source": [
     "# this just tests that the function is setup properly\n",
     "# the actual functionality is tested in lamindb\n",
-    "set_token(None)\n",
+    "set_db_token(None)\n",
     "# set_token sql function is not defined\n",
     "with pytest.raises(UndefinedFunction):\n",
-    "    set_token(\"test\")"
+    "    set_db_token(\"test\")"
    ]
   },
   {

{lamindb_setup-1.3.0 → lamindb_setup-1.3.1}/lamindb_setup/__init__.py

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

{lamindb_setup-1.3.0 → lamindb_setup-1.3.1}/lamindb_setup/_connect_instance.py

@@ -168,6 +168,7 @@ def _connect_instance(
                 schema_id=None
                 if (schema_id := instance_result["schema_id"]) is None
                 else UUID(schema_id),
+                fine_grained_access=instance_result.get("fine_grained_access", False),
             )
         else:
             if hub_result != "anonymous-user":
@@ -205,7 +206,6 @@ def connect(instance: str | None = None, **kwargs) -> str | tuple | None:
     for kwarg in kwargs:
         if kwarg not in valid_kwargs:
             raise TypeError(f"connect() got unexpected keyword argument '{kwarg}'")
-
     isettings: InstanceSettings = None  # type: ignore
     # _db is still needed because it is called in init
     _db: str | None = kwargs.get("_db", None)

{lamindb_setup-1.3.0 → lamindb_setup-1.3.1}/lamindb_setup/_init_instance.py

@@ -6,6 +6,7 @@ import uuid
 from typing import TYPE_CHECKING, Literal
 from uuid import UUID
 
+import click
 from django.core.exceptions import FieldError
 from django.db.utils import OperationalError, ProgrammingError
 from lamin_utils import logger
@@ -25,6 +26,11 @@ if TYPE_CHECKING:
     from .core.types import UPathStr
 
 
+class InstanceNotCreated(click.ClickException):
+    def show(self, file=None):
+        pass
+
+
 def get_schema_module_name(module_name, raise_import_error: bool = True) -> str | None:
     import importlib.util
 
@@ -242,7 +248,7 @@ def init(
             raise CannotSwitchDefaultInstance(MESSAGE_CANNOT_SWITCH_DEFAULT_INSTANCE)
         elif _write_settings:
             close_instance(mute=True)
-        from .core._hub_core import init_instance as init_instance_hub
+        from .core._hub_core import init_instance_hub
 
         name_str, instance_id, instance_state, _ = validate_init_args(
             storage=storage,
@@ -284,6 +290,13 @@ def init(
             isettings.is_remote and instance_state != "instance-corrupted-or-deleted"
         )
         if register_on_hub:
+            # can't register the instance in the hub
+            # if storage is not in the hub
+            # raise the exception and initiate cleanups
+            if not isettings.storage.is_on_hub:
+                raise InstanceNotCreated(
+                    "Unable to create the instance because failed to register the storage."
+                )
             init_instance_hub(
                 isettings, account_id=user__uuid, access_token=access_token
             )

{lamindb_setup-1.3.0 → lamindb_setup-1.3.1}/lamindb_setup/_migrate.py

@@ -23,25 +23,36 @@ def check_whether_migrations_in_sync(db_version_str: str):
         return None
     installed_version = version.parse(installed_version_str)
     db_version = version.parse(db_version_str)
-    if installed_version.major < db_version.major or (
+    if installed_version.major < db_version.major:
+        logger.warning(
+            f"the database ({db_version_str}) is far ahead of your installed lamindb package ({installed_version_str})"
+        )
+        logger.important(
+            f"please update lamindb: pip install lamindb>={db_version.major}"
+        )
+    elif (
         installed_version.major == db_version.major
         and installed_version.minor < db_version.minor
     ):
         db_version_lower = f"{db_version.major}.{db_version.minor}"
-        db_version_upper = f"{db_version.major}.{db_version.minor + 1}"
-        logger.warning(
+        logger.important(
             f"the database ({db_version_str}) is ahead of your installed lamindb"
             f" package ({installed_version_str})"
         )
         logger.important(
-            "please update lamindb: pip install"
-            f' "lamindb>={db_version_lower},<{db_version_upper}"'
+            f"consider updating lamindb: pip install lamindb>={db_version_lower}"
         )
-    elif installed_version.major > db_version.major or (
+    elif installed_version.major > db_version.major:
+        logger.warning(
+            f"the database ({db_version_str}) is far behind your installed lamindb package"
+            f" ({installed_version_str})"
+        )
+        logger.important("migrate your database: lamin migrate deploy")
+    elif (
         installed_version.major == db_version.major
         and installed_version.minor > db_version.minor
     ):
-        logger.warning(
+        logger.important(
             f"the database ({db_version_str}) is behind your installed lamindb package"
             f" ({installed_version_str})"
         )

{lamindb_setup-1.3.0 → lamindb_setup-1.3.1}/lamindb_setup/_register_instance.py

@@ -10,8 +10,7 @@ from .core.django import setup_django
 def register(_test: bool = False):
     """Register an instance on the hub."""
     from ._check_setup import _check_instance_setup
-    from .core._hub_core import init_instance as init_instance_hub
-    from .core._hub_core import init_storage as init_storage_hub
+    from .core._hub_core import init_instance_hub, init_storage_hub
 
     logger.warning("""lamin register will be removed soon""")
 

{lamindb_setup-1.3.0 → lamindb_setup-1.3.1}/lamindb_setup/core/_hub_client.py

@@ -180,3 +180,37 @@ def call_with_fallback(
             except NameError:
                 pass
     return result
+
+
+def requests_client():
+    # local is used in tests
+    if os.environ.get("LAMIN_ENV", "prod") == "local":
+        from fastapi.testclient import TestClient
+        from laminhub_rest.main import app
+
+        return TestClient(app)
+
+    import requests  # type: ignore
+
+    return requests
+
+
+def request_get_auth(url: str, access_token: str, renew_token: bool = True):
+    requests = requests_client()
+
+    response = requests.get(url, headers={"Authorization": f"Bearer {access_token}"})
+    # upate access_token and try again if failed
+    if response.status_code != 200 and renew_token:
+        from lamindb_setup import settings
+
+        access_token = get_access_token(
+            settings.user.email, settings.user.password, settings.user.api_key
+        )
+
+        settings.user.access_token = access_token
+        save_user_settings(settings.user)
+
+        response = requests.get(
+            url, headers={"Authorization": f"Bearer {access_token}"}
+        )
+    return response

{lamindb_setup-1.3.0 → lamindb_setup-1.3.1}/lamindb_setup/core/_hub_core.py

@@ -16,6 +16,7 @@ from ._hub_client import (
     call_with_fallback,
     call_with_fallback_auth,
     connect_hub,
+    request_get_auth,
 )
 from ._hub_crud import (
     _delete_instance_record,
@@ -115,7 +116,7 @@ def _select_storage(
         return True
 
 
-def init_storage(
+def init_storage_hub(
     ssettings: StorageSettings,
     auto_populate_instance: bool = True,
     created_by: UUID | None = None,
@@ -123,7 +124,7 @@ def init_storage(
 ) -> Literal["hub-record-retireved", "hub-record-created"]:
     if settings.user.handle != "anonymous" or access_token is not None:
         return call_with_fallback_auth(
-            _init_storage,
+            _init_storage_hub,
             ssettings=ssettings,
             auto_populate_instance=auto_populate_instance,
             created_by=created_by,
@@ -139,7 +140,7 @@ def init_storage(
             raise ValueError("Log in to create a storage location on the hub.")
 
 
-def _init_storage(
+def _init_storage_hub(
     client: Client,
     ssettings: StorageSettings,
     auto_populate_instance: bool,
@@ -269,20 +270,20 @@ def delete_instance_record(instance_id: UUID, access_token: str | None = None) -
     )
 
 
-def init_instance(
+def init_instance_hub(
     isettings: InstanceSettings,
     account_id: UUID | None = None,
     access_token: str | None = None,
 ) -> None:
     return call_with_fallback_auth(
-        _init_instance,
+        _init_instance_hub,
         isettings=isettings,
         account_id=account_id,
         access_token=access_token,
     )
 
 
-def _init_instance(
+def _init_instance_hub(
     client: Client, isettings: InstanceSettings, account_id: UUID | None = None
 ) -> None:
     from ._settings import settings
@@ -437,6 +438,38 @@ 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:
+    if access_token is None:
+        if settings.user.handle == "anonymous":
+            raise RuntimeError(
+                f"Can only get fine-grained access to {isettings.slug} if authenticated."
+            )
+        else:
+            access_token = settings.user.access_token
+            renew_token = True
+    else:
+        renew_token = False
+    # local is used in tests
+    url = f"/access_v2/instances/{isettings._id}/db_token"
+    if os.environ.get("LAMIN_ENV", "prod") != "local":
+        api_url = isettings._api_url
+        if api_url is None:
+            raise RuntimeError(
+                f"Can only get fine-grained access to {isettings.slug} if api_url is present."
+            )
+        url = 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}"
+        )
+    if "token" not in response_json:
+        raise RuntimeError("The response of access_db does not contain a db token.")
+    return response_json["token"]
+
+
 def get_lamin_site_base_url():
     if "LAMIN_ENV" in os.environ:
         if os.environ["LAMIN_ENV"] == "local":

{lamindb_setup-1.3.0 → lamindb_setup-1.3.1}/lamindb_setup/core/_settings_instance.py

@@ -59,6 +59,7 @@ class InstanceSettings:
         is_on_hub: bool | None = None,  # initialized from hub
         api_url: str | None = None,
         schema_id: UUID | None = None,
+        fine_grained_access: bool = False,
         _locker_user: UserSettings | None = None,  # user to lock for if cloud sqlite
     ):
         from ._hub_utils import validate_db_arg
@@ -76,9 +77,12 @@ class InstanceSettings:
         self._keep_artifacts_local = keep_artifacts_local
         self._storage_local: StorageSettings | None = None
         self._is_on_hub = is_on_hub
-        # private, needed for writing instance settings
+        # private, needed for api requests
         self._api_url = api_url
         self._schema_id = schema_id
+        # private, whether fine grained access is used
+        # needed to be set to request jwt etc
+        self._fine_grained_access = fine_grained_access
         # if None then settings.user is used
         self._locker_user = _locker_user
 

{lamindb_setup-1.3.0 → lamindb_setup-1.3.1}/lamindb_setup/core/_settings_load.py

@@ -101,6 +101,9 @@ def setup_instance_from_store(store: InstanceSettingsStore) -> InstanceSettings:
         modules=_null_to_value(store.schema_str),
         git_repo=_null_to_value(store.git_repo),
         keep_artifacts_local=store.keep_artifacts_local,  # type: ignore
+        api_url=_null_to_value(store.api_url),
+        schema_id=None if store.schema_id == "null" else UUID(store.schema_id),
+        fine_grained_access=store.fine_grained_access,
     )
 
 

{lamindb_setup-1.3.0 → lamindb_setup-1.3.1}/lamindb_setup/core/_settings_save.py

@@ -60,6 +60,7 @@ def save_settings(
                         "id",
                         "api_url",
                         "schema_id",
+                        "fine_grained_access",
                     }:
                         settings_key = f"_{store_key.rstrip('_')}"
                     else:

{lamindb_setup-1.3.0 → lamindb_setup-1.3.1}/lamindb_setup/core/_settings_storage.py

@@ -150,8 +150,7 @@ def init_storage(
     # the below might update the uid with one that's already taken on the hub
     if not prevent_register_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
+            from ._hub_core import delete_storage_record, init_storage_hub
 
             hub_record_status = init_storage_hub(
                 ssettings,
@@ -175,6 +174,7 @@ def init_storage(
         # only newly created
         if hub_record_status == "hub-record-created" and ssettings._uuid is not None:
             delete_storage_record(ssettings._uuid, access_token=access_token)  # type: ignore
+            ssettings._uuid_ = None
             hub_record_status = "hub-record-not-created"
         ssettings._instance_id = None
     return ssettings, hub_record_status

{lamindb_setup-1.3.0 → lamindb_setup-1.3.1}/lamindb_setup/core/_settings_store.py

@@ -57,6 +57,7 @@ class InstanceSettingsStore(BaseSettings):
     db: Optional[str]  # doesn't like new types on 3.9 even with future annotations
     schema_str: Optional[str]
     schema_id: Optional[str] = None
+    fine_grained_access: bool = False
     id: str
     git_repo: Optional[str]
     keep_artifacts_local: Optional[bool]

{lamindb_setup-1.3.0 → lamindb_setup-1.3.1}/lamindb_setup/core/django.py

@@ -14,7 +14,7 @@ IS_MIGRATING = False
 CONN_MAX_AGE = 299
 
 
-def set_token(token: str | None, connection_name: str = "default"):
+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
@@ -125,6 +125,11 @@ def setup_django(
 
         BaseDatabaseWrapper.close_if_health_check_failed = close_if_health_check_failed
 
+        if isettings._fine_grained_access:
+            from ._hub_core import access_db
+
+            set_db_token(access_db(isettings))
+
     if configure_only:
         return None
 

{lamindb_setup-1.3.0 → lamindb_setup-1.3.1}/noxfile.py

@@ -52,7 +52,9 @@ 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"
+        cmds += (
+            "\nuv pip install --system -e ./laminhub/rest-hub line_profiler sentry_sdk"
+        )
 
     run(session, "uv pip install --system pandera")  # needed to import lamindb
     [run(session, line) for line in cmds.splitlines()]
@@ -85,7 +87,7 @@ def hub_local(session: nox.Session):
     # the -n 1 is to ensure that supabase thread exits properly
     run(
         session,
-        f"pytest -n 1 {COVERAGE_ARGS} ./tests/hub-local",
+        f"pytest {COVERAGE_ARGS} ./tests/hub-local",
         env=os.environ,
     )
 

{lamindb_setup-1.3.0 → lamindb_setup-1.3.1}/pyproject.toml

@@ -11,7 +11,7 @@ dynamic = ["version", "description"]
 dependencies = [
     "lamin_utils>=0.3.3",
     # External dependencies
-    "django>=5,<5.2",
+    "django>=5.1,<5.2",
     "dj_database_url>=1.3.0,<3.0.0",
     "pydantic-settings",
     "appdirs<2.0.0",

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

@@ -0,0 +1,18 @@
+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
+
+# 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)

{lamindb_setup-1.3.0 → lamindb_setup-1.3.1}/tests/hub-local/test_all.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import os
+import subprocess
 from uuid import UUID, uuid4
 
 import lamindb_setup as ln_setup
@@ -13,9 +14,10 @@ from lamindb_setup.core._hub_client import (
 )
 from lamindb_setup.core._hub_core import (
     _connect_instance_hub,
+    access_db,
     connect_instance_hub,
-    init_instance,
-    init_storage,
+    init_instance_hub,
+    init_storage_hub,
     sign_in_hub,
     sign_up_local_hub,
 )
@@ -35,8 +37,14 @@ from lamindb_setup.core._settings_instance import InstanceSettings
 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_store import instance_settings_file
 from lamindb_setup.core._settings_user import UserSettings
+from laminhub_rest.core.access_v2 import OrganizationHandler
 from laminhub_rest.core.instance.collaborator import InstanceCollaboratorHandler
+from laminhub_rest.test.instance.utils import (
+    create_hosted_test_instance,
+    delete_hosted_test_instance,
+)
 from postgrest.exceptions import APIError
 from supafunc.errors import FunctionsHttpError
 
@@ -127,7 +135,7 @@ def create_myinstance(create_testadmin1_session):  # -> Dict
         )[0],
         db=db_str,
     )
-    init_instance(isettings)
+    init_instance_hub(isettings)
     # test loading it
     with pytest.raises(PermissionError) as error:
         ln_setup.connect("testadmin1/myinstance", _test=True)
@@ -159,6 +167,18 @@ def create_myinstance(create_testadmin1_session):  # -> Dict
     yield instance
 
 
+@pytest.fixture(scope="session")
+def create_instance_fine_grained_access(create_testadmin1_session):
+    client, testadmin1 = create_testadmin1_session
+
+    org_handler = OrganizationHandler(client)
+    org_handler.create(testadmin1._uuid)
+
+    instance = create_hosted_test_instance("instance_access_v2", access_v2=True)
+    yield instance
+    delete_hosted_test_instance(instance)
+
+
 def test_connection_string_decomp(create_myinstance, create_testadmin1_session):
     client, _ = create_testadmin1_session
     assert create_myinstance["db_scheme"] == "postgresql"
@@ -357,7 +377,7 @@ def test_init_storage_with_non_existing_bucket(create_testadmin1_session):
     from botocore.exceptions import ClientError
 
     with pytest.raises(ClientError) as error:
-        init_storage(
+        init_storage_hub(
             ssettings=init_storage_base(
                 "s3://non_existing_storage_root", instance_id=uuid4()
             )[0]
@@ -369,3 +389,27 @@ def test_init_storage_incorrect_protocol():
     with pytest.raises(ValueError) as error:
         init_storage_base("incorrect-protocol://some-path/some-path-level")
     assert "Protocol incorrect-protocol is not supported" in error.exconly()
+
+
+def test_fine_grained_access(create_instance_fine_grained_access):
+    instance = create_instance_fine_grained_access
+
+    isettings_file = instance_settings_file(
+        instance.name, ln_setup.settings.user.handle
+    )
+    # the file is written by create_instance_fine_grained_access
+    # has fine_grained_access=False because create_instance_fine_grained_access
+    # updates the instance after init without updating the settings file
+    assert isettings_file.exists()
+    # need to delete it, because otheriwse
+    # isettings.is_remote evaluates to False
+    # and ln_setup.connect doesn't make a hub request
+    # thus fine_grained_access stays False
+    isettings_file.unlink()
+    # run from a script because test_update_schema_in_hub.py has ln_setup.init
+    # which fails if we connect here
+    subprocess.run(
+        "python ./tests/hub-local/scripts/script-connect-fine-grained-access.py",
+        shell=True,
+        check=True,
+    )

{lamindb_setup-1.3.0 → lamindb_setup-1.3.1}/tests/storage/test_storage_access.py

@@ -5,6 +5,7 @@ from uuid import UUID
 
 import lamindb_setup as ln_setup
 import pytest
+from lamindb_setup._init_instance import InstanceNotCreated
 from lamindb_setup.core._hub_client import connect_hub_with_auth
 from lamindb_setup.core._hub_crud import (
     select_account_by_handle,
@@ -33,6 +34,16 @@ def test_connect_instance_with_private_storage_and_no_storage_access():
         path.fs.call_s3("head_bucket", Bucket=path.drive)
 
 
+def test_init_instance_with_private_storage_and_no_storage_access():
+    ln_setup.login("testuser1@lamin.ai")
+    # test creating with no access to a cloud storage
+    with pytest.raises(InstanceNotCreated):
+        ln_setup.init(
+            storage="s3://lndb-setup-ci-eu-central-1/surely-nothing-here",
+            _test=True,
+        )
+
+
 def test_connect_instance_with_public_storage():
     # this loads a persistent instance created with a public s3 bucket
     # with s3:GetObject and s3:ListBucket policies enabled for all

{lamindb_setup-1.3.0 → lamindb_setup-1.3.1}/tests/storage/test_storage_stats.py

@@ -41,9 +41,9 @@ def test_get_stat_file_cloud_http():
     string_path = "https://raw.githubusercontent.com/laminlabs/lamindb-setup/refs/heads/main/README.md"
     path = UPath(string_path)
     size, hash, hash_type = get_stat_file_cloud(path.stat().as_info())
-    assert hash == "jGjepGeCASc6lx1OI23yKw"
+    assert hash == "h3XDCTkMambmtSVpTQetLQ"
     assert hash_type == "md5-etag"
-    assert size == 265
+    assert size == 272
 
 
 def test_get_stat_dir_cloud_aws():