lamindb_setup 0.74.3__tar.gz → 0.76.0__tar.gz

{lamindb_setup-0.74.3 → lamindb_setup-0.76.0}/.pre-commit-config.yaml

@@ -17,7 +17,7 @@ repos:
               docs/notes/
           )
   - repo: https://github.com/astral-sh/ruff-pre-commit
-    rev: v0.1.7
+    rev: v0.5.5
     hooks:
       - id: ruff
         args: [--fix, --exit-non-zero-on-fix, --unsafe-fixes]

{lamindb_setup-0.74.3 → lamindb_setup-0.76.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: lamindb_setup
-Version: 0.74.3
+Version: 0.76.0
 Summary: Setup & configure LaminDB.
 Author-email: Lamin Labs <open-source@lamin.ai>
 Description-Content-Type: text/markdown

{lamindb_setup-0.74.3 → lamindb_setup-0.76.0}/docs/hub-cloud/01-init-local-instance.ipynb

@@ -48,6 +48,7 @@
    "outputs": [],
    "source": [
     "from pathlib import Path\n",
+    "from lnschema_core.models import Storage\n",
     "\n",
     "assert ln_setup.settings.instance.storage.type_is_cloud == False\n",
     "assert ln_setup.settings.instance.owner == ln_setup.settings.user.handle\n",
@@ -59,7 +60,9 @@
     "assert (\n",
     "    ln_setup.settings.instance.db\n",
     "    == f\"sqlite:///{Path('./mydata').resolve().as_posix()}/{ln_setup.settings.instance._id.hex}.lndb\"\n",
-    ")"
+    ")\n",
+    "assert ln_setup.settings.storage._instance_id == ln_setup.settings.instance._id\n",
+    "assert Storage.objects.get(instance_uid=ln_setup.settings.instance.uid).root == ln_setup.settings.storage.root_as_str\n"
    ]
   },
   {

{lamindb_setup-0.74.3 → lamindb_setup-0.76.0}/docs/hub-cloud/04-test-bionty.ipynb

@@ -49,7 +49,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "from lnschema_bionty import Source"
+    "from bionty import Source"
    ]
   },
   {
@@ -70,7 +70,7 @@
    },
    "outputs": [],
    "source": [
-    "from bionty_base import settings as bionty_base_settings\n",
+    "from bionty.base import settings as bionty_base_settings\n",
     "\n",
     "assert sources_df.shape[0] > 0\n",
     "assert bionty_base_settings.lamindb_sources.exists()"
@@ -154,7 +154,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.9.16"
+   "version": "3.10.13"
   },
   "vscode": {
    "interpreter": {

{lamindb_setup-0.74.3 → lamindb_setup-0.76.0}/docs/hub-cloud/05-init-hosted-instance.ipynb

@@ -125,7 +125,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.9.17"
+   "version": "3.10.13"
   }
  },
  "nbformat": 4,

{lamindb_setup-0.74.3 → lamindb_setup-0.76.0}/docs/hub-cloud/06-connect-hosted-instance.ipynb

@@ -170,7 +170,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.9.17"
+   "version": "3.10.13"
   }
  },
  "nbformat": 4,

{lamindb_setup-0.74.3 → lamindb_setup-0.76.0}/docs/hub-prod/test-sqlite-lock.ipynb

@@ -272,7 +272,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.9.17"
+   "version": "3.10.13"
   }
  },
  "nbformat": 4,

{lamindb_setup-0.74.3 → lamindb_setup-0.76.0}/lamindb_setup/__init__.py

@@ -34,7 +34,7 @@ Modules & settings:
 
 """
 
-__version__ = "0.74.3"  # denote a release candidate for 0.1.0 with 0.1rc1
+__version__ = "0.76.0"  # denote a release candidate for 0.1.0 with 0.1rc1
 
 import sys
 from os import name as _os_name

{lamindb_setup-0.74.3 → lamindb_setup-0.76.0}/lamindb_setup/_close.py

@@ -24,8 +24,9 @@ def close(mute: bool = False) -> None:
                 logger.warning("did not upload cache file - not enough permissions")
             else:
                 raise e
+        if "bionty" in settings.instance.schema:
+            delete_bionty_sources_yaml()
         current_instance_settings_file().unlink()
-        delete_bionty_sources_yaml()
         clear_locker()
         if not mute:
             logger.success(f"closed instance: {instance}")

{lamindb_setup-0.74.3 → lamindb_setup-0.76.0}/lamindb_setup/_connect_instance.py

@@ -4,7 +4,6 @@ import os
 from typing import TYPE_CHECKING
 from uuid import UUID
 
-from django.db import ProgrammingError
 from lamin_utils import logger
 
 from ._check_setup import _check_instance_setup
@@ -21,7 +20,7 @@ from .core._settings import settings
 from .core._settings_instance import InstanceSettings
 from .core._settings_load import load_instance_settings
 from .core._settings_storage import StorageSettings
-from .core._settings_store import instance_settings_file
+from .core._settings_store import instance_settings_file, settings_dir
 from .core.cloud_sqlite_locker import unlock_cloud_sqlite_upon_exception
 
 if TYPE_CHECKING:
@@ -257,9 +256,109 @@ def connect(
         if isettings is not None:
             isettings._get_settings_file().unlink(missing_ok=True)  # type: ignore
         raise e
+    # rename lnschema_bionty to bionty for sql tables
+    if "bionty" in isettings.schema:
+        no_lnschema_bionty_file = (
+            settings_dir / f"no_lnschema_bionty-{isettings.slug.replace('/', '')}"
+        )
+        if not no_lnschema_bionty_file.exists():
+            migrate_lnschema_bionty(isettings, no_lnschema_bionty_file)
     return None
 
 
+def migrate_lnschema_bionty(isettings: InstanceSettings, no_lnschema_bionty_file: Path):
+    """Migrate lnschema_bionty tables to bionty tables if bionty_source doesn't exist.
+
+    :param db_uri: str, database URI (e.g., 'sqlite:///path/to/db.sqlite' or 'postgresql://user:password@host:port/dbname')
+    """
+    from urllib.parse import urlparse
+
+    parsed_uri = urlparse(isettings.db)
+    db_type = parsed_uri.scheme
+
+    if db_type == "sqlite":
+        import sqlite3
+
+        conn = sqlite3.connect(parsed_uri.path)
+    elif db_type in ["postgresql", "postgres"]:
+        import psycopg2
+
+        conn = psycopg2.connect(isettings.db)
+    else:
+        raise ValueError("Unsupported database type. Use 'sqlite' or 'postgresql' URI.")
+
+    cur = conn.cursor()
+
+    try:
+        # check if bionty_source table exists
+        if db_type == "sqlite":
+            cur.execute(
+                "SELECT name FROM sqlite_master WHERE type='table' AND name='bionty_source'"
+            )
+            migrated = cur.fetchone() is not None
+
+            # tables that need to be renamed
+            cur.execute(
+                "SELECT name FROM sqlite_master WHERE type='table' AND name LIKE 'lnschema_bionty_%'"
+            )
+            tables_to_rename = [
+                row[0][len("lnschema_bionty_") :] for row in cur.fetchall()
+            ]
+        else:  # postgres
+            cur.execute(
+                "SELECT EXISTS (SELECT FROM information_schema.tables WHERE table_name = 'bionty_source')"
+            )
+            migrated = cur.fetchone()[0]
+
+            # tables that need to be renamed
+            cur.execute(
+                "SELECT table_name FROM information_schema.tables WHERE table_name LIKE 'lnschema_bionty_%'"
+            )
+            tables_to_rename = [
+                row[0][len("lnschema_bionty_") :] for row in cur.fetchall()
+            ]
+
+        if migrated:
+            no_lnschema_bionty_file.touch(exist_ok=True)
+        else:
+            try:
+                # rename tables only if bionty_source doesn't exist and there are tables to rename
+                for table in tables_to_rename:
+                    if db_type == "sqlite":
+                        cur.execute(
+                            f"ALTER TABLE lnschema_bionty_{table} RENAME TO bionty_{table}"
+                        )
+                    else:  # postgres
+                        cur.execute(
+                            f"ALTER TABLE lnschema_bionty_{table} RENAME TO bionty_{table};"
+                        )
+
+                # update django_migrations table
+                cur.execute(
+                    "UPDATE django_migrations SET app = 'bionty' WHERE app = 'lnschema_bionty'"
+                )
+
+                logger.warning(
+                    "Please uninstall lnschema-bionty via `pip uninstall lnschema-bionty`!"
+                )
+
+                no_lnschema_bionty_file.touch(exist_ok=True)
+            except Exception:
+                # read-only users can't rename tables
+                pass
+
+        conn.commit()
+
+    except Exception as e:
+        print(f"An error occurred: {e}")
+        conn.rollback()
+
+    finally:
+        # close the cursor and connection
+        cur.close()
+        conn.close()
+
+
 def load(
     slug: str,
     *,

{lamindb_setup-0.74.3 → lamindb_setup-0.76.0}/lamindb_setup/_init_instance.py

@@ -15,6 +15,7 @@ from ._close import close as close_instance
 from ._silence_loggers import silence_loggers
 from .core import InstanceSettings
 from .core._settings import settings
+from .core._settings_instance import is_local_db_url
 from .core._settings_storage import StorageSettings, init_storage
 from .core.upath import UPath
 
@@ -245,10 +246,16 @@ def init(
         if instance_state == "connected":
             settings.auto_connect = True  # we can also debate this switch here
             return None
-        # cannot past instance_id here because instance does not yet exist!
-        # the instance_id field of the storage table is populated at the end of
-        # init_instance_hub
-        ssettings = init_storage(storage)
+        # the conditions here match `isettings.is_remote`, but I currently don't
+        # see a way of making this more elegant; should become possible if we
+        # remove the instance.storage_id FK on the hub
+        prevent_register_hub = is_local_db_url(db) if db is not None else False
+        ssettings = init_storage(
+            storage,
+            instance_id=instance_id,
+            init_instance=True,
+            prevent_register_hub=prevent_register_hub,
+        )
         isettings = InstanceSettings(
             id=instance_id,  # type: ignore
             owner=settings.user.handle,

{lamindb_setup-0.74.3 → lamindb_setup-0.76.0}/lamindb_setup/_register_instance.py

@@ -23,7 +23,10 @@ def register(_test: bool = False):
     if ssettings._uid is None and _test:
         # because django isn't up, we can't get it from the database
         ssettings._uid = base62(8)
-    init_storage_hub(ssettings)
+    # cannot yet populate the instance id here
+    ssettings._instance_id = None
+    # flag auto_populate_instance can be removed once FK migration is over
+    init_storage_hub(ssettings, auto_populate_instance=False)
     init_instance_hub(isettings)
     isettings._is_on_hub = True
     isettings._persist()

{lamindb_setup-0.74.3 → lamindb_setup-0.76.0}/lamindb_setup/_schema_metadata.py

@@ -102,6 +102,8 @@ Type = Literal[
     "JSONField",
     "DateField",
     "FloatField",
+    "PositiveIntegerField",
+    "PositiveBigIntegerField",
 ]
 
 

{lamindb_setup-0.74.3 → lamindb_setup-0.76.0}/lamindb_setup/core/__init__.py

@@ -11,6 +11,7 @@ Settings:
    StorageSettings
 
 """
+
 from . import django, types, upath
 from ._deprecated import deprecated
 from ._docs import doc_args

{lamindb_setup-0.74.3 → lamindb_setup-0.76.0}/lamindb_setup/core/_hub_core.py

@@ -118,11 +118,13 @@ def _select_storage(
 
 def init_storage(
     ssettings: StorageSettings,
+    auto_populate_instance: bool = True,
 ) -> None:
     if settings.user.handle != "anonymous":
         return call_with_fallback_auth(
             _init_storage,
             ssettings=ssettings,
+            auto_populate_instance=auto_populate_instance,
         )
     else:
         storage_exists = call_with_fallback(
@@ -134,7 +136,9 @@ def init_storage(
             raise ValueError("Log in to create a storage location on the hub.")
 
 
-def _init_storage(ssettings: StorageSettings, client: Client) -> None:
+def _init_storage(
+    ssettings: StorageSettings, auto_populate_instance: bool, client: Client
+) -> None:
     from lamindb_setup import settings
 
     # storage roots are always stored without the trailing slash in the SQL
@@ -146,13 +150,19 @@ def _init_storage(ssettings: StorageSettings, client: Client) -> None:
         id = uuid.uuid5(uuid.NAMESPACE_URL, root)
     else:
         id = uuid.uuid4()
-    if ssettings._instance_id is None and settings._instance_exists:
+    if (
+        ssettings._instance_id is None
+        and settings._instance_exists
+        and auto_populate_instance
+    ):
         logger.warning(
             f"will manage storage location {ssettings.root_as_str} with instance {settings.instance.slug}"
         )
         ssettings._instance_id = settings.instance._id
     instance_id_hex = (
-        None if ssettings._instance_id is None else ssettings._instance_id.hex
+        ssettings._instance_id.hex
+        if (ssettings._instance_id is not None and auto_populate_instance)
+        else None
     )
     fields = {
         "id": id.hex,

{lamindb_setup-0.74.3 → lamindb_setup-0.76.0}/lamindb_setup/core/_settings_instance.py

@@ -29,6 +29,16 @@ def sanitize_git_repo_url(repo_url: str) -> str:
     return repo_url.replace(".git", "")
 
 
+def is_local_db_url(db_url: str) -> bool:
+    if "@localhost:" in db_url:
+        return True
+    if "@0.0.0.0:" in db_url:
+        return True
+    if "@127.0.0.1" in db_url:
+        return True
+    return False
+
+
 class InstanceSettings:
     """Instance settings."""
 
@@ -370,17 +380,8 @@ class InstanceSettings:
         if not self.storage.type_is_cloud:
             return False
 
-        def is_local_uri(uri: str):
-            if "@localhost:" in uri:
-                return True
-            if "@0.0.0.0:" in uri:
-                return True
-            if "@127.0.0.1" in uri:
-                return True
-            return False
-
         if self.dialect == "postgresql":
-            if is_local_uri(self.db):
+            if is_local_db_url(self.db):
                 return False
         # returns True for cloud SQLite
         # and remote postgres

{lamindb_setup-0.74.3 → lamindb_setup-0.76.0}/lamindb_setup/core/_settings_storage.py

@@ -78,7 +78,11 @@ def mark_storage_root(root: UPathStr, uid: str):
 
 
 def init_storage(
-    root: UPathStr, instance_id: UUID | None = None, register_hub: bool | None = None
+    root: UPathStr,
+    instance_id: UUID | None = None,
+    register_hub: bool | None = None,
+    prevent_register_hub: bool = False,
+    init_instance: bool = False,
 ) -> StorageSettings:
     if root is None:
         raise ValueError("`storage` argument can't be `None`")
@@ -114,11 +118,12 @@ def init_storage(
         instance_id=instance_id,
     )
     # the below might update the uid with one that's already taken on the hub
-    if ssettings.type_is_cloud or register_hub:
-        from ._hub_core import delete_storage_record
-        from ._hub_core import init_storage as init_storage_hub
+    if not prevent_register_hub:
+        if ssettings.type_is_cloud or register_hub:
+            from ._hub_core import delete_storage_record
+            from ._hub_core import init_storage as init_storage_hub
 
-        init_storage_hub(ssettings)
+            init_storage_hub(ssettings, auto_populate_instance=not init_instance)
     # below comes last only if everything else was successful
     try:
         # (federated) credentials for AWS access are provisioned under-the-hood

{lamindb_setup-0.74.3 → lamindb_setup-0.76.0}/lamindb_setup/core/_setup_bionty_sources.py

@@ -7,6 +7,9 @@ from django.db.utils import OperationalError, ProgrammingError
 if TYPE_CHECKING:
     from ._settings_instance import InstanceSettings
 
+# bionty.Source -> bionty.base
+RENAME = {"name": "source", "description": "source_name"}
+
 
 def write_bionty_sources(isettings: InstanceSettings) -> None:
     """Write bionty sources to Source table."""
@@ -14,9 +17,13 @@ def write_bionty_sources(isettings: InstanceSettings) -> None:
         return None
     import shutil
 
-    import bionty_base
-    from bionty_base.dev._handle_sources import parse_sources_yaml
-    from lnschema_bionty.models import Source
+    import bionty
+    import bionty.base as bionty_base
+    from bionty._bionty import list_biorecord_models
+    from bionty.base.dev._handle_sources import parse_sources_yaml
+    from bionty.models import Source
+
+    bionty_models = list_biorecord_models(bionty)
 
     shutil.copy(
         bionty_base.settings.current_sources, bionty_base.settings.lamindb_sources
@@ -46,7 +53,10 @@ def write_bionty_sources(isettings: InstanceSettings) -> None:
         # won't need this once lamindb is released with the new pin
         kwargs["run"] = None  # can't yet access tracking information
         kwargs["in_db"] = False
-        # kwargs["name"] = kwargs.pop("source")
+        for db_field, base_col in RENAME.items():
+            kwargs[db_field] = kwargs.pop(base_col)
+        if kwargs["entity"] in bionty_models:
+            kwargs["entity"] = f"bionty.{kwargs['entity']}"
         record = Source(**kwargs)
         all_records.append(record)
 
@@ -58,14 +68,20 @@ def load_bionty_sources(isettings: InstanceSettings):
     if "bionty" not in isettings.schema:
         return None
 
-    import bionty_base
-    from bionty_base.dev._handle_sources import parse_currently_used_sources
-    from bionty_base.dev._io import write_yaml
-    from lnschema_bionty.models import Source
+    import bionty.base as bionty_base
+    from bionty.base.dev._handle_sources import parse_currently_used_sources
+    from bionty.base.dev._io import write_yaml
+    from bionty.models import Source
 
     try:
         # need try except because of integer primary key migration
         active_records = Source.objects.filter(currently_used=True).all().values()
+        for kwargs in active_records:
+            for db_field, base_col in RENAME.items():
+                kwargs[base_col] = kwargs.pop(db_field)
+                # TODO: non-bionty schema?
+                if db_field == "entity":
+                    kwargs["entity"] = kwargs["entity"].split(".")[1]
         write_yaml(
             parse_currently_used_sources(active_records),
             bionty_base.settings.lamindb_sources,
@@ -77,7 +93,7 @@ def load_bionty_sources(isettings: InstanceSettings):
 def delete_bionty_sources_yaml():
     """Delete LAMINDB_SOURCES_PATH in bionty."""
     try:
-        import bionty_base
+        import bionty.base as bionty_base
 
         bionty_base.settings.lamindb_sources.unlink(missing_ok=True)
     except ModuleNotFoundError:

{lamindb_setup-0.74.3 → lamindb_setup-0.76.0}/lamindb_setup/core/hashing.py

@@ -17,6 +17,8 @@ from typing import TYPE_CHECKING, Iterable
 
 import psutil
 
+HASH_LENGTH = 22
+
 if TYPE_CHECKING:
     from .types import Path, UPathStr
 
@@ -39,8 +41,8 @@ def b16_to_b64(s: str):
 # a lot to read about this: lamin-notes/2022/hashing
 def hash_set(s: set[str]) -> str:
     bstr = ":".join(sorted(s)).encode("utf-8")
-    # as we're truncating at 20 b64, we choose md5 over sha512
-    return to_b64_str(hashlib.md5(bstr).digest())[:20]
+    # as we're truncating at 22 b64, we choose md5 over sha512
+    return to_b64_str(hashlib.md5(bstr).digest())[:HASH_LENGTH]
 
 
 def hash_md5s_from_dir(hashes: Iterable[str]) -> tuple[str, str]:
@@ -50,7 +52,7 @@ def hash_md5s_from_dir(hashes: Iterable[str]) -> tuple[str, str]:
         hashlib.md5(hash.encode("utf-8")).digest() for hash in sorted(hashes)
     )
     digest = hashlib.md5(digests).digest()
-    return to_b64_str(digest)[:22], "md5-d"
+    return to_b64_str(digest)[:HASH_LENGTH], "md5-d"
 
 
 def hash_code(file_path: UPathStr):
@@ -85,7 +87,7 @@ def hash_file(
                 hashlib.sha1(first_chunk).digest() + hashlib.sha1(last_chunk).digest()
             ).digest()
             hash_type = "sha1-fl"
-    return to_b64_str(digest)[:22], hash_type
+    return to_b64_str(digest)[:HASH_LENGTH], hash_type
 
 
 def hash_dir(path: Path):

{lamindb_setup-0.74.3 → lamindb_setup-0.76.0}/lamindb_setup/core/upath.py

@@ -772,7 +772,7 @@ def check_storage_is_empty(
     hint += " ignored"
     message = (
         f"Storage {directory_string} contains {n_objects - n_offset_objects} objects "
-        f"({hint}) - {ask_for_deletion}\n{objects}"
+        f"({hint}) - {ask_for_deletion}"
     )
     if n_diff > 0:
         if raise_error:

{lamindb_setup-0.74.3 → lamindb_setup-0.76.0}/noxfile.py

@@ -27,8 +27,8 @@ def lint(session: nox.Session) -> None:
     ["hub-local", "hub-prod", "hub-cloud", "storage", "docs"],
 )
 def install(session: nox.Session, group: str) -> None:
-    no_deps_packages = "git+https://github.com/laminlabs/lnschema-bionty git+https://github.com/laminlabs/lnschema-core git+https://github.com/laminlabs/wetlab lamin-cli"
-    schema_deps = f"""uv pip install --system bionty git+https://github.com/laminlabs/bionty-base
+    no_deps_packages = "git+https://github.com/laminlabs/lnschema-core git+https://github.com/laminlabs/wetlab lamin-cli"
+    schema_deps = f"""uv pip install --system git+https://github.com/laminlabs/bionty git+https://github.com/laminlabs/lamindb@main
 uv pip install --system --no-deps {no_deps_packages}
 """
     if group == "hub-cloud":

lamindb_setup-0.76.0/tests/hub-local/conftest.py

@@ -0,0 +1,29 @@
+from __future__ import annotations
+
+import os
+
+from laminhub_rest.dev._seed import seed_local_test
+from laminhub_rest.dev._supabase import SupabaseResources
+from laminhub_rest.dev._utils import remove_lamin_local_settings
+
+supabase_resources = SupabaseResources()
+
+
+pytest_plugins = [
+    "laminhub_rest.core.account.user.test.fixtures",
+    "laminhub_rest.test.fixtures.run_id",
+]
+
+
+def pytest_configure():
+    os.environ["LAMIN_ENV"] = "local"
+    remove_lamin_local_settings()
+    supabase_resources.start_local()
+    supabase_resources.reset_local()
+    supabase_resources.migrate()
+    seed_local_test()
+
+
+def pytest_unconfigure():
+    if supabase_resources.edge_function_process:
+        supabase_resources.stop_local_edge_functions()

{lamindb_setup-0.74.3 → lamindb_setup-0.76.0}/tests/hub-local/test_update_schema_in_hub.py

@@ -55,6 +55,20 @@ def test_update_schema_in_hub(setup_instance):
         "related_schema_name": None,
     }
 
+    assert schema["schema_json"]["core"]["artifact"]["fields"]["_accessor"] == {
+        "type": "CharField",
+        "column_name": "accessor",
+        "through": None,
+        "field_name": "_accessor",
+        "model_name": "artifact",
+        "schema_name": "core",
+        "is_link_table": False,
+        "relation_type": None,
+        "related_field_name": None,
+        "related_model_name": None,
+        "related_schema_name": None,
+    }
+
     assert schema["schema_json"]["core"]["artifact"]["fields"]["created_by"] == {
         "type": "ForeignKey",
         "column_name": "created_by_id",
@@ -79,7 +93,7 @@ def test_update_schema_in_hub(setup_instance):
         "through": {
             "left_key": "gene_id",
             "right_key": "pathway_id",
-            "link_table_name": "lnschema_bionty_pathway_genes",
+            "link_table_name": "bionty_pathway_genes",
         },
         "field_name": "pathways",
         "model_name": "gene",

lamindb_setup-0.74.3/tests/hub-local/conftest.py

@@ -1,23 +0,0 @@
-from __future__ import annotations
-
-import os
-
-from lamin_utils import logger
-from laminhub_rest.dev._setup_laminapp_rest import setup_local
-
-pytest_plugins = [
-    "laminhub_rest.core.account.user.test.fixtures",
-    "laminhub_rest.test.fixtures.run_id",
-]
-
-local_setup_state = setup_local()
-
-
-def pytest_configure():
-    assert os.environ["LAMIN_ENV"] == "local"
-    local_setup_state.__enter__()
-
-
-def pytest_unconfigure():
-    if os.environ["LAMIN_ENV"] == "local":
-        local_setup_state.__exit__(None, None, None)