lamindb 0.64.1__py3-none-any.whl → 0.64.2__py3-none-any.whl

lamindb/_registry.py

@@ -125,7 +125,7 @@ def __init__(orm: Registry, *args, **kwargs):
 def from_values(
     cls, values: ListLike, field: Optional[StrField] = None, **kwargs
 ) -> List["Registry"]:
-    """{}"""
+    """{}."""
     from_bionty = True if cls.__module__.startswith("lnschema_bionty.") else False
     field_str = get_default_str_field(cls, field=field)
     return get_or_create_records(
@@ -236,7 +236,7 @@ def search(
     case_sensitive: bool = False,
     synonyms_field: Optional[StrField] = "synonyms",
 ) -> Union["pd.DataFrame", "QuerySet"]:
-    """{}"""
+    """{}."""
     return _search(
         cls=cls,
         string=string,
@@ -253,7 +253,7 @@ def _lookup(
     field: Optional[StrField] = None,
     return_field: Optional[StrField] = None,
 ) -> NamedTuple:
-    """{}"""
+    """{}."""
     queryset = _queryset(cls)
     field = get_default_str_field(orm=queryset.model, field=field)
 
@@ -278,7 +278,7 @@ def lookup(
     field: Optional[StrField] = None,
     return_field: Optional[StrField] = None,
 ) -> NamedTuple:
-    """{}"""
+    """{}."""
     return _lookup(cls=cls, field=field, return_field=return_field)
 
 
@@ -323,7 +323,7 @@ def get_default_str_field(
         except AttributeError:
             raise TypeError(
                 "please pass a Registry string field, e.g., `CellType.name`!"
-            )
+            ) from None
 
     return field
 
@@ -349,7 +349,7 @@ def using(
     cls,
     instance: str,
 ) -> "QuerySet":
-    """{}"""
+    """{}."""
     owner, name = get_owner_name_from_identifier(instance)
     load_result = load_instance(owner=owner, name=name)
     if isinstance(load_result, str):
@@ -511,5 +511,5 @@ def __get_name_with_schema__(cls) -> str:
     return f"{schema_name}.{cls.__name__}"
 
 
-setattr(Registry, "__get_schema_name__", __get_schema_name__)
-setattr(Registry, "__get_name_with_schema__", __get_name_with_schema__)
+Registry.__get_schema_name__ = __get_schema_name__
+Registry.__get_name_with_schema__ = __get_name_with_schema__

lamindb/_save.py

@@ -4,7 +4,7 @@ import traceback
 from collections import defaultdict
 from datetime import datetime
 from functools import partial
-from typing import Iterable, List, Optional, Tuple, Union, overload  # noqa
+from typing import Iterable, List, Optional, Tuple, Union, overload
 
 import lamindb_setup
 from django.db import transaction
@@ -47,6 +47,7 @@ def save(
            unique or another constraint. However, it won't inplace update the id
            fields of records. If you need records with ids, you need to query
            them from the database.
+        **kwargs: Get kwargs related to parents.
 
     Examples:
 
@@ -74,8 +75,7 @@ def save(
     # previously, this was all set based,
     # but models without primary keys aren't hashable
     # we distinguish between artifacts and non-artifacts
-    # for artifacts, we want to bulk-upload
-    # rather than upload one-by-one
+    # for artifacts, we want to bulk-upload rather than upload one-by-one
     non_artifacts, artifacts = partition(lambda r: isinstance(r, Artifact), records)
     if non_artifacts:
         # first save all records that do not yet have a primary key without

lamindb/_storage.py

@@ -10,9 +10,9 @@ def root_as_path(self) -> UPath:
 @property  # type: ignore
 @doc_args(Storage.path.__doc__)
 def path(self) -> UPath:
-    """{}"""
+    """{}."""
     return create_path(self.root)
 
 
-setattr(Storage, "root_as_path", root_as_path)
-setattr(Storage, "path", path)
+Storage.root_as_path = root_as_path
+Storage.path = path

lamindb/_transform.py

@@ -1,10 +1,12 @@
-from typing import Optional
+from typing import TYPE_CHECKING, Optional
 
 from lnschema_core.models import TRANSFORM_TYPE_DEFAULT, Transform
-from lnschema_core.types import TransformType
 
 from .dev.versioning import get_ids_from_old_version, init_uid
 
+if TYPE_CHECKING:
+    from lnschema_core.types import TransformType
+
 
 def __init__(transform: Transform, *args, **kwargs):
     if len(args) == len(transform._meta.concrete_fields):

lamindb/_ulabel.py

@@ -29,7 +29,7 @@ def __init__(self, *args, **kwargs):
     )
     if len(kwargs) > 0:
         raise ValueError(
-            "Only name, description, reference, reference_type are valid keyword arguments"  # noqa
+            "Only name, description, reference, reference_type are valid keyword arguments"
         )
     super(ULabel, self).__init__(
         name=name,
@@ -42,7 +42,7 @@ def __init__(self, *args, **kwargs):
 @classmethod  # type:ignore
 @doc_args(ULabel.from_values.__doc__)
 def from_values(cls, values: ListLike, **kwargs) -> List["ULabel"]:
-    """{}"""
+    """{}."""
     records = get_or_create_records(
         iterable=values,
         field=ULabel.name,

lamindb/_validate.py

@@ -27,7 +27,7 @@ def inspect(
     mute: bool = False,
     **kwargs,
 ) -> InspectResult:
-    """{}"""
+    """{}."""
     return _inspect(
         cls=cls,
         values=values,
@@ -47,7 +47,7 @@ def validate(
     mute: bool = False,
     **kwargs,
 ) -> np.ndarray:
-    """{}"""
+    """{}."""
     return _validate(cls=cls, values=values, field=field, mute=mute, **kwargs)
 
 
@@ -59,7 +59,7 @@ def _inspect(
     mute: bool = False,
     **kwargs,
 ) -> Union["pd.DataFrame", Dict[str, List[str]]]:
-    """{}"""
+    """{}."""
     from lamin_utils._inspect import inspect
 
     if isinstance(values, str):
@@ -142,7 +142,7 @@ def _validate(
     mute: bool = False,
     **kwargs,
 ) -> np.ndarray:
-    """{}"""
+    """{}."""
     from lamin_utils._inspect import validate
 
     return_str = True if isinstance(values, str) else False
@@ -191,7 +191,7 @@ def standardize(
     synonyms_field: str = "synonyms",
     **kwargs,
 ) -> Union[List[str], Dict[str, str]]:
-    """{}"""
+    """{}."""
     return _standardize(
         cls=cls,
         values=values,
@@ -253,7 +253,7 @@ def _standardize(
     synonyms_field: str = "synonyms",
     **kwargs,
 ) -> Union[List[str], Dict[str, str]]:
-    """{}"""
+    """{}."""
     from lamin_utils._standardize import standardize as map_synonyms
 
     return_str = True if isinstance(values, str) else False
@@ -283,13 +283,13 @@ def _standardize(
     except FieldDoesNotExist:
         df = pd.DataFrame()
 
-    _kwargs = dict(
-        field=field,
-        return_field=return_field,
-        case_sensitive=case_sensitive,
-        keep=keep,
-        synonyms_field=synonyms_field,
-    )
+    _kwargs = {
+        "field": field,
+        "return_field": return_field,
+        "case_sensitive": case_sensitive,
+        "keep": keep,
+        "synonyms_field": synonyms_field,
+    }
     # standardized names from the DB
     std_names_db = map_synonyms(
         df=df,
@@ -383,7 +383,7 @@ def _add_or_remove_synonyms(
     if isinstance(synonym, str):
         if len(synonym) == 0:
             return
-        syn_new_set = set([synonym])
+        syn_new_set = {synonym}
     else:
         if synonym == [""]:
             return
@@ -392,7 +392,7 @@ def _add_or_remove_synonyms(
     if len(syn_new_set) == 0:
         return
     # because we use | as the separator
-    if any(["|" in i for i in syn_new_set]):
+    if any("|" in i for i in syn_new_set):
         raise AssertionError("a synonym can't contain '|'!")
 
     # existing synonyms
@@ -429,7 +429,7 @@ def _check_synonyms_field_exist(record: Registry):
     except AttributeError:
         raise NotImplementedError(
             f"No synonyms field found in table {record.__class__.__name__}!"
-        )
+        ) from None
 
 
 def _filter_query_based_on_organism(

lamindb/_view.py

@@ -56,7 +56,7 @@ def view(
                 df = orm.filter().order_by("-updated_at")[:n].df()
             else:
                 # need to adjust in the future
-                df = orm.filter().df().iloc[-n:]
+                df = orm.df().iloc[-n:]
             if df.shape[0] > 0:
                 logger.print(colors.blue(colors.bold(orm.__name__)))
                 display(df)

lamindb/dev/__init__.py

@@ -58,7 +58,7 @@ from lamindb._query_set import QuerySet
 from lamindb.dev._feature_manager import FeatureManager
 from lamindb.dev._label_manager import LabelManager
 
-from . import _data, datasets, exceptions, fields, types  # noqa
+from . import _data, datasets, exceptions, fields, types
 from ._mapped_dataset import MappedDataset
 from ._run_context import run_context
 from ._settings import Settings

lamindb/dev/_data.py

@@ -17,14 +17,14 @@ from lnschema_core.models import (
 )
 from lnschema_core.types import StrField
 
-from lamindb.dev._settings import settings
-
-from .._feature_set import (
+from lamindb._feature_set import (
     dict_related_model_to_related_name,
     dict_schema_name_to_model_name,
 )
-from .._parents import view_flow
-from .._query_set import QuerySet
+from lamindb._parents import view_lineage
+from lamindb._query_set import QuerySet
+from lamindb.dev._settings import settings
+
 from ._feature_manager import (
     FeatureManager,
     get_feature_set_links,
@@ -91,7 +91,7 @@ def save_feature_set_links(self: Union[Artifact, Dataset]) -> None:
 
 @doc_args(Data.describe.__doc__)
 def describe(self: Data):
-    """{}"""
+    """{}."""
     model_name = self.__class__.__name__
     msg = ""
 
@@ -106,7 +106,7 @@ def describe(self: Data):
 
     # Display Provenance
     # display line by line the foreign key fields
-    from .._parents import _transform_emoji
+    from lamindb._parents import _transform_emoji
 
     emojis = {
         "storage": "🗃️",
@@ -117,7 +117,7 @@ def describe(self: Data):
         "file": "📄",
     }
     if len(foreign_key_fields) > 0:  # always True for Artifact and Dataset
-        record_msg = f"{colors.green(model_name)}{__repr__(self, include_foreign_keys=False).lstrip(model_name)}"  # noqa
+        record_msg = f"{colors.green(model_name)}{__repr__(self, include_foreign_keys=False).lstrip(model_name)}"
         msg += f"{record_msg}\n\n"
 
         msg += f"{colors.green('Provenance')}:\n  "
@@ -134,7 +134,7 @@ def describe(self: Data):
     if self.id is not None and self.input_of.exists():
         values = [format_field_value(i.run_at) for i in self.input_of.all()]
         msg += f"⬇️ input_of ({colors.italic('core.Run')}): {values}\n    "
-    msg = msg.rstrip("    ")
+    msg = msg.rstrip(" ")  # do not use removesuffix as we need to remove 2 or 4 spaces
     msg += print_features(self)
     msg += print_labels(self)
 
@@ -146,9 +146,7 @@ def validate_feature(feature: Feature, records: List[Registry]) -> None:
     if not isinstance(feature, Feature):
         raise TypeError("feature has to be of type Feature")
     if feature._state.adding:
-        registries = set(
-            [record.__class__.__get_name_with_schema__() for record in records]
-        )
+        registries = {record.__class__.__get_name_with_schema__() for record in records}
         registries_str = "|".join(registries)
         msg = (
             f"ln.Feature(name='{feature.name}', type='category',"
@@ -163,7 +161,7 @@ def get_labels(
     mute: bool = False,
     flat_names: bool = False,
 ) -> Union[QuerySet, Dict[str, QuerySet], List]:
-    """{}"""
+    """{}."""
     if not isinstance(feature, Feature):
         raise TypeError("feature has to be of type Feature")
     if feature.registries is None:
@@ -190,7 +188,7 @@ def get_labels(
             ).all()
     if flat_names:
         # returns a flat list of names
-        from .._registry import get_default_str_field
+        from lamindb._registry import get_default_str_field
 
         values = []
         for v in qs_by_registry.values():
@@ -209,7 +207,7 @@ def add_labels(
     *,
     field: Optional[StrField] = None,
 ) -> None:
-    """{}"""
+    """{}."""
     if self._state.adding:
         raise ValueError("Please save the file/dataset before adding a label!")
 
@@ -220,6 +218,8 @@ def add_labels(
     if not isinstance(records, List):  # avoids warning for pd Series
         records = list(records)
     # create records from values
+    if len(records) == 0:
+        return None
     if isinstance(records[0], str):  # type: ignore
         records_validated = []
         # feature is needed if we want to create records from values
@@ -290,7 +290,7 @@ def add_labels(
             for feature_set in feature_sets
             if "core.Feature" == feature_set.registry
         }
-        for registry_name, records in records_by_registry.items():
+        for registry_name, _ in records_by_registry.items():
             msg = ""
             if feature.registries is None or registry_name not in feature.registries:
                 if len(msg) > 0:
@@ -423,7 +423,7 @@ def _track_run_input(
 @property  # type: ignore
 @doc_args(Data.features.__doc__)
 def features(self) -> "FeatureManager":
-    """{}"""
+    """{}."""
     from lamindb.dev._feature_manager import FeatureManager
 
     return FeatureManager(self)
@@ -432,13 +432,14 @@ def features(self) -> "FeatureManager":
 @property  # type: ignore
 @doc_args(Data.labels.__doc__)
 def labels(self) -> "LabelManager":
-    """{}"""
+    """{}."""
     from lamindb.dev._label_manager import LabelManager
 
     return LabelManager(self)
 
 
-setattr(Data, "features", features)
-setattr(Data, "labels", labels)
-setattr(Data, "describe", describe)
-setattr(Data, "view_flow", view_flow)
+Data.features = features
+Data.labels = labels
+Data.describe = describe
+Data.view_lineage = view_lineage
+Data.view_flow = view_lineage  # backward compat

lamindb/dev/_feature_manager.py

@@ -4,15 +4,15 @@ import numpy as np
 from lamin_utils import colors
 from lnschema_core.models import Artifact, Data, Dataset, Feature
 
-from .._feature_set import FeatureSet
-from .._query_set import QuerySet
-from .._registry import (
+from lamindb._feature_set import FeatureSet
+from lamindb._query_set import QuerySet
+from lamindb._registry import (
     REGISTRY_UNIQUE_FIELD,
     get_default_str_field,
     transfer_fk_to_default_db_bulk,
     transfer_to_default_db,
 )
-from .._save import save
+from lamindb._save import save
 
 
 def get_host_id_field(host: Union[Artifact, Dataset]) -> str:
@@ -76,7 +76,7 @@ def get_feature_set_links(host: Union[Artifact, Dataset]) -> QuerySet:
 
 
 def print_features(self: Data) -> str:
-    from .._from_values import _print_values
+    from lamindb._from_values import _print_values
 
     msg = ""
     features_lookup = Feature.objects.using(self._state.db).lookup().dict()
@@ -102,7 +102,7 @@ def print_features(self: Data) -> str:
                         indent = "    "
                     else:
                         labels = {row["registries"]: labels}
-                    for registry, labels in labels.items():
+                    for registry, labels in labels.items():  # noqa: B020
                         count_str = f"{len(labels)}, {colors.italic(f'{registry}')}"
                         field = get_default_str_field(labels)
                         print_values = _print_values(labels.list(field), n=10)

lamindb/dev/_label_manager.py

@@ -1,19 +1,19 @@
-from typing import Dict, List, Optional, Union
+from typing import Dict, List, Optional, Tuple, Union
 
 import numpy as np
 from lamin_utils import colors, logger
 from lnschema_core.models import Artifact, Data, Dataset, Feature, Registry
 
-from .._feature_set import dict_related_model_to_related_name
-from .._from_values import _print_values
-from .._query_set import QuerySet
-from .._registry import (
+from lamindb._feature_set import dict_related_model_to_related_name
+from lamindb._from_values import _print_values
+from lamindb._query_set import QuerySet
+from lamindb._registry import (
     REGISTRY_UNIQUE_FIELD,
     get_default_str_field,
     transfer_fk_to_default_db_bulk,
     transfer_to_default_db,
 )
-from .._save import save
+from lamindb._save import save
 
 
 def get_labels_as_dict(self: Data):
@@ -42,7 +42,7 @@ def print_labels(self: Data):
             n = labels.count()
             field = get_default_str_field(labels)
             print_values = _print_values(labels.list(field), n=10)
-            labels_msg += f"  🏷️ {related_name} ({n}, {colors.italic(related_model)}): {print_values}\n"  # noqa
+            labels_msg += f"  🏷️ {related_name} ({n}, {colors.italic(related_model)}): {print_values}\n"
     if len(labels_msg) > 0:
         return f"{colors.green('Labels')}:\n{labels_msg}"
     else:
@@ -73,7 +73,11 @@ def transfer_add_labels(labels, features_lookup_self, self, row):
 
 
 def validate_labels(labels: Union[QuerySet, List, Dict]):
-    def validate_labels_registry(labels: Union[QuerySet, List, Dict]):
+    def validate_labels_registry(
+        labels: Union[QuerySet, List, Dict],
+    ) -> Tuple[List[str], List[str]]:
+        if len(labels) == 0:
+            return [], []
         registry = labels[0].__class__
         field = REGISTRY_UNIQUE_FIELD.get(registry.__name__.lower(), "uid")
         label_uids = np.array(

lamindb/dev/_mapped_dataset.py

@@ -116,7 +116,7 @@ class MappedDataset:
             with _Connect(storage) as store:
                 var_list.append(_safer_read_index(store["var"]))
         if self.join_vars == "auto":
-            vars_eq = all([var_list[0].equals(vrs) for vrs in var_list[1:]])
+            vars_eq = all(var_list[0].equals(vrs) for vrs in var_list[1:])
             if vars_eq:
                 self.join_vars = None
                 return
@@ -159,7 +159,7 @@ class MappedDataset:
         layer_key: Optional[str] = None,
     ):
         """Get the index for the data."""
-        layer = storage["X"] if layer_key is None else storage["layers"][layer_key]  # type: ignore # noqa
+        layer = storage["X"] if layer_key is None else storage["layers"][layer_key]  # type: ignore
         if isinstance(layer, ArrayTypes):  # type: ignore
             # todo: better way to select variables
             return layer[idx] if var_idxs is None else layer[idx][var_idxs]
@@ -174,7 +174,7 @@ class MappedDataset:
             layer_idx[indices[s]] = data[s]
             return layer_idx if var_idxs is None else layer_idx[var_idxs]
 
-    def get_label_idx(self, storage: StorageType, idx: int, label_key: str):  # type: ignore # noqa
+    def get_label_idx(self, storage: StorageType, idx: int, label_key: str):  # type: ignore
         """Get the index for the label by key."""
         obs = storage["obs"]  # type: ignore
         # how backwards compatible do we want to be here actually?

lamindb/dev/_run_context.py

@@ -257,7 +257,7 @@ class run_context:
                         old_version_of,
                     ) = get_transform_kwargs_from_uid_prefix(
                         module.__lamindb_uid_prefix__,
-                        module.__version__,  # noqa type: ignore
+                        module.__version__,  # type: ignore
                     )
                     short_name = Path(module.__file__).name  # type: ignore
                     is_tracked = cls._create_or_load_transform(
@@ -293,7 +293,9 @@ class run_context:
             cls.transform = transform_exists
 
         if new_run is None:  # for notebooks, default to loading latest runs
-            new_run = False if cls.transform.type == TransformType.notebook.value else True  # type: ignore  # noqa
+            new_run = (
+                False if cls.transform.type == TransformType.notebook.value else True
+            )  # type: ignore
 
         run = None
         if not new_run:  # try loading latest run by same user
@@ -371,9 +373,9 @@ class run_context:
             try:
                 path_env = get_notebook_path(return_env=True)
             except Exception:
-                raise RuntimeError(msg_path_failed)
+                raise RuntimeError(msg_path_failed) from None
             if path_env is None:
-                raise RuntimeError(msg_path_failed)
+                raise RuntimeError(msg_path_failed) from None
             notebook_path, _env = path_env
         else:
             notebook_path, _env = notebook_path, editor
@@ -410,7 +412,7 @@ class run_context:
                     " notebook'))`\n\nPlease consider pasting error at:"
                     f" https://github.com/laminlabs/nbproject/issues/new\n\n{e}"
                 )
-                raise RuntimeError(nbproject_failed_msg)
+                raise RuntimeError(nbproject_failed_msg) from None
             try:
                 from nbproject.dev._metadata_display import DisplayMeta
                 from nbproject.dev._pypackage import infer_pypackages
@@ -418,7 +420,7 @@ class run_context:
                 dm = DisplayMeta(metadata)
                 logger.important(
                     "notebook imports:"
-                    f" {' '.join(dm.pypackage(infer_pypackages(nb, pin_versions=True)))}"  # noqa
+                    f" {' '.join(dm.pypackage(infer_pypackages(nb, pin_versions=True)))}"
                 )
             except Exception:
                 logger.debug("inferring imported packages failed")
@@ -455,11 +457,11 @@ class run_context:
                 raise NotebookNotSavedError(
                     "The notebook is not saved, please save the notebook and"
                     " rerun `ln.track()`"
-                )
+                ) from None
             if nbproject_title is None:
                 raise NoTitleError(
                     "Please add a title to your notebook in a markdown cell: # Title"
-                )
+                ) from None
         # colab parsing successful
         if colab_id is not None:
             uid = colab_id[:14]
@@ -521,7 +523,7 @@ class run_context:
             if updated:
                 raise SystemExit("You can now rerun the script.")
             else:
-                raise IOError("You did not update uid prefix or version")
+                raise OSError("You did not update uid prefix or version")
 
     @classmethod
     def _create_or_load_transform(

lamindb/dev/_view_tree.py

@@ -1,5 +1,6 @@
 import os
 from collections import defaultdict
+from pathlib import Path
 from typing import Iterable
 
 from lamindb_setup import settings as setup_settings
@@ -13,7 +14,7 @@ def view_tree(
     length_limit: int = 1000,
     max_files_per_dir_per_type: int = 7,
 ) -> None:
-    """{}"""
+    """{}."""
     if cls.__class__.__name__ == "QuerySet":
         print("queryset")
         qs = cls
@@ -68,14 +69,16 @@ def _view_tree(
             node = node[part]
             if node == {}:
                 n_files += 1
-                suffix = os.path.splitext(part)[1]
+                suffix = Path(part).suffix
                 if suffix:
                     suffixes.add(suffix)
             else:
                 n_directories += 1
 
     # Function to print the tree
-    def print_tree(node, prefix="", depth=0, count=[0], n_files_per_dir_per_type=None):
+    def print_tree(node, prefix="", depth=0, count=None, n_files_per_dir_per_type=None):
+        if count is None:
+            count = [0]
         if n_files_per_dir_per_type is None:
             n_files_per_dir_per_type = defaultdict(int)
 
@@ -86,7 +89,7 @@ def _view_tree(
                 return
             if only_dirs and child == {}:
                 continue
-            suffix = os.path.splitext(name)[1]
+            suffix = Path(name).suffix
             n_files_per_dir_per_type[suffix] += 1
             if (
                 depth > 0