lamindb_setup 1.15.2__tar.gz → 1.16.0__tar.gz

{lamindb_setup-1.15.2 → lamindb_setup-1.16.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
@@ -119,7 +119,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:

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: lamindb_setup
-Version: 1.15.2
+Version: 1.16.0
 Summary: Setup & configure LaminDB.
 Author-email: Lamin Labs <open-source@lamin.ai>
 Requires-Python: >=3.10
@@ -8,6 +8,7 @@ Description-Content-Type: text/markdown
 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

{lamindb_setup-1.15.2 → lamindb_setup-1.16.0}/lamindb_setup/__init__.py

@@ -35,7 +35,7 @@ Migration management
 
 """
 
-__version__ = "1.15.2"  # denote a release candidate for 0.1.0 with 0.1rc1
+__version__ = "1.16.0"  # denote a release candidate for 0.1.0 with 0.1rc1
 
 import os
 import warnings

{lamindb_setup-1.15.2 → lamindb_setup-1.16.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.16.0}/lamindb_setup/_setup_user.py

@@ -43,6 +43,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:
@@ -90,6 +98,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 +155,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.16.0}/lamindb_setup/core/_clone.py

@@ -5,6 +5,7 @@
 
    init_local_sqlite
    connect_local_sqlite
+   connect_remote_sqlite
    upload_sqlite_clone
 """
 
@@ -13,7 +14,6 @@ import os
 import shutil
 from pathlib import Path
 
-from lamindb_setup.core._settings_instance import InstanceSettings
 from lamindb_setup.core._settings_load import load_instance_settings
 from lamindb_setup.core._settings_store import instance_settings_file
 from lamindb_setup.core.django import reset_django

{lamindb_setup-1.15.2 → lamindb_setup-1.16.0}/lamindb_setup/core/_private_django_api.py

@@ -37,7 +37,6 @@ def private_django_api(reverse=False):
         "MultipleObjectsReturned",
         "add_to_class",
         "adelete",
-        "refresh_from_db",
         "asave",
         "clean",
         "clean_fields",

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

@@ -238,6 +238,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,

{lamindb_setup-1.15.2 → lamindb_setup-1.16.0}/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"

{lamindb_setup-1.15.2 → lamindb_setup-1.16.0}/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,13 @@ from django.db import models, transaction
 from rich.progress import Progress
 
 if TYPE_CHECKING:
-    from collections.abc import Sequence
+    from collections.abc import Iterable, Sequence
     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)
-        )
 
     return [
         name
@@ -40,8 +29,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 +48,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 +62,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 +73,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 +114,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}"
@@ -163,7 +169,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 +179,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 +230,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 +244,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 +322,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",
@@ -362,7 +387,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

{lamindb_setup-1.15.2 → lamindb_setup-1.16.0}/pyproject.toml

@@ -13,6 +13,7 @@ dependencies = [
     # External dependencies
     "django>=5.2,<5.3",
     "dj_database_url>=1.3.0,<3.0.0",
+    "django-pgtrigger",  # 30kB pure python, no dependencies
     "pydantic-settings",
     "platformdirs<5.0.0",
     "httpx_retries<1.0.0",
@@ -160,4 +161,5 @@ filterwarnings = [
     "ignore:The 'verify' parameter is deprecated. Please configure it in the http client instead.:DeprecationWarning",
     "ignore:There is no current event loop:DeprecationWarning",
     "ignore:DateTimeField.*received a naive datetime.*while time zone support is active:RuntimeWarning",
+    "ignore::sqlalchemy.exc.SAWarning"
 ]

{lamindb_setup-1.15.2 → lamindb_setup-1.16.0}/tests/hub-cloud/test_clone_instance.py

@@ -99,8 +99,8 @@ def test_connect_remote_sqlite(tmp_path):
             "lamindb_setup._connect_instance._connect_instance"
         ) as mock_connect_instance,
         patch("lamindb_setup.settings") as mock_settings,
-        patch("lamindb_setup.core._clone.InstanceSettings"),
-        patch("lamindb_setup.core._clone.create_path") as mock_create_path,
+        patch("lamindb_setup.core._settings_instance.InstanceSettings"),
+        patch("lamindb_setup.core.upath.create_path") as mock_create_path,
         patch("lamindb_setup.core._clone.connect_local_sqlite"),
     ):
         mock_instance = Mock()

{lamindb_setup-1.15.2 → lamindb_setup-1.16.0}/tests/hub-local/test_update_schema_in_hub.py

@@ -42,7 +42,11 @@ def test_update_schema_in_hub(setup_instance):
     assert "wetlab" in schema["schema_json"]
 
     assert not schema["schema_json"]["core"]["artifact"]["is_link_table"]
+    assert not schema["schema_json"]["core"]["artifact"]["is_auto_created"]
     assert schema["schema_json"]["core"]["artifactulabel"]["is_link_table"]
+    assert not schema["schema_json"]["core"]["artifactulabel"]["is_auto_created"]
+    assert schema["schema_json"]["core"]["artifact_input_of_runs"]["is_link_table"]
+    assert schema["schema_json"]["core"]["artifact_input_of_runs"]["is_auto_created"]
 
     assert schema["schema_json"]["core"]["artifact"]["name_field"] == "key"
     assert schema["schema_json"]["core"]["artifact"]["ontology_id_field"] is None
@@ -170,9 +174,9 @@ def test_update_schema_in_hub(setup_instance):
         "type": "ManyToManyField",
         "column_name": None,
         "through": {
-            "left_key": "from_transform_id",
-            "right_key": "to_transform_id",
-            "link_table_name": "lamindb_transform_predecessors",
+            "left_key": "successor_id",
+            "right_key": "predecessor_id",
+            "link_table_name": "lamindb_transformtransform",
         },
         "field_name": "predecessors",
         "model_name": "transform",
@@ -191,9 +195,9 @@ def test_update_schema_in_hub(setup_instance):
         "type": "ManyToManyField",
         "column_name": None,
         "through": {
-            "left_key": "to_transform_id",
-            "right_key": "from_transform_id",
-            "link_table_name": "lamindb_transform_predecessors",
+            "left_key": "predecessor_id",
+            "right_key": "successor_id",
+            "link_table_name": "lamindb_transformtransform",
         },
         "field_name": "successors",
         "model_name": "transform",

{lamindb_setup-1.15.2 → lamindb_setup-1.16.0}/tests/storage/test_db_import_export.py

@@ -76,6 +76,8 @@ def test_exportdb_multiple_modules(simple_instance: Callable, cleanup_export_dir
     ).save()
     gene = bt.Gene.from_source(symbol="TCF7").save()
     artifact.genes.add(gene)
+    feature = ln.Feature(name="temperature", dtype=int).save()
+    artifact.features.add_values({"temperature": 10})
 
     export_db(
         module_names=["lamindb", "bionty"],
@@ -91,6 +93,13 @@ def test_exportdb_multiple_modules(simple_instance: Callable, cleanup_export_dir
     gene_df = pd.read_parquet(cleanup_export_dir / "bionty_gene.parquet")
     assert "TCF7" in gene_df["symbol"].values
 
+    featurevalue_df = pd.read_parquet(
+        cleanup_export_dir / "lamindb_featurevalue.parquet"
+    )
+    assert len(featurevalue_df) == 1
+    assert featurevalue_df.iloc[0]["feature_id"] == feature.id
+    assert featurevalue_df.iloc[0]["value"] == "10"
+
     artifact_df = pd.read_parquet(cleanup_export_dir / "lamindb_artifact.parquet")
     assert artifact.uid in artifact_df["uid"].values
 
@@ -107,6 +116,7 @@ def test_exportdb_multiple_modules(simple_instance: Callable, cleanup_export_dir
 
     artifact.delete(permanent=True)
     gene.delete(permanent=True)
+    feature.delete(permanent=True)
 
 
 def test_exportdb_default_module(simple_instance: Callable, cleanup_export_dir: Path):
@@ -127,7 +137,42 @@ def test_exportdb_exports_link_tables(
     assert len(link_tables) > 0
 
 
-def test_import_db_from_parquet(simple_instance: Callable, tmp_path):
+def test_exportdb_handles_mixed_null_and_string_values(
+    simple_instance: Callable, cleanup_export_dir: Path
+):
+    import bionty as bt
+    import lamindb_setup as ln_setup
+
+    organism = bt.Organism.filter(name="human").one()
+
+    # Create one gene with ncbi_gene_ids populated
+    gene1 = bt.Gene(
+        symbol="GENE1",
+        ensembl_gene_id="ENSG00000001",
+        ncbi_gene_ids="12345,67890",  # String value
+        organism=organism,
+        source_id=1,
+        created_by_id=ln_setup.settings.user.id,
+    ).save()
+
+    # Create one gene with ncbi_gene_ids NULL
+    gene2 = bt.Gene(
+        symbol="GENE2",
+        ensembl_gene_id="ENSG00000002",
+        ncbi_gene_ids=None,  # NULL value
+        organism=organism,
+        source_id=1,
+        created_by_id=ln_setup.settings.user.id,
+    ).save()
+
+    # This would crash with ArrowTypeError without keep_default_na=False
+    export_db(module_names=["bionty"], output_dir=cleanup_export_dir)
+
+    gene1.delete(permanent=True)
+    gene2.delete(permanent=True)
+
+
+def test_import_db_from_parquet(simple_instance: Callable, tmp_path: Path):
     """Tests imports of a parquet file.
 
     Implicitly also tests whether `import_db` can deal with FK constraints.
@@ -223,3 +268,116 @@ def test_import_db_from_parquet(simple_instance: Callable, tmp_path):
         )
         create_stmt = cursor.fetchone()[0]
         assert "PRIMARY KEY" in create_stmt
+
+
+def test_import_db_converts_boolean_strings(simple_instance: Callable, tmp_path: Path):
+    import lamindb as ln
+    import lamindb_setup as ln_setup
+
+    export_dir = tmp_path / "export"
+    export_dir.mkdir()
+
+    artifact_data = pd.DataFrame(
+        {
+            "id": [777],
+            "uid": ["test_bool_uid"],
+            "key": ["test_bool_key"],
+            "_key_is_virtual": ["t"],
+            "_overwrite_versions": ["f"],
+            "description": ["Test boolean conversion"],
+            "suffix": [".txt"],
+            "kind": ["dataset"],
+            "size": [1024],
+            "hash": ["testhash456"],
+            "is_latest": ["t"],
+            "is_locked": ["f"],
+            "storage_id": [1],
+            "created_by_id": [ln_setup.settings.user.id],
+            "created_at": [pd.Timestamp.now()],
+            "updated_at": [pd.Timestamp.now()],
+        }
+    )
+    artifact_data.to_parquet(export_dir / "lamindb_artifact.parquet", index=False)
+
+    import_db(input_dir=export_dir, module_names=["lamindb"], if_exists="append")
+
+    imported = ln.Artifact.get(id=777)
+    assert imported._key_is_virtual is True
+    assert imported._overwrite_versions is False
+    assert imported.is_latest is True
+    assert imported.is_locked is False
+
+
+def test_import_db_converts_empty_strings_to_none(
+    simple_instance: Callable, tmp_path: Path
+):
+    import lamindb as ln
+    import lamindb_setup as ln_setup
+
+    export_dir = tmp_path / "export"
+    export_dir.mkdir()
+
+    artifact_data = pd.DataFrame(
+        {
+            "id": [666],
+            "uid": ["test_empty_str_uid"],
+            "key": ["test_empty_str_key"],
+            "_key_is_virtual": ["f"],
+            "_overwrite_versions": ["f"],
+            "_real_key": [""],
+            "description": [""],
+            "suffix": [".txt"],
+            "kind": ["dataset"],
+            "size": [1024],
+            "hash": ["testhash789"],
+            "is_latest": ["t"],
+            "is_locked": ["f"],
+            "storage_id": [1],
+            "created_by_id": [ln_setup.settings.user.id],
+            "created_at": [pd.Timestamp.now()],
+            "updated_at": [pd.Timestamp.now()],
+        }
+    )
+    artifact_data.to_parquet(export_dir / "lamindb_artifact.parquet", index=False)
+
+    import_db(input_dir=export_dir, module_names=["lamindb"], if_exists="append")
+
+    imported = ln.Artifact.get(id=666)
+    assert imported._real_key is None
+    assert imported.description is None
+
+
+def test_import_db_converts_numeric_strings(simple_instance: Callable, tmp_path: Path):
+    import lamindb as ln
+    import lamindb_setup as ln_setup
+
+    export_dir = tmp_path / "export"
+    export_dir.mkdir()
+
+    artifact_data = pd.DataFrame(
+        {
+            "id": ["555"],
+            "uid": ["test_numeric_uid"],
+            "key": ["test_numeric_key"],
+            "_key_is_virtual": ["f"],
+            "_overwrite_versions": ["f"],
+            "description": ["Test numeric conversion"],
+            "suffix": [".txt"],
+            "kind": ["dataset"],
+            "size": ["2048"],
+            "hash": ["testhash999"],
+            "is_latest": ["t"],
+            "is_locked": ["f"],
+            "storage_id": ["1"],
+            "created_by_id": [str(ln_setup.settings.user.id)],
+            "created_at": [pd.Timestamp.now()],
+            "updated_at": [pd.Timestamp.now()],
+        }
+    )
+    artifact_data.to_parquet(export_dir / "lamindb_artifact.parquet", index=False)
+
+    import_db(input_dir=export_dir, module_names=["lamindb"], if_exists="append")
+
+    imported = ln.Artifact.get(id=555)
+    assert isinstance(imported.size, int)
+    assert imported.size == 2048

{lamindb_setup-1.15.2 → lamindb_setup-1.16.0}/tests/storage/test_storage_basis.py

@@ -20,6 +20,7 @@ def test_extract_suffix_from_path():
         ("salmon.merged.gene_counts.tsv", ".tsv"),
         ("salmon.merged.gene_counts.tsv.gz", ".tsv.gz"),
         ("filename.v1.1.0.anndata.zarr", ".anndata.zarr"),
+        ("filename.h5ad.tar.gz", ".h5ad.tar.gz"),
     ]
     for path, suffix in collection:
         filepath = Path(path)