lamindb_setup 1.18.2__py3-none-any.whl → 1.19.1__py3-none-any.whl

lamindb_setup/core/_settings_instance.py

@@ -5,14 +5,8 @@ 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
 
-from ._deprecated import deprecated
-from ._hub_client import call_with_fallback
-from ._hub_crud import select_account_handle_name_by_lnid
-from ._hub_utils import LaminDsn, LaminDsnModel
 from ._settings_save import save_instance_settings
 from ._settings_storage import (
     LEGACY_STORAGE_UID_FILE_KEY,
@@ -85,6 +79,7 @@ class InstanceSettings:
         _locker_user: UserSettings | None = None,  # user to lock for if cloud sqlite,
         _is_clone: bool = False,
     ):
+        # dynamic import to avoid importing pydantic at root
         from ._hub_utils import validate_db_arg
 
         self._id_: UUID = id
@@ -135,6 +130,9 @@ class InstanceSettings:
                     )
             elif attr == "db":
                 if self.dialect != "sqlite":
+                    # dynamic import to avoid importing pydantic at root
+                    from ._hub_utils import LaminDsn, LaminDsnModel
+
                     model = LaminDsnModel(db=value)
                     db_print = LaminDsn.build(
                         scheme=model.db.scheme,
@@ -166,6 +164,7 @@ class InstanceSettings:
     def _search_local_root(
         self, local_root: str | None = None, mute_warning: bool = False
     ) -> StorageSettings | None:
+        from django.db.utils import ProgrammingError
         from lamindb.models import Storage
 
         if local_root is not None:
@@ -364,6 +363,28 @@ class InstanceSettings:
         else:
             return self.api_url.replace("/api", "")
 
+    @property
+    def is_read_only_connection(self) -> bool:
+        """Whether the current connection to the database is read-only."""
+        # should we check for self._is_clone?
+        if self.dialect == "postgresql":
+            db_url = self.db
+            if "read" in db_url or "public" in db_url:
+                return True
+            # works only for the default instance
+            if self._db_permissions == "jwt":
+                from ._settings import settings
+
+                db_token = settings._get_db_token()
+                # should not happen
+                if db_token is None:
+                    logger.warning("DB token is not set")
+                    return False
+                # inits or refreshes the token if needed
+                db_token.token_query  # noqa: B018
+                return db_token._type == "read-only"
+        return False
+
     @property
     def available_spaces(self) -> dict | None:
         """Available spaces with roles for instances fine-grained permissions.
@@ -375,6 +396,7 @@ class InstanceSettings:
         if self._db_permissions != "jwt":
             return None
 
+        from django.db import connection
         from lamindb.models import Space
 
         spaces: dict = {"admin": [], "write": [], "read": []}
@@ -452,6 +474,9 @@ class InstanceSettings:
             sqlite_file.synchronize_to(cache_file, print_progress=True)  # type: ignore
 
     def _check_sqlite_lock(self):
+        from ._hub_client import call_with_fallback
+        from ._hub_crud import select_account_handle_name_by_lnid
+
         if not self._cloud_sqlite_locker.has_lock:
             locked_by = self._cloud_sqlite_locker._locked_by
             lock_msg = "Cannot load the instance, it is locked by "
@@ -560,7 +585,7 @@ class InstanceSettings:
         Will return `False` in case the user token can't find the instance.
         """
         if self._is_on_hub is None:
-            from ._hub_client import call_with_fallback_auth
+            from ._hub_client import call_with_fallback, call_with_fallback_auth
             from ._hub_crud import select_instance_by_id
             from ._settings import settings
 

lamindb_setup/core/_settings_load.py

@@ -1,159 +1,162 @@
-from __future__ import annotations
-
-import os
-from importlib.util import find_spec
-from pathlib import Path
-from typing import TYPE_CHECKING
-from uuid import UUID, uuid4
-
-from dotenv import dotenv_values
-from lamin_utils import logger
-from pydantic import ValidationError
-
-from lamindb_setup.errors import CurrentInstanceNotConfigured, SettingsEnvFileOutdated
-
-from ._settings_instance import InstanceSettings
-from ._settings_storage import StorageSettings
-from ._settings_store import (
-    InstanceSettingsStore,
-    UserSettingsStore,
-    current_instance_settings_file,
-    current_user_settings_file,
-    platform_user_storage_settings_file,
-    system_settings_file,
-)
-from ._settings_user import UserSettings
-
-
-def load_cache_path_from_settings(storage_settings: Path | None = None) -> Path | None:
-    if storage_settings is None:
-        paltform_user_storage_settings = platform_user_storage_settings_file()
-        if paltform_user_storage_settings.exists():
-            cache_path = dotenv_values(paltform_user_storage_settings).get(
-                "lamindb_cache_path", None
-            )
-        else:
-            cache_path = None
-
-        if cache_path in {None, "null", ""}:
-            storage_settings = system_settings_file()
-        else:
-            return Path(cache_path)
-
-    if storage_settings.exists():
-        cache_path = dotenv_values(storage_settings).get("lamindb_cache_path", None)
-        return Path(cache_path) if cache_path not in {None, "null", ""} else None
-    else:
-        return None
-
-
-def find_module_candidates():
-    """Find all local packages that depend on lamindb."""
-    candidates = ["bionty", "pertdb"]
-    return [c for c in candidates if find_spec(c) is not None]
-
-
-def load_instance_settings(instance_settings_file: Path | None = None):
-    if instance_settings_file is None:
-        isettings_file = current_instance_settings_file()
-        if not isettings_file.exists():
-            isettings = InstanceSettings(
-                id=UUID("00000000-0000-0000-0000-000000000000"),
-                owner="none",
-                name="none",
-                storage=None,
-                modules=",".join(find_module_candidates()),
-            )
-            return isettings
-    else:
-        isettings_file = instance_settings_file
-
-    if not isettings_file.exists():
-        # this errors only if the file was explicitly provided
-        raise CurrentInstanceNotConfigured
-    try:
-        settings_store = InstanceSettingsStore(_env_file=isettings_file)
-    except (ValidationError, TypeError) as error:
-        raise SettingsEnvFileOutdated(
-            f"\n\n{error}\n\nYour instance settings file with\n\n{isettings_file.read_text()}\nis invalid"
-            f" (likely outdated), see validation error. Please delete {isettings_file} &"
-            " reload (remote) or re-initialize (local) the instance with the same name & storage location."
-        ) from error
-    isettings = setup_instance_from_store(settings_store)
-    return isettings
-
-
-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():
-        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
-
-        save_user_settings(usettings)
-    else:
-        usettings = load_user_settings(current_user_settings)
-    return usettings
-
-
-def load_user_settings(user_settings_file: Path):
-    try:
-        settings_store = UserSettingsStore(_env_file=user_settings_file)
-    except (ValidationError, TypeError) as error:
-        msg = (
-            "Your user settings file is invalid, please delete"
-            f" {user_settings_file} and log in again."
-        )
-        print(msg)
-        raise SettingsEnvFileOutdated(msg) from error
-    settings = setup_user_from_store(settings_store)
-    return settings
-
-
-def _null_to_value(field, value=None):
-    return field if field != "null" else value
-
-
-def setup_instance_from_store(store: InstanceSettingsStore) -> InstanceSettings:
-    ssettings = StorageSettings(
-        root=store.storage_root,
-        region=_null_to_value(store.storage_region),
-    )
-    return InstanceSettings(
-        id=UUID(store.id),
-        owner=store.owner,
-        name=store.name,
-        storage=ssettings,
-        db=_null_to_value(store.db),
-        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 in {None, "null"} else UUID(store.schema_id),
-        fine_grained_access=store.fine_grained_access,
-        db_permissions=_null_to_value(store.db_permissions),
-        _is_clone=store.is_clone,
-    )
-
-
-def setup_user_from_store(store: UserSettingsStore) -> UserSettings:
-    settings = UserSettings()
-    settings.email = _null_to_value(store.email)
-    settings.password = _null_to_value(store.password)
-    settings.access_token = store.access_token
-    settings.api_key = _null_to_value(store.api_key)
-    settings.uid = store.uid
-    settings.handle = _null_to_value(store.handle, value="anonymous")
-    settings.name = _null_to_value(store.name)
-    settings._uuid = UUID(store.uuid) if store.uuid != "null" else None
-    return settings
+from __future__ import annotations
+
+import os
+from importlib.util import find_spec
+from pathlib import Path
+from typing import TYPE_CHECKING
+from uuid import UUID, uuid4
+
+from dotenv import dotenv_values
+from lamin_utils import logger
+
+from lamindb_setup.errors import CurrentInstanceNotConfigured, SettingsEnvFileOutdated
+
+from ._settings_instance import InstanceSettings
+from ._settings_storage import StorageSettings
+from ._settings_store import (
+    InstanceSettingsStore,
+    UserSettingsStore,
+    current_instance_settings_file,
+    current_user_settings_file,
+    platform_user_storage_settings_file,
+    system_settings_file,
+)
+from ._settings_user import UserSettings
+
+
+def load_cache_path_from_settings(storage_settings: Path | None = None) -> Path | None:
+    if storage_settings is None:
+        paltform_user_storage_settings = platform_user_storage_settings_file()
+        if paltform_user_storage_settings.exists():
+            cache_path = dotenv_values(paltform_user_storage_settings).get(
+                "lamindb_cache_path", None
+            )
+        else:
+            cache_path = None
+
+        if cache_path in {None, "null", ""}:
+            storage_settings = system_settings_file()
+        else:
+            return Path(cache_path)
+
+    if storage_settings.exists():
+        cache_path = dotenv_values(storage_settings).get("lamindb_cache_path", None)
+        return Path(cache_path) if cache_path not in {None, "null", ""} else None
+    else:
+        return None
+
+
+def find_module_candidates():
+    """Find all local packages that depend on lamindb."""
+    candidates = ["bionty", "pertdb"]
+    return [c for c in candidates if find_spec(c) is not None]
+
+
+def load_instance_settings(instance_settings_file: Path | None = None):
+    if instance_settings_file is None:
+        isettings_file = current_instance_settings_file()
+        if not isettings_file.exists():
+            isettings = InstanceSettings(
+                id=UUID("00000000-0000-0000-0000-000000000000"),
+                owner="none",
+                name="none",
+                storage=None,
+                modules=",".join(find_module_candidates()),
+            )
+            return isettings
+    else:
+        isettings_file = instance_settings_file
+
+    if not isettings_file.exists():
+        # this errors only if the file was explicitly provided
+        raise CurrentInstanceNotConfigured
+    try:
+        settings_store = InstanceSettingsStore.from_env_file(
+            isettings_file, "lamindb_instance_"
+        )
+    except (ValueError, KeyError, TypeError) as error:
+        raise SettingsEnvFileOutdated(
+            f"\n\n{error}\n\nYour instance settings file with\n\n{isettings_file.read_text()}\nis invalid"
+            f" (likely outdated), see validation error. Please delete {isettings_file} &"
+            " reload (remote) or re-initialize (local) the instance with the same name & storage location."
+        ) from error
+    isettings = setup_instance_from_store(settings_store)
+    return isettings
+
+
+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():
+        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
+
+        save_user_settings(usettings)
+    else:
+        usettings = load_user_settings(current_user_settings)
+    return usettings
+
+
+def load_user_settings(user_settings_file: Path):
+    try:
+        settings_store = UserSettingsStore.from_env_file(
+            user_settings_file, "lamin_user_"
+        )
+    except (ValueError, KeyError, TypeError) as error:
+        msg = (
+            "Your user settings file is invalid, please delete"
+            f" {user_settings_file} and log in again."
+        )
+        print(msg)
+        raise SettingsEnvFileOutdated(msg) from error
+    settings = setup_user_from_store(settings_store)
+    return settings
+
+
+def _null_to_value(field, value=None):
+    return value if field in (None, "null") else field
+
+
+def setup_instance_from_store(store: InstanceSettingsStore) -> InstanceSettings:
+    ssettings = StorageSettings(
+        root=store.storage_root,
+        region=_null_to_value(store.storage_region),
+    )
+    return InstanceSettings(
+        id=UUID(store.id),
+        owner=store.owner,
+        name=store.name,
+        storage=ssettings,
+        db=_null_to_value(store.db),
+        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 in {None, "null"} else UUID(store.schema_id),
+        fine_grained_access=store.fine_grained_access,
+        db_permissions=_null_to_value(store.db_permissions),
+        _is_clone=store.is_clone,
+    )
+
+
+def setup_user_from_store(store: UserSettingsStore) -> UserSettings:
+    settings = UserSettings()
+    settings.email = _null_to_value(store.email)
+    settings.password = _null_to_value(store.password)
+    settings.access_token = store.access_token
+    settings.api_key = _null_to_value(store.api_key)
+    settings.uid = store.uid
+    settings.handle = _null_to_value(store.handle, value="anonymous")
+    settings.name = _null_to_value(store.name)
+    settings._uuid = UUID(store.uuid) if store.uuid not in (None, "null") else None
+    return settings

lamindb_setup/core/_settings_save.py

@@ -1,96 +1,108 @@
-from __future__ import annotations
-
-from pathlib import Path
-from typing import TYPE_CHECKING, Any, Optional, get_type_hints
-from uuid import UUID
-
-from ._settings_store import (
-    InstanceSettingsStore,
-    UserSettingsStore,
-    current_user_settings_file,
-    platform_user_storage_settings_file,
-    user_settings_file_email,
-    user_settings_file_handle,
-)
-
-if TYPE_CHECKING:
-    from lamindb_setup.types import UPathStr
-
-    from ._settings_user import UserSettings
-
-
-def save_user_settings(settings: UserSettings):
-    type_hints = get_type_hints(UserSettingsStore)
-    prefix = "lamin_user_"
-    save_settings(settings, current_user_settings_file(), type_hints, prefix)
-    if settings.email is not None:
-        save_settings(
-            settings, user_settings_file_email(settings.email), type_hints, prefix
-        )
-    if settings.handle is not None and settings.handle != "anonymous":
-        save_settings(
-            settings, user_settings_file_handle(settings.handle), type_hints, prefix
-        )
-
-
-def save_settings(
-    settings: Any,
-    settings_file: Path,
-    type_hints: dict[str, Any],
-    prefix: str,
-):
-    with open(settings_file, "w") as f:
-        for store_key, type_ in type_hints.items():
-            if type_ == Optional[str]:  # noqa: UP045
-                type_ = str
-            if type_ == Optional[bool]:  # noqa: UP045
-                type_ = bool
-            if "__" not in store_key:
-                if store_key == "model_config":
-                    continue
-                if store_key == "storage_root":
-                    value = settings.storage.root_as_str
-                elif store_key == "storage_region":
-                    value = settings.storage.region
-                else:
-                    if store_key in {
-                        "db",
-                        "schema_str",
-                        "name_",
-                        "uuid",
-                        "id",
-                        "api_url",
-                        "schema_id",
-                        "fine_grained_access",
-                        "db_permissions",
-                        "is_clone",
-                    }:
-                        settings_key = f"_{store_key.rstrip('_')}"
-                    else:
-                        settings_key = store_key
-                    value = getattr(settings, settings_key, None)
-                if value is None:
-                    value = "null"
-                elif isinstance(value, UUID):
-                    value = value.hex
-                else:
-                    value = type_(value)
-                f.write(f"{prefix}{store_key}={value}\n")
-
-
-def save_instance_settings(settings: Any, settings_file: Path):
-    type_hints = get_type_hints(InstanceSettingsStore)
-    prefix = "lamindb_instance_"
-    save_settings(settings, settings_file, type_hints, prefix)
-
-
-def save_platform_user_storage_settings(
-    cache_path: UPathStr | None, settings_file: UPathStr | None = None
-):
-    cache_path = "null" if cache_path is None else cache_path
-    if isinstance(cache_path, Path):  # also True for UPath
-        cache_path = cache_path.as_posix()
-    if settings_file is None:
-        settings_file = platform_user_storage_settings_file()
-    with open(settings_file, "w") as f:
-        f.write(f"lamindb_cache_path={cache_path}")
+from __future__ import annotations
+
+from pathlib import Path
+from typing import TYPE_CHECKING, Any, Optional, get_args, get_type_hints
+from uuid import UUID
+
+from ._settings_store import (
+    InstanceSettingsStore,
+    UserSettingsStore,
+    current_user_settings_file,
+    platform_user_storage_settings_file,
+    user_settings_file_email,
+    user_settings_file_handle,
+)
+
+if TYPE_CHECKING:
+    from lamindb_setup.types import UPathStr
+
+    from ._settings_user import UserSettings
+
+
+def save_user_settings(settings: UserSettings):
+    type_hints = get_type_hints(UserSettingsStore)
+    prefix = "lamin_user_"
+    save_settings(settings, current_user_settings_file(), type_hints, prefix)
+    if settings.email is not None:
+        save_settings(
+            settings, user_settings_file_email(settings.email), type_hints, prefix
+        )
+    if settings.handle is not None and settings.handle != "anonymous":
+        save_settings(
+            settings, user_settings_file_handle(settings.handle), type_hints, prefix
+        )
+
+
+def _coerce_type_for_write(type_: Any) -> Any:
+    """Resolve union types to the non-None part for coercion when value is not None."""
+    if type_ in (str, bool):
+        return type_
+    if type_ == Optional[str]:  # noqa: UP045
+        return str
+    if type_ == Optional[bool]:  # noqa: UP045
+        return bool
+    args = get_args(type_) or ()
+    if type(None) in args:
+        non_none = next((a for a in args if a is not type(None)), type_)
+        return non_none if non_none in (str, bool) else type_
+    return type_
+
+
+def save_settings(
+    settings: Any,
+    settings_file: Path,
+    type_hints: dict[str, Any],
+    prefix: str,
+):
+    with open(settings_file, "w") as f:
+        for store_key, type_ in type_hints.items():
+            type_ = _coerce_type_for_write(type_)
+            if "__" not in store_key:
+                if store_key == "model_config":
+                    continue
+                if store_key == "storage_root":
+                    value = settings.storage.root_as_str
+                elif store_key == "storage_region":
+                    value = settings.storage.region
+                else:
+                    if store_key in {
+                        "db",
+                        "schema_str",
+                        "name_",
+                        "uuid",
+                        "id",
+                        "api_url",
+                        "schema_id",
+                        "fine_grained_access",
+                        "db_permissions",
+                        "is_clone",
+                    }:
+                        settings_key = f"_{store_key.rstrip('_')}"
+                    else:
+                        settings_key = store_key
+                    value = getattr(settings, settings_key, None)
+                if value is None:
+                    value = "null"
+                elif isinstance(value, UUID):
+                    value = value.hex
+                else:
+                    value = type_(value)
+                f.write(f"{prefix}{store_key}={value}\n")
+
+
+def save_instance_settings(settings: Any, settings_file: Path):
+    type_hints = get_type_hints(InstanceSettingsStore)
+    prefix = "lamindb_instance_"
+    save_settings(settings, settings_file, type_hints, prefix)
+
+
+def save_platform_user_storage_settings(
+    cache_path: UPathStr | None, settings_file: UPathStr | None = None
+):
+    cache_path = "null" if cache_path is None else cache_path
+    if isinstance(cache_path, Path):  # also True for UPath
+        cache_path = cache_path.as_posix()
+    if settings_file is None:
+        settings_file = platform_user_storage_settings_file()
+    with open(settings_file, "w") as f:
+        f.write(f"lamindb_cache_path={cache_path}")