lamindb_setup 0.81.4__py3-none-any.whl → 1.0a5__py3-none-any.whl

lamindb_setup/_schema_metadata.py

@@ -232,21 +232,21 @@ class _ModelHandler:
         return related_fields
 
     def _get_field_metadata(self, model, field: Field):
-        from lnschema_core.models import LinkORM
+        from lamindb.models import LinkORM
 
         internal_type = field.get_internal_type()
         model_name = field.model._meta.model_name
         relation_type = self._get_relation_type(model, field)
         if field.related_model is None:
-            schema_name = field.model.__get_schema_name__()
+            schema_name = field.model.__get_module_name__()
             related_model_name = None
             related_schema_name = None
             related_field_name = None
             field_name = field.name
         else:
             related_model_name = field.related_model._meta.model_name
-            related_schema_name = field.related_model.__get_schema_name__()
-            schema_name = field.model.__get_schema_name__()
+            related_schema_name = field.related_model.__get_module_name__()
+            schema_name = field.model.__get_module_name__()
             related_field_name = field.remote_field.name
             field_name = field.name
 
@@ -273,14 +273,16 @@ class _ModelHandler:
             through = self._get_through(field)
 
         return FieldMetadata(
-            schema_name=schema_name,
+            schema_name=schema_name if schema_name != "lamindb" else "core",
             model_name=model_name,
             field_name=field_name,
             type=internal_type,
             is_link_table=issubclass(field.model, LinkORM),
             column_name=column,
             relation_type=relation_type,
-            related_schema_name=related_schema_name,
+            related_schema_name=related_schema_name
+            if related_schema_name != "lamindb"
+            else "core",
             related_model_name=related_model_name,
             related_field_name=related_field_name,
             through=through,
@@ -288,7 +290,7 @@ class _ModelHandler:
 
     @staticmethod
     def _get_through_many_to_many(field_or_rel: ManyToManyField | ManyToManyRel):
-        from lnschema_core.models import Registry
+        from lamindb.models import Registry
 
         if isinstance(field_or_rel, ManyToManyField):
             if field_or_rel.model != Registry:
@@ -360,12 +362,12 @@ class _ModelHandler:
 
 class _SchemaHandler:
     def __init__(self) -> None:
-        self.included_modules = ["core"] + list(settings.instance.schema)
+        self.included_modules = ["core"] + list(settings.instance.modules)
         self.modules = self._get_modules_metadata()
 
     def to_dict(self, include_django_objects: bool = True):
         return {
-            module_name: {
+            module_name if module_name != "lamindb" else "core": {
                 model_name: model.to_dict(include_django_objects)
                 for model_name, model in module.items()
             }
@@ -376,7 +378,7 @@ class _SchemaHandler:
         return self.to_dict(include_django_objects=False)
 
     def _get_modules_metadata(self):
-        from lnschema_core.models import Record, Registry
+        from lamindb.models import Record, Registry
 
         all_models = {
             module_name: {
@@ -389,7 +391,7 @@ class _SchemaHandler:
                 if model.__class__ is Registry
                 and model is not Record
                 and not model._meta.abstract
-                and model.__get_schema_name__() == module_name
+                and model.__get_module_name__() == module_name
             }
             for module_name in self.included_modules
         }
@@ -401,6 +403,8 @@ class _SchemaHandler:
         module_set_info = []
         for module_name in self.included_modules:
             module = self._get_schema_module(module_name)
+            if module_name == "lamindb":
+                module_name = "core"
             module_set_info.append(
                 {"id": 0, "name": module_name, "version": module.__version__}
             )

lamindb_setup/core/_aws_credentials.py

@@ -3,6 +3,7 @@ from __future__ import annotations
 import os
 import time
 
+from lamin_utils import logger
 from upath.implementations.cloud import S3Path
 
 HOSTED_REGIONS = [
@@ -40,8 +41,15 @@ class AWSCredentialsManager:
 
         # this is cached so will be resued with the connection initialized
         fs = S3FileSystem(cache_regions=True)
-        fs.connect()
-        self.anon: bool = fs.session._credentials is None
+        try:
+            fs.connect()
+            self.anon: bool = fs.session._credentials is None
+        except Exception as e:
+            logger.warning(
+                f"There is a problem with your default AWS Credentials: {e}\n"
+                "`anon` mode will be used for all non-managed buckets."
+            )
+            self.anon = True
         self.anon_public: bool | None = None
         if not self.anon:
             try:

lamindb_setup/core/_deprecated.py

@@ -30,23 +30,30 @@ from functools import wraps
 def deprecated(new_name: str):
     """Deprecated.
 
-    This is a decorator which can be used to mark functions
+    This is a decorator which can be used to mark functions, methods and properties
     as deprecated. It will result in a warning being emitted
     when the function is used.
+
+    It will also hide the function from the docs.
+
+    Example::
+
+        @property
+        @deprecated("n_files")
+        def n_objects(self) -> int:
+            return self.n_files
+
     """
 
     def decorator(func):
         @wraps(func)
         def new_func(*args, **kwargs):
-            # turn off filter
-            warnings.simplefilter("always", DeprecationWarning)
             warnings.warn(
                 f"Use {new_name} instead of {func.__name__}, "
                 f"{func.__name__} will be removed in the future.",
-                category=DeprecationWarning,
+                category=FutureWarning,
                 stacklevel=2,
             )
-            warnings.simplefilter("default", DeprecationWarning)  # reset filter
             return func(*args, **kwargs)
 
         setattr(new_func, "__deprecated", True)

lamindb_setup/core/_hub_core.py

@@ -233,11 +233,11 @@ def _delete_instance(
     )
     if require_empty:
         for storage_record in storage_records:
+            root_string: str = storage_record["root"]  # type: ignore
             account_for_sqlite_file = (
                 instance_with_storage["db_scheme"] is None
-                and instance_with_storage["storage"]["root"] == storage_record["root"]
+                and instance_with_storage["storage"]["root"] == root_string
             )
-            root_string = storage_record["root"]
             # gate storage and instance deletion on empty storage location for
             # normally auth.get_session() doesn't have access_token
             # so this block is useless i think (Sergei)

lamindb_setup/core/_hub_crud.py

@@ -144,17 +144,14 @@ def select_collaborator(
 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
+    data = (
+        client.table("storage")
+        .select("*")
+        .eq("instance_id", instance_id)
+        .eq("is_default", True)
+        .execute()
+        .data
+    )
     if len(data) == 0:
         return None
     return data[0]

lamindb_setup/core/_hub_utils.py

@@ -7,15 +7,6 @@ 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)

lamindb_setup/core/_settings.py

@@ -164,7 +164,7 @@ class SetupSettings:
 
     @property
     def paths(self) -> type[SetupPaths]:
-        """Convert cloud paths to lamidb local paths.
+        """Convert cloud paths to lamindb local paths.
 
         Use `settings.paths.cloud_to_local_no_update`
         or `settings.paths.cloud_to_local`.
@@ -179,7 +179,7 @@ class SetupSettings:
         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"
+        repr += f"Cache directory: {self.cache_dir.as_posix()}\n"
         if self._instance_exists:
             repr += self.instance.__repr__()
         else:

lamindb_setup/core/_settings_instance.py

@@ -8,6 +8,7 @@ from typing import TYPE_CHECKING, Literal
 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
@@ -53,7 +54,7 @@ class InstanceSettings:
         keep_artifacts_local: bool = False,  # default to local storage
         uid: str | None = None,  # instance uid/lnid
         db: str | None = None,  # DB URI
-        schema: str | None = None,  # comma-separated string of schema names
+        modules: str | None = None,  # comma-separated string of module names
         git_repo: str | None = None,  # a git repo URL
         is_on_hub: bool | None = None,  # initialized from hub
         api_url: str | None = None,
@@ -69,7 +70,7 @@ class InstanceSettings:
         self._storage: StorageSettings = storage
         validate_db_arg(db)
         self._db: str | None = db
-        self._schema_str: str | None = schema
+        self._schema_str: str | None = modules
         self._git_repo = None if git_repo is None else sanitize_git_repo_url(git_repo)
         # local storage
         self._keep_artifacts_local = keep_artifacts_local
@@ -84,7 +85,7 @@ class InstanceSettings:
     def __repr__(self):
         """Rich string representation."""
         representation = f"Current instance: {self.slug}"
-        attrs = ["owner", "name", "storage", "db", "schema", "git_repo"]
+        attrs = ["owner", "name", "storage", "db", "modules", "git_repo"]
         for attr in attrs:
             value = getattr(self, attr)
             if attr == "storage":
@@ -121,7 +122,7 @@ class InstanceSettings:
     def _search_local_root(
         self, local_root: str | None = None, mute_warning: bool = False
     ) -> StorageSettings | None:
-        from lnschema_core.models import Storage
+        from lamindb.models import Storage
 
         if local_root is not None:
             local_records = Storage.objects.filter(root=local_root)
@@ -271,12 +272,20 @@ class InstanceSettings:
         return hash_and_encode_as_b62(self._id.hex)[:12]
 
     @property
-    def schema(self) -> set[str]:
-        """Schema modules in addition to core schema."""
+    def modules(self) -> set[str]:
+        """The set of modules that defines the database schema.
+
+        The core schema contained in lamindb is not included in this set.
+        """
         if self._schema_str is None:
             return {}  # type: ignore
         else:
-            return {schema for schema in self._schema_str.split(",") if schema != ""}
+            return {module for module in self._schema_str.split(",") if module != ""}
+
+    @property
+    @deprecated("modules")
+    def schema(self) -> set[str]:
+        return self.modules
 
     @property
     def _sqlite_file(self) -> UPath:
@@ -358,7 +367,7 @@ class InstanceSettings:
             sqlite_filepath = self.storage.cloud_to_local(
                 self._sqlite_file, error_no_origin=False
             )
-            return f"sqlite:///{sqlite_filepath}"
+            return f"sqlite:///{sqlite_filepath.as_posix()}"
         else:
             return self._db
 
@@ -457,11 +466,24 @@ class InstanceSettings:
         settings._instance_settings = self
 
     def _init_db(self):
+        from lamindb_setup import _check_setup
+
         from .django import setup_django
 
+        _check_setup.IS_LOADING = True
         setup_django(self, init=True)
+        _check_setup.IS_LOADING = False
+
+        from lamindb.models import Space
+
+        Space.objects.get_or_create(
+            name="All",
+            description="Every team & user with access to the instance has access.",
+        )
 
     def _load_db(self) -> tuple[bool, str]:
+        from lamindb_setup import _check_setup
+
         # Is the database available and initialized as LaminDB?
         # returns a tuple of status code and message
         if self.dialect == "sqlite" and not self._sqlite_file.exists():
@@ -472,7 +494,6 @@ class InstanceSettings:
                     f" {legacy_file} to {self._sqlite_file}"
                 )
             return False, f"SQLite file {self._sqlite_file} does not exist"
-        from lamindb_setup import settings  # to check user
 
         from .django import setup_django
 
@@ -481,5 +502,7 @@ class InstanceSettings:
         # setting up django also performs a check for migrations & prints them
         # as warnings
         # this should fail, e.g., if the db is not reachable
+        _check_setup.IS_LOADING = True
         setup_django(self)
+        _check_setup.IS_LOADING = False
         return True, ""

lamindb_setup/core/_settings_load.py

@@ -98,7 +98,7 @@ def setup_instance_from_store(store: InstanceSettingsStore) -> InstanceSettings:
         name=store.name,
         storage=ssettings,
         db=_null_to_value(store.db),
-        schema=_null_to_value(store.schema_str),
+        modules=_null_to_value(store.schema_str),
         git_repo=_null_to_value(store.git_repo),
         keep_artifacts_local=store.keep_artifacts_local,  # type: ignore
     )

lamindb_setup/core/_settings_storage.py

@@ -230,7 +230,7 @@ class StorageSettings:
         """Storage record in the current instance."""
         if self._record is None:
             # dynamic import because of import order
-            from lnschema_core.models import Storage
+            from lamindb.models import Storage
 
             from ._settings import settings
 

lamindb_setup/core/_settings_user.py

@@ -48,7 +48,7 @@ class UserSettings:
     @property
     def id(self):
         """Integer id valid in current intance."""
-        from lnschema_core.users import current_user_id
+        from lamindb.base.users import current_user_id
 
         # there is no cache needed here because current_user_id()
         # has its own cache

lamindb_setup/core/_setup_bionty_sources.py

@@ -17,7 +17,7 @@ RENAME = {"name": "source", "description": "source_name"}
 
 def write_bionty_sources(isettings: InstanceSettings) -> None:
     """Write bionty sources to Source table."""
-    if "bionty" not in isettings.schema:
+    if "bionty" not in isettings.modules:
         return None
     import shutil
 
@@ -79,7 +79,7 @@ def load_bionty_sources(isettings: InstanceSettings | None = None):
             # not setting up bionty sources
             return None
     if isettings is not None:
-        if "bionty" not in isettings.schema:
+        if "bionty" not in isettings.modules:
             # no need to setup anything
             return None
 
@@ -96,7 +96,7 @@ def load_bionty_sources(isettings: InstanceSettings | None = None):
         for kwargs in active_records:
             for db_field, base_col in RENAME.items():
                 kwargs[base_col] = kwargs.pop(db_field)
-            # TODO: non-bionty schema?
+            # TODO: non-bionty modules?
             kwargs["entity"] = kwargs["entity"].replace("bionty.", "")
         write_yaml(
             parse_currently_used_sources(active_records),

lamindb_setup/core/django.py

@@ -5,10 +5,8 @@ import builtins
 import os
 from pathlib import Path
 import time
-from lamin_utils import logger
-from ._settings_store import current_instance_settings_file
 from ._settings_instance import InstanceSettings
-import sys
+
 
 IS_RUN_FROM_IPYTHON = getattr(builtins, "__IPYTHON__", False)
 IS_SETUP = False
@@ -54,14 +52,14 @@ def setup_django(
         }
         from .._init_instance import get_schema_module_name
 
-        schema_names = ["core"] + list(isettings.schema)
+        module_names = ["core"] + list(isettings.modules)
         raise_import_error = True if init else False
         installed_apps = [
             package_name
-            for n in schema_names
+            for name in module_names
             if (
                 package_name := get_schema_module_name(
-                    n, raise_import_error=raise_import_error
+                    name, raise_import_error=raise_import_error
                 )
             )
             is not None
@@ -115,7 +113,9 @@ def setup_django(
     elif init:
         global IS_MIGRATING
         IS_MIGRATING = True
-        call_command("migrate", verbosity=0)
+        call_command(
+            "migrate", verbosity=2
+        )  # may change back to verbosity 0 in the future
         IS_MIGRATING = False
 
     global IS_SETUP

lamindb_setup/core/hashing.py

@@ -12,6 +12,7 @@ from __future__ import annotations
 
 import base64
 import hashlib
+import json
 from concurrent.futures import ThreadPoolExecutor
 from typing import TYPE_CHECKING
 
@@ -40,11 +41,21 @@ def b16_to_b64(s: str):
     return to_b64_str(base64.b16decode(s.strip('"'), casefold=True))
 
 
+def hash_string(string: str) -> str:
+    # as we're truncating (not here) at 22 b64, we choose md5 over sha512
+    return to_b64_str(hashlib.md5(string.encode("utf-8")).digest())
+
+
 # a lot to read about this: lamin-notes/2022/hashing
 def hash_set(s: set[str]) -> str:
-    bstr = ":".join(sorted(s)).encode("utf-8")
-    # as we're truncating at 22 b64, we choose md5 over sha512
-    return to_b64_str(hashlib.md5(bstr).digest())[:HASH_LENGTH]
+    join_s = ":".join(sorted(s))
+    return hash_string(join_s)[:HASH_LENGTH]
+
+
+def hash_dict(d: dict) -> str:
+    return to_b64_str(hashlib.md5(json.dumps(d, sort_keys=True).encode()).digest())[
+        :HASH_LENGTH
+    ]
 
 
 def hash_from_hashes_list(hashes: Iterable[str]) -> str:
@@ -111,6 +122,6 @@ def hash_dir(path: Path):
     hashes, sizes = zip(*hashes_sizes)
 
     hash, hash_type = hash_from_hashes_list(hashes), "md5-d"
-    n_objects = len(hashes)
+    n_files = len(hashes)
     size = sum(sizes)
-    return size, hash, hash_type, n_objects
+    return size, hash, hash_type, n_files