lamindb_setup 1.16.0__tar.gz → 1.18.0__tar.gz

{lamindb_setup-1.16.0 → lamindb_setup-1.18.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
@@ -138,7 +137,7 @@ jobs:
           touch .env.local
           echo "AWS_ACCESS_KEY_ID_HOSTED_S3=${{ secrets.AWS_ACCESS_KEY_ID }}" >> .env.local
           echo "AWS_SECRET_ACCESS_KEY_HOSTED_S3=${{ secrets.AWS_SECRET_ACCESS_KEY }}" >> .env.local
-        working-directory: laminhub/rest-hub/supabase
+        working-directory: laminhub/backend/central/supabase
       - uses: actions/setup-python@v6
         with:
           python-version: "3.11" # we need to run everything for coverage on 3.11
@@ -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.18.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.18.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: lamindb_setup
-Version: 1.16.0
+Version: 1.18.0
 Summary: Setup & configure LaminDB.
 Author-email: Lamin Labs <open-source@lamin.ai>
 Requires-Python: >=3.10
@@ -15,14 +15,13 @@ 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: websockets>=13.0
 Requires-Dist: pyjwt<3.0.0
 Requires-Dist: psutil
 Requires-Dist: packaging
 Requires-Dist: aiobotocore[boto3]>=2.12.4,<3.0.0 ; extra == "aws"
-Requires-Dist: s3fs>=2023.12.2,<=2025.9.0,!=2024.10.0 ; extra == "aws"
+Requires-Dist: s3fs>=2023.12.2,<=2025.12.0,!=2024.10.0 ; extra == "aws"
 Requires-Dist: line_profiler ; extra == "dev"
 Requires-Dist: psycopg2-binary ; extra == "dev"
 Requires-Dist: python-dotenv ; extra == "dev"
@@ -33,7 +32,7 @@ Requires-Dist: pytest-xdist ; extra == "dev"
 Requires-Dist: nbproject-test>=0.4.3 ; extra == "dev"
 Requires-Dist: pandas ; extra == "dev"
 Requires-Dist: django-schema-graph ; extra == "erdiagram"
-Requires-Dist: gcsfs>=2023.12.2,<=2025.9.0 ; extra == "gcp"
+Requires-Dist: gcsfs>=2023.12.2,<=2025.12.0 ; extra == "gcp"
 Project-URL: Home, https://github.com/laminlabs/lamindb-setup
 Provides-Extra: aws
 Provides-Extra: dev

{lamindb_setup-1.16.0 → lamindb_setup-1.18.0}/docs/hub-cloud/01-init-local-instance.ipynb

@@ -24,7 +24,8 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "import lamindb_setup as ln_setup"
+    "import lamindb_setup as ln_setup\n",
+    "import os"
    ]
   },
   {
@@ -42,7 +43,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "ln_setup.init(storage=\"./mydata\")"
+    "ln_setup.init(storage=\"./mydata\", modules=\"bionty\")"
    ]
   },
   {
@@ -70,10 +71,11 @@
     "assert ln_setup.settings.instance.storage.type_is_cloud is False\n",
     "assert ln_setup.settings.instance.owner == ln_setup.settings.user.handle\n",
     "assert ln_setup.settings.instance.name == \"mydata\"\n",
+    "assert ln_setup.settings.instance.modules == {\"bionty\"}\n",
     "assert ln_setup.settings.storage.root.as_posix() == Path(\"mydata\").resolve().as_posix()\n",
     "storage_root = ln_setup.settings.storage.root\n",
     "assert storage_root.exists()\n",
-    "assert ln_setup.settings.storage.id is not None\n",
+    "assert ln_setup.settings.storage._id is not None\n",
     "assert (\n",
     "    ln_setup.settings.instance.db\n",
     "    == f\"sqlite:///{Path('./mydata').resolve().as_posix()}/.lamindb/lamin.db\"\n",
@@ -85,6 +87,16 @@
     ")"
    ]
   },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "exit_status = os.system(\"lamin migrate deploy\")\n",
+    "assert exit_status == 0"
+   ]
+  },
   {
    "cell_type": "code",
    "execution_count": null,
@@ -124,7 +136,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.10.16"
+   "version": "3.11.14"
   }
  },
  "nbformat": 4,

{lamindb_setup-1.16.0 → lamindb_setup-1.18.0}/docs/hub-cloud/02-connect-local-instance.ipynb

@@ -171,7 +171,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.10.16"
+   "version": "3.11.14"
   },
   "vscode": {
    "interpreter": {

{lamindb_setup-1.16.0 → lamindb_setup-1.18.0}/docs/hub-cloud/03-add-managed-storage.ipynb

@@ -7,7 +7,7 @@
     "tags": []
    },
    "source": [
-    "# Add managed and referenced storage locations"
+    "# Add writeable and read-only storage locations to an instance"
    ]
   },
   {
@@ -84,22 +84,12 @@
     "ln_setup.init(storage=\"./storage1\", name=\"test-add-managed-storage\", db=pgurl)"
    ]
   },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "95a61826",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "ln_setup.settings.instance.is_on_hub"
-   ]
-  },
   {
    "cell_type": "markdown",
    "id": "b62e84cb",
    "metadata": {},
    "source": [
-    "Test adding referenced storage location."
+    "Test adding a referenced read-only storage location."
    ]
   },
   {
@@ -120,7 +110,7 @@
    "id": "93234f70",
    "metadata": {},
    "source": [
-    "Now continue with managed storage locations."
+    "Now continue with writeable storage locations."
    ]
   },
   {
@@ -134,6 +124,14 @@
     "storage1_uid = ln_setup.settings.storage.uid"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "id": "548190d1",
+   "metadata": {},
+   "source": [
+    "This errors at first."
+   ]
+  },
   {
    "cell_type": "code",
    "execution_count": null,
@@ -149,6 +147,14 @@
     ")"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "id": "845d9c9c",
+   "metadata": {},
+   "source": [
+    "Register the instance on the hub."
+   ]
+  },
   {
    "cell_type": "code",
    "execution_count": null,
@@ -162,11 +168,12 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "825c34b7",
+   "id": "1660bb27",
    "metadata": {},
    "outputs": [],
    "source": [
-    "ln_setup.settings.instance.is_on_hub"
+    "assert ln_setup.settings.instance.is_on_hub\n",
+    "assert not ln_setup.settings.instance.is_managed_by_hub"
    ]
   },
   {
@@ -417,7 +424,7 @@
    "outputs": [],
    "source": [
     "from lamindb_setup.core._hub_client import connect_hub_with_auth\n",
-    "from laminhub_rest.core._central_client import SupabaseClientWrapper\n",
+    "from lamincentral.client import SupabaseClientWrapper\n",
     "from laminhub_rest.core.instance_collaborator import InstanceCollaboratorHandler\n",
     "from laminhub_rest.core.organization import OrganizationMemberHandler\n",
     "\n",
@@ -432,11 +439,16 @@
     "account_id = ln_setup.settings.user._uuid\n",
     "\n",
     "try:\n",
-    "    organization_member_handler.add(\n",
-    "        organization_id=organization_id,\n",
-    "        account_id=account_id,\n",
-    "        role=\"member\",\n",
-    "    )\n",
+    "    try:\n",
+    "        organization_member_handler.add(\n",
+    "            organization_id=organization_id,\n",
+    "            account_id=account_id,\n",
+    "            role=\"member\",\n",
+    "        )\n",
+    "    except KeyError:\n",
+    "        # we don't set LAMIN_API_KEY, so broadcasting cache invalidation fails\n",
+    "        # it should still be fine with adding to the organization\n",
+    "        pass\n",
     "    try:\n",
     "        InstanceCollaboratorHandler(admin_hub).add(\n",
     "            account_id=account_id,\n",
@@ -456,10 +468,15 @@
     "        ln_setup.delete(\"testuser1/test-add-managed-storage\", force=True)\n",
     "\n",
     "finally:\n",
-    "    organization_member_handler.remove(\n",
-    "        organization_id=organization_id,\n",
-    "        account_id=account_id,\n",
-    "    )\n",
+    "    try:\n",
+    "        organization_member_handler.remove(\n",
+    "            organization_id=organization_id,\n",
+    "            account_id=account_id,\n",
+    "        )\n",
+    "    except KeyError:\n",
+    "        # we don't set LAMIN_API_KEY, so broadcasting cache invalidation fails\n",
+    "        # it should still be fine with deletion from the organization\n",
+    "        pass\n",
     "    admin_hub.auth.sign_out(options={\"scope\": \"local\"})"
    ]
   },
@@ -525,7 +542,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.10.16"
+   "version": "3.11.14"
   }
  },
  "nbformat": 4,

{lamindb_setup-1.16.0 → lamindb_setup-1.18.0}/docs/hub-cloud/05-init-hosted-instance.ipynb

@@ -95,7 +95,7 @@
     "assert ln_setup.settings.instance.owner == ln_setup.settings.user.handle\n",
     "assert ln_setup.settings.instance.name == \"my-hosted\"\n",
     "assert ln_setup.settings.storage.root.as_posix().startswith(HOSTED_BUCKETS)\n",
-    "assert ln_setup.settings.storage.id is not None\n",
+    "assert ln_setup.settings.storage._id is not None\n",
     "\n",
     "assert ln_setup.settings.storage._mark_storage_root.exists()"
    ]

{lamindb_setup-1.16.0 → lamindb_setup-1.18.0}/docs/hub-prod/test-import-schema.ipynb

@@ -49,7 +49,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "import wetlab as lb"
+    "import wetlab as wl"
    ]
   },
   {
@@ -69,7 +69,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "lb.Experiment"
+    "wl.Compound"
    ]
   },
   {

{lamindb_setup-1.16.0 → lamindb_setup-1.18.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.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-1.18.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.18.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
@@ -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