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

lamindb_setup/__init__.py

@@ -35,7 +35,7 @@ Migration management
 
 """
 
-__version__ = "1.18.2"  # denote a release candidate for 0.1.0 with 0.1rc1
+__version__ = "1.19.1"  # denote a release candidate for 0.1.0 with 0.1rc1
 
 import os
 import warnings
@@ -48,9 +48,9 @@ warnings.filterwarnings(
 )
 warnings.filterwarnings("ignore", category=DeprecationWarning, module="postgrest")
 
-from packaging import version as packaging_version
-
-from . import core, errors, io, types
+# do not import io by default to reduce import time
+# it's not immediately needed in the default user workflows
+from . import core, errors, types
 from ._check_setup import _check_instance_setup
 from ._connect_instance import connect
 from ._delete import delete
@@ -63,20 +63,6 @@ from ._register_instance import register
 from ._setup_user import login, logout
 from .core._settings import settings
 
-# check that the version of s3fs is higher than the lower bound
-# needed because spatialdata installs old versions of s3fs
-try:
-    from s3fs import __version__ as s3fs_version
-
-    if packaging_version.parse(s3fs_version) < packaging_version.parse("2023.12.2"):
-        raise RuntimeError(
-            f"The version of s3fs you have ({s3fs_version}) is impompatible "
-            "with lamindb, please upgrade it: pip install s3fs>=2023.12.2"
-        )
-except ImportError:
-    # might be not installed
-    pass
-
 
 def _is_CI_environment() -> bool:
     ci_env_vars = [
@@ -112,5 +98,4 @@ _call_registered_entry_points("lamindb_setup.on_import")
 
 settings.__doc__ = """Global :class:`~lamindb.setup.core.SetupSettings`."""
 
-
 close = disconnect  # backward compatibility

lamindb_setup/_cache.py

@@ -1,87 +1,87 @@
-from __future__ import annotations
-
-import shutil
-from pathlib import Path
-
-from dotenv import dotenv_values
-from lamin_utils import logger
-
-from .core._settings_save import save_platform_user_storage_settings
-from .core._settings_store import system_settings_file
-from .errors import CurrentInstanceNotConfigured
-
-
-def clear_cache_dir():
-    from lamindb_setup import disconnect, settings
-
-    try:
-        if settings.instance._is_cloud_sqlite:
-            logger.warning(
-                "disconnecting the current instance to update the cloud sqlite database."
-            )
-            disconnect()
-    except CurrentInstanceNotConfigured:
-        pass
-
-    cache_dir = settings.cache_dir
-    if cache_dir.exists():
-        shutil.rmtree(cache_dir)
-        cache_dir.mkdir()
-        logger.success("the cache directory was cleared")
-    else:
-        logger.warning("the cache directory doesn't exist")
-
-
-def get_cache_dir():
-    from lamindb_setup import settings
-
-    return settings.cache_dir.as_posix()
-
-
-def set_cache_dir(cache_dir: str):
-    from lamindb_setup.core._settings import (
-        DEFAULT_CACHE_DIR,
-        _process_cache_path,
-        settings,
-    )
-
-    old_cache_dir = settings.cache_dir
-    new_cache_dir = _process_cache_path(cache_dir)
-
-    system_cache_dir = None
-    if (system_settings := system_settings_file()).exists():
-        system_cache_dir = dotenv_values(system_settings).get(
-            "lamindb_cache_path", None
-        )
-        system_cache_dir = (
-            Path(system_cache_dir) if system_cache_dir is not None else None
-        )
-
-    need_reset = False
-    if new_cache_dir is None:
-        need_reset = True
-        new_cache_dir = (
-            DEFAULT_CACHE_DIR if system_cache_dir is None else system_cache_dir
-        )
-
-    if new_cache_dir != old_cache_dir:
-        if old_cache_dir.exists():
-            shutil.copytree(old_cache_dir, new_cache_dir, dirs_exist_ok=True)
-            logger.info(
-                f"the current cache directory was copied to {new_cache_dir.as_posix()} "
-            )
-            if old_cache_dir != system_cache_dir:
-                shutil.rmtree(old_cache_dir)
-                logger.info(
-                    f"cleared the old cache directory {old_cache_dir.as_posix()}"
-                )
-            else:
-                logger.info(
-                    f"didn't clear the system cache directory {system_cache_dir.as_posix()}, "
-                    "please clear it manually if you need"
-                )
-        else:
-            new_cache_dir.mkdir(parents=True, exist_ok=True)
-        new_cache_dir = new_cache_dir.resolve()
-    save_platform_user_storage_settings(None if need_reset else new_cache_dir)
-    settings._cache_dir = new_cache_dir
+from __future__ import annotations
+
+import shutil
+from pathlib import Path
+
+from dotenv import dotenv_values
+from lamin_utils import logger
+
+from .core._settings_save import save_platform_user_storage_settings
+from .core._settings_store import system_settings_file
+from .errors import CurrentInstanceNotConfigured
+
+
+def clear_cache_dir():
+    from lamindb_setup import disconnect, settings
+
+    try:
+        if settings.instance._is_cloud_sqlite:
+            logger.warning(
+                "disconnecting the current instance to update the cloud sqlite database."
+            )
+            disconnect()
+    except CurrentInstanceNotConfigured:
+        pass
+
+    cache_dir = settings.cache_dir
+    if cache_dir.exists():
+        shutil.rmtree(cache_dir)
+        cache_dir.mkdir()
+        logger.success("the cache directory was cleared")
+    else:
+        logger.warning("the cache directory doesn't exist")
+
+
+def get_cache_dir():
+    from lamindb_setup import settings
+
+    return settings.cache_dir.as_posix()
+
+
+def set_cache_dir(cache_dir: str):
+    from lamindb_setup.core._settings import (
+        DEFAULT_CACHE_DIR,
+        _process_cache_path,
+        settings,
+    )
+
+    old_cache_dir = settings.cache_dir
+    new_cache_dir = _process_cache_path(cache_dir)
+
+    system_cache_dir = None
+    if (system_settings := system_settings_file()).exists():
+        system_cache_dir = dotenv_values(system_settings).get(
+            "lamindb_cache_path", None
+        )
+        system_cache_dir = (
+            Path(system_cache_dir) if system_cache_dir is not None else None
+        )
+
+    need_reset = False
+    if new_cache_dir is None:
+        need_reset = True
+        new_cache_dir = (
+            DEFAULT_CACHE_DIR if system_cache_dir is None else system_cache_dir
+        )
+
+    if new_cache_dir != old_cache_dir:
+        if old_cache_dir.exists():
+            shutil.copytree(old_cache_dir, new_cache_dir, dirs_exist_ok=True)
+            logger.info(
+                f"the current cache directory was copied to {new_cache_dir.as_posix()} "
+            )
+            if old_cache_dir != system_cache_dir:
+                shutil.rmtree(old_cache_dir)
+                logger.info(
+                    f"cleared the old cache directory {old_cache_dir.as_posix()}"
+                )
+            else:
+                logger.info(
+                    f"didn't clear the system cache directory {system_cache_dir.as_posix()}, "
+                    "please clear it manually if you need"
+                )
+        else:
+            new_cache_dir.mkdir(parents=True, exist_ok=True)
+        new_cache_dir = new_cache_dir.resolve()
+    save_platform_user_storage_settings(None if need_reset else new_cache_dir)
+    settings._cache_dir = new_cache_dir

lamindb_setup/_check.py

@@ -1,7 +1,7 @@
-from __future__ import annotations
-
-
-def check():
-    from django.core.management import call_command
-
-    call_command("check")
+from __future__ import annotations
+
+
+def check():
+    from django.core.management import call_command
+
+    call_command("check")

lamindb_setup/_check_setup.py

@@ -1,131 +1,131 @@
-from __future__ import annotations
-
-import functools
-import importlib as il
-import inspect
-import os
-from typing import TYPE_CHECKING
-from uuid import UUID
-
-from lamin_utils import logger
-
-from ._silence_loggers import silence_loggers
-from .core import django as django_lamin
-from .core._settings import settings
-from .core._settings_store import current_instance_settings_file
-from .errors import (
-    MODULE_WASNT_CONFIGURED_MESSAGE_TEMPLATE,
-    ModuleWasntConfigured,
-)
-
-if TYPE_CHECKING:
-    from collections.abc import Callable
-
-    from .core._settings_instance import InstanceSettings
-
-
-IS_LOADING: bool = False
-
-
-# decorator to disable auto-connect when importing a module such as lamindb
-def disable_auto_connect(func: Callable):
-    @functools.wraps(func)
-    def wrapper(*args, **kwargs):
-        global IS_LOADING
-        IS_LOADING = True
-        try:
-            return func(*args, **kwargs)
-        finally:
-            IS_LOADING = False
-
-    return wrapper
-
-
-def _normalize_module_name(module_name: str) -> str:
-    return module_name.replace("lnschema_", "").replace("_", "-")
-
-
-# checks that the provided modules is in the modules of the provided instance
-# or in the apps setup by django
-def _check_module_in_instance_modules(
-    module: str, isettings: InstanceSettings | None = None
-) -> None:
-    if isettings is not None:
-        modules_raw = isettings.modules
-        modules = set(modules_raw).union(
-            _normalize_module_name(module) for module in modules_raw
-        )
-        if _normalize_module_name(module) not in modules and module not in modules:
-            raise ModuleWasntConfigured(
-                MODULE_WASNT_CONFIGURED_MESSAGE_TEMPLATE.format(module)
-            )
-        else:
-            return
-
-    from django.apps import apps
-
-    for app in apps.get_app_configs():
-        # app.name is always unnormalized module (python package) name
-        if module == app.name or module == _normalize_module_name(app.name):
-            return
-    raise ModuleWasntConfigured(MODULE_WASNT_CONFIGURED_MESSAGE_TEMPLATE.format(module))
-
-
-# infer the name of the module that calls this function
-def _infer_callers_module_name() -> str | None:
-    stack = inspect.stack()
-    if len(stack) < 3:
-        return None
-    module = inspect.getmodule(stack[2][0])
-    return module.__name__.partition(".")[0] if module is not None else None
-
-
-# we make this a private function because in all the places it's used,
-# users should not see it
-def _check_instance_setup(from_module: str | None = None) -> bool:
-    if django_lamin.IS_SETUP:
-        if from_module is not None:
-            if from_module != "lamindb":
-                _check_module_in_instance_modules(from_module)
-        else:
-            infer_module = _infer_callers_module_name()
-            if infer_module is not None and infer_module not in {
-                "lamindb",
-                "lamindb_setup",
-                "lamin_cli",
-            }:
-                _check_module_in_instance_modules(infer_module)
-        return True
-    silence_loggers()
-    if os.environ.get("LAMINDB_MULTI_INSTANCE") == "true":
-        logger.warning(
-            "running LaminDB in multi-instance mode; you'll experience "
-            "errors in regular lamindb usage"
-        )
-        return True
-
-    if IS_LOADING or from_module is None:
-        return False
-
-    if (
-        not settings._instance_exists
-        and os.environ.get("LAMIN_CURRENT_INSTANCE") is not None
-    ):
-        from ._connect_instance import connect
-
-        connect(_write_settings=False, _reload_lamindb=False)
-        return django_lamin.IS_SETUP
-    else:
-        isettings = settings.instance
-        if from_module != "lamindb":
-            _check_module_in_instance_modules(from_module, isettings)
-
-            import lamindb  # connect to the instance
-        else:
-            # disable_auto_connect to avoid triggering _check_instance_setup in modules
-            disable_auto_connect(django_lamin.setup_django)(isettings)
-            if isettings.slug != "none/none":
-                logger.important(f"connected lamindb: {isettings.slug}")
-                # update of local storage location through search_local_root()
-                settings._instance_settings = isettings
-    return django_lamin.IS_SETUP
+from __future__ import annotations
+
+import functools
+import importlib as il
+import inspect
+import os
+from typing import TYPE_CHECKING
+from uuid import UUID
+
+from lamin_utils import logger
+
+from ._silence_loggers import silence_loggers
+from .core import django as django_lamin
+from .core._settings import settings
+from .core._settings_store import current_instance_settings_file
+from .errors import (
+    MODULE_WASNT_CONFIGURED_MESSAGE_TEMPLATE,
+    ModuleWasntConfigured,
+)
+
+if TYPE_CHECKING:
+    from collections.abc import Callable
+
+    from .core._settings_instance import InstanceSettings
+
+
+IS_LOADING: bool = False
+
+
+# decorator to disable auto-connect when importing a module such as lamindb
+def disable_auto_connect(func: Callable):
+    @functools.wraps(func)
+    def wrapper(*args, **kwargs):
+        global IS_LOADING
+        IS_LOADING = True
+        try:
+            return func(*args, **kwargs)
+        finally:
+            IS_LOADING = False
+
+    return wrapper
+
+
+def _normalize_module_name(module_name: str) -> str:
+    return module_name.replace("lnschema_", "").replace("_", "-")
+
+
+# checks that the provided modules is in the modules of the provided instance
+# or in the apps setup by django
+def _check_module_in_instance_modules(
+    module: str, isettings: InstanceSettings | None = None
+) -> None:
+    if isettings is not None:
+        modules_raw = isettings.modules
+        modules = set(modules_raw).union(
+            _normalize_module_name(module) for module in modules_raw
+        )
+        if _normalize_module_name(module) not in modules and module not in modules:
+            raise ModuleWasntConfigured(
+                MODULE_WASNT_CONFIGURED_MESSAGE_TEMPLATE.format(module)
+            )
+        else:
+            return
+
+    from django.apps import apps
+
+    for app in apps.get_app_configs():
+        # app.name is always unnormalized module (python package) name
+        if module == app.name or module == _normalize_module_name(app.name):
+            return
+    raise ModuleWasntConfigured(MODULE_WASNT_CONFIGURED_MESSAGE_TEMPLATE.format(module))
+
+
+# infer the name of the module that calls this function
+def _infer_callers_module_name() -> str | None:
+    stack = inspect.stack()
+    if len(stack) < 3:
+        return None
+    module = inspect.getmodule(stack[2][0])
+    return module.__name__.partition(".")[0] if module is not None else None
+
+
+# we make this a private function because in all the places it's used,
+# users should not see it
+def _check_instance_setup(from_module: str | None = None) -> bool:
+    if django_lamin.IS_SETUP:
+        if from_module is not None:
+            if from_module != "lamindb":
+                _check_module_in_instance_modules(from_module)
+        else:
+            infer_module = _infer_callers_module_name()
+            if infer_module is not None and infer_module not in {
+                "lamindb",
+                "lamindb_setup",
+                "lamin_cli",
+            }:
+                _check_module_in_instance_modules(infer_module)
+        return True
+    silence_loggers()
+    if os.environ.get("LAMINDB_MULTI_INSTANCE") == "true":
+        logger.warning(
+            "running LaminDB in multi-instance mode; you'll experience "
+            "errors in regular lamindb usage"
+        )
+        return True
+
+    if IS_LOADING or from_module is None:
+        return False
+
+    if (
+        not settings._instance_exists
+        and os.environ.get("LAMIN_CURRENT_INSTANCE") is not None
+    ):
+        from ._connect_instance import connect
+
+        connect(_write_settings=False, _reload_lamindb=False)
+        return django_lamin.IS_SETUP
+    else:
+        isettings = settings.instance
+        if from_module != "lamindb":
+            _check_module_in_instance_modules(from_module, isettings)
+
+            import lamindb  # connect to the instance
+        else:
+            # disable_auto_connect to avoid triggering _check_instance_setup in modules
+            disable_auto_connect(django_lamin.setup_django)(isettings)
+            if isettings.slug != "none/none":
+                logger.important(f"connected lamindb: {isettings.slug}")
+                # update of local storage location through search_local_root()
+                settings._instance_settings = isettings
+    return django_lamin.IS_SETUP