lamindb_setup 1.16.0__py3-none-any.whl → 1.18.0__py3-none-any.whl

lamindb_setup/__init__.py

@@ -35,14 +35,17 @@ Migration management
 
 """
 
-__version__ = "1.16.0"  # denote a release candidate for 0.1.0 with 0.1rc1
+__version__ = "1.18.0"  # denote a release candidate for 0.1.0 with 0.1rc1
 
 import os
 import warnings
 
-# ignore for now, remove this after supabase upgrade in the deps
+# ignore for now, this is for timeout parameter,
+# it is more convenient to specify it directly for now
 warnings.filterwarnings("ignore", category=DeprecationWarning, module="supabase")
-warnings.filterwarnings("ignore", category=DeprecationWarning, module="supafunc")
+warnings.filterwarnings(
+    "ignore", category=DeprecationWarning, module="supabase_functions"
+)
 warnings.filterwarnings("ignore", category=DeprecationWarning, module="postgrest")
 
 from packaging import version as packaging_version

lamindb_setup/_check_setup.py

@@ -4,7 +4,6 @@ import functools
 import importlib as il
 import inspect
 import os
-from importlib.metadata import distributions
 from typing import TYPE_CHECKING
 from uuid import UUID
 
@@ -16,7 +15,6 @@ from .core._settings import settings
 from .core._settings_store import current_instance_settings_file
 from .errors import (
     MODULE_WASNT_CONFIGURED_MESSAGE_TEMPLATE,
-    InstanceNotSetupError,
     ModuleWasntConfigured,
 )
 
@@ -26,8 +24,6 @@ if TYPE_CHECKING:
     from .core._settings_instance import InstanceSettings
 
 
-CURRENT_ISETTINGS: InstanceSettings | None = None
-MODULE_CANDIDATES: set[str] | None = None
 IS_LOADING: bool = False
 
 
@@ -45,55 +41,6 @@ def disable_auto_connect(func: Callable):
     return wrapper
 
 
-def find_module_candidates():
-    """Find all local packages that depend on lamindb."""
-    global MODULE_CANDIDATES
-    if MODULE_CANDIDATES is not None:
-        return MODULE_CANDIDATES
-    all_dists = list(distributions())
-    lamindb_deps = {
-        dist.metadata["Name"].lower()
-        for dist in all_dists
-        if dist.requires and any("lamindb" in req.lower() for req in dist.requires)
-    }
-    lamindb_deps.remove("lamindb")
-    MODULE_CANDIDATES = lamindb_deps
-    return lamindb_deps
-
-
-def _get_current_instance_settings(from_module: str | None = None) -> InstanceSettings:
-    from .core._settings_instance import InstanceSettings
-
-    global CURRENT_ISETTINGS
-
-    if CURRENT_ISETTINGS is not None:
-        return CURRENT_ISETTINGS
-    if current_instance_settings_file().exists():
-        from .core._settings_load import load_instance_settings
-
-        try:
-            isettings = load_instance_settings()
-        except Exception as e:
-            # user will get more detailed traceback once they run the CLI
-            logger.error(
-                "Current instance cannot be reached, disconnect from it: `lamin disconnect`\n"
-                "Alternatively, init or load a connectable instance on the"
-                " command line: `lamin connect <instance>` or `lamin init <...>`"
-            )
-            raise e
-    else:
-        module_candidates = find_module_candidates()
-        isettings = InstanceSettings(
-            id=UUID("00000000-0000-0000-0000-000000000000"),
-            owner="none",
-            name="none",
-            storage=None,
-            modules=",".join(module_candidates),
-        )
-    CURRENT_ISETTINGS = isettings
-    return isettings
-
-
 def _normalize_module_name(module_name: str) -> str:
     return module_name.replace("lnschema_", "").replace("_", "-")
 
@@ -137,12 +84,9 @@ def _infer_callers_module_name() -> str | None:
 # users should not see it
 def _check_instance_setup(from_module: str | None = None) -> bool:
     if django_lamin.IS_SETUP:
-        # reload logic here because module might not yet have been imported
-        # upon first setup
         if from_module is not None:
             if from_module != "lamindb":
                 _check_module_in_instance_modules(from_module)
-                il.reload(il.import_module(from_module))
         else:
             infer_module = _infer_callers_module_name()
             if infer_module is not None and infer_module not in {
@@ -159,34 +103,29 @@ def _check_instance_setup(from_module: str | None = None) -> bool:
             "errors in regular lamindb usage"
         )
         return True
-    isettings = _get_current_instance_settings()
-    if isettings is not None:
-        if from_module is not None and not django_lamin.IS_SETUP and not IS_LOADING:
-            if from_module != "lamindb":
-                _check_module_in_instance_modules(from_module, isettings)
-
-                import lamindb
-
-                il.reload(il.import_module(from_module))
-            else:
-                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
-                else:
-                    logger.warning("not connected, call: ln.connect('account/name')")
+
+    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:
-        if from_module is not None:
-            # the below enables users to auto-connect to an instance
-            # simply by setting an environment variable, bypassing the
-            # need of calling connect() manually
-            if 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:
-                logger.warning(InstanceNotSetupError.default_message)
-        return False
+        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

lamindb_setup/_connect_instance.py

@@ -9,10 +9,7 @@ from uuid import UUID
 
 from lamin_utils import logger
 
-from ._check_setup import (
-    _check_instance_setup,
-    _get_current_instance_settings,
-)
+from ._check_setup import _check_instance_setup
 from ._disconnect import disconnect
 from ._init_instance import load_from_isettings
 from ._silence_loggers import silence_loggers
@@ -25,7 +22,7 @@ from .core._settings_storage import StorageSettings
 from .core._settings_store import instance_settings_file
 from .core.cloud_sqlite_locker import unlock_cloud_sqlite_upon_exception
 from .core.django import reset_django
-from .errors import CannotSwitchDefaultInstance
+from .errors import CannotSwitchDefaultInstance, InstanceNotFoundError
 
 if TYPE_CHECKING:
     from pathlib import Path
@@ -36,8 +33,6 @@ if TYPE_CHECKING:
 # this is for testing purposes only
 # set to True only to test failed load
 _TEST_FAILED_LOAD = False
-
-
 INSTANCE_NOT_FOUND_MESSAGE = (
     "'{owner}/{name}' not found:"
     " '{hub_result}'\nCheck your permissions:"
@@ -45,10 +40,6 @@ INSTANCE_NOT_FOUND_MESSAGE = (
 )
 
 
-class InstanceNotFoundError(SystemExit):
-    pass
-
-
 def check_db_dsn_equal_up_to_credentials(db_dsn_hub, db_dsn_local):
     return (
         db_dsn_hub.scheme == db_dsn_local.scheme
@@ -105,6 +96,7 @@ def _connect_instance(
     use_root_db_user: bool = False,
     use_proxy_db: bool = False,
     access_token: str | None = None,
+    raise_systemexit: bool = False,
 ) -> InstanceSettings:
     settings_file = instance_settings_file(name, owner)
     make_hub_request = True
@@ -173,12 +165,17 @@ def _connect_instance(
                 )
             else:
                 message = "It is not possible to load an anonymous-owned instance from the hub"
+            exception = (
+                SystemExit(message)
+                if raise_systemexit
+                else InstanceNotFoundError(message)
+            )
             if settings_file.exists():
                 isettings = load_instance_settings(settings_file)
                 if isettings.is_remote:
-                    raise InstanceNotFoundError(message)
+                    raise exception
             else:
-                raise InstanceNotFoundError(message)
+                raise exception
     return isettings
 
 
@@ -242,7 +239,11 @@ def _connect_cli(
 
     owner, name = get_owner_name_from_identifier(instance)
     isettings = _connect_instance(
-        owner, name, use_root_db_user=use_root_db_user, use_proxy_db=use_proxy_db
+        owner,
+        name,
+        use_root_db_user=use_root_db_user,
+        use_proxy_db=use_proxy_db,
+        raise_systemexit=True,
     )
     isettings._persist(write_to_disk=True)
     if not isettings.is_on_hub or isettings._is_cloud_sqlite:
@@ -266,13 +267,8 @@ def validate_connection_state(
     from django.db import connection
 
     if (
-        settings._instance_exists
+        settings._instance_exists  # exists only for real instances, not for none/none
         and f"{owner}/{name}" == settings.instance.slug
-        # below is to ensure that if another process interferes
-        # we don't use the in-memory mock database
-        # could be made more specific by checking whether the django
-        # configured database is the same as the one in settings
-        and connection.settings_dict["NAME"] != ":memory:"
         and not use_root_db_user  # always re-connect for root db user
     ):
         logger.important(
@@ -280,7 +276,7 @@ def validate_connection_state(
         )
         return None
     else:
-        if settings._instance_exists and settings.instance.slug != "none/none":
+        if settings._instance_exists:
             import lamindb as ln
 
             if ln.context.transform is not None:
@@ -292,7 +288,9 @@ def validate_connection_state(
 
 @unlock_cloud_sqlite_upon_exception(ignore_prev_locker=True)
 def connect(instance: str | None = None, **kwargs: Any) -> str | tuple | None:
-    """Connect to an instance.
+    """Connect the global default instance.
+
+    If you want to create a read-only database client, use :class:`~lamindb.DB` instead.
 
     Args:
         instance: Pass a slug (`account/name`) or URL (`https://lamin.ai/account/name`).
@@ -340,12 +338,9 @@ def connect(instance: str | None = None, **kwargs: Any) -> str | tuple | None:
             if settings._instance_exists:
                 isettings = settings.instance
             else:
-                isettings_or_none = _get_current_instance_settings()
-                if isettings_or_none is None:
-                    raise ValueError(
-                        "No instance was connected through the CLI, pass a value to `instance` or connect via the CLI."
-                    )
-                isettings = isettings_or_none
+                raise ValueError(
+                    "No instance was connected through the CLI, pass a value to `instance` or connect via the CLI."
+                )
             if use_root_db_user:
                 reset_django()
                 owner, name = isettings.owner, isettings.name
@@ -414,7 +409,6 @@ def connect(instance: str | None = None, **kwargs: Any) -> str | tuple | None:
 
         load_from_isettings(isettings, user=_user, write_settings=_write_settings)
         if _reload_lamindb:
-            importlib.reload(importlib.import_module("lamindb"))
             reset_django_module_variables()
         if isettings.slug != "none/none":
             logger.important(f"connected lamindb: {isettings.slug}")
@@ -424,10 +418,6 @@ def connect(instance: str | None = None, **kwargs: Any) -> str | tuple | None:
                 isettings._get_settings_file().unlink(missing_ok=True)  # type: ignore
             settings._instance_settings = None
         raise e
-    if settings.dev_dir is None:
-        logger.important_hint(
-            "to map a local dev directory, set: ln.setup.settings.dev_dir = '.'"
-        )
     return None
 
 

lamindb_setup/_delete.py

@@ -11,6 +11,7 @@ from .core._aws_options import HOSTED_BUCKETS
 from .core._hub_core import delete_instance as delete_instance_on_hub
 from .core._hub_core import get_storage_records_for_instance
 from .core._settings import settings
+from .core._settings_load import load_instance_settings
 from .core._settings_storage import StorageSettings
 from .core.upath import LocalPathClasses, check_storage_is_empty
 
@@ -38,6 +39,8 @@ def delete_exclusion_dir(isettings: InstanceSettings) -> None:
 
 
 def delete_by_isettings(isettings: InstanceSettings) -> None:
+    assert isettings.slug != "none/none"
+
     settings_file = isettings._get_settings_file()
     if settings_file.exists():
         settings_file.unlink()
@@ -51,12 +54,14 @@ def delete_by_isettings(isettings: InstanceSettings) -> None:
                 "Did not have permission to delete SQLite file:"
                 f" {isettings._sqlite_file}"
             )
-            pass
     # unset the global instance settings
-    if settings._instance_exists and isettings.slug == settings.instance.slug:
-        if settings._instance_settings_path.exists():
-            settings._instance_settings_path.unlink()
-        settings._instance_settings = None
+    isettings_on_disk = load_instance_settings()
+    if isettings_on_disk.slug == isettings.slug:
+        settings._instance_settings_path.unlink()  # current instance settings file
+        # settings.instance can differ from instance in current_settings_file()
+        # due to connect() in the same process
+        if settings.instance.slug == isettings.slug:
+            settings._instance_settings = None
 
 
 def delete(slug: str, force: bool = False, require_empty: bool = True) -> int | None:

lamindb_setup/_disconnect.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 from lamin_utils import logger
 
 from .core._settings import settings
-from .core._settings_store import current_instance_settings_file
+from .core._settings_load import load_instance_settings
 from .core.cloud_sqlite_locker import clear_locker
 
 
@@ -15,10 +15,11 @@ def disconnect(mute: bool = False) -> None:
     See Also:
         Clear default instance configuration via the CLI, see `here <https://docs.lamin.ai/cli#disconnect>`__.
     """
-    if current_instance_settings_file().exists():
-        instance = settings.instance.slug
+    # settings._instance_exists can be true due to connect even without having a file
+    if settings._instance_exists:
+        instance = settings.instance
         try:
-            settings.instance._update_cloud_sqlite_file()
+            instance._update_cloud_sqlite_file()
         except Exception as e:
             if isinstance(e, FileNotFoundError):
                 logger.warning("did not find local cache file")
@@ -26,10 +27,12 @@ def disconnect(mute: bool = False) -> None:
                 logger.warning("did not upload cache file - not enough permissions")
             else:
                 raise e
-        current_instance_settings_file().unlink()
         clear_locker()
+        # instance in current instance file can differ from instance in settings
+        if load_instance_settings().slug == instance.slug:
+            settings._instance_settings_path.unlink(missing_ok=True)
+        settings._instance_settings = None
         if not mute:
-            logger.success(f"disconnected instance: {instance}")
-    else:
-        if not mute:
-            logger.info("no instance loaded")
+            logger.success(f"disconnected instance: {instance.slug}")
+    elif not mute:
+        logger.info("no instance loaded")

lamindb_setup/_init_instance.py

@@ -340,7 +340,6 @@ def init(
             from ._schema_metadata import update_schema_in_hub
 
             update_schema_in_hub(access_token=access_token)
-        importlib.reload(importlib.import_module("lamindb"))
         reset_django_module_variables()
         logger.important(f"initialized lamindb: {isettings.slug}")
     except Exception as e:

lamindb_setup/_migrate.py

@@ -1,5 +1,7 @@
 from __future__ import annotations
 
+import os
+
 import httpx
 from django.db import connection
 from django.db.migrations.loader import MigrationLoader
@@ -98,16 +100,19 @@ class migrate:
 
     @classmethod
     def deploy(cls, package_name: str | None = None, number: int | None = None) -> None:
-        import os
+        assert settings._instance_exists, (
+            "Not connected to an instance, please connect to migrate."
+        )
 
         # NOTE: this is a temporary solution to avoid breaking tests
         LAMIN_MIGRATE_ON_LAMBDA = (
-            os.environ.get("LAMIN_MIGRATE_ON_LAMBDA", "false") == "true"
+            os.getenv("LAMIN_MIGRATE_ON_LAMBDA", "false") == "true"
         )
+        isettings = settings.instance
 
-        if settings.instance.is_on_hub and LAMIN_MIGRATE_ON_LAMBDA:
+        if isettings.is_on_hub and LAMIN_MIGRATE_ON_LAMBDA:
             response = httpx.post(
-                f"{settings.instance.api_url}/instances/{settings.instance._id}/migrate",
+                f"{isettings.api_url}/instances/{isettings._id}/migrate",
                 headers={"Authorization": f"Bearer {settings.user.access_token}"},
                 timeout=None,  # this can take time
             )
@@ -125,49 +130,41 @@ class migrate:
         from lamindb_setup._schema_metadata import update_schema_in_hub
         from lamindb_setup.core._hub_client import call_with_fallback_auth
         from lamindb_setup.core._hub_crud import (
-            select_collaborator,
             update_instance,
         )
 
-        if settings.instance.is_on_hub:
-            # double check that user is an admin, otherwise will fail below
-            # due to insufficient SQL permissions with cryptic error
-            collaborator = call_with_fallback_auth(
-                select_collaborator,
-                instance_id=settings.instance._id,
-                account_id=settings.user._uuid,
-                fine_grained_access=settings.instance._fine_grained_access,
-            )
-            if collaborator is None or collaborator["role"] != "admin":
-                raise SystemExit(
-                    "❌ Only admins can deploy migrations, please ensure that you're an"
-                    f" admin: https://lamin.ai/{settings.instance.slug}/settings"
-                )
+        isettings = settings.instance
+        is_managed_by_hub = isettings.is_managed_by_hub
+        is_on_hub = is_managed_by_hub or isettings.is_on_hub
+
+        if is_managed_by_hub and "root" not in isettings.db:
             # ensure we connect with the root user
-            if "root" not in settings.instance.db:
-                connect(use_root_db_user=True)
-                assert "root" in (instance_db := settings.instance.db), instance_db
+            connect(use_root_db_user=True)
+            assert "root" in (instance_db := settings.instance.db), instance_db
+        if is_on_hub:
             # we need lamindb to be installed, otherwise we can't populate the version
             # information in the hub
+            # this also connects
             import lamindb
-
+        # this is needed to avoid connecting on importing apps inside setup_django process
+        setup_django_disable_autoconnect = disable_auto_connect(setup_django)
         # this sets up django and deploys the migrations
         if package_name is not None and number is not None:
-            setup_django(
-                settings.instance,
+            setup_django_disable_autoconnect(
+                isettings,
                 deploy_migrations=True,
                 appname_number=(package_name, number),
             )
         else:
-            setup_django(settings.instance, deploy_migrations=True)
+            setup_django_disable_autoconnect(isettings, deploy_migrations=True)
         # this populates the hub
-        if settings.instance.is_on_hub:
+        if is_on_hub:
             logger.important(f"updating lamindb version in hub: {lamindb.__version__}")
-            if settings.instance.dialect != "sqlite":
+            if isettings.dialect != "sqlite":
                 update_schema_in_hub()
             call_with_fallback_auth(
                 update_instance,
-                instance_id=settings.instance._id.hex,
+                instance_id=isettings._id.hex,
                 instance_fields={"lamindb_version": lamindb.__version__},
             )
 
@@ -175,16 +172,45 @@ class migrate:
     @disable_auto_connect
     def check(cls) -> bool:
         """Check whether Registry definitions are in sync with migrations."""
+        import io
+
         from django.core.management import call_command
 
         setup_django(settings.instance)
+
+        # Capture stdout/stderr to show what migrations are needed if check fails
+        stdout = io.StringIO()
+        stderr = io.StringIO()
+
         try:
-            call_command("makemigrations", check_changes=True)
+            call_command(
+                "makemigrations", check_changes=True, stdout=stdout, stderr=stderr
+            )
         except SystemExit:
             logger.error(
                 "migrations are not in sync with ORMs, please create a migration: lamin"
                 " migrate create"
             )
+            # Print captured output from the check
+            if stdout.getvalue():
+                logger.error(f"makemigrations --check stdout:\n{stdout.getvalue()}")
+            if stderr.getvalue():
+                logger.error(f"makemigrations --check stderr:\n{stderr.getvalue()}")
+
+            # Run makemigrations --dry-run to show what would be created
+            stdout2 = io.StringIO()
+            stderr2 = io.StringIO()
+            try:
+                call_command(
+                    "makemigrations", dry_run=True, stdout=stdout2, stderr=stderr2
+                )
+            except SystemExit:
+                pass
+            if stdout2.getvalue():
+                logger.error(f"makemigrations --dry-run stdout:\n{stdout2.getvalue()}")
+            if stderr2.getvalue():
+                logger.error(f"makemigrations --dry-run stderr:\n{stderr2.getvalue()}")
+
             return False
         return True
 

lamindb_setup/_set_managed_storage.py

@@ -16,6 +16,9 @@ if TYPE_CHECKING:
 def set_managed_storage(root: UPathStr, host: str | None = None, **fs_kwargs):
     """Add or switch to another managed storage location.
 
+    Note: This function should be called `set_writeable_storage_location` instead. But likely it will disappear
+    in refactoring that consolidates with the `ln.Storage()` path.
+
     Args:
         root: `UPathStr` - The new storage root, e.g., an S3 bucket.
         host: `str | None = None` For a shared local storage location, pass a globally unique host identifier, e.g. `"my-institute-cluster-1"`, `"my-server-abcd"`, ...

lamindb_setup/_setup_user.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import os
+from time import sleep
 from typing import TYPE_CHECKING
 
 from lamin_utils import logger
@@ -59,15 +60,14 @@ def login(
 
     `login()` prompts for your API key unless you set it via the `LAMIN_API_KEY` environment variable or pass it as an argument.
 
-    You can create your API key in your account settings on LaminHub (top right corner).
+    You can create your API key in your account settings on LaminHub at `lamin.ai/settings <https://lamin.ai/settings>`__.
+
+    Note that the preferred method is to use the CLI command `lamin login`: `docs.lamin.ai/cli#login <https://docs.lamin.ai/cli#login>`__.
 
     Args:
         user: User handle.
         api_key: API key.
 
-    See Also:
-        Login via the CLI command `lamin login`, see `here <https://docs.lamin.ai/cli#login>`__.
-
     Examples:
 
         Logging in the first time::
@@ -80,12 +80,15 @@ def login(
 
             ln.setup.login("myhandle")  # pass your user handle
     """
+    from getpass import getpass
+
     if user is None:
         if api_key is None:
             if "LAMIN_API_KEY" in os.environ:
                 api_key = os.environ["LAMIN_API_KEY"]
             else:
-                api_key = input("Your API key: ")
+                print("Copy your API key. To create one: https://lamin.ai/settings")
+                api_key = getpass("Paste it: ")
     elif api_key is not None:
         raise ValueError("Please provide either 'user' or 'api_key', not both.")
 

lamindb_setup/_silence_loggers.py

@@ -25,6 +25,8 @@ def silence_loggers():
         set_stream_logger(name="botocore.auth", level=logging.WARNING)
         set_stream_logger(name="botocore.endpoint", level=logging.WARNING)
         set_stream_logger(name="httpx", level=logging.WARNING)
+        set_stream_logger(name="httpcore", level=logging.WARNING)
+        set_stream_logger(name="hpack", level=logging.WARNING)
         try:
             import aiobotocore
 

lamindb_setup/core/__init__.py

@@ -24,9 +24,6 @@ Storage
 
 from . import django, upath
 from ._clone import (
-    connect_local_sqlite,
-    connect_remote_sqlite,
-    init_local_sqlite,
     upload_sqlite_clone,
 )
 from ._deprecated import deprecated  # documented in lamindb.base