lamindb_setup 1.9.0__py3-none-any.whl → 1.9.1__py3-none-any.whl

lamindb_setup/core/_settings_store.py

@@ -1,91 +1,91 @@
-import os
-from pathlib import Path
-from typing import Optional
-
-from lamin_utils import logger
-from platformdirs import site_config_dir
-from pydantic_settings import BaseSettings, SettingsConfigDict
-
-if "LAMIN_SETTINGS_DIR" in os.environ:
-    # Needed when running with AWS Lambda, as only tmp/ directory has a write access
-    settings_dir = Path(f"{os.environ['LAMIN_SETTINGS_DIR']}/.lamin")
-else:
-    # user_config_dir is weird on MacOS!
-    # hence, let's take home/.lamin
-    settings_dir = Path.home() / ".lamin"
-
-
-try:
-    settings_dir.mkdir(parents=True, exist_ok=True)
-except Exception as e:
-    logger.warning(f"Failed to create lamin settings directory at {settings_dir}: {e}")
-
-
-system_settings_dir = Path(site_config_dir(appname="lamindb", appauthor="laminlabs"))
-
-
-def get_settings_file_name_prefix():
-    if "LAMIN_ENV" in os.environ:
-        if os.environ["LAMIN_ENV"] != "prod":
-            return f"{os.environ['LAMIN_ENV']}--"
-    return ""
-
-
-def current_instance_settings_file():
-    return settings_dir / f"{get_settings_file_name_prefix()}current_instance.env"
-
-
-def current_user_settings_file():
-    return settings_dir / f"{get_settings_file_name_prefix()}current_user.env"
-
-
-def instance_settings_file(name: str, owner: str):
-    return (
-        settings_dir / f"{get_settings_file_name_prefix()}instance--{owner}--{name}.env"
-    )
-
-
-def user_settings_file_email(email: str):
-    return settings_dir / f"{get_settings_file_name_prefix()}user--{email}.env"
-
-
-def user_settings_file_handle(handle: str):
-    return settings_dir / f"{get_settings_file_name_prefix()}user--{handle}.env"
-
-
-# here user means the user directory on os, not a lamindb user
-def platform_user_storage_settings_file():
-    return settings_dir / "storage.env"
-
-
-def system_settings_file():
-    return system_settings_dir / "system.env"
-
-
-class InstanceSettingsStore(BaseSettings):
-    api_url: Optional[str] = None
-    owner: str
-    name: str
-    storage_root: str
-    storage_region: Optional[str]  # take old type annotations here because pydantic
-    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
-    db_permissions: Optional[str] = None
-    id: str
-    git_repo: Optional[str]
-    keep_artifacts_local: Optional[bool]
-    model_config = SettingsConfigDict(env_prefix="lamindb_instance_", env_file=".env")
-
-
-class UserSettingsStore(BaseSettings):
-    email: str
-    password: str
-    access_token: str
-    api_key: Optional[str] = None
-    uid: str
-    uuid: str
-    handle: str
-    name: str
-    model_config = SettingsConfigDict(env_prefix="lamin_user_", env_file=".env")
+import os
+from pathlib import Path
+from typing import Optional
+
+from lamin_utils import logger
+from platformdirs import site_config_dir
+from pydantic_settings import BaseSettings, SettingsConfigDict
+
+if "LAMIN_SETTINGS_DIR" in os.environ:
+    # Needed when running with AWS Lambda, as only tmp/ directory has a write access
+    settings_dir = Path(f"{os.environ['LAMIN_SETTINGS_DIR']}/.lamin")
+else:
+    # user_config_dir is weird on MacOS!
+    # hence, let's take home/.lamin
+    settings_dir = Path.home() / ".lamin"
+
+
+try:
+    settings_dir.mkdir(parents=True, exist_ok=True)
+except Exception as e:
+    logger.warning(f"Failed to create lamin settings directory at {settings_dir}: {e}")
+
+
+system_settings_dir = Path(site_config_dir(appname="lamindb", appauthor="laminlabs"))
+
+
+def get_settings_file_name_prefix():
+    if "LAMIN_ENV" in os.environ:
+        if os.environ["LAMIN_ENV"] != "prod":
+            return f"{os.environ['LAMIN_ENV']}--"
+    return ""
+
+
+def current_instance_settings_file():
+    return settings_dir / f"{get_settings_file_name_prefix()}current_instance.env"
+
+
+def current_user_settings_file():
+    return settings_dir / f"{get_settings_file_name_prefix()}current_user.env"
+
+
+def instance_settings_file(name: str, owner: str):
+    return (
+        settings_dir / f"{get_settings_file_name_prefix()}instance--{owner}--{name}.env"
+    )
+
+
+def user_settings_file_email(email: str):
+    return settings_dir / f"{get_settings_file_name_prefix()}user--{email}.env"
+
+
+def user_settings_file_handle(handle: str):
+    return settings_dir / f"{get_settings_file_name_prefix()}user--{handle}.env"
+
+
+# here user means the user directory on os, not a lamindb user
+def platform_user_storage_settings_file():
+    return settings_dir / "storage.env"
+
+
+def system_settings_file():
+    return system_settings_dir / "system.env"
+
+
+class InstanceSettingsStore(BaseSettings):
+    api_url: Optional[str] = None
+    owner: str
+    name: str
+    storage_root: str
+    storage_region: Optional[str]  # take old type annotations here because pydantic
+    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
+    db_permissions: Optional[str] = None
+    id: str
+    git_repo: Optional[str]
+    keep_artifacts_local: Optional[bool]
+    model_config = SettingsConfigDict(env_prefix="lamindb_instance_", env_file=".env")
+
+
+class UserSettingsStore(BaseSettings):
+    email: str
+    password: str
+    access_token: str
+    api_key: Optional[str] = None
+    uid: str
+    uuid: str
+    handle: str
+    name: str
+    model_config = SettingsConfigDict(env_prefix="lamin_user_", env_file=".env")

lamindb_setup/core/_settings_user.py

@@ -1,55 +1,55 @@
-from __future__ import annotations
-
-from dataclasses import dataclass
-from typing import TYPE_CHECKING
-
-if TYPE_CHECKING:
-    from uuid import UUID
-
-
-class user_description:
-    email = """User email."""
-    password = """API key or legacy password."""
-    uid = """Universal user ID."""
-    handle = "Unique handle."
-    name = "Full name."
-
-
-@dataclass
-class UserSettings:
-    """User data. All synched from cloud."""
-
-    handle: str = "anonymous"
-    """Unique handle."""
-    email: str | None = None
-    """User email."""
-    api_key: str | None = None
-    """API key."""
-    password: str | None = None
-    """legacy API key or legacy password."""
-    access_token: str | None = None
-    """User access token."""
-    uid: str = "null"
-    """Universal user ID."""
-    _uuid: UUID | None = None
-    """Lamin's internal user ID."""
-    name: str | None = None
-    """Full name."""
-
-    def __repr__(self) -> str:
-        """Rich string representation."""
-        representation = "Current user:"
-        attrs = ["handle", "uid"]
-        for attr in attrs:
-            value = getattr(self, attr)
-            representation += f"\n - {attr}: {value}"
-        return representation
-
-    @property
-    def id(self):
-        """Integer id valid in current instance."""
-        from lamindb.base.users import current_user_id
-
-        # there is no cache needed here because current_user_id()
-        # has its own cache
-        return current_user_id()
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from uuid import UUID
+
+
+class user_description:
+    email = """User email."""
+    password = """API key or legacy password."""
+    uid = """Universal user ID."""
+    handle = "Unique handle."
+    name = "Full name."
+
+
+@dataclass
+class UserSettings:
+    """User data. All synched from cloud."""
+
+    handle: str = "anonymous"
+    """Unique handle."""
+    email: str | None = None
+    """User email."""
+    api_key: str | None = None
+    """API key."""
+    password: str | None = None
+    """legacy API key or legacy password."""
+    access_token: str | None = None
+    """User access token."""
+    uid: str = "null"
+    """Universal user ID."""
+    _uuid: UUID | None = None
+    """Lamin's internal user ID."""
+    name: str | None = None
+    """Full name."""
+
+    def __repr__(self) -> str:
+        """Rich string representation."""
+        representation = "Current user:"
+        attrs = ["handle", "uid"]
+        for attr in attrs:
+            value = getattr(self, attr)
+            representation += f"\n - {attr}: {value}"
+        return representation
+
+    @property
+    def id(self):
+        """Integer id valid in current instance."""
+        from lamindb.base.users import current_user_id
+
+        # there is no cache needed here because current_user_id()
+        # has its own cache
+        return current_user_id()

lamindb_setup/core/_setup_bionty_sources.py

@@ -1,44 +1,44 @@
-from __future__ import annotations
-
-from typing import TYPE_CHECKING
-
-if TYPE_CHECKING:
-    from ._settings_instance import InstanceSettings
-
-
-def write_bionty_sources(isettings: InstanceSettings) -> None:
-    """Write public bionty sources to bt.Source table."""
-    if "bionty" not in isettings.modules:
-        return None
-
-    import bionty
-    import bionty.base as bionty_base
-    from bionty._biorecord import list_biorecord_models
-    from bionty.base.dev._handle_sources import parse_sources_yaml
-    from bionty.models import Source
-
-    bionty_models = list_biorecord_models(bionty)
-
-    all_sources = parse_sources_yaml(bionty_base.settings.public_sources)
-    all_sources_dict = all_sources.to_dict(orient="records")
-
-    currently_used = (
-        bionty_base.display_currently_used_sources(mute=True)
-        .reset_index()
-        .set_index(["entity", "organism"])
-    )
-
-    all_records = []
-    for kwargs in all_sources_dict:
-        act = currently_used.loc[(kwargs["entity"], kwargs["organism"])].to_dict()
-        if (act["name"] == kwargs["name"]) and (act["version"] == kwargs["version"]):
-            kwargs["currently_used"] = True
-
-        kwargs["run"] = None  # can't yet access tracking information
-        kwargs["in_db"] = False
-        if kwargs["entity"] in bionty_models:
-            kwargs["entity"] = f"bionty.{kwargs['entity']}"
-        record = Source(**kwargs)
-        all_records.append(record)
-
-    Source.objects.bulk_create(all_records, ignore_conflicts=True)
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from ._settings_instance import InstanceSettings
+
+
+def write_bionty_sources(isettings: InstanceSettings) -> None:
+    """Write public bionty sources to bt.Source table."""
+    if "bionty" not in isettings.modules:
+        return None
+
+    import bionty
+    import bionty.base as bionty_base
+    from bionty._biorecord import list_biorecord_models
+    from bionty.base.dev._handle_sources import parse_sources_yaml
+    from bionty.models import Source
+
+    bionty_models = list_biorecord_models(bionty)
+
+    all_sources = parse_sources_yaml(bionty_base.settings.public_sources)
+    all_sources_dict = all_sources.to_dict(orient="records")
+
+    currently_used = (
+        bionty_base.display_currently_used_sources(mute=True)
+        .reset_index()
+        .set_index(["entity", "organism"])
+    )
+
+    all_records = []
+    for kwargs in all_sources_dict:
+        act = currently_used.loc[(kwargs["entity"], kwargs["organism"])].to_dict()
+        if (act["name"] == kwargs["name"]) and (act["version"] == kwargs["version"]):
+            kwargs["currently_used"] = True
+
+        kwargs["run"] = None  # can't yet access tracking information
+        kwargs["in_db"] = False
+        if kwargs["entity"] in bionty_models:
+            kwargs["entity"] = f"bionty.{kwargs['entity']}"
+        record = Source(**kwargs)
+        all_records.append(record)
+
+    Source.objects.bulk_create(all_records, ignore_conflicts=True)