lamindb_setup 0.77.4__py2.py3-none-any.whl → 0.77.5__py2.py3-none-any.whl

lamindb_setup/core/_hub_crud.py

@@ -1,211 +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."
-        )
+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

@@ -1,109 +1,109 @@
-from __future__ import annotations
-
-from typing import Any, ClassVar, Optional
-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}
+from __future__ import annotations
+
+from typing import Any, ClassVar, Optional
+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}