lamindb_setup 1.15.2__tar.gz → 1.17.0__tar.gz

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

@@ -12,7 +12,7 @@ jobs:
   # tests only on production hub
   hub-prod:
     runs-on: ubuntu-latest
-    timeout-minutes: 12
+    timeout-minutes: 13
     steps:
       - uses: actions/checkout@v4
       - uses: actions/setup-python@v6
@@ -44,7 +44,7 @@ jobs:
             python-version: "3.11"
           - lamin_env: "staging"
             python-version: "3.10"
-    timeout-minutes: 12
+    timeout-minutes: 13
     steps:
       - uses: aws-actions/configure-aws-credentials@v4
         with:
@@ -94,7 +94,7 @@ jobs:
   # test user access to storage
   storage:
     runs-on: ubuntu-latest
-    timeout-minutes: 12
+    timeout-minutes: 13
     steps:
       - uses: actions/checkout@v4
       - uses: actions/setup-python@v6
@@ -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
@@ -119,7 +118,7 @@ jobs:
   # test low-level hub functionality
   hub-local:
     runs-on: ubuntu-latest
-    timeout-minutes: 12
+    timeout-minutes: 13
     steps:
       - uses: aws-actions/configure-aws-credentials@v4
         with:
@@ -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.15.2 → lamindb_setup-1.17.0}/.gitignore

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

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

@@ -1,22 +1,22 @@
-Metadata-Version: 2.3
+Metadata-Version: 2.4
 Name: lamindb_setup
-Version: 1.15.2
+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
+Requires-Dist: django-pgtrigger
 Requires-Dist: pydantic-settings
 Requires-Dist: platformdirs<5.0.0
 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.15.2 → lamindb_setup-1.17.0}/lamindb_setup/__init__.py

@@ -35,14 +35,17 @@ Migration management
 
 """
 
-__version__ = "1.15.2"  # 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.15.2 → 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.15.2 → 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.15.2 → 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.15.2 → 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.15.2 → 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.15.2 → lamindb_setup-1.17.0}/lamindb_setup/_schema_metadata.py

@@ -172,7 +172,8 @@ class _ModelHandler:
         self.table_name = model._meta.db_table
         self.included_modules = included_modules
         self.fields = self._get_fields_metadata(self.model)
-        self.is_link_table = issubclass(model, IsLink)
+        self.is_auto_created = bool(model._meta.auto_created)
+        self.is_link_table = issubclass(model, IsLink) or self.is_auto_created
         self.name_field = model._name_field if hasattr(model, "_name_field") else None
         self.ontology_id_field = (
             model._ontology_id_field if hasattr(model, "_ontology_id_field") else None
@@ -183,6 +184,7 @@ class _ModelHandler:
             "fields": self.fields.copy(),
             "class_name": self.class_name,
             "table_name": self.table_name,
+            "is_auto_created": self.is_auto_created,
             "is_link_table": self.is_link_table,
             "name_field": self.name_field,
             "ontology_id_field": self.ontology_id_field,
@@ -249,13 +251,13 @@ class _ModelHandler:
         return related_fields
 
     def _get_field_metadata(self, model, field: Field):
-        from lamindb.models import IsLink
+        from lamindb.models import IsLink, Registry
 
         internal_type = field.get_internal_type()
         model_name = field.model._meta.model_name
         relation_type = self._get_relation_type(model, field)
 
-        schema_name = field.model.__get_module_name__()
+        schema_name = Registry.__get_module_name__(field.model)
 
         if field.related_model is None:
             related_model_name = None
@@ -265,7 +267,7 @@ class _ModelHandler:
             max_length = field.max_length
         else:
             related_model_name = field.related_model._meta.model_name
-            related_schema_name = field.related_model.__get_module_name__()
+            related_schema_name = Registry.__get_module_name__(field.related_model)
             related_field_name = field.remote_field.name
             is_editable = False
             max_length = None
@@ -418,14 +420,10 @@ class _SchemaHandler:
         all_models = {module_name: {} for module_name in self.included_modules}
 
         # Iterate through all registered Django models
-        for model in apps.get_models():
+        for model in apps.get_models(include_auto_created=True):
             # Check if model meets the criteria
-            if (
-                model.__class__ is Registry
-                and model is not SQLRecord
-                and not model._meta.abstract
-            ):
-                module_name = model.__get_module_name__()
+            if model is not SQLRecord and not model._meta.abstract:
+                module_name = Registry.__get_module_name__(model)
                 # Only include if module is in our included list
                 if module_name in self.included_modules:
                     model_name = model._meta.model_name

{lamindb_setup-1.15.2 → 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
@@ -43,6 +44,14 @@ def load_user(email: str | None = None, handle: str | None = None) -> UserSettin
     return user_settings
 
 
+def current_user_uid() -> str:
+    current_user_settings = current_user_settings_file()
+    if current_user_settings.exists():
+        return load_user_settings(current_user_settings).uid
+
+    return "00000000"  # anonymous
+
+
 def login(
     user: str | None = None, *, api_key: str | None = None, **kwargs
 ) -> UserSettings:
@@ -51,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::
@@ -72,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.")
 
@@ -90,6 +101,9 @@ def login(
             "the legacy API key is deprecated and will likely be removed in a future version"
         )
 
+    # do this here because load_user overwrites current_user_settings_file
+    previous_user_uid = current_user_uid()
+
     if api_key is None:
         if "@" in user:  # type: ignore
             email, handle = user, None
@@ -144,8 +158,15 @@ def login(
     user_settings.api_key = api_key
     save_user_settings(user_settings)
 
-    if settings._instance_exists and _check_instance_setup():
-        register_user(user_settings)
+    if settings._instance_exists:
+        if (
+            isettings := settings.instance
+        ).is_on_hub and previous_user_uid != user_settings.uid:
+            logger.important_hint(
+                f"consider re-connecting to update permissions: lamin connect {isettings.slug}"
+            )
+        if _check_instance_setup():
+            register_user(user_settings)
 
     settings._user_settings = None
     # aws s3 credentials are scoped to the user

{lamindb_setup-1.15.2 → 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