lamindb 0.69.2__py3-none-any.whl → 0.69.3__py3-none-any.whl

lamindb/_artifact.py

@@ -15,8 +15,7 @@ from lamindb_setup.core.types import UPathStr
 from lamindb_setup.core.upath import (
     create_path,
     extract_suffix_from_path,
-    get_stat_dir_gs,
-    get_stat_dir_s3,
+    get_stat_dir_cloud,
     get_stat_file_cloud,
 )
 from lnschema_core import Artifact, Run, Storage
@@ -192,10 +191,7 @@ def get_stat_or_artifact(
             if "ETag" in stat:  # is file
                 size, hash, hash_type = get_stat_file_cloud(stat)
             elif path.is_dir():
-                if path.protocol == "s3":
-                    size, hash, hash_type, n_objects = get_stat_dir_s3(path)
-                elif path.protocol == "gs":
-                    size, hash, hash_type, n_objects = get_stat_dir_gs(path)
+                size, hash, hash_type, n_objects = get_stat_dir_cloud(path)
         if hash is None:
             logger.warning(f"did not add hash for {path}")
             return size, hash, hash_type, n_objects

lamindb/_query_set.py

@@ -243,7 +243,7 @@ class QuerySet(models.QuerySet, CanValidate, IsTree):
         self, values: ListLike, field: Optional[Union[str, StrField]] = None, **kwargs
     ):
         """{}."""
-        from ._validate import _validate
+        from ._can_validate import _validate
 
         return _validate(cls=self, values=values, field=field, **kwargs)
 
@@ -252,7 +252,7 @@ class QuerySet(models.QuerySet, CanValidate, IsTree):
         self, values: ListLike, field: Optional[Union[str, StrField]] = None, **kwargs
     ):
         """{}."""
-        from ._validate import _inspect
+        from ._can_validate import _inspect
 
         return _inspect(cls=self, values=values, field=field, **kwargs)
 
@@ -261,7 +261,7 @@ class QuerySet(models.QuerySet, CanValidate, IsTree):
         self, values: Iterable, field: Optional[Union[str, StrField]] = None, **kwargs
     ):
         """{}."""
-        from ._validate import _standardize
+        from ._can_validate import _standardize
 
         return _standardize(cls=self, values=values, field=field, **kwargs)
 

lamindb/core/__init__.py

@@ -14,6 +14,9 @@ Registries:
    LabelManager
    IsTree
    IsVersioned
+   DataFrameAnnotator
+   AnnDataAnnotator
+   AnnotateLookup
    CanValidate
    HasParents
    InspectResult
@@ -50,6 +53,7 @@ from lnschema_core.models import (
     Registry,
 )
 
+from lamindb._annotate import AnnDataAnnotator, AnnotateLookup, DataFrameAnnotator
 from lamindb._query_manager import QueryManager
 from lamindb._query_set import QuerySet, RecordsList
 from lamindb.core._feature_manager import FeatureManager

{lamindb-0.69.2.dist-info → lamindb-0.69.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: lamindb
-Version: 0.69.2
+Version: 0.69.3
 Summary: A data framework for biology.
 Author-email: Lamin Labs <open-source@lamin.ai>
 Requires-Python: >=3.8
@@ -10,7 +10,7 @@ Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Requires-Dist: lnschema_core==0.64.1
-Requires-Dist: lamindb_setup==0.68.0
+Requires-Dist: lamindb_setup==0.68.1
 Requires-Dist: lamin_utils==0.13.1
 Requires-Dist: lamin_cli==0.10.2
 Requires-Dist: rapidfuzz
@@ -26,7 +26,7 @@ Requires-Dist: urllib3<2 ; extra == "aws"
 Requires-Dist: aiobotocore[boto3]>=2.5.4,<3.0.0 ; extra == "aws"
 Requires-Dist: s3fs==2023.12.2 ; extra == "aws"
 Requires-Dist: fsspec[s3]==2023.12.2 ; extra == "aws"
-Requires-Dist: bionty==0.42.2 ; extra == "bionty"
+Requires-Dist: bionty==0.42.4 ; extra == "bionty"
 Requires-Dist: pandas<2 ; extra == "dev"
 Requires-Dist: pre-commit ; extra == "dev"
 Requires-Dist: nox ; extra == "dev"

{lamindb-0.69.2.dist-info → lamindb-0.69.3.dist-info}/RECORD

@@ -1,5 +1,7 @@
-lamindb/__init__.py,sha256=hJStNsXJq-qclYj7tDUz2t-4j5sDhkZdBen5URQ1_dA,2051
-lamindb/_artifact.py,sha256=3H8hemGysZLlyHkb02MEXCie1FluQ60LdGIBXOv13uc,35999
+lamindb/__init__.py,sha256=Xy8yw0Woc26c9DxrgHP5c_UvVJpocigGwfCj8Ho_VZo,2108
+lamindb/_annotate.py,sha256=k9Is43plKcQaMvGnzVw6OeWvZDWcSxw3FQ7nsQVDHzw,27744
+lamindb/_artifact.py,sha256=RV36tcHMZ6wH6u65jOAQ_H4rfmFiIzZmAr8IY7kFhm0,35817
+lamindb/_can_validate.py,sha256=w7lrUGTWldpvwaRiXBRrjfU_ZRidA7CooOu_r5MbocY,14569
 lamindb/_collection.py,sha256=03CQ0u8eCY_dx31pIT5ZMZsmxbbj6J5dJ9zUqJLrDGY,18427
 lamindb/_feature.py,sha256=ahRv87q1tcRLQ0UM5FA3KtcMQvIjW__fZq1yAdRAV7s,6728
 lamindb/_feature_set.py,sha256=G_Ss6mKh4D0Eji-xSfLRbKVFXwgUE82YOqIUmkV0CAA,8767
@@ -9,7 +11,7 @@ lamindb/_from_values.py,sha256=Ei11ml77Q1xubVekt2C4-mbox2-qnC7kP18B-LhCdSc,11886
 lamindb/_is_versioned.py,sha256=DXp5t-1DwErpqqMc9eb08kpQPCHOC2fNzaozMoBunR4,1337
 lamindb/_parents.py,sha256=pTDsW8HjQ_txFbPKrBU0WjjtCNH6sx2LASUuGWpJuYE,14742
 lamindb/_query_manager.py,sha256=lyYMEsstUQlns2H01oZXN5Ly0X6ug2VOPebyu9fHn4s,4008
-lamindb/_query_set.py,sha256=OXL5meaGoWHV5aPhT-LYUboPHFB0i1BPWfmvKTSeYF4,11306
+lamindb/_query_set.py,sha256=DafHKwufvWQaWWSZsuxq24wpxae5Vfw7wD_3KCr7kLc,11318
 lamindb/_registry.py,sha256=vEsjn33BV2vxlanE3fyvDiy7AJoq7RKqEn_Sspo4_Dc,19232
 lamindb/_run.py,sha256=CvH6cAFUb83o38iOdpBsktF3JGAwmuZrDZ4p4wvUr0g,1853
 lamindb/_save.py,sha256=uIzHfNulzn7rpSKyAvUHT1OuN294OWFGC04gLmwrScY,11452
@@ -17,9 +19,8 @@ lamindb/_storage.py,sha256=VW8xq3VRv58-ciholvOdlcgvp_OIlLxx5GxLt-e2Irs,614
 lamindb/_transform.py,sha256=oZq-7MgyCs4m6Bj901HwDlbvF0JuvTpe3RxN0Zb8PgE,3515
 lamindb/_ulabel.py,sha256=euXsDPD7wC99oopLXVkT-vq7f3E6-zP4Z4akI-yh0aM,1913
 lamindb/_utils.py,sha256=LGdiW4k3GClLz65vKAVRkL6Tw-Gkx9DWAdez1jyA5bE,428
-lamindb/_validate.py,sha256=w7lrUGTWldpvwaRiXBRrjfU_ZRidA7CooOu_r5MbocY,14569
 lamindb/_view.py,sha256=yFMu4vnt0YqvN1q11boAkwigxCH1gdliDUSbzh3IuDw,2175
-lamindb/core/__init__.py,sha256=RYNsg2foVZRawpCW2J5J82vHZt6ub_Tze8wiDMxXCH8,988
+lamindb/core/__init__.py,sha256=Mw4sI-xgnMXNsu84oYFQBZOF8mxxxhp6-e3BjTQqjlA,1131
 lamindb/core/_data.py,sha256=Q8w1I8pXXOaLVIxfjWBkLV6GGnzaQxCXamu9tplFgsA,17287
 lamindb/core/_feature_manager.py,sha256=II0nuxtjOdEtU_9a7eB18_Clw9d1n5k1JOqk_vHisRw,13940
 lamindb/core/_label_manager.py,sha256=zrWDSd2AkR6fKsGDxLSWqHC9fz9BcGlavPZEh92Wzjg,9063
@@ -45,13 +46,7 @@ lamindb/core/storage/file.py,sha256=WTeC4ENn_O6HEoinmTviB89W81UrJT3bSGtnpqPpIyE,
 lamindb/core/storage/object.py,sha256=MPUb2M8Fleq2j9x1Ryqr3BETmvsDKyf11Ifvbxd3NpA,1097
 lamindb/setup/__init__.py,sha256=OwZpZzPDv5lPPGXZP7-zK6UdO4FHvvuBh439yZvIp3A,410
 lamindb/setup/core/__init__.py,sha256=LqIIvJNcONxkqjbnP6CUaP4d45Lbd6TSMAcXFp4C7_8,231
-lamindb/validation/__init__.py,sha256=AuonqVEhyYDXAoRqXnM9JweTUnYfAoExza8A5mQuM7Q,347
-lamindb/validation/_anndata_validator.py,sha256=lFCVLE4F4VN-9DTEwY9RUqSw8I2C6eTPYvXotGdKgvU,3782
-lamindb/validation/_lookup.py,sha256=HIGwk85e-c8yaVg4NkcvBdW4LIhnxwRI02km8uYOiFY,1545
-lamindb/validation/_register.py,sha256=UKsNVwXZhBl-spheZX1nkugjLF8g1yANT2vumcyzx6Y,9765
-lamindb/validation/_validate.py,sha256=FPQ4e_qDcP3tlKsYOVyo7-yb8nIbKyzoZHwgMbJJog0,4588
-lamindb/validation/_validator.py,sha256=6vzOfKIPQdA0pWwtXlRJWvjgLIjpivkBeLtgD6QODvY,7861
-lamindb-0.69.2.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-lamindb-0.69.2.dist-info/WHEEL,sha256=EZbGkh7Ie4PoZfRQ8I0ZuP9VklN_TvcZ6DSE5Uar4z4,81
-lamindb-0.69.2.dist-info/METADATA,sha256=ly2Nwd236G0yxp4sX3DStxyzFFzqSv7sJuccmnc142Y,2856
-lamindb-0.69.2.dist-info/RECORD,,
+lamindb-0.69.3.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+lamindb-0.69.3.dist-info/WHEEL,sha256=EZbGkh7Ie4PoZfRQ8I0ZuP9VklN_TvcZ6DSE5Uar4z4,81
+lamindb-0.69.3.dist-info/METADATA,sha256=X4upu_QrdDsy861PJvPiQ_nw1f6N89NrVqN1Zxn6i14,2856
+lamindb-0.69.3.dist-info/RECORD,,

lamindb/validation/__init__.py

@@ -1,19 +0,0 @@
-"""Validators built on LaminDB.
-
-Import the package::
-
-   from lamindb.validation import Validator, AnnDataValidator
-
-This is the complete API reference:
-
-.. autosummary::
-   :toctree: .
-
-   Validator
-   AnnDataValidator
-   Lookup
-"""
-
-from ._anndata_validator import AnnDataValidator
-from ._lookup import Lookup
-from ._validator import Validator

lamindb/validation/_anndata_validator.py

@@ -1,117 +0,0 @@
-from typing import Dict, Optional
-
-import anndata as ad
-from lnschema_core.types import FieldAttr
-from pandas.core.api import DataFrame as DataFrame
-
-import lamindb as ln
-
-from ._lookup import Lookup
-from ._register import register_artifact, register_labels
-from ._validate import validate_anndata
-from ._validator import ValidationError, Validator
-
-
-class AnnDataValidator(Validator):
-    """Lamin AnnData validator.
-
-    Args:
-        adata: The AnnData object to validate.
-        var_field: The registry field to validate variables index against.
-        obs_fields: A dictionary mapping obs_column to registry_field.
-            For example:
-            {"cell_type_ontology_id": bt.CellType.ontology_id, "donor_id": ln.ULabel.name}
-        using: The reference instance containing registries to validate against.
-    """
-
-    def __init__(
-        self,
-        adata: ad.AnnData,
-        var_field: FieldAttr,
-        obs_fields: Dict[str, FieldAttr],
-        using: str = "default",
-        verbosity: str = "hint",
-        **kwargs,
-    ) -> None:
-        self._adata = adata
-        self._var_field = var_field
-        super().__init__(
-            df=self._adata.obs,
-            fields=obs_fields,
-            using=using,
-            verbosity=verbosity,
-            **kwargs,
-        )
-        self._obs_fields = obs_fields
-        self._register_variables()
-
-    @property
-    def var_field(self) -> FieldAttr:
-        """Return the registry field to validate variables index against."""
-        return self._var_field
-
-    @property
-    def obs_fields(self) -> Dict:
-        """Return the obs fields to validate against."""
-        return self._obs_fields
-
-    def lookup(self, using: Optional[str] = None) -> Lookup:
-        """Lookup features and labels."""
-        fields = {
-            **{"feature": ln.Feature.name, "variables": self.var_field},
-            **self.obs_fields,
-        }
-        return Lookup(fields=fields, using=using or self._using)
-
-    def _register_variables(self, validated_only: bool = True, **kwargs):
-        """Register variable records."""
-        self._kwargs.update(kwargs)
-        register_labels(
-            values=self._adata.var_names,
-            field=self.var_field,
-            feature_name="variables",
-            using=self._using,
-            validated_only=validated_only,
-            kwargs=self._kwargs,
-        )
-
-    def validate(self, **kwargs) -> bool:
-        """Validate variables and categorical observations."""
-        self._kwargs.update(kwargs)
-        self._validated = validate_anndata(
-            self._adata,
-            var_field=self.var_field,
-            obs_fields=self.obs_fields,
-            **self._kwargs,
-        )
-        return self._validated
-
-    def register_labels(self, feature: str, validated_only: bool = True, **kwargs):
-        """Register labels for a feature."""
-        if feature == "variables":
-            self._register_variables(validated_only=validated_only, **kwargs)
-        else:
-            super().register_labels(feature, validated_only, **kwargs)
-
-    def register_artifact(self, description: str, **kwargs) -> ln.Artifact:
-        """Register the validated AnnData and metadata.
-
-        Args:
-            description: Description of the AnnData object.
-            **kwargs: Object level metadata.
-
-        Returns:
-            A registered artifact record.
-        """
-        self._kwargs.update(kwargs)
-        if not self._validated:
-            raise ValidationError("Please run `validate()` first!")
-
-        self._artifact = register_artifact(
-            self._adata,
-            description=description,
-            feature_field=self.var_field,
-            fields=self.obs_fields,
-            **self._kwargs,
-        )
-        return self._artifact

lamindb/validation/_lookup.py

@@ -1,42 +0,0 @@
-from typing import Dict, Optional
-
-from lamin_utils import colors, logger
-from lnschema_core.types import FieldAttr
-
-import lamindb as ln
-
-from ._validate import get_registry_instance
-
-
-class Lookup:
-    """Lookup features and labels from the reference instance."""
-
-    def __init__(
-        self, fields: Dict[str, FieldAttr], using: Optional[str] = None
-    ) -> None:
-        self._fields = fields
-        self._using = None if using == "default" else using
-        self._using_name = using or ln.setup.settings.instance.slug
-        logger.debug(f"Lookup objects from the {colors.italic(self._using_name)}")
-
-    def __getitem__(self, name):
-        if name in self._fields:
-            registry = self._fields[name].field.model
-            if self._using == "public":
-                return registry.public().lookup()
-            else:
-                return get_registry_instance(registry, self._using).lookup()
-        raise AttributeError(
-            f"'{self.__class__.__name__}' object has no attribute '{name}'"
-        )
-
-    def __repr__(self) -> str:
-        if len(self._fields) > 0:
-            fields = "\n ".join([str([key]) for key in self._fields.keys()])
-            return (
-                f"Lookup objects from the {colors.italic(self._using_name)}:\n {colors.green(fields)}\n\n"
-                "Example:\n    → categories = validator.lookup().['cell_type']\n"
-                "    → categories.alveolar_type_1_fibroblast_cell"
-            )
-        else:
-            return colors.warning("No fields are found!")

lamindb/validation/_register.py

@@ -1,265 +0,0 @@
-from typing import Dict, List, Optional, Tuple, Union
-
-import anndata as ad
-import pandas as pd
-from lamin_utils import colors, logger
-from lnschema_core.types import FieldAttr
-
-import lamindb as ln
-
-from ._validate import (
-    check_registry_organism,
-    get_registry_instance,
-    standardize_and_inspect,
-)
-
-
-def register_artifact(
-    data: Union[pd.DataFrame, ad.AnnData],
-    description: str,
-    fields: Dict[str, FieldAttr],
-    feature_field: FieldAttr,
-    **kwargs,
-) -> ln.Artifact:
-    """Register all metadata with an Artifact.
-
-    Args:
-        data: The DataFrame or AnnData object to register.
-        description: A description of the artifact.
-        fields: A dictionary mapping obs_column to registry_field.
-        feature_field: The registry field to validate variables index against.
-        kwargs: Additional keyword arguments to pass to the registry model.
-
-    Returns:
-        The registered Artifact.
-    """
-    if isinstance(data, ad.AnnData):
-        artifact = ln.Artifact.from_anndata(data, description=description)
-        artifact.n_observations = data.n_obs
-    elif isinstance(data, pd.DataFrame):
-        artifact = ln.Artifact.from_df(data, description=description)
-    else:
-        raise ValueError("data must be a DataFrame or AnnData object")
-    artifact.save()
-
-    feature_kwargs: Dict = {}
-    organism = check_registry_organism(
-        feature_field.field.model, kwargs.pop("organism", None)
-    )
-    if organism is not None:
-        feature_kwargs["organism"] = organism
-
-    if isinstance(data, ad.AnnData):
-        artifact.features.add_from_anndata(var_field=feature_field, **feature_kwargs)
-    else:
-        artifact.features.add_from_df(field=feature_field, **feature_kwargs)
-
-    features = ln.Feature.lookup().dict()
-    for feature_name, field in fields.items():
-        feature = features.get(feature_name)
-        registry = field.field.model
-        filter_kwargs = kwargs.copy()
-        organism = check_registry_organism(registry, organism)
-        if organism is not None:
-            filter_kwargs["organism"] = organism
-        df = data.obs if isinstance(data, ad.AnnData) else data
-        labels = registry.from_values(df[feature_name], field=field, **filter_kwargs)
-        artifact.labels.add(labels, feature)
-
-    slug = ln.setup.settings.instance.slug
-    logger.success(f"registered artifact in {colors.italic(slug)}")
-    if ln.setup.settings.instance.is_remote:
-        logger.info(f"🔗 https://lamin.ai/{slug}/artifact/{artifact.uid}")
-
-    return artifact
-
-
-def register_labels(
-    values: List[str],
-    field: FieldAttr,
-    feature_name: str,
-    using: Optional[str] = None,
-    validated_only: bool = True,
-    kwargs: Optional[Dict] = None,
-    df: Optional[pd.DataFrame] = None,
-) -> None:
-    """Register features or labels records in the default instance from the using instance.
-
-    Args:
-        values: A list of values to be registered as labels.
-        field: The FieldAttr object representing the field for which labels are being registered.
-        feature_name: The name of the feature to register.
-        using: The name of the instance from which to transfer labels (if applicable).
-        validated_only: If True, only register validated labels.
-        kwargs: Additional keyword arguments to pass to the registry model.
-        df: A DataFrame to register labels from.
-    """
-    filter_kwargs = {} if kwargs is None else kwargs.copy()
-    registry = field.field.model
-    if registry == ln.ULabel:
-        validated_only = False
-
-    organism = check_registry_organism(registry, filter_kwargs.pop("organism", None))
-    if organism is not None:
-        filter_kwargs["organism"] = organism
-
-    verbosity = ln.settings.verbosity
-    try:
-        ln.settings.verbosity = "error"
-        inspect_result_current = standardize_and_inspect(
-            values=values, field=field, registry=registry, **filter_kwargs
-        )
-        if not inspect_result_current.non_validated:
-            ln.settings.verbosity = verbosity
-            return
-
-        labels_registered: Dict = {"from public": [], "without reference": []}
-
-        (
-            labels_registered[f"from {using}"],
-            non_validated_labels,
-        ) = register_labels_from_using_instance(
-            inspect_result_current.non_validated,
-            field=field,
-            using=using,
-            kwargs=filter_kwargs,
-        )
-
-        public_records = (
-            registry.from_values(non_validated_labels, field=field, **filter_kwargs)
-            if non_validated_labels
-            else []
-        )
-        ln.save(public_records)
-        labels_registered["from public"] = [
-            getattr(r, field.field.name) for r in public_records
-        ]
-        labels_registered["without reference"] = [
-            i for i in non_validated_labels if i not in labels_registered["from public"]
-        ]
-
-        if not validated_only:
-            non_validated_records = []
-            if df is not None and registry == ln.Feature:
-                non_validated_records = ln.Feature.from_df(df)
-            else:
-                if "organism" in filter_kwargs:
-                    filter_kwargs["organism"] = _register_organism(name=organism)
-                for value in labels_registered["without reference"]:
-                    filter_kwargs[field.field.name] = value
-                    if registry == ln.Feature:
-                        filter_kwargs["type"] = "category"
-                    non_validated_records.append(registry(**filter_kwargs))
-            ln.save(non_validated_records)
-
-        if registry == ln.ULabel and field.field.name == "name":
-            register_ulabels_with_parent(values, field=field, feature_name=feature_name)
-    finally:
-        ln.settings.verbosity = verbosity
-
-    log_registered_labels(
-        labels_registered,
-        feature_name=feature_name,
-        model_field=f"{registry.__name__}.{field.field.name}",
-        validated_only=validated_only,
-    )
-
-
-def log_registered_labels(
-    labels_registered: Dict,
-    feature_name: str,
-    model_field: str,
-    validated_only: bool = True,
-) -> None:
-    """Log the registered labels."""
-    labels_type = "features" if feature_name == "feature" else "labels"
-    model_field = colors.italic(model_field)
-    for key, labels in labels_registered.items():
-        if not labels:
-            continue
-
-        if key == "without reference" and validated_only:
-            msg = colors.yellow(
-                f"{len(labels)} non-validated {labels_type} are not registered with {model_field}: {labels}!"
-            )
-            lookup_print = f".lookup().['{feature_name}']"
-            msg += f"\n      → to lookup categories, use {lookup_print}"
-            msg += (
-                f"\n      → to register, run {colors.yellow('register_features(validated_only=False)')}"
-                if labels_type == "features"
-                else f"\n      → to register, set {colors.yellow('validated_only=False')}"
-            )
-            logger.warning(msg)
-        else:
-            key = "" if key == "without reference" else f"{colors.green(key)} "
-            logger.success(
-                f"registered {len(labels)} {labels_type} {key}with {model_field}: {labels}"
-            )
-
-
-def register_ulabels_with_parent(
-    values: List[str], field: FieldAttr, feature_name: str
-) -> None:
-    """Register a parent label for the given labels."""
-    registry = field.field.model
-    assert registry == ln.ULabel
-    all_records = registry.from_values(values, field=field)
-    is_feature = registry.filter(name=f"is_{feature_name}").one_or_none()
-    if is_feature is None:
-        is_feature = registry(name=f"is_{feature_name}")
-        is_feature.save()
-    is_feature.children.add(*all_records)
-
-
-def register_labels_from_using_instance(
-    values: List[str],
-    field: FieldAttr,
-    using: Optional[str] = None,
-    kwargs: Optional[Dict] = None,
-) -> Tuple[List[str], List[str]]:
-    """Register features or labels records from the using instance.
-
-    Args:
-        values: A list of values to be registered as labels.
-        field: The FieldAttr object representing the field for which labels are being registered.
-        using: The name of the instance from which to transfer labels (if applicable).
-        kwargs: Additional keyword arguments to pass to the registry model.
-
-    Returns:
-        A tuple containing the list of registered labels and the list of non-registered labels.
-    """
-    kwargs = kwargs or {}
-    labels_registered = []
-    not_registered = values
-
-    if using is not None and using != "default":
-        registry = field.field.model
-        registry_using = get_registry_instance(registry, using)
-        inspect_result_using = standardize_and_inspect(
-            values=values, field=field, registry=registry_using, **kwargs
-        )
-        labels_using = registry_using.filter(
-            **{f"{field.field.name}__in": inspect_result_using.validated}
-        ).all()
-        for label_using in labels_using:
-            label_using.save()
-            labels_registered.append(getattr(label_using, field.field.name))
-        not_registered = inspect_result_using.non_validated
-
-    return labels_registered, not_registered
-
-
-def _register_organism(name: str):
-    """Register an organism record."""
-    import bionty as bt
-
-    organism = bt.Organism.filter(name=name).one_or_none()
-    if organism is None:
-        organism = bt.Organism.from_public(name=name)
-        if organism is None:
-            raise ValueError(
-                f"Organism '{name}' not found\n"
-                f"      → please register it: bt.Organism(name='{name}').save()"
-            )
-        organism.save()
-    return organism