lamindb_setup 1.10.0__tar.gz → 1.10.1__tar.gz

{lamindb_setup-1.10.0 → lamindb_setup-1.10.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: lamindb_setup
-Version: 1.10.0
+Version: 1.10.1
 Summary: Setup & configure LaminDB.
 Author-email: Lamin Labs <open-source@lamin.ai>
 Requires-Python: >=3.10
@@ -27,7 +27,7 @@ Requires-Dist: psycopg2-binary ; extra == "dev"
 Requires-Dist: python-dotenv ; extra == "dev"
 Requires-Dist: nox ; extra == "dev"
 Requires-Dist: pytest>=6.0 ; extra == "dev"
-Requires-Dist: pytest-cov ; extra == "dev"
+Requires-Dist: pytest-cov<7.0.0 ; extra == "dev"
 Requires-Dist: pytest-xdist ; extra == "dev"
 Requires-Dist: nbproject-test>=0.4.3 ; extra == "dev"
 Requires-Dist: pandas ; extra == "dev"

{lamindb_setup-1.10.0 → lamindb_setup-1.10.1}/docs/hub-cloud/02-connect-local-instance.ipynb

@@ -60,10 +60,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "# bionty is not in the (schema) modules of mydata\n",
-    "# _check_instance_setup is called inside with from_module=None\n",
-    "# the branch where django is not setup yet\n",
-    "# as from_module=None it won't connect to an instance here\n",
+    "# no instance connected, prompts to connect\n",
     "import bionty"
    ]
   },
@@ -79,6 +76,17 @@
     ")  # also test passing _reload_lamindb explicitly"
    ]
   },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "5a59b8d0",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# this is a local intstance, no spaces needed\n",
+    "assert ln_setup.settings.instance.available_spaces is None"
+   ]
+  },
   {
    "cell_type": "code",
    "execution_count": null,
@@ -88,8 +96,7 @@
    "source": [
     "# wetlab is not in the (schema) modules of mydata\n",
     "with pytest.raises(ModuleWasntConfigured):\n",
-    "    # _check_instance_setup is called inside with from_module=None\n",
-    "    # the branch where django is setup\n",
+    "    # _check_instance_setup is called inside\n",
     "    import wetlab"
    ]
   },
@@ -100,12 +107,9 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "# wetlab is not in the (schema) modules of mydata\n",
+    "# bionty is not in the (schema) modules of mydata\n",
     "with pytest.raises(ModuleWasntConfigured):\n",
-    "    # _check_instance_setup is called inside with from_module=\"bionty\"\n",
-    "    # the branch where django is setup\n",
-    "    # in __getattr__ in __init__.py\n",
-    "    bionty.CellType"
+    "    import bionty"
    ]
   },
   {

lamindb_setup-1.10.1/docs/hub-cloud/09-test-migrate.ipynb

@@ -0,0 +1,94 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "5acb0094",
+   "metadata": {},
+   "source": [
+    "# Migrate a hosted instance"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "213594a4",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import lamindb_setup as ln_setup"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "0a310f89",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "ln_setup.login(\"testuser1\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "eecceaf0",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "ln_setup.connect(\"laminlabs/lamindata\", use_root_db_user=True)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "ffb9b496",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# double connect to check migration with django reset\n",
+    "ln_setup.connect(\"laminlabs/lamindata\", use_root_db_user=True)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "e9887c91",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "assert \"root\" in ln_setup.settings.instance.db"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "657de4c6",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "ln_setup.migrate.deploy()"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.10.16"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

{lamindb_setup-1.10.0 → lamindb_setup-1.10.1}/docs/hub-prod/test-import-schema.ipynb

@@ -1,7 +1,6 @@
 {
  "cells": [
   {
-   "attachments": {},
    "cell_type": "markdown",
    "id": "261ca5e4-f46f-4361-9c3e-f944bbe14484",
    "metadata": {},
@@ -16,7 +15,7 @@
    "source": [
     "Also see the corresponding FAQ notebook in lamindb: `import-modules`.\n",
     "\n",
-    "If you try to access an attribute (other than `model`), you'll load the instance in the same way as calling `import lamindb`."
+    "You'll load the instance in the same way as calling `import lamindb` when you import a schema module."
    ]
   },
   {
@@ -60,7 +59,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "assert not lamindb_setup.core.django.IS_SETUP"
+    "assert lamindb_setup.core.django.IS_SETUP"
    ]
   },
   {
@@ -110,7 +109,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.10.13"
+   "version": "3.10.16"
   },
   "nbproject": {
    "id": "2lhqA4uTKSFP",

{lamindb_setup-1.10.0 → lamindb_setup-1.10.1}/lamindb_setup/__init__.py

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

{lamindb_setup-1.10.0 → lamindb_setup-1.10.1}/lamindb_setup/_connect_instance.py

@@ -24,6 +24,7 @@ from .core._settings_load import load_instance_settings
 from .core._settings_storage import StorageSettings
 from .core._settings_store import instance_settings_file, settings_dir
 from .core.cloud_sqlite_locker import unlock_cloud_sqlite_upon_exception
+from .core.django import reset_django
 from .errors import CannotSwitchDefaultInstance
 
 if TYPE_CHECKING:
@@ -101,6 +102,7 @@ def _connect_instance(
     *,
     db: str | None = None,
     raise_permission_error: bool = True,
+    use_root_db_user: bool = False,
     access_token: str | None = None,
 ) -> InstanceSettings:
     settings_file = instance_settings_file(name, owner)
@@ -120,7 +122,10 @@ def _connect_instance(
         # do not call hub if the user is anonymous
         if owner != "anonymous":
             hub_result = connect_instance_hub(
-                owner=owner, name=name, access_token=access_token
+                owner=owner,
+                name=name,
+                access_token=access_token,
+                use_root_db_user=use_root_db_user,
             )
         else:
             hub_result = "anonymous-user"
@@ -155,7 +160,9 @@ 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),
+                fine_grained_access=bool(
+                    instance_result["fine_grained_access"]
+                ),  # can be None
                 db_permissions=instance_result.get("db_permissions", None),
             )
         else:
@@ -186,6 +193,8 @@ def reset_django_module_variables():
     # to the old classes
     # There doesn't seem to be an easy way to fix this problem
 
+    logger.important_hint("resetting django module variables")
+
     import types
 
     from django.apps import apps
@@ -230,12 +239,11 @@ def reset_django_module_variables():
                 continue
 
 
-def _connect_cli(instance: str) -> None:
+def _connect_cli(instance: str, use_root_db_user: bool = False) -> None:
     from lamindb_setup import settings as settings_
 
-    settings_.auto_connect = True
     owner, name = get_owner_name_from_identifier(instance)
-    isettings = _connect_instance(owner, name)
+    isettings = _connect_instance(owner, name, use_root_db_user=use_root_db_user)
     isettings._persist(write_to_disk=True)
     if not isettings.is_on_hub or isettings._is_cloud_sqlite:
         # there are two reasons to call the full-blown connect
@@ -262,6 +270,7 @@ def connect(instance: str | None = None, **kwargs: Any) -> str | tuple | None:
     """
     # validate kwargs
     valid_kwargs = {
+        "use_root_db_user",
         "_db",
         "_write_settings",
         "_raise_not_found_error",
@@ -274,6 +283,7 @@ def connect(instance: str | None = None, **kwargs: Any) -> str | tuple | None:
             raise TypeError(f"connect() got unexpected keyword argument '{kwarg}'")
     isettings: InstanceSettings = None  # type: ignore
     # _db is still needed because it is called in init
+    use_root_db_user: bool = kwargs.get("use_root_db_user", False)
     _db: str | None = kwargs.get("_db", None)
     _write_settings: bool = kwargs.get("_write_settings", False)
     _raise_not_found_error: bool = kwargs.get("_raise_not_found_error", True)
@@ -289,12 +299,18 @@ def connect(instance: str | None = None, **kwargs: Any) -> str | tuple | None:
 
     try:
         if instance is None:
-            isettings_or_none = _get_current_instance_settings()
-            if isettings_or_none is None:
-                raise ValueError(
-                    "No instance was connected through the CLI, pass a value to `instance` or connect via the CLI."
-                )
-            isettings = isettings_or_none
+            if settings._instance_exists:
+                isettings = settings.instance
+            else:
+                isettings_or_none = _get_current_instance_settings()
+                if isettings_or_none is None:
+                    raise ValueError(
+                        "No instance was connected through the CLI, pass a value to `instance` or connect via the CLI."
+                    )
+                isettings = isettings_or_none
+            if use_root_db_user:
+                reset_django()
+                owner, name = isettings.owner, isettings.name
             if _db is not None and isettings.dialect == "postgresql":
                 isettings._db = _db
         else:
@@ -310,14 +326,13 @@ def connect(instance: str | None = None, **kwargs: Any) -> str | tuple | None:
                     # could be made more specific by checking whether the django
                     # configured database is the same as the one in settings
                     and connection.settings_dict["NAME"] != ":memory:"
+                    and not use_root_db_user  # always re-connect for root db user
                 ):
                     logger.important(
                         f"doing nothing, already connected lamindb: {settings.instance.slug}"
                     )
                     return None
                 else:
-                    from lamindb_setup.core.django import reset_django
-
                     if (
                         settings._instance_exists
                         and settings.instance.slug != "none/none"
@@ -328,11 +343,6 @@ def connect(instance: str | None = None, **kwargs: Any) -> str | tuple | None:
                             raise CannotSwitchDefaultInstance(
                                 "Cannot switch default instance while `ln.track()` is live: call `ln.finish()`"
                             )
-                        else:
-                            logger.important_hint(
-                                "switching the default lamindb instance might produce unexpected side effects with function-scoped imports: "
-                                "please import lamindb at the module level instead of inside functions"
-                            )
                     reset_django()
             elif (
                 _write_settings
@@ -341,9 +351,14 @@ def connect(instance: str | None = None, **kwargs: Any) -> str | tuple | None:
             ):
                 disconnect(mute=True)
 
+        if instance is not None or use_root_db_user:
             try:
                 isettings = _connect_instance(
-                    owner, name, db=_db, access_token=access_token
+                    owner,
+                    name,
+                    db=_db,
+                    access_token=access_token,
+                    use_root_db_user=use_root_db_user,
                 )
             except InstanceNotFoundError as e:
                 if _raise_not_found_error:

{lamindb_setup-1.10.0 → lamindb_setup-1.10.1}/lamindb_setup/_migrate.py

@@ -93,17 +93,13 @@ class migrate:
     @disable_auto_connect
     def create(cls) -> None:
         """Create a migration."""
-        if _check_instance_setup():
-            raise RuntimeError("Restart Python session to create migration or use CLI!")
         setup_django(settings.instance, create_migrations=True)
 
     @classmethod
     def deploy(cls, package_name: str | None = None, number: int | None = None) -> None:
         """Deploy a migration."""
-        from ._schema_metadata import update_schema_in_hub
-
-        if _check_instance_setup():
-            raise RuntimeError("Restart Python session to migrate or use CLI!")
+        from lamindb_setup._connect_instance import connect
+        from lamindb_setup._schema_metadata import update_schema_in_hub
         from lamindb_setup.core._hub_client import call_with_fallback_auth
         from lamindb_setup.core._hub_crud import (
             select_collaborator,
@@ -117,12 +113,17 @@ class migrate:
                 select_collaborator,
                 instance_id=settings.instance._id,
                 account_id=settings.user._uuid,
+                fine_grained_access=settings.instance._fine_grained_access,
             )
             if collaborator is None or collaborator["role"] != "admin":
                 raise SystemExit(
                     "❌ Only admins can deploy migrations, please ensure that you're an"
                     f" admin: https://lamin.ai/{settings.instance.slug}/settings"
                 )
+            # ensure we connect with the root user
+            if "root" not in settings.instance.db:
+                connect(use_root_db_user=True)
+                assert "root" in (instance_db := settings.instance.db), instance_db
             # we need lamindb to be installed, otherwise we can't populate the version
             # information in the hub
             import lamindb
@@ -139,7 +140,6 @@ class migrate:
         # this populates the hub
         if settings.instance.is_on_hub:
             logger.important(f"updating lamindb version in hub: {lamindb.__version__}")
-            # TODO: integrate update of instance table within update_schema_in_hub & below
             if settings.instance.dialect != "sqlite":
                 update_schema_in_hub()
             call_with_fallback_auth(

{lamindb_setup-1.10.0 → lamindb_setup-1.10.1}/lamindb_setup/core/_deprecated.py

@@ -51,7 +51,7 @@ def deprecated(new_name: str):
             warnings.warn(
                 f"Use {new_name} instead of {func.__name__}, "
                 f"{func.__name__} will be removed in the future.",
-                category=FutureWarning,
+                category=DeprecationWarning,
                 stacklevel=2,
             )
             return func(*args, **kwargs)

{lamindb_setup-1.10.0 → lamindb_setup-1.10.1}/lamindb_setup/core/_hub_core.py

@@ -424,6 +424,7 @@ def _init_instance_hub(
 def _connect_instance_hub(
     owner: str,  # account_handle
     name: str,  # instance_name
+    use_root_db_user: bool,
     client: Client,
 ) -> tuple[dict, dict] | str:
     response = client.functions.invoke(
@@ -475,17 +476,29 @@ def _connect_instance_hub(
 
     if instance["db_scheme"] is not None:
         db_user_name, db_user_password = None, None
-        if "db_user_name" in instance and "db_user_password" in instance:
+        if (
+            "db_user_name" in instance
+            and "db_user_password" in instance
+            and not use_root_db_user
+        ):
             db_user_name, db_user_password = (
                 instance["db_user_name"],
                 instance["db_user_password"],
             )
         else:
-            db_user = select_db_user_by_instance(instance["id"], client)
+            if use_root_db_user:
+                fine_grained_access = False
+            else:
+                fine_grained_access = bool(
+                    instance["fine_grained_access"]
+                )  # can be None
+            db_user = select_db_user_by_instance(
+                instance["id"], fine_grained_access, client
+            )
             if db_user is not None:
                 db_user_name, db_user_password = (
-                    db_user["db_user_name"],
-                    db_user["db_user_password"],
+                    db_user["name" if fine_grained_access else "db_user_name"],
+                    db_user["password" if fine_grained_access else "db_user_password"],
                 )
         db_dsn = LaminDsn.build(
             scheme=instance["db_scheme"],
@@ -505,15 +518,25 @@ def connect_instance_hub(
     owner: str,  # account_handle
     name: str,  # instance_name
     access_token: str | None = None,
+    use_root_db_user: bool = False,
 ) -> tuple[dict, dict] | str:
     from ._settings import settings
 
     if settings.user.handle != "anonymous" or access_token is not None:
         return call_with_fallback_auth(
-            _connect_instance_hub, owner=owner, name=name, access_token=access_token
+            _connect_instance_hub,
+            owner=owner,
+            name=name,
+            use_root_db_user=use_root_db_user,
+            access_token=access_token,
         )
     else:
-        return call_with_fallback(_connect_instance_hub, owner=owner, name=name)
+        return call_with_fallback(
+            _connect_instance_hub,
+            owner=owner,
+            name=name,
+            use_root_db_user=use_root_db_user,
+        )
 
 
 def access_aws(storage_root: str, access_token: str | None = None) -> dict[str, dict]:
@@ -570,7 +593,7 @@ def access_db(
     if isinstance(instance, InstanceSettings):
         instance_id = instance._id
         instance_slug = instance.slug
-        instance_api_url = instance._api_url
+        instance_api_url = instance.api_url
     else:
         instance_id = UUID(instance["id"])
         instance_slug = instance["owner"] + "/" + instance["name"]

{lamindb_setup-1.10.0 → lamindb_setup-1.10.1}/lamindb_setup/core/_hub_crud.py

@@ -137,10 +137,12 @@ def update_instance(instance_id: str, instance_fields: dict, client: Client):
 def select_collaborator(
     instance_id: str,
     account_id: str,
+    fine_grained_access: bool,
     client: Client,
 ):
+    table = "access_instance" if fine_grained_access else "account_instance"
     data = (
-        client.table("account_instance")
+        client.table(table)
         .select("*")
         .eq("instance_id", instance_id)
         .eq("account_id", account_id)
@@ -180,35 +182,53 @@ def insert_db_user(
     db_user_name: str,
     db_user_password: str,
     instance_id: UUID,
+    fine_grained_access: bool,
     client: Client,
 ) -> None:
-    fields = (
-        {
-            "id": uuid4().hex,
-            "instance_id": instance_id.hex,
-            "name": name,
-            "db_user_name": db_user_name,
-            "db_user_password": db_user_password,
-        },
-    )
-    data = client.table("db_user").insert(fields).execute().data
+    fields = {"instance_id": instance_id.hex}
+    if fine_grained_access:
+        table = "access_db_user"
+        fields.update(
+            {
+                "name": db_user_name,
+                "password": db_user_password,
+                "type": name,
+            }
+        )
+    else:
+        table = "db_user"
+        fields.update(
+            {
+                "id": uuid4().hex,
+                "name": name,
+                "db_user_name": db_user_name,
+                "db_user_password": db_user_password,
+            }
+        )
+
+    data = client.table(table).insert(fields).execute().data
     return data[0]
 
 
-def select_db_user_by_instance(instance_id: str, client: Client):
+def select_db_user_by_instance(
+    instance_id: str, fine_grained_access: bool, client: Client
+):
     """Get db_user for which client has permission."""
-    data = (
-        client.table("db_user")
-        .select("*")
-        .eq("instance_id", instance_id)
-        .execute()
-        .data
-    )
+    if fine_grained_access:
+        table = "access_db_user"
+        type_name = "type"
+        type_priority = "jwt"
+    else:
+        table = "db_user"
+        type_name = "name"
+        type_priority = "write"
+
+    data = client.table(table).select("*").eq("instance_id", instance_id).execute().data
     if len(data) == 0:
         return None
     elif len(data) > 1:
         for item in data:
-            if item["name"] == "write":
+            if item[type_name] == type_priority:
                 return item
         logger.warning("found multiple db credentials, using the first one")
     return data[0]

{lamindb_setup-1.10.0 → lamindb_setup-1.10.1}/lamindb_setup/core/_settings.py

@@ -79,24 +79,15 @@ class SetupSettings:
     def auto_connect(self) -> bool:
         """Auto-connect to current instance upon `import lamindb`.
 
-        Upon installing `lamindb`, this setting is `False`.
-
-        Upon calling `lamin init` or `lamin connect` on the CLI, this setting is switched to `True`.
-
-        `ln.connect()` doesn't change the value of this setting.
-
-        You can manually change this setting
-
-        - in Python: `ln.setup.settings.auto_connect = True/False`
-        - via the CLI: `lamin settings set auto-connect true/false`
+        This setting is always `True` and will be removed in a future version.
         """
         return True
 
     @auto_connect.setter
     def auto_connect(self, value: bool) -> None:
-        # logger.warning(
-        #     "setting auto_connect to `False` no longer has an effect and the setting will likely be removed in the future; since lamindb 1.7, auto_connect `True` no longer clashes with connecting in a Python session",
-        # )
+        logger.warning(
+            "setting auto_connect to `False` no longer has an effect and the setting will likely be removed in the future",
+        )
         if value:
             self._auto_connect_path.touch()
         else:
@@ -324,7 +315,6 @@ class SetupSettings:
         else:
             repr += "Current instance: None"
         repr += "\nConfig:\n"
-        repr += f" - auto-connect in Python: {self.auto_connect}\n"
         repr += f" - private Django API: {self.private_django_api}\n"
         repr += "Local directories:\n"
         repr += f" - cache: {self.cache_dir.as_posix()}\n"

{lamindb_setup-1.10.0 → lamindb_setup-1.10.1}/lamindb_setup/core/_settings_instance.py

@@ -5,6 +5,7 @@ import shutil
 from pathlib import Path
 from typing import TYPE_CHECKING, Literal
 
+from django.db import connection
 from django.db.utils import ProgrammingError
 from lamin_utils import logger
 
@@ -343,6 +344,37 @@ class InstanceSettings:
         """
         return self._git_repo
 
+    @property
+    def api_url(self) -> str | None:
+        """URL for REST API.
+
+        Use this URL for API calls related to this instance.
+        """
+        return self._api_url
+
+    @property
+    def available_spaces(self) -> dict | None:
+        """Available spaces with roles for instances fine-grained permissions.
+
+        Returns a dictionary with roles as keys and lists of available spaces
+        as values if this instance has fine-grained permissions and the current user
+        is a collaborator, `None` otherwise.
+        """
+        if self._db_permissions != "jwt":
+            return None
+
+        from lamindb.models import Space
+
+        spaces: dict = {"admin": [], "write": [], "read": []}
+        with connection.cursor() as cur:
+            cur.execute("SELECT * FROM check_access() WHERE type = 'space'")
+            rows = cur.fetchall()
+        for row in rows:
+            spaces[row[1]].append(row[0])
+        return {
+            k: Space.filter(id__in=v).to_list() if v else [] for k, v in spaces.items()
+        }
+
     @property
     def _id(self) -> UUID:
         """The internal instance id."""