lamindb_setup 0.78.0__py3-none-any.whl

lamindb_setup/core/_hub_crud.py

@@ -0,0 +1,211 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+from uuid import UUID, uuid4
+
+from lamin_utils import logger
+from supabase.client import Client  # noqa
+
+
+def select_instance_by_owner_name(
+    owner: str,
+    name: str,
+    client: Client,
+) -> dict | None:
+    try:
+        data = (
+            client.table("instance")
+            .select(
+                "*, account!inner!instance_account_id_28936e8f_fk_account_id(*),"
+                " storage!inner!storage_instance_id_359fca71_fk_instance_id(*)"
+            )
+            .eq("name", name)
+            .eq("account.handle", owner)
+            .eq("storage.is_default", True)
+            .execute()
+            .data
+        )
+    except Exception:
+        return None
+    if len(data) == 0:
+        return None
+    result = data[0]
+    # this is now a list
+    # assume only one default storage
+    result["storage"] = result["storage"][0]
+    return result
+
+
+# --------------- ACCOUNT ----------------------
+def select_account_by_handle(
+    handle: str,
+    client: Client,
+):
+    data = client.table("account").select("*").eq("handle", handle).execute().data
+    if len(data) == 0:
+        return None
+    return data[0]
+
+
+def select_account_handle_name_by_lnid(lnid: str, client: Client):
+    data = (
+        client.table("account").select("handle, name").eq("lnid", lnid).execute().data
+    )
+    if not data:
+        return None
+    return data[0]
+
+
+# --------------- INSTANCE ----------------------
+def select_instance_by_name(
+    account_id: str,
+    name: str,
+    client: Client,
+):
+    data = (
+        client.table("instance")
+        .select("*")
+        .eq("account_id", account_id)
+        .eq("name", name)
+        .execute()
+        .data
+    )
+    if len(data) == 0:
+        return None
+    return data[0]
+
+
+def select_instance_by_id(
+    instance_id: str,
+    client: Client,
+):
+    response = client.table("instance").select("*").eq("id", instance_id).execute()
+    if len(response.data) == 0:
+        return None
+    return response.data[0]
+
+
+def select_instance_by_id_with_storage(
+    instance_id: str,
+    client: Client,
+):
+    response = (
+        client.table("instance")
+        .select("*, storage!instance_storage_id_87963cc8_fk_storage_id(*)")
+        .eq("id", instance_id)
+        .execute()
+    )
+    if len(response.data) == 0:
+        return None
+    return response.data[0]
+
+
+def update_instance(instance_id: str, instance_fields: dict, client: Client):
+    response = (
+        client.table("instance").update(instance_fields).eq("id", instance_id).execute()
+    )
+    if len(response.data) == 0:
+        raise PermissionError(
+            f"Update of instance with {instance_id} was not successful. Probably, you"
+            " don't have sufficient permissions."
+        )
+    return response.data[0]
+
+
+# --------------- COLLABORATOR ----------------------
+
+
+def select_collaborator(
+    instance_id: str,
+    account_id: str,
+    client: Client,
+):
+    data = (
+        client.table("account_instance")
+        .select("*")
+        .eq("instance_id", instance_id)
+        .eq("account_id", account_id)
+        .execute()
+        .data
+    )
+    if len(data) == 0:
+        return None
+    return data[0]
+
+
+# --------------- STORAGE ----------------------
+
+
+def select_default_storage_by_instance_id(
+    instance_id: str, client: Client
+) -> dict | None:
+    try:
+        data = (
+            client.table("storage")
+            .select("*")
+            .eq("instance_id", instance_id)
+            .eq("is_default", True)
+            .execute()
+            .data
+        )
+    except Exception:
+        return None
+    if len(data) == 0:
+        return None
+    return data[0]
+
+
+# --------------- DBUser ----------------------
+
+
+def insert_db_user(
+    *,
+    name: str,
+    db_user_name: str,
+    db_user_password: str,
+    instance_id: UUID,
+    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
+    return data[0]
+
+
+def select_db_user_by_instance(instance_id: str, client: Client):
+    """Get db_user for which client has permission."""
+    data = (
+        client.table("db_user")
+        .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":
+                return item
+        logger.warning("found multiple db credentials, using the first one")
+    return data[0]
+
+
+def _delete_instance_record(instance_id: UUID, client: Client) -> None:
+    if not isinstance(instance_id, UUID):
+        instance_id = UUID(instance_id)
+    response = client.table("instance").delete().eq("id", instance_id.hex).execute()
+    if response.data:
+        logger.important(f"deleted instance record on hub {instance_id.hex}")
+    else:
+        raise PermissionError(
+            f"Deleting of instance with {instance_id.hex} was not successful. Probably, you"
+            " don't have sufficient permissions."
+        )

lamindb_setup/core/_hub_utils.py

@@ -0,0 +1,109 @@
+from __future__ import annotations
+
+from typing import Any, ClassVar
+from urllib.parse import urlparse, urlunparse
+
+from pydantic import BaseModel, Field, GetCoreSchemaHandler
+from pydantic_core import CoreSchema, core_schema
+
+
+def validate_schema_arg(schema: str | None = None) -> str:
+    if schema is None or schema == "":
+        return ""
+    # currently no actual validation, can add back if we see a need
+    # the following just strips white spaces
+    to_be_validated = [s.strip() for s in schema.split(",")]
+    return ",".join(to_be_validated)
+
+
+def validate_db_arg(db: str | None) -> None:
+    if db is not None:
+        LaminDsnModel(db=db)
+
+
+class LaminDsn(str):
+    allowed_schemes: ClassVar[set[str]] = {
+        "postgresql",
+        # future enabled schemes
+        # "snowflake",
+        # "bigquery"
+    }
+
+    @classmethod
+    def __get_pydantic_core_schema__(
+        cls, source_type: Any, handler: GetCoreSchemaHandler
+    ) -> CoreSchema:
+        return core_schema.no_info_after_validator_function(
+            cls.validate,
+            core_schema.str_schema(),
+            serialization=core_schema.plain_serializer_function_ser_schema(str),
+        )
+
+    @classmethod
+    def validate(cls, v: Any) -> LaminDsn:
+        if isinstance(v, str):
+            parsed = urlparse(v)
+            if parsed.scheme not in cls.allowed_schemes:
+                raise ValueError(f"Invalid scheme: {parsed.scheme}")
+            return cls(v)
+        elif isinstance(v, cls):
+            return v
+        else:
+            raise ValueError(f"Invalid value for LaminDsn: {v}")
+
+    @property
+    def user(self) -> str | None:
+        return urlparse(self).username
+
+    @property
+    def password(self) -> str | None:
+        return urlparse(self).password
+
+    @property
+    def host(self) -> str | None:
+        return urlparse(self).hostname
+
+    @property
+    def port(self) -> int | None:
+        return urlparse(self).port
+
+    @property
+    def database(self) -> str:
+        return urlparse(self).path.lstrip("/")
+
+    @property
+    def scheme(self) -> str:
+        return urlparse(self).scheme
+
+    @classmethod
+    def build(
+        cls,
+        *,
+        scheme: str,
+        user: str | None = None,
+        password: str | None = None,
+        host: str,
+        port: int | None = None,
+        database: str | None = None,
+        query: str | None = None,
+        fragment: str | None = None,
+    ) -> LaminDsn:
+        netloc = host
+        if port is not None:
+            netloc = f"{netloc}:{port}"
+        if user is not None:
+            auth = user
+            if password is not None:
+                auth = f"{auth}:{password}"
+            netloc = f"{auth}@{netloc}"
+
+        path = f"/{database}" if database else ""
+
+        url = urlunparse((scheme, netloc, path, "", query or "", fragment or ""))
+        return cls(url)
+
+
+class LaminDsnModel(BaseModel):
+    db: LaminDsn = Field(..., description="The database DSN")
+
+    model_config = {"arbitrary_types_allowed": True}

lamindb_setup/core/_private_django_api.py

@@ -0,0 +1,88 @@
+from __future__ import annotations
+
+import os
+from pathlib import Path
+
+
+def find_vscode_stubs_folder() -> Path | None:
+    # Possible locations of VSCode extensions
+    possible_locations = [
+        Path.home() / ".vscode" / "extensions",  # Linux and macOS
+        Path.home() / ".vscode-server" / "extensions",  # Remote development
+        Path(os.environ.get("APPDATA", "")) / "Code" / "User" / "extensions",  # Windows
+        Path("/usr/share/code/resources/app/extensions"),  # Some Linux distributions
+    ]
+    for location in possible_locations:
+        if location.exists():
+            # Look for Pylance extension folder
+            pylance_folders = list(location.glob("ms-python.vscode-pylance-*"))
+            if pylance_folders:
+                # Sort to get the latest version
+                latest_pylance = sorted(pylance_folders)[-1]
+                stubs_folder = (
+                    latest_pylance / "dist" / "bundled" / "stubs" / "django-stubs"
+                )
+                if stubs_folder.exists():
+                    return stubs_folder
+
+    return None
+
+
+def private_django_api(reverse=False):
+    from django import db
+
+    # the order here matters
+    # changing it might break the tests
+    attributes = [
+        "DoesNotExist",
+        "MultipleObjectsReturned",
+        "add_to_class",
+        "adelete",
+        "refresh_from_db",
+        "asave",
+        "clean",
+        "clean_fields",
+        "date_error_message",
+        "get_constraints",
+        "get_deferred_fields",
+        "prepare_database_save",
+        "save_base",
+        "serializable_value",
+        "unique_error_message",
+        "validate_constraints",
+        "validate_unique",
+    ]
+    if reverse:
+        attributes.append("arefresh_from_db")
+        attributes.append("full_clean")
+    else:
+        attributes.append("a_refresh_from_db")
+        attributes.append("full__clean")
+
+    django_path = Path(db.__file__).parent.parent
+
+    encoding = "utf8" if os.name == "nt" else None
+
+    def prune_file(file_path):
+        content = file_path.read_text(encoding=encoding)
+        original_content = content
+
+        for attr in attributes:
+            old_name = f"_{attr}" if reverse else attr
+            new_name = attr if reverse else f"_{attr}"
+            content = content.replace(old_name, new_name)
+
+        if not reverse:
+            content = content.replace("Field_DoesNotExist", "FieldDoesNotExist")
+            content = content.replace("Object_DoesNotExist", "ObjectDoesNotExist")
+
+        if content != original_content:
+            file_path.write_text(content, encoding=encoding)
+
+    for file_path in django_path.rglob("*.py"):
+        prune_file(file_path)
+
+    pylance_path = find_vscode_stubs_folder()
+    if pylance_path is not None:
+        for file_path in pylance_path.rglob("*.pyi"):
+            prune_file(file_path)

lamindb_setup/core/_settings.py

@@ -0,0 +1,184 @@
+from __future__ import annotations
+
+import os
+from typing import TYPE_CHECKING
+
+from appdirs import AppDirs
+
+from ._settings_load import (
+    load_instance_settings,
+    load_or_create_user_settings,
+    load_system_storage_settings,
+)
+from ._settings_store import current_instance_settings_file, settings_dir
+from .upath import LocalPathClasses, UPath
+
+if TYPE_CHECKING:
+    from pathlib import Path
+
+    from lamindb_setup.core import InstanceSettings, StorageSettings, UserSettings
+
+    from .types import UPathStr
+
+
+DEFAULT_CACHE_DIR = UPath(AppDirs("lamindb", "laminlabs").user_cache_dir)
+
+
+def _process_cache_path(cache_path: UPathStr | None):
+    if cache_path is None or cache_path == "null":
+        return None
+    cache_dir = UPath(cache_path)
+    if not isinstance(cache_dir, LocalPathClasses):
+        raise ValueError("cache dir should be a local path.")
+    if cache_dir.exists() and not cache_dir.is_dir():
+        raise ValueError("cache dir should be a directory.")
+    return cache_dir
+
+
+class SetupSettings:
+    """Setup settings."""
+
+    _using_key: str | None = None  # set through lamindb.settings
+
+    _user_settings: UserSettings | None = None
+    _instance_settings: InstanceSettings | None = None
+
+    _user_settings_env: str | None = None
+    _instance_settings_env: str | None = None
+
+    _auto_connect_path: Path = settings_dir / "auto_connect"
+    _private_django_api_path: Path = settings_dir / "private_django_api"
+
+    _cache_dir: Path | None = None
+
+    @property
+    def _instance_settings_path(self) -> Path:
+        return current_instance_settings_file()
+
+    @property
+    def settings_dir(self) -> Path:
+        """The directory that holds locally persisted settings."""
+        return settings_dir
+
+    @property
+    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`
+        """
+        return self._auto_connect_path.exists()
+
+    @auto_connect.setter
+    def auto_connect(self, value: bool) -> None:
+        if value:
+            self._auto_connect_path.touch()
+        else:
+            self._auto_connect_path.unlink(missing_ok=True)
+
+    @property
+    def private_django_api(self) -> bool:
+        """Turn internal Django API private to clean up the API (default `False`).
+
+        This patches your local pip-installed django installation. You can undo
+        the patch by setting this back to `False`.
+        """
+        return self._private_django_api_path.exists()
+
+    @private_django_api.setter
+    def private_django_api(self, value: bool) -> None:
+        from ._private_django_api import private_django_api
+
+        # we don't want to call private_django_api() twice
+        if value and not self.private_django_api:
+            private_django_api()
+            self._private_django_api_path.touch()
+        elif not value and self.private_django_api:
+            private_django_api(reverse=True)
+            self._private_django_api_path.unlink(missing_ok=True)
+
+    @property
+    def user(self) -> UserSettings:
+        """Settings of current user."""
+        env_changed = (
+            self._user_settings_env is not None
+            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()
+            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>")
+        return self._user_settings  # type: ignore
+
+    @property
+    def instance(self) -> InstanceSettings:
+        """Settings of current LaminDB instance."""
+        env_changed = (
+            self._instance_settings_env is not None
+            and self._instance_settings_env != get_env_name()
+        )
+        if self._instance_settings is None or env_changed:
+            self._instance_settings = load_instance_settings()
+            self._instance_settings_env = get_env_name()
+        return self._instance_settings  # type: ignore
+
+    @property
+    def storage(self) -> StorageSettings:
+        """Settings of default storage."""
+        return self.instance.storage
+
+    @property
+    def _instance_exists(self):
+        try:
+            self.instance  # noqa
+            return True
+        # this is implicit logic that catches if no instance is loaded
+        except SystemExit:
+            return False
+
+    @property
+    def cache_dir(self) -> UPath:
+        """Cache root, a local directory to cache cloud files."""
+        if "LAMIN_CACHE_DIR" in os.environ:
+            cache_dir = UPath(os.environ["LAMIN_CACHE_DIR"])
+        elif self._cache_dir is None:
+            cache_path = load_system_storage_settings().get("lamindb_cache_path", None)
+            cache_dir = _process_cache_path(cache_path)
+            if cache_dir is None:
+                cache_dir = DEFAULT_CACHE_DIR
+            self._cache_dir = cache_dir
+        else:
+            cache_dir = self._cache_dir
+        cache_dir.mkdir(parents=True, exist_ok=True)
+        return cache_dir
+
+    def __repr__(self) -> str:
+        """Rich string representation."""
+        repr = self.user.__repr__()
+        repr += f"\nAuto-connect in Python: {self.auto_connect}\n"
+        repr += f"Private Django API: {self.private_django_api}\n"
+        repr += f"Cache directory: {self.cache_dir}\n"
+        if self._instance_exists:
+            repr += self.instance.__repr__()
+        else:
+            repr += "\nNo instance connected"
+        return repr
+
+
+def get_env_name():
+    if "LAMIN_ENV" in os.environ:
+        return os.environ["LAMIN_ENV"]
+    else:
+        return "prod"
+
+
+settings = SetupSettings()