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

lamindb/core/storage/_backed_access.py

@@ -163,28 +163,65 @@ def read_dataframe(elem: Union[h5py.Dataset, h5py.Group]):
 
 @registry.register("h5py")
 def safer_read_partial(elem, indices):
-    if get_spec(elem).encoding_type == "":
-        if isinstance(elem, h5py.Dataset):
+    is_dataset = isinstance(elem, h5py.Dataset)
+    indices_inverse: Optional[list] = None
+    encoding_type = get_spec(elem).encoding_type
+    # h5py selection for datasets requires sorted indices
+    if is_dataset or encoding_type == "dataframe":
+        indices_increasing = []
+        indices_inverse = []
+        for indices_dim in indices:
+            if isinstance(indices_dim, np.ndarray) and not np.all(
+                np.diff(indices_dim) > 0
+            ):
+                idx_unique, idx_inverse = np.unique(indices_dim, return_inverse=True)
+                indices_increasing.append(idx_unique)
+                indices_inverse.append(idx_inverse)
+            else:
+                indices_increasing.append(indices_dim)
+                indices_inverse.append(None)
+        indices = tuple(indices_increasing)
+        if all(idx is None for idx in indices_inverse):
+            indices_inverse = None
+    result = None
+    if encoding_type == "":
+        if is_dataset:
             dims = len(elem.shape)
             if dims == 2:
-                return elem[indices]
+                result = elem[indices]
             elif dims == 1:
                 if indices[0] == slice(None):
-                    return elem[indices[1]]
+                    result = elem[indices[1]]
                 elif indices[1] == slice(None):
-                    return elem[indices[0]]
+                    result = elem[indices[0]]
         elif isinstance(elem, h5py.Group):
             try:
                 ds = CSRDataset(elem)
-                return _subset_sparse(ds, indices)
+                result = _subset_sparse(ds, indices)
             except Exception:
                 pass
-        raise ValueError(
-            "Can not get a subset of the element of type"
-            f" {type(elem).__name__} with an empty spec."
-        )
+        if result is None:
+            raise ValueError(
+                "Can not get a subset of the element of type"
+                f" {type(elem).__name__} with an empty spec."
+            )
+    else:
+        result = read_elem_partial(elem, indices=indices)
+    if indices_inverse is None:
+        return result
     else:
-        return read_elem_partial(elem, indices=indices)
+        if indices_inverse[0] is None:
+            if len(result.shape) == 2:
+                return result[:, indices_inverse[1]]
+            else:
+                return result[indices_inverse[1]]
+        elif indices_inverse[1] is None:
+            if isinstance(result, pd.DataFrame):
+                return result.iloc[indices_inverse[0]]
+            else:
+                return result[indices_inverse[0]]
+        else:
+            return result[tuple(indices_inverse)]
 
 
 @registry.register("h5py")

lamindb/core/storage/file.py

@@ -105,10 +105,7 @@ def read_adata_h5ad(filepath, **kwargs) -> ad.AnnData:
 
 
 def store_artifact(localpath: UPathStr, storagepath: UPath) -> None:
-    """Store directory or file to configured storage location.
-
-    Returns size in bytes.
-    """
+    """Store directory or file to configured storage location."""
     localpath = Path(localpath)
     if not isinstance(storagepath, LocalPathClasses):
         # this uploads files and directories
@@ -200,9 +197,7 @@ def load_to_memory(filepath: UPathStr, stream: bool = False, **kwargs):
     """
     filepath = create_path(filepath)
 
-    if filepath.suffix in (".zarr", ".zrad"):
-        stream = True
-    elif filepath.suffix != ".h5ad":
+    if filepath.suffix not in {".h5ad", ".zarr", ".zrad"}:
         stream = False
 
     if not stream:

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: lamindb
-Version: 0.69.1
+Version: 0.69.3
 Summary: A data framework for biology.
 Author-email: Lamin Labs <open-source@lamin.ai>
 Requires-Python: >=3.8
@@ -9,10 +9,10 @@ Classifier: Programming Language :: Python :: 3.8
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
-Requires-Dist: lnschema_core==0.64.0
-Requires-Dist: lamindb_setup==0.67.1
-Requires-Dist: lamin_utils==0.13.0
-Requires-Dist: lamin_cli==0.10.1
+Requires-Dist: lnschema_core==0.64.1
+Requires-Dist: lamindb_setup==0.68.1
+Requires-Dist: lamin_utils==0.13.1
+Requires-Dist: lamin_cli==0.10.2
 Requires-Dist: rapidfuzz
 Requires-Dist: pyarrow
 Requires-Dist: typing_extensions!=4.6.0
@@ -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"
@@ -64,7 +64,7 @@ Provides-Extra: zarr
 - Track data lineage across notebooks & pipelines.
 - Integrate registries for experimental metadata & in-house ontologies.
 - Validate, standardize & annotate.
-- Collaborate across a mesh of distributed LaminDB instances.
+- Collaborate across distributed LaminDB instances.
 
 ## Documentation
 

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

@@ -1,30 +1,31 @@
-lamindb/__init__.py,sha256=BgkzsNWC9WfhQrW1AYUGL0bg_tedMBBfB3CPh_0rxuk,2115
-lamindb/_artifact.py,sha256=g4p1E-y0U7PKQMOP3Ij35UcTs46G7MPZtr5QbV9sQWo,36130
-lamindb/_collection.py,sha256=esjFYaVPIz7E5J-dk3FppAOZsimszd4m7MYGxErmrk4,18097
-lamindb/_feature.py,sha256=B_vjiH7wOW0mugZOmIHYKkAe20E1Ca9PnMppAW9KJU4,6677
+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
 lamindb/_filter.py,sha256=_PjyQWQBR3ohDAvJbR3hMvZ-2p2GvzFxLfKGC-gPnHI,1320
-lamindb/_finish.py,sha256=2YdHcHXZeu5414jIbk9id-u5_m9W73hfqzLH-AwYK1Y,1269
+lamindb/_finish.py,sha256=it-fSpSmMW9ybdsylBV5Lbugh6iXRGWgIiSLwPaow_8,8590
 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=JXw43IoSW0QVmarOmRqZGBNn4aFUYetwWEAJcoG_g6Q,11235
+lamindb/_query_set.py,sha256=DafHKwufvWQaWWSZsuxq24wpxae5Vfw7wD_3KCr7kLc,11318
 lamindb/_registry.py,sha256=vEsjn33BV2vxlanE3fyvDiy7AJoq7RKqEn_Sspo4_Dc,19232
-lamindb/_run.py,sha256=O5TcVPZqgdUvk4nBmI_HXzvWOG_Zr3B_HMDaw228w-4,1719
-lamindb/_save.py,sha256=2V3u0F2FFJZBlaBtViBYLIPDIVlwY-uXlhPDfA-wCMo,11102
+lamindb/_run.py,sha256=CvH6cAFUb83o38iOdpBsktF3JGAwmuZrDZ4p4wvUr0g,1853
+lamindb/_save.py,sha256=uIzHfNulzn7rpSKyAvUHT1OuN294OWFGC04gLmwrScY,11452
 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/_data.py,sha256=D89NN22Py832wT53U5neFNpvft_U4_WQS4XcFNQ0fVM,17214
-lamindb/core/_feature_manager.py,sha256=a1HXGmMgSRWEsE7nmlMMKYZzDo8oFAmieOM6HGa-yyU,13901
+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
 lamindb/core/_mapped_collection.py,sha256=e4P3AoykIMjD4_88BWbISWvKyWWTklwHl-_WLa72ZG4,16841
-lamindb/core/_run_context.py,sha256=bwMHgO01oA4DxWTFqj4VDNBPS7Ti89Heuh1vHPv7HjU,17063
+lamindb/core/_run_context.py,sha256=EK0lFJWx32NY2FdqFR1YozR9zioC-BjA394nPu-KwLQ,17510
 lamindb/core/_settings.py,sha256=kHL5e20dWKSbf7mJOAddvS7SQBrr1D0ZTeG_5sj5RpY,5735
 lamindb/core/_sync_git.py,sha256=Bn_ofx2ynaw6etmskgEUNW8n7LDJs-7r2aB41BgCvdA,3928
 lamindb/core/_track_environment.py,sha256=QjHWbyl2u8J4hbJG8Q_ToFaZIgS-H15Ej6syJgk-dvY,662
@@ -39,19 +40,13 @@ lamindb/core/datasets/_core.py,sha256=Y1UP_gPN2w6-QijaqmeKV57luYXYb5d2G-bmuSobS1
 lamindb/core/datasets/_fake.py,sha256=S8mNho-oSh1M9x9oOSsUBLLHmBAegsOLlFk6LnF81EA,942
 lamindb/core/storage/__init__.py,sha256=9alBNtyH59VnoWJS-IdjLwFKlK-kgeCGl6jXk0_wGeQ,369
 lamindb/core/storage/_anndata_sizes.py,sha256=0XVzA6AQeVGPaGPrhGusKyxFgFjeo3qSN29hxb8D5E8,993
-lamindb/core/storage/_backed_access.py,sha256=MD58DbKMen-62I7eloaCSUFYpU2zTERGbJuPWus2qsE,22871
+lamindb/core/storage/_backed_access.py,sha256=DUJIDjkGkemjmKLD05blndP_rO5DpUD0EZdowos46HQ,24361
 lamindb/core/storage/_zarr.py,sha256=bMQSCsTOCtQy4Yo3KwCVpbUkKdWRApN9FM1rM-d2_G0,2839
-lamindb/core/storage/file.py,sha256=JmDnux5aNL2L30Tkyb4-uRgavlFfEJrQjt9X8957lYY,7321
+lamindb/core/storage/file.py,sha256=WTeC4ENn_O6HEoinmTviB89W81UrJT3bSGtnpqPpIyE,7242
 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=1tc0GjmRTjTw2EEo30EHD212hp25HJ6FaldMURynx0k,4070
-lamindb/validation/_lookup.py,sha256=hC81FomT86tzYXM6_czoxgu9P_JVn7TfLaRyMtBUuU8,1425
-lamindb/validation/_register.py,sha256=RCvY7cNrqnJ0oTGGExePHEqdEe2EZvYaCL2ZGw6ajek,8261
-lamindb/validation/_validate.py,sha256=esStmPdp_B6YDKgSkcCBuAJxYo--QRNTd9f6FfOGoBA,4145
-lamindb/validation/_validator.py,sha256=vfYCo0ORC1hNajFYrSqMdf9lLC9B7ZNUUrRMU7RXyGo,6876
-lamindb-0.69.1.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-lamindb-0.69.1.dist-info/WHEEL,sha256=EZbGkh7Ie4PoZfRQ8I0ZuP9VklN_TvcZ6DSE5Uar4z4,81
-lamindb-0.69.1.dist-info/METADATA,sha256=5aQTa6m3YG6x--MSlse9D3xph_lc1PPS47jibL-RFaE,2866
-lamindb-0.69.1.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,130 +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 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
-        super().__init__(
-            df=self._adata.obs,
-            fields=obs_fields,
-            using=using,
-            verbosity=verbosity,
-            **kwargs,
-        )
-        self._obs_fields = obs_fields
-        self._var_field = var_field
-        self._fields = {"variables": var_field, **obs_fields}
-
-    @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._add_kwargs(**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 register_labels(self, feature: str, validated_only: bool = True, **kwargs):
-        """Register labels for the given feature.
-
-        Args:
-            feature: The feature to register labels for.
-                if "variables", register variables.
-            validated_only: If True, only register validated labels.
-            **kwargs: Additional metadata needed.
-        """
-        if feature == "variables":
-            self._register_variables(validated_only=validated_only, **kwargs)
-        else:
-            super().register_labels(feature, validated_only, **kwargs)
-
-    def validate(self, **kwargs) -> bool:
-        """Validate variables and categorical observations."""
-        self._add_kwargs(**kwargs)
-        self._validated = validate_anndata(
-            self._adata,
-            var_field=self.var_field,
-            obs_fields=self.obs_fields,
-            **self._kwargs,
-        )
-
-        return self._validated
-
-    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._add_kwargs(**kwargs)
-        if not self._validated:
-            raise ValueError("please run `validate()` first!")
-
-        self._artifact = register_artifact(
-            self._adata,
-            description=description,
-            var_field=self.var_field,
-            fields=self.obs_fields,
-            **self._kwargs,
-        )
-
-        return self._artifact

lamindb/validation/_lookup.py

@@ -1,38 +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 _registry_using
-
-
-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 = using
-        self._using_name = using or ln.setup.settings.instance.slug
-        logger.print(f"Lookup objects from the {colors.green(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 _registry_using(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.green(self._using_name)}:\n {colors.green(fields)}\n\nExample:\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,214 +0,0 @@
-from typing import Dict, List, Optional, 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 _registry_using, check_if_registry_needs_organism
-
-
-def register_artifact(
-    data: Union[pd.DataFrame, ad.AnnData],
-    description: str,
-    fields: Dict[str, FieldAttr],
-    var_field: Optional[FieldAttr] = None,
-    **kwargs,
-):
-    """Registers 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.
-        var_field: The registry field to validate variables index against.
-        kwargs: Additional keyword arguments to pass to the registry model.
-    """
-    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()
-
-    organism = kwargs.pop("organism", None)
-
-    if isinstance(data, ad.AnnData):
-        artifact.features.add_from_anndata(var_field=var_field, organism=organism)
-    else:
-        artifact.features.add_from_df()
-
-    # link validated obs metadata
-    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()
-        if check_if_registry_needs_organism(registry, organism):
-            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)
-
-    logger.print("\n\n🎉 registered artifact in LaminDB!\n")
-    if ln.setup.settings.instance.is_remote:
-        logger.print(
-            f"🔗 https://lamin.ai/{ln.setup.settings.instance.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: Dict = 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.
-    """
-    if kwargs is None:
-        kwargs = {}
-    registry = field.field.model
-
-    check_if_registry_needs_organism(registry, kwargs.get("organism"))
-    verbosity = ln.settings.verbosity
-    try:
-        ln.settings.verbosity = "error"
-        # for labels that are registered in the using instance, transfer them to the current instance
-        # first inspect the current instance
-        inspect_result_current = registry.inspect(
-            values, field=field, mute=True, **kwargs
-        )
-        if len(inspect_result_current.non_validated) == 0:
-            # everything is validated in the current instance, no need to register
-            ln.settings.verbosity = verbosity
-            return
-
-        labels_registered: Dict = {"from public": [], "without reference": []}
-
-        # register labels from the using instance
-        (
-            labels_registered[f"from {using}"],
-            non_validated_labels,
-        ) = register_labels_from_using_instance(
-            inspect_result_current.non_validated,
-            field=field,
-            using=using,
-            kwargs=kwargs,
-        )
-
-        # for labels that are not registered in the using instance, register them in the current instance
-        from_values_records = (
-            registry.from_values(non_validated_labels, field=field, **kwargs)
-            if len(non_validated_labels) > 0
-            else []
-        )
-        ln.save(from_values_records)
-        labels_registered["from public"] = [
-            getattr(r, field.field.name) for r in from_values_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 = []
-            for value in labels_registered["without reference"]:
-                kwargs[field.field.name] = value
-                if registry.__name__ == "Feature":
-                    kwargs["type"] = "category"
-                # register non-validated labels
-                non_validated_records.append(registry(**kwargs))
-            ln.save(non_validated_records)
-
-        # for ulabels, also register a parent label: is_{feature_name}
-        if registry == ln.ULabel and field.field.name == "name":
-            register_ulabels_with_parent(values, field)
-    finally:
-        ln.settings.verbosity = verbosity
-    log_registered_labels(
-        labels_registered, feature_name=feature_name, validated_only=validated_only
-    )
-
-
-def log_registered_labels(
-    labels_registered: Dict, feature_name: str, validated_only: bool = True
-):
-    """Log the registered labels."""
-    for key, labels in labels_registered.items():
-        if len(labels) > 0:
-            if key == "without reference" and validated_only:
-                msg = (
-                    f"{len(labels)} non-validated labels are not registered: {labels}!\n"
-                    "      → to lookup categories, use `.lookup().{feature_name}`\n"
-                    "      → to register, set `validated_only=False`"
-                )
-                logger.warning(colors.yellow(msg))
-                continue
-            logger.success(
-                f"registered {len(labels)} records {colors.green(key)}: {labels}"
-            )
-
-
-def register_ulabels_with_parent(values: List[str], field: FieldAttr):
-    """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_{field.field.name}").one_or_none()
-    if is_feature is None:
-        is_feature = registry(name=f"is_{field.field.name}")
-        is_feature.save()
-    # link all labels to the parent label
-    is_feature.children.add(*all_records)
-
-
-def register_labels_from_using_instance(
-    values: List[str],
-    field: FieldAttr,
-    using: Optional[str] = None,
-    kwargs: Dict = None,
-):
-    """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.
-    """
-    if kwargs is None:
-        kwargs = {}
-    labels_registered = []
-    not_registered = values
-    if using is not None and using != "default":
-        registry = field.field.model
-        registry_using = _registry_using(registry, using)
-        # then inspect the using instance
-        inspect_result_using = registry_using.inspect(
-            values, field=field, mute=True, **kwargs
-        )
-        # register the labels that are validated in the using instance
-        # TODO: filter 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