lamindb_setup 1.16.0__tar.gz → 1.17.0__tar.gz

{lamindb_setup-1.16.0 → lamindb_setup-1.17.0}/.github/workflows/build.yml

@@ -107,7 +107,6 @@ jobs:
       - run: nox -s lint
       - run: nox -s storage
         env:
-          TEST_INSTANCE_PRIVATE_POSTGRES: ${{ secrets.TEST_INSTANCE_PRIVATE_POSTGRES }}
           TMP_AWS_ACCESS_KEY_ID: ${{ secrets.AWS_ACCESS_KEY_ID }}
           TMP_AWS_SECRET_ACCESS_KEY: ${{ secrets.AWS_SECRET_ACCESS_KEY }}
       - uses: actions/upload-artifact@v4
@@ -163,6 +162,60 @@ jobs:
           path: .coverage
           include-hidden-files: true
 
+  # test custom proxies and certificates
+  connectivity:
+    runs-on: ubuntu-latest
+    timeout-minutes: 13
+    steps:
+      - uses: aws-actions/configure-aws-credentials@v4
+        with:
+          aws-access-key-id: ${{ secrets.AWS_ACCESS_KEY_ID }}
+          aws-secret-access-key: ${{ secrets.AWS_SECRET_ACCESS_KEY }}
+          aws-region: eu-central-1
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v6
+        with:
+          python-version: "3.11"
+          cache: "pip"
+          cache-dependency-path: ".github/workflows/build.yml"
+      - run: pip install "laminci@git+https://x-access-token:${{ secrets.LAMIN_BUILD_DOCS }}@github.com/laminlabs/laminci"
+      - run: nox -s "install(group='connectivity')"
+      - name: cache mitmproxy
+        id: cache-mitmproxy
+        uses: actions/cache@v4
+        with:
+          path: ~/mitmproxy.tar
+          key: cache-mitmproxy-0
+      - name: cache mitmproxy miss
+        if: ${{ steps.cache-mitmproxy.outputs.cache-hit != 'true' }}
+        run: docker pull mitmproxy/mitmproxy:latest && docker image save mitmproxy/mitmproxy:latest --output ~/mitmproxy.tar
+      - name: cache mitmproxy use
+        if: ${{ steps.cache-mitmproxy.outputs.cache-hit == 'true' }}
+        run: docker image load --input ~/mitmproxy.tar
+      - name: start mitmproxy
+        run: |
+          # Start mitmdump (headless mitmproxy) as a forward proxy on 8080
+          docker run -d \
+            --name mitmproxy \
+            -p 8080:8080 \
+            mitmproxy/mitmproxy:latest \
+            mitmdump --mode regular --listen-port 8080
+          # Give it a few seconds to start and generate the CA
+          sleep 10
+          echo "mitmproxy state:"
+          docker ps -a
+          echo "Container ~/.mitmproxy contents:"
+          docker exec mitmproxy ls -l /home/mitmproxy/.mitmproxy || true
+          echo "Container logs (if it still exited):"
+          docker logs mitmproxy || true
+      - name: export mitmproxy certificate
+        run: |
+          # Copy CA cert from inside the container to the workspace
+          docker cp mitmproxy:/home/mitmproxy/.mitmproxy/mitmproxy-ca-cert.pem ./mitmproxy-ca.pem
+          ls -l ./mitmproxy-ca.pem
+      - name: run tests
+        run: nox -s connectivity
+
   coverage:
     needs: [hub-prod, hub-cloud, storage, hub-local]
     runs-on: ubuntu-latest

{lamindb_setup-1.16.0 → lamindb_setup-1.17.0}/.gitignore

@@ -115,3 +115,4 @@ storage_uid.txt
 test.ipynb
 test2.ipynb
 *_export
+update_clone.py

{lamindb_setup-1.16.0 → lamindb_setup-1.17.0}/PKG-INFO

@@ -1,10 +1,11 @@
-Metadata-Version: 2.3
+Metadata-Version: 2.4
 Name: lamindb_setup
-Version: 1.16.0
+Version: 1.17.0
 Summary: Setup & configure LaminDB.
 Author-email: Lamin Labs <open-source@lamin.ai>
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
+License-File: LICENSE
 Requires-Dist: lamin_utils>=0.3.3
 Requires-Dist: django>=5.2,<5.3
 Requires-Dist: dj_database_url>=1.3.0,<3.0.0
@@ -15,9 +16,7 @@ Requires-Dist: httpx_retries<1.0.0
 Requires-Dist: requests
 Requires-Dist: universal_pathlib==0.2.6
 Requires-Dist: botocore<2.0.0
-Requires-Dist: supabase>=2.8.1,<=2.16.0
-Requires-Dist: gotrue<=2.12.0
-Requires-Dist: storage3!=0.11.2; python_version < '3.11'
+Requires-Dist: supabase>=2.20.0,<=2.24.0
 Requires-Dist: pyjwt<3.0.0
 Requires-Dist: psutil
 Requires-Dist: packaging

{lamindb_setup-1.16.0 → lamindb_setup-1.17.0}/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.17.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-1.17.0/lamindb_setup/_check_setup.py

@@ -0,0 +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

{lamindb_setup-1.16.0 → lamindb_setup-1.17.0}/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
@@ -266,13 +263,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 +272,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 +284,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 +334,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 +405,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 +414,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-1.16.0 → lamindb_setup-1.17.0}/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-1.16.0 → lamindb_setup-1.17.0}/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-1.16.0 → lamindb_setup-1.17.0}/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-1.16.0 → lamindb_setup-1.17.0}/lamindb_setup/_migrate.py

@@ -125,24 +125,10 @@ 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"
-                )
             # ensure we connect with the root user
             if "root" not in settings.instance.db:
                 connect(use_root_db_user=True)

{lamindb_setup-1.16.0 → lamindb_setup-1.17.0}/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-1.16.0 → lamindb_setup-1.17.0}/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-1.16.0 → lamindb_setup-1.17.0}/lamindb_setup/core/_aws_options.py

@@ -60,6 +60,7 @@ class AWSOptionsManager:
         from aiobotocore.session import AioSession
         from s3fs import S3FileSystem
 
+        anon_env = os.getenv("LAMIN_S3_ANON") == "true"
         # this is cached so will be resued with the connection initialized
         # these options are set for paths in _path_inject_options
         # here we set the same options to cache the filesystem
@@ -68,19 +69,28 @@ class AWSOptionsManager:
             use_listings_cache=True,
             version_aware=False,
             config_kwargs={"max_pool_connections": 64},
+            anon=anon_env,
         )
 
         self._suppress_aiobotocore_traceback_logging()
 
-        try:
-            fs.connect()
-            self.anon: bool = fs.session._credentials is None
-        except Exception as e:
+        if anon_env:
+            self.anon: bool = True
             logger.warning(
-                f"There is a problem with your default AWS Credentials: {e}\n"
-                "`anon` mode will be used for all non-managed buckets."
+                "`anon` mode will be used for all non-managed buckets "
+                "because the environment variable LAMIN_S3_ANON was set to 'true'"
             )
-            self.anon = True
+        else:
+            try:
+                fs.connect()
+                self.anon = 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-1.16.0 → lamindb_setup-1.17.0}/lamindb_setup/core/_hub_client.py

@@ -11,8 +11,7 @@ import httpx
 from httpx_retries import Retry, RetryTransport
 from lamin_utils import logger
 from pydantic_settings import BaseSettings
-from supabase import Client, create_client  # type: ignore
-from supabase.lib.client_options import ClientOptions
+from supabase import Client, ClientOptions, create_client
 
 from ._settings_save import save_user_settings
 

{lamindb_setup-1.16.0 → lamindb_setup-1.17.0}/lamindb_setup/core/_hub_core.py

@@ -383,7 +383,8 @@ def _init_instance_hub(
 ) -> None:
     from ._settings import settings
 
-    account_id = settings.user._uuid if account_id is None else account_id
+    created_by_id = settings.user._uuid.hex if account_id is None else account_id.hex  # type: ignore
+    owner_account_id = os.getenv("LAMINDB_ACCOUNT_ID_INIT", created_by_id)
 
     try:
         lamindb_version = metadata.version("lamindb")
@@ -391,13 +392,13 @@ def _init_instance_hub(
         lamindb_version = None
     fields = {
         "id": isettings._id.hex,
-        "account_id": account_id.hex,  # type: ignore
+        "account_id": owner_account_id,
         "name": isettings.name,
         "lnid": isettings.uid,
         "schema_str": isettings._schema_str,
         "lamindb_version": lamindb_version,
         "public": False,
-        "created_by_id": account_id.hex,  # type: ignore
+        "created_by_id": created_by_id,
     }
     if isettings.dialect != "sqlite":
         db_dsn = LaminDsnModel(db=isettings.db)
@@ -407,7 +408,7 @@ def _init_instance_hub(
             "db_port": db_dsn.db.port,
             "db_database": db_dsn.db.database,
         }
-        fields.update(db_fields)
+        fields.update(db_fields)  # type: ignore
     slug = isettings.slug
     # I'd like the following to be an upsert, but this seems to violate RLS
     # Similarly, if we don't specify `returning="minimal"`, we'll violate RLS
@@ -415,7 +416,9 @@ def _init_instance_hub(
     # as then init_instance is no longer idempotent
     try:
         client.table("instance").insert(fields, returning="minimal").execute()
-    except APIError:
+    except APIError as e:
+        if "new row violates row-level security policy" in str(e):
+            raise e
         logger.warning(f"instance already existed at: https://lamin.ai/{slug}")
         return None
     if isettings.dialect != "sqlite" and isettings.is_remote:
@@ -713,7 +716,7 @@ def get_lamin_site_base_url():
 
 
 def sign_up_local_hub(email) -> str | tuple[str, str, str]:
-    # raises gotrue.errors.AuthApiError: User already registered
+    # raises AuthApiError: User already registered
     password = base62(40)  # generate new password
     sign_up_kwargs = {"email": email, "password": password}
     client = connect_hub()

{lamindb_setup-1.16.0 → lamindb_setup-1.17.0}/lamindb_setup/core/_settings.py

@@ -46,6 +46,12 @@ def _process_cache_path(cache_path: UPathStr | None) -> UPath | None:
     return cache_dir
 
 
+# returned by settings.branch for none/none instance
+class MainBranchMock:
+    id = 1
+    name = "main"
+
+
 class SetupSettings:
     """Setup settings."""
 
@@ -140,6 +146,10 @@ class SetupSettings:
     # and we never need a DB request
     def branch(self) -> Branch:
         """Default branch."""
+        # this is needed for .filter() with non-default connections
+        if not self._instance_exists:
+            return MainBranchMock()
+
         if self._branch is None:
             from lamindb import Branch
 
@@ -222,10 +232,9 @@ class SetupSettings:
         If `True`, the current instance is connected, meaning that the db and other settings
         are properly configured for use.
         """
-        if self._instance_exists:
-            return self.instance.slug != "none/none"
-        else:
-            return False
+        from . import django
+
+        return self._instance_exists and django.IS_SETUP
 
     @property
     def private_django_api(self) -> bool:
@@ -284,12 +293,7 @@ class SetupSettings:
 
     @property
     def _instance_exists(self):
-        try:
-            self.instance  # noqa
-            return True
-        # this is implicit logic that catches if no instance is loaded
-        except CurrentInstanceNotConfigured:
-            return False
+        return self.instance.slug != "none/none"
 
     @property
     def cache_dir(self) -> UPath: