lamindb 0.75.0__py3-none-any.whl → 0.75.1__py3-none-any.whl

lamindb/__init__.py

@@ -42,7 +42,7 @@ Modules & settings:
 """
 
 # denote a release candidate for 0.1.0 with 0.1rc1, 0.1a1, 0.1b1, etc.
-__version__ = "0.75.0"
+__version__ = "0.75.1"
 
 import os as _os
 

lamindb/_can_validate.py

@@ -60,6 +60,25 @@ def validate(
     )
 
 
+def _check_source_db(source: Record, using_key: str | None):
+    """Check if the source is from the DB."""
+    if using_key is not None and using_key != "default":
+        if source._state.db != using_key:
+            raise ValueError(
+                f"source must be a bionty.Source record from instance '{using_key}'!"
+            )
+
+
+def _check_organism_db(organism: Record, using_key: str | None):
+    """Check if the organism is from the DB."""
+    if isinstance(organism, Record):
+        if using_key is not None and using_key != "default":
+            if organism._state.db != using_key:
+                raise ValueError(
+                    f"organism must be a bionty.Organism record from instance '{using_key}'!"
+                )
+
+
 def _inspect(
     cls,
     values: ListLike,
@@ -78,10 +97,13 @@ def _inspect(
 
     field = get_name_field(cls, field=field)
     queryset = _queryset(cls, using_key)
-    if isinstance(source, Record) and hasattr(cls, "source_id"):
+    using_key = queryset.db
+    if isinstance(source, Record):
+        _check_source_db(source, using_key)
         queryset = queryset.filter(source=source).all()
-    orm = queryset.model
-    model_name = orm._meta.model.__name__
+    _check_organism_db(organism, using_key)
+    registry = queryset.model
+    model_name = registry._meta.model.__name__
 
     # inspect in the DB
     result_db = inspect(
@@ -94,9 +116,9 @@ def _inspect(
     )
     nonval = set(result_db.non_validated).difference(result_db.synonyms_mapper.keys())
 
-    if len(nonval) > 0 and orm.__get_schema_name__() == "bionty":
+    if len(nonval) > 0 and registry.__get_schema_name__() == "bionty":
         try:
-            bionty_result = orm.public(organism=organism, source=source).inspect(
+            bionty_result = registry.public(organism=organism, source=source).inspect(
                 values=nonval, field=field, mute=True
             )
             bionty_validated = bionty_result.validated
@@ -140,7 +162,7 @@ def _inspect(
         logger.print(f"   couldn't validate {labels}: {colors.red(print_values)}")
         logger.print(
             f"→  if you are sure, create new record{s} via"
-            f" {colors.italic(f'{orm.__name__}()')} and save to your registry"
+            f" {colors.italic(f'{registry.__name__}()')} and save to your registry"
         )
 
     return result_db
@@ -166,8 +188,11 @@ def _validate(
     field = get_name_field(cls, field=field)
 
     queryset = _queryset(cls, using_key)
-    if isinstance(source, Record) and hasattr(cls, "source_id"):
+    using_key = queryset.db
+    if isinstance(source, Record):
+        _check_source_db(source, using_key)
         queryset = queryset.filter(source=source).all()
+    _check_organism_db(organism, using_key)
     field_values = pd.Series(
         _filter_query_based_on_organism(
             queryset=queryset,
@@ -296,21 +321,24 @@ def _standardize(
         cls, field=field if return_field is None else return_field
     )
     queryset = _queryset(cls, using_key)
-    if isinstance(source, Record) and hasattr(cls, "source_id"):
+    using_key = queryset.db
+    if isinstance(source, Record):
+        _check_source_db(source, using_key)
         queryset = queryset.filter(source=source).all()
-    orm = queryset.model
+    _check_organism_db(organism, using_key)
+    registry = queryset.model
 
-    if _has_organism_field(orm):
+    if _has_organism_field(registry):
         # here, we can safely import bionty
         from bionty._bionty import create_or_get_organism_record
 
-        organism_record = create_or_get_organism_record(organism=organism, orm=orm)
+        organism_record = create_or_get_organism_record(organism=organism, orm=registry)
         organism = (
             organism_record.name if organism_record is not None else organism_record
         )
 
     try:
-        orm._meta.get_field(synonyms_field)
+        registry._meta.get_field(synonyms_field)
         df = _filter_query_based_on_organism(
             queryset=queryset, field=field, organism=organism
         )
@@ -342,7 +370,7 @@ def _standardize(
             return result
 
     # map synonyms in Bionty
-    if orm.__get_schema_name__() == "bionty" and public_aware:
+    if registry.__get_schema_name__() == "bionty" and public_aware:
         mapper = {}
         if return_mapper:
             mapper = std_names_db
@@ -350,12 +378,14 @@ def _standardize(
                 df=df, identifiers=values, return_mapper=False, mute=True, **_kwargs
             )
 
-        val_res = orm.validate(std_names_db, field=field, mute=True, organism=organism)
+        val_res = registry.validate(
+            std_names_db, field=field, mute=True, organism=organism
+        )
         if all(val_res):
             return _return(result=std_names_db, mapper=mapper)
 
         nonval = np.array(std_names_db)[~val_res]
-        std_names_bt_mapper = orm.public(organism=organism).standardize(
+        std_names_bt_mapper = registry.public(organism=organism).standardize(
             nonval, return_mapper=True, mute=True, **_kwargs
         )
 
@@ -367,7 +397,7 @@ def _standardize(
                 f" {list(std_names_bt_mapper.keys())}"
             )
             warn_msg += (
-                f"\n   please add corresponding {orm._meta.model.__name__} records via"
+                f"\n   please add corresponding {registry._meta.model.__name__} records via"
                 f" `.from_values({list(set(std_names_bt_mapper.values()))})`"
             )
             logger.warning(warn_msg)
@@ -478,13 +508,13 @@ def _filter_query_based_on_organism(
     """Filter a queryset based on organism."""
     import pandas as pd
 
-    orm = queryset.model
+    registry = queryset.model
 
-    if _has_organism_field(orm) and not _field_is_id(field, orm):
+    if _has_organism_field(registry) and not _field_is_id(field, registry):
         # here, we can safely import bionty
         from bionty._bionty import create_or_get_organism_record
 
-        organism_record = create_or_get_organism_record(organism=organism, orm=orm)
+        organism_record = create_or_get_organism_record(organism=organism, orm=registry)
         if organism_record is not None:
             queryset = queryset.filter(organism__name=organism_record.name)
 
@@ -494,10 +524,10 @@ def _filter_query_based_on_organism(
         return queryset.values_list(values_list_field, flat=True)
 
 
-def _field_is_id(field: str, orm: type[Record]) -> bool:
+def _field_is_id(field: str, registry: type[Record]) -> bool:
     """Check if the field is an ontology ID."""
-    if hasattr(orm, "_ontology_id_field"):
-        if field == orm._ontology_id_field:
+    if hasattr(registry, "_ontology_id_field"):
+        if field == registry._ontology_id_field:
             return True
     if field.endswith("id"):
         return True