lamindb_setup 1.15.2__py3-none-any.whl → 1.17.0__py3-none-any.whl

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:

lamindb_setup/core/_settings_instance.py

@@ -125,10 +125,11 @@ class InstanceSettings:
                 if self._local_storage is not None:
                     value_local = self.local_storage
                     representation += f"\n - local storage: {value_local.root_as_str} ({value_local.region})"
-                    representation += (
-                        f"\n - cloud storage: {value.root_as_str} ({value.region})"
-                    )
-                else:
+                    if value is not None:
+                        representation += (
+                            f"\n - cloud storage: {value.root_as_str} ({value.region})"
+                        )
+                elif value is not None:
                     representation += (
                         f"\n - storage: {value.root_as_str} ({value.region})"
                     )
@@ -513,17 +514,36 @@ class InstanceSettings:
 
     @property
     def dialect(self) -> Literal["sqlite", "postgresql"]:
-        """SQL dialect."""
+        """SQL dialect.
+
+        Equivalent to :attr:`vendor`.
+
+        "vendor" is the Django terminology for the type of database. "dialect" is the SQLAlchemy terminology.
+        """
         if self._db is None or self._db.startswith("sqlite://"):
             return "sqlite"
         else:
             assert self._db.startswith("postgresql"), f"Unexpected DB value: {self._db}"
             return "postgresql"
 
+    @property
+    def vendor(self) -> Literal["sqlite", "postgresql"]:
+        """Database vendor.
+
+        Equivalent to :attr:`dialect`.
+
+        "vendor" is the Django terminology for the type of database. "dialect" is the SQLAlchemy terminology.
+        """
+        return self.dialect
+
     @property
     def _is_cloud_sqlite(self) -> bool:
         """Is this a cloud instance with sqlite db."""
-        return self.dialect == "sqlite" and self.storage.type_is_cloud
+        return (
+            self.dialect == "sqlite"
+            and self.storage is not None
+            and self.storage.type_is_cloud
+        )
 
     @property
     def _cloud_sqlite_locker(self):
@@ -543,6 +563,8 @@ class InstanceSettings:
     @property
     def is_remote(self) -> bool:
         """Boolean indicating if an instance has no local component."""
+        if self.storage is None and self.db == "sqlite:///:memory:":
+            return False
         return check_is_instance_remote(self.storage.root_as_str, self.db)
 
     @property

lamindb_setup/core/_settings_load.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import os
+from importlib.util import find_spec
 from pathlib import Path
 from typing import TYPE_CHECKING
 from uuid import UUID, uuid4
@@ -46,19 +47,36 @@ def load_cache_path_from_settings(storage_settings: Path | None = None) -> Path
         return None
 
 
+def find_module_candidates():
+    """Find all local packages that depend on lamindb."""
+    candidates = ["bionty", "wetlab"]
+    return [c for c in candidates if find_spec(c) is not None]
+
+
 def load_instance_settings(instance_settings_file: Path | None = None):
     if instance_settings_file is None:
-        instance_settings_file = current_instance_settings_file()
-    if not instance_settings_file.exists():
+        isettings_file = current_instance_settings_file()
+        if not isettings_file.exists():
+            isettings = InstanceSettings(
+                id=UUID("00000000-0000-0000-0000-000000000000"),
+                owner="none",
+                name="none",
+                storage=None,
+                modules=",".join(find_module_candidates()),
+            )
+            return isettings
+    else:
+        isettings_file = instance_settings_file
+
+    if not isettings_file.exists():
+        # this errors only if the file was explicitly provided
         raise CurrentInstanceNotConfigured
     try:
-        settings_store = InstanceSettingsStore(_env_file=instance_settings_file)
+        settings_store = InstanceSettingsStore(_env_file=isettings_file)
     except (ValidationError, TypeError) as error:
-        with open(instance_settings_file) as f:
-            content = f.read()
         raise SettingsEnvFileOutdated(
-            f"\n\n{error}\n\nYour instance settings file with\n\n{content}\nis invalid"
-            f" (likely outdated), see validation error. Please delete {instance_settings_file} &"
+            f"\n\n{error}\n\nYour instance settings file with\n\n{isettings_file.read_text()}\nis invalid"
+            f" (likely outdated), see validation error. Please delete {isettings_file} &"
             " reload (remote) or re-initialize (local) the instance with the same name & storage location."
         ) from error
     isettings = setup_instance_from_store(settings_store)

lamindb_setup/core/_settings_storage.py

@@ -122,6 +122,7 @@ def init_storage(
     access_token: str | None = None,
     region: str | None = None,
     space_uuid: UUID | None = None,
+    skip_mark_storage_root: bool = False,
 ) -> tuple[
     StorageSettings,
     Literal["hub-record-not-created", "hub-record-retrieved", "hub-record-created"],
@@ -181,7 +182,8 @@ def init_storage(
         space_id=space_uuid,
     )
     # we check the write access here if the storage record has not been retrieved from the hub
-    if hub_record_status != "hub-record-retrieved":
+    # Sergei: should it in fact still go through if hub_record_status == "hub-record-not-created"?
+    if hub_record_status != "hub-record-retrieved" and not skip_mark_storage_root:
         try:
             # (federated) credentials for AWS access are provisioned under-the-hood
             # discussion: https://laminlabs.slack.com/archives/C04FPE8V01W/p1719260587167489

lamindb_setup/core/django.py

@@ -5,13 +5,15 @@ import builtins
 import os
 import sys
 import importlib as il
+import gzip
 import jwt
 import time
 import threading
 from pathlib import Path
+import shutil
 from packaging import version
 from ._settings_instance import InstanceSettings, is_local_db_url
-
+from ..errors import CurrentInstanceNotConfigured
 from lamin_utils import logger
 
 
@@ -21,6 +23,24 @@ IS_MIGRATING = False
 CONN_MAX_AGE = 299
 
 
+def get_connection(connection_name: str):
+    from django.db import connections
+
+    return connections[connection_name]
+
+
+def error_no_instance_wrapper(execute, sql, params, many, context):
+    connection = context["connection"]
+
+    if (
+        connection.vendor == "sqlite"
+        and connection.settings_dict.get("NAME") == ":memory:"
+    ):
+        raise CurrentInstanceNotConfigured
+
+    return execute(sql, params, many, context)
+
+
 # db token that refreshes on access if needed
 class DBToken:
     def __init__(
@@ -64,11 +84,6 @@ class DBTokenManager:
 
         self.tokens: dict[str, DBToken] = {}
 
-    def get_connection(self, connection_name: str):
-        from django.db import connections
-
-        return connections[connection_name]
-
     def set(self, token: DBToken, connection_name: str = "default"):
         if connection_name in self.tokens:
             return
@@ -77,11 +92,7 @@ class DBTokenManager:
         from django.db.backends.signals import connection_created
 
         def set_token_wrapper(execute, sql, params, many, context):
-            not_in_atomic_block = (
-                context is None
-                or "connection" not in context
-                or not context["connection"].in_atomic_block
-            )
+            not_in_atomic_block = not context["connection"].in_atomic_block
             # ignore atomic blocks
             if not_in_atomic_block:
                 sql = token.token_query + sql
@@ -98,7 +109,7 @@ class DBTokenManager:
                 result.nextset()
             return result
 
-        self.get_connection(connection_name).execute_wrappers.append(set_token_wrapper)
+        get_connection(connection_name).execute_wrappers.append(set_token_wrapper)
 
         def connection_callback(sender, connection, **kwargs):
             if (
@@ -124,7 +135,7 @@ class DBTokenManager:
                 if connection_name in self.tokens:
                     # here we don't use the connection from the closure
                     # because Atomic is a single class to manage transactions for all connections
-                    connection = self.get_connection(connection_name)
+                    connection = get_connection(connection_name)
                     if len(connection.atomic_blocks) == 1:
                         token = self.tokens[connection_name]
                         # use raw psycopg2 connection here
@@ -142,7 +153,7 @@ class DBTokenManager:
 
         from django.db.backends.signals import connection_created
 
-        connection = self.get_connection(connection_name)
+        connection = get_connection(connection_name)
 
         connection.execute_wrappers = [
             w
@@ -238,6 +249,8 @@ def setup_django(
         if view_schema:
             installed_apps = installed_apps[::-1]  # to fix how apps appear
             installed_apps += ["schema_graph", "django.contrib.staticfiles"]
+        if isettings.dialect == "postgresql":
+            installed_apps.insert(0, "pgtrigger")
 
         kwargs = dict(
             INSTALLED_APPS=installed_apps,
@@ -289,6 +302,9 @@ def setup_django(
             django.db.connections._connections = threading.local()
             logger.debug("django.db.connections._connections has been patched")
 
+        # error if trying to query with the default connection without setting up an instance
+        get_connection("default").execute_wrappers.insert(0, error_no_instance_wrapper)
+
         if isettings._fine_grained_access and isettings._db_permissions == "jwt":
             db_token = DBToken(isettings)
             db_token_manager.set(db_token)  # sets for the default connection
@@ -309,10 +325,24 @@ def setup_django(
             call_command("migrate", app_name, app_number, verbosity=2)
         isettings._update_cloud_sqlite_file(unlock_cloud_sqlite=False)
     elif init:
-        global IS_MIGRATING
-        IS_MIGRATING = True
-        call_command("migrate", verbosity=0)
-        IS_MIGRATING = False
+        modules_beyond_bionty = isettings.modules.copy()
+        compressed_sqlite_path = Path(__file__).parent / "lamin.db.gz"
+        if "bionty" in modules_beyond_bionty:
+            modules_beyond_bionty.remove("bionty")
+        if (
+            isettings.dialect == "postgresql"
+            or os.getenv("LAMINDB_INIT_FROM_SCRATCH", "false") == "true"
+            or len(modules_beyond_bionty) > 0
+            or not compressed_sqlite_path.exists()
+        ):
+            global IS_MIGRATING
+            IS_MIGRATING = True
+            call_command("migrate", verbosity=0)
+            IS_MIGRATING = False
+        else:
+            with gzip.open(compressed_sqlite_path, "rb") as f_in:
+                with open(isettings._sqlite_file_local, "wb") as f_out:
+                    shutil.copyfileobj(f_in, f_out)
 
     global IS_SETUP
     IS_SETUP = True

lamindb_setup/core/upath.py

@@ -93,10 +93,12 @@ def extract_suffix_from_path(path: Path, arg_name: str | None = None) -> str:
         else:
             return suffix
 
-    if len(path.suffixes) <= 1:
+    suffixes = path.suffixes
+
+    if len(suffixes) <= 1:
         return process_digits(path.suffix)
 
-    total_suffix = "".join(path.suffixes)
+    total_suffix = "".join(suffixes)
     if total_suffix in VALID_SIMPLE_SUFFIXES:
         return total_suffix
     elif total_suffix.endswith(tuple(VALID_COMPOSITE_SUFFIXES)):
@@ -115,14 +117,24 @@ def extract_suffix_from_path(path: Path, arg_name: str | None = None) -> str:
         # in COMPRESSION_SUFFIXES to detect something like .random.gz and then
         # add ".random.gz" but concluded it's too dangerous it's safer to just
         # use ".gz" in such a case
-        if path.suffixes[-2] in VALID_SIMPLE_SUFFIXES:
-            suffix = "".join(path.suffixes[-2:])
-            msg += f"inferring: '{suffix}'"
+        if suffixes[-2] in VALID_SIMPLE_SUFFIXES:
+            suffix = "".join(suffixes[-2:])
+            # if the suffix preceding the compression suffixes is a valid suffix,
+            # we account for it; otherwise we don't.
+            # i.e. we should have .h5ad.tar.gz or .csv.tar.gz, not just .tar.gz
+            if (
+                suffix == ".tar.gz"
+                and len(suffixes) > 2
+                and (suffix_3 := suffixes[-3]) in VALID_SIMPLE_SUFFIXES
+            ):
+                suffix = suffix_3 + suffix
             # do not print a warning for things like .tar.gz, .fastq.gz
-            if path.suffixes[-1] == ".gz":
+            if suffixes[-1] == ".gz":
                 print_hint = False
+            else:
+                msg += f"inferring: '{suffix}'"
         else:
-            suffix = path.suffixes[-1]  # this is equivalent to path.suffix
+            suffix = suffixes[-1]  # this is equivalent to path.suffix
             msg += (
                 f"using only last suffix: '{suffix}' - if you want your composite"
                 " suffix to be recognized add it to"
@@ -993,13 +1005,22 @@ def check_storage_is_empty(
         objects = [o for o in objects if "/.lamindb/_exclusion/" not in o]
     n_files = len(objects)
     n_diff = n_files - n_offset_objects
-    ask_for_deletion = (
-        "delete them prior to deleting the storage location"
-        if raise_error
-        else "consider deleting them"
-    )
-    message = f"'{directory_string}' contains {n_diff} objects - {ask_for_deletion}"
     if n_diff > 0:
+        ask_for_deletion = (
+            "delete them prior to deleting the storage location"
+            if raise_error
+            else "consider deleting them"
+        )
+        message = f"'{directory_string}' contains {n_diff} objects:\n"
+        message += "\n".join(
+            [
+                o
+                for o in objects
+                if not o.endswith(".lamindb/storage_uid.txt")
+                and not (account_for_sqlite_file and o.endswith(".lamindb/lamin.db"))
+            ]
+        )
+        message += f"\n{ask_for_deletion}"
         if raise_error:
             raise StorageNotEmpty(message) from None
         else:

lamindb_setup/errors.py

@@ -1,7 +1,6 @@
 """Errors.
 
 .. autoexception:: CurrentInstanceNotConfigured
-.. autoexception:: InstanceNotSetupError
 .. autoexception:: ModuleWasntConfigured
 .. autoexception:: StorageAlreadyManaged
 .. autoexception:: StorageNotEmpty
@@ -25,17 +24,6 @@ class DefaultMessageException(Exception):
         super().__init__(message)
 
 
-# TODO: remove this exception sooner or later because we don't have a need for it anymore
-class InstanceNotSetupError(DefaultMessageException):
-    default_message = """\
-To use lamindb, you need to connect to an instance.
-
-Connect to an instance: `ln.connect()`. Init an instance: `ln.setup.init()`.
-
-If you used the CLI to set up lamindb in a notebook, restart the Python session.
-"""
-
-
 class CurrentInstanceNotConfigured(DefaultMessageException):
     default_message = """\
 No instance is connected! Call

lamindb_setup/io.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 import io
 import json
 import warnings
-from concurrent.futures import ProcessPoolExecutor, as_completed
+from concurrent.futures import ThreadPoolExecutor, as_completed
 from importlib import import_module
 from pathlib import Path
 from typing import TYPE_CHECKING
@@ -14,24 +14,16 @@ from django.db import models, transaction
 from rich.progress import Progress
 
 if TYPE_CHECKING:
-    from collections.abc import Sequence
+    from collections.abc import Iterable
     from typing import Literal
 
 
 def _get_registries(module_name: str) -> list[str]:
     """Get registry class names from a module."""
     schema_module = import_module(module_name)
-    exclude = {"SQLRecord", "BaseSQLRecord"}
 
-    if module_name == "lamindb":
-        module_filter = lambda cls, name: cls.__module__.startswith(
-            f"{module_name}.models."
-        ) and name in dir(schema_module)
-    else:
-        module_filter = (
-            lambda cls, name: cls.__module__ == f"{module_name}.models"
-            and name in dir(schema_module)
-        )
+    # Ensure that models are loaded; we've observed empty exports otherwise
+    from django.db import models
 
     return [
         name
@@ -40,8 +32,8 @@ def _get_registries(module_name: str) -> list[str]:
             name[0].isupper()
             and isinstance(cls := getattr(schema_module.models, name, None), type)
             and issubclass(cls, models.Model)
-            and module_filter(cls, name)
-            and name not in exclude
+            # Table names starting with `None_` are abstract base classes or Django mixins
+            and not cls._meta.db_table.startswith("None_")  # type: ignore
         )
     ]
 
@@ -59,7 +51,7 @@ def _export_full_table(
     For SQLite with large tables, reads in chunks to avoid memory issues when tables exceed available RAM.
 
     Args:
-        registry_info: Tuple of (module_name, model_name, field_name) where field_name
+        registry_info: Tuple of (module_name, model_name, field_name) where `field_name`
             is None for regular tables or the field name for M2M link tables.
         directory: Output directory for parquet files.
         chunk_size: Maximum rows per chunk for SQLite large tables.
@@ -73,7 +65,7 @@ def _export_full_table(
 
     module_name, model_name, field_name = registry_info
     schema_module = import_module(module_name)
-    registry = getattr(schema_module, model_name)
+    registry = getattr(schema_module.models, model_name)
 
     if field_name:
         registry = getattr(registry, field_name).through
@@ -84,12 +76,19 @@ def _export_full_table(
         if ln_setup.settings.instance.dialect == "postgresql":
             buffer = io.StringIO()
             with connection.cursor() as cursor:
+                cursor.execute("SET statement_timeout = 0")
                 cursor.copy_expert(
                     f'COPY "{table_name}" TO STDOUT WITH (FORMAT CSV, HEADER TRUE)',
                     buffer,
                 )
             buffer.seek(0)
-            df = pd.read_csv(buffer)
+            # Prevent pandas from converting empty strings to float NaN (which PyArrow rejects)
+            df = pd.read_csv(buffer, keep_default_na=False)
+            # Convert object columns to string to handle mixed types from data corruption,
+            # schema migrations, or manual SQL inserts. PyArrow rejects mixed-type objects.
+            df = df.astype(
+                {col: str for col in df.columns if df[col].dtype == "object"}
+            )
             df.to_parquet(directory / f"{table_name}.parquet", compression=None)
             return (
                 f"{module_name}.{model_name}.{field_name}"
@@ -118,11 +117,21 @@ def _export_full_table(
                         chunk_file = (
                             directory / f"{table_name}_chunk_{chunk_id}.parquet"
                         )
+                        df = df.astype(
+                            {
+                                col: str
+                                for col in df.columns
+                                if df[col].dtype == "object"
+                            }
+                        )
                         df.to_parquet(chunk_file, compression=None)
                         chunk_files.append((table_name, chunk_file))
                     return chunk_files
                 else:
                     df = pd.read_sql_table(table_name, ln_setup.settings.instance.db)
+                    df = df.astype(
+                        {col: str for col in df.columns if df[col].dtype == "object"}
+                    )
                     df.to_parquet(directory / f"{table_name}.parquet", compression=None)
                     return (
                         f"{module_name}.{model_name}.{field_name}"
@@ -136,9 +145,9 @@ def _export_full_table(
 
 
 def export_db(
-    module_names: Sequence[str] | None = None,
+    module_names: Iterable[str] | None = None,
     *,
-    output_dir: str | Path = "./lamindb_export/",
+    output_dir: str | Path | None = None,
     max_workers: int = 8,
     chunk_size: int = 500_000,
 ) -> None:
@@ -153,6 +162,11 @@ def export_db(
         max_workers: Number of parallel processes.
         chunk_size: Number of rows per chunk for large tables.
     """
+    import lamindb_setup as ln_setup
+
+    if output_dir is None:
+        output_dir = f"./{ln_setup.settings.instance.name}_export/"
+
     directory = Path(output_dir)
     directory.mkdir(parents=True, exist_ok=True)
 
@@ -163,7 +177,7 @@ def export_db(
     for module_name, model_names in modules.items():
         schema_module = import_module(module_name)
         for model_name in model_names:
-            registry = getattr(schema_module, model_name)
+            registry = getattr(schema_module.models, model_name)
             tasks.append((module_name, model_name, None))
             for field in registry._meta.many_to_many:
                 tasks.append((module_name, model_name, field.name))
@@ -173,13 +187,8 @@ def export_db(
     with Progress() as progress:
         task_id = progress.add_task("Exporting", total=len(tasks))
 
-        import multiprocessing
-
-        mp_context = multiprocessing.get_context("spawn")
-
-        with ProcessPoolExecutor(
-            max_workers=max_workers, mp_context=mp_context
-        ) as executor:
+        # This must be a ThreadPoolExecutor and not a ProcessPoolExecutor to inherit JWTs
+        with ThreadPoolExecutor(max_workers=max_workers) as executor:
             futures = {
                 executor.submit(_export_full_table, task, directory, chunk_size): task
                 for task in tasks
@@ -229,7 +238,6 @@ def _import_registry(
     parquet_file = directory / f"{table_name}.parquet"
 
     if not parquet_file.exists():
-        print(f"Skipped {table_name} (file not found)")
         return
 
     df = pd.read_parquet(parquet_file)
@@ -244,12 +252,37 @@ def _import_registry(
             if mask.any():
                 df.loc[mask, col] = df.loc[mask, col].map(_serialize_value)
 
+    for field in registry._meta.fields:
+        # Convert PostgreSQL boolean string literals ('t'/'f') to Python booleans for SQLite compatibility
+        if field.get_internal_type() == "BooleanField" and field.column in df.columns:
+            df[field.column] = df[field.column].map(
+                {"t": True, "f": False, True: True, False: False, None: None}
+            )
+
+        # PostgreSQL CSV export writes NULL as empty string; convert back to None for nullable fields
+        if field.null and field.column in df.columns:
+            df[field.column] = df[field.column].replace("", None)
+
+        # Convert numeric fields from strings to proper types for SQLite
+        if (
+            field.get_internal_type()
+            in (
+                "IntegerField",
+                "BigIntegerField",
+                "PositiveIntegerField",
+                "FloatField",
+                "DecimalField",
+            )
+            and field.column in df.columns
+        ):
+            df[field.column] = pd.to_numeric(df[field.column], errors="coerce")
+
     if if_exists == "append":
         # Fill NULL values in NOT NULL columns to handle schema mismatches between postgres source and SQLite target
         # This allows importing data where fields were nullable
         for field in registry._meta.fields:
             if field.column in df.columns and not field.null:
-                df[field.column] = df[field.column].fillna("")
+                df[field.column] = df[field.column].fillna("").infer_objects(copy=False)
 
     if df.empty:
         return
@@ -297,7 +330,7 @@ def _import_registry(
 
 
 def import_db(
-    module_names: Sequence[str] | None = None,
+    module_names: Iterable[str] | None = None,
     *,
     input_dir: str | Path = "./lamindb_export/",
     if_exists: Literal["fail", "replace", "append"] = "replace",
@@ -307,12 +340,15 @@ def import_db(
     Temporarily disables FK constraints to allow insertion in arbitrary order.
     Requires superuser/RDS admin privileges for postgres databases.
 
+    Note: When running in a subprocess, add a short delay or explicit connection close after `import_db()`
+    to ensure all SQLite writes are flushed to disk before process termination.
+
     Args:
         input_dir: Directory containing parquet files to import.
         module_names: Module names to import (e.g., ["lamindb", "bionty", "wetlab"]).
         if_exists: How to behave if table exists: 'fail', 'replace', or 'append'.
-            If set to 'replace', existing data is deleted and new data is imported. PKs and indices are not guaranteed to be preserved which can lead to write errors.
-            If set to 'append', new data is added to existing data without clearing the table. PKs and indices are preserved but database size will greatly increase.
+            If set to 'replace', existing data is deleted and new data is imported. All PKs and indices are not guaranteed to be preserved which can lead to write errors.
+            If set to 'append', new data is added to existing data without clearing the table. All PKs and indices are preserved allowing write operations but database size will greatly increase.
             If set to 'fail', raises an error if the table contains any data.
     """
     from django.db import connection
@@ -362,7 +398,7 @@ def import_db(
                         progress.update(
                             task, description=f"[cyan]{module_name}.{model_name}"
                         )
-                        registry = getattr(schema_module, model_name)
+                        registry = getattr(schema_module.models, model_name)
                         _import_registry(registry, directory, if_exists=if_exists)
                         for field in registry._meta.many_to_many:
                             link_orm = getattr(registry, field.name).through