lamindb 0.69.7__py3-none-any.whl → 0.69.8__py3-none-any.whl

lamindb/_can_validate.py

@@ -1,28 +1,32 @@
-from typing import Dict, Iterable, List, Literal, Optional, Set, Union
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Iterable, Literal
 
 import lamindb_setup as ln_setup
 import numpy as np
 import pandas as pd
 from django.core.exceptions import FieldDoesNotExist
-from django.db.models import QuerySet
 from lamin_utils import colors, logger
-from lamin_utils._inspect import InspectResult
 from lamindb_setup.core._docs import doc_args
 from lnschema_core import CanValidate, Registry
-from lnschema_core.types import ListLike, StrField
 
 from lamindb._utils import attach_func_to_class_method
 
 from ._from_values import _has_organism_field, _print_values
 from ._registry import _queryset, get_default_str_field
 
+if TYPE_CHECKING:
+    from django.db.models import QuerySet
+    from lamin_utils._inspect import InspectResult
+    from lnschema_core.types import ListLike, StrField
+
 
 @classmethod  # type: ignore
 @doc_args(CanValidate.inspect.__doc__)
 def inspect(
     cls,
     values: ListLike,
-    field: Optional[Union[str, StrField]] = None,
+    field: str | StrField | None = None,
     *,
     mute: bool = False,
     **kwargs,
@@ -42,7 +46,7 @@ def inspect(
 def validate(
     cls,
     values: ListLike,
-    field: Optional[Union[str, StrField]] = None,
+    field: str | StrField | None = None,
     *,
     mute: bool = False,
     **kwargs,
@@ -54,12 +58,12 @@ def validate(
 def _inspect(
     cls,
     values: ListLike,
-    field: Optional[Union[str, StrField]] = None,
+    field: str | StrField | None = None,
     *,
     mute: bool = False,
-    using_key: Optional[str] = None,
+    using_key: str | None = None,
     **kwargs,
-) -> Union["pd.DataFrame", Dict[str, List[str]]]:
+) -> pd.DataFrame | dict[str, list[str]]:
     """{}."""
     from lamin_utils._inspect import inspect
 
@@ -138,10 +142,10 @@ def _inspect(
 def _validate(
     cls,
     values: ListLike,
-    field: Optional[Union[str, StrField]] = None,
+    field: str | StrField | None = None,
     *,
     mute: bool = False,
-    using_key: Optional[str] = None,
+    using_key: str | None = None,
     **kwargs,
 ) -> np.ndarray:
     """{}."""
@@ -182,7 +186,7 @@ def _validate(
 def standardize(
     cls,
     values: Iterable,
-    field: Optional[Union[str, StrField]] = None,
+    field: str | StrField | None = None,
     *,
     return_field: str = None,
     return_mapper: bool = False,
@@ -192,7 +196,7 @@ def standardize(
     keep: Literal["first", "last", False] = "first",
     synonyms_field: str = "synonyms",
     **kwargs,
-) -> Union[List[str], Dict[str, str]]:
+) -> list[str] | dict[str, str]:
     """{}."""
     return _standardize(
         cls=cls,
@@ -226,9 +230,9 @@ def set_abbr(self, value: str):
 
 def add_synonym(
     self,
-    synonym: Union[str, ListLike],
+    synonym: str | ListLike,
     force: bool = False,
-    save: Optional[bool] = None,
+    save: bool | None = None,
 ):
     _check_synonyms_field_exist(self)
     _add_or_remove_synonyms(
@@ -236,7 +240,7 @@ def add_synonym(
     )
 
 
-def remove_synonym(self, synonym: Union[str, ListLike]):
+def remove_synonym(self, synonym: str | ListLike):
     _check_synonyms_field_exist(self)
     _add_or_remove_synonyms(synonym=synonym, record=self, action="remove")
 
@@ -244,7 +248,7 @@ def remove_synonym(self, synonym: Union[str, ListLike]):
 def _standardize(
     cls,
     values: Iterable,
-    field: Optional[Union[str, StrField]] = None,
+    field: str | StrField | None = None,
     *,
     return_field: str = None,
     return_mapper: bool = False,
@@ -253,9 +257,9 @@ def _standardize(
     public_aware: bool = True,
     keep: Literal["first", "last", False] = "first",
     synonyms_field: str = "synonyms",
-    using_key: Optional[str] = None,
+    using_key: str | None = None,
     **kwargs,
-) -> Union[List[str], Dict[str, str]]:
+) -> list[str] | dict[str, str]:
     """{}."""
     from lamin_utils._standardize import standardize as map_synonyms
 
@@ -302,7 +306,7 @@ def _standardize(
         **_kwargs,
     )
 
-    def _return(result: List, mapper: Dict):
+    def _return(result: list, mapper: dict):
         if return_mapper:
             return mapper
         else:
@@ -350,15 +354,15 @@ def _standardize(
 
 
 def _add_or_remove_synonyms(
-    synonym: Union[str, Iterable],
+    synonym: str | Iterable,
     record: Registry,
     action: Literal["add", "remove"],
     force: bool = False,
-    save: Optional[bool] = None,
+    save: bool | None = None,
 ):
     """Add or remove synonyms."""
 
-    def check_synonyms_in_all_records(synonyms: Set[str], record: Registry):
+    def check_synonyms_in_all_records(synonyms: set[str], record: Registry):
         """Errors if input synonym is associated with other records in the DB."""
         import pandas as pd
         from IPython.display import display
@@ -437,8 +441,8 @@ def _check_synonyms_field_exist(record: Registry):
 
 def _filter_query_based_on_organism(
     queryset: QuerySet,
-    organism: Optional[Union[str, Registry]] = None,
-    values_list_field: Optional[str] = None,
+    organism: str | Registry | None = None,
+    values_list_field: str | None = None,
 ):
     """Filter a queryset based on organism."""
     import pandas as pd

lamindb/_collection.py

@@ -1,14 +1,11 @@
+from __future__ import annotations
+
 from collections import defaultdict
 from typing import (
     TYPE_CHECKING,
     Any,
-    Dict,
     Iterable,
-    List,
     Literal,
-    Optional,
-    Tuple,
-    Union,
 )
 
 import anndata as ad
@@ -24,12 +21,10 @@ from lnschema_core.types import DataLike, VisibilityChoice
 from lamindb._utils import attach_func_to_class_method
 from lamindb.core._data import _track_run_input
 from lamindb.core._mapped_collection import MappedCollection
-from lamindb.core.storage import UPath
 from lamindb.core.versioning import get_uid_from_old_version, init_uid
 
 from . import Artifact, Run
 from ._artifact import data_is_anndata
-from ._query_set import QuerySet
 from ._registry import init_self_from_db
 from .core._data import (
     add_transform_to_kwargs,
@@ -39,10 +34,13 @@ from .core._data import (
 )
 
 if TYPE_CHECKING:
+    from lamindb.core.storage import UPath
     from lamindb.core.storage._backed_access import AnnDataAccessor, BackedAccessor
 
+    from ._query_set import QuerySet
+
 
-def _check_accessor_collection(data: Any, accessor: Optional[str] = None):
+def _check_accessor_collection(data: Any, accessor: str | None = None):
     if accessor is None and isinstance(data, (AnnData, pd.DataFrame)):
         if isinstance(data, pd.DataFrame):
             logger.warning("data is a DataFrame, please use .from_df()")
@@ -64,31 +62,29 @@ def __init__(
     # now we proceed with the user-facing constructor
     if len(args) > 1:
         raise ValueError("Only one non-keyword arg allowed: data")
-    data: Union[Artifact, Iterable[Artifact]] = (
+    data: Artifact | Iterable[Artifact] = (
         kwargs.pop("data") if len(args) == 0 else args[0]
     )
-    meta: Optional[str] = kwargs.pop("meta") if "meta" in kwargs else None
-    name: Optional[str] = kwargs.pop("name") if "name" in kwargs else None
-    description: Optional[str] = (
+    meta: str | None = kwargs.pop("meta") if "meta" in kwargs else None
+    name: str | None = kwargs.pop("name") if "name" in kwargs else None
+    description: str | None = (
         kwargs.pop("description") if "description" in kwargs else None
     )
-    reference: Optional[str] = (
-        kwargs.pop("reference") if "reference" in kwargs else None
-    )
-    reference_type: Optional[str] = (
+    reference: str | None = kwargs.pop("reference") if "reference" in kwargs else None
+    reference_type: str | None = (
         kwargs.pop("reference_type") if "reference_type" in kwargs else None
     )
-    run: Optional[Run] = kwargs.pop("run") if "run" in kwargs else None
-    is_new_version_of: Optional[Collection] = (
+    run: Run | None = kwargs.pop("run") if "run" in kwargs else None
+    is_new_version_of: Collection | None = (
         kwargs.pop("is_new_version_of") if "is_new_version_of" in kwargs else None
     )
-    version: Optional[str] = kwargs.pop("version") if "version" in kwargs else None
-    visibility: Optional[int] = (
+    version: str | None = kwargs.pop("version") if "version" in kwargs else None
+    visibility: int | None = (
         kwargs.pop("visibility")
         if "visibility" in kwargs
         else VisibilityChoice.default.value
     )
-    feature_sets: Dict[str, FeatureSet] = (
+    feature_sets: dict[str, FeatureSet] = (
         kwargs.pop("feature_sets") if "feature_sets" in kwargs else {}
     )
     accessor = kwargs.pop("accessor") if "accessor" in kwargs else None
@@ -166,7 +162,7 @@ def __init__(
 
 
 # internal function, not exposed to user
-def from_artifacts(artifacts: Iterable[Artifact]) -> Tuple[str, Dict[str, str]]:
+def from_artifacts(artifacts: Iterable[Artifact]) -> tuple[str, dict[str, str]]:
     # assert all artifacts are already saved
     logger.debug("check not saved")
     saved = not any(artifact._state.adding for artifact in artifacts)
@@ -228,16 +224,16 @@ def from_artifacts(artifacts: Iterable[Artifact]) -> Tuple[str, Dict[str, str]]:
 # docstring handled through attach_func_to_class_method
 def mapped(
     self,
-    label_keys: Optional[Union[str, List[str]]] = None,
-    join: Optional[Literal["inner", "outer"]] = "inner",
-    encode_labels: Union[bool, List[str]] = True,
-    unknown_label: Optional[Union[str, Dict[str, str]]] = None,
+    label_keys: str | list[str] | None = None,
+    join: Literal["inner", "outer"] | None = "inner",
+    encode_labels: bool | list[str] = True,
+    unknown_label: str | dict[str, str] | None = None,
     cache_categories: bool = True,
     parallel: bool = False,
-    dtype: Optional[str] = None,
+    dtype: str | None = None,
     stream: bool = False,
-    is_run_input: Optional[bool] = None,
-) -> "MappedCollection":
+    is_run_input: bool | None = None,
+) -> MappedCollection:
     path_list = []
     for artifact in self.artifacts.all():
         if artifact.suffix not in {".h5ad", ".zrad", ".zarr"}:
@@ -263,7 +259,7 @@ def mapped(
 
 
 # docstring handled through attach_func_to_class_method
-def stage(self, is_run_input: Optional[bool] = None) -> List[UPath]:
+def stage(self, is_run_input: bool | None = None) -> list[UPath]:
     _track_run_input(self, is_run_input)
     path_list = []
     for artifact in self.artifacts.all():
@@ -275,7 +271,7 @@ def stage(self, is_run_input: Optional[bool] = None) -> List[UPath]:
 def load(
     self,
     join: Literal["inner", "outer"] = "outer",
-    is_run_input: Optional[bool] = None,
+    is_run_input: bool | None = None,
     **kwargs,
 ) -> DataLike:
     # cannot call _track_run_input here, see comment further down
@@ -301,7 +297,7 @@ def load(
 
 
 # docstring handled through attach_func_to_class_method
-def delete(self, permanent: Optional[bool] = None) -> None:
+def delete(self, permanent: bool | None = None) -> None:
     # change visibility to trash
     trash_visibility = VisibilityChoice.trash.value
     if self.visibility > trash_visibility and permanent is not True:

lamindb/_feature.py

@@ -1,10 +1,11 @@
-from typing import Dict, List, Optional, Union
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, List
 
 import lamindb_setup as ln_setup
 import pandas as pd
 from lamindb_setup.core._docs import doc_args
 from lnschema_core.models import Feature, Registry
-from lnschema_core.types import FieldAttr
 from pandas.api.types import CategoricalDtype, is_string_dtype
 
 from lamindb._utils import attach_func_to_class_method
@@ -12,6 +13,9 @@ from lamindb.core._settings import settings
 
 from ._query_set import RecordsList
 
+if TYPE_CHECKING:
+    from lnschema_core.types import FieldAttr
+
 FEATURE_TYPES = {
     "int": "number",
     "float": "number",
@@ -41,7 +45,7 @@ def __init__(self, *args, **kwargs):
     type: Optional[Union[type, str]] = (  # noqa
         kwargs.pop("type") if "type" in kwargs else None
     )
-    registries: Optional[List[Registry]] = (
+    registries: list[Registry] | None = (
         kwargs.pop("registries") if "registries" in kwargs else None
     )
     # cast type
@@ -55,7 +59,7 @@ def __init__(self, *args, **kwargs):
         raise ValueError("type has to be one of 'number', 'category', 'bool'!")
     kwargs["type"] = type_str
     # cast registries
-    registries_str: Optional[str] = None
+    registries_str: str | None = None
     if registries is not None:
         if isinstance(registries, str):
             # TODO: add more validation
@@ -73,7 +77,7 @@ def __init__(self, *args, **kwargs):
     super(Feature, self).__init__(*args, **kwargs)
 
 
-def categoricals_from_df(df: "pd.DataFrame") -> Dict:
+def categoricals_from_df(df: pd.DataFrame) -> dict:
     """Returns categorical columns."""
     string_cols = [col for col in df.columns if is_string_dtype(df[col])]
     categoricals = {
@@ -90,9 +94,7 @@ def categoricals_from_df(df: "pd.DataFrame") -> Dict:
 
 @classmethod  # type:ignore
 @doc_args(Feature.from_df.__doc__)
-def from_df(
-    cls, df: "pd.DataFrame", field: Optional[FieldAttr] = None
-) -> "RecordsList":
+def from_df(cls, df: pd.DataFrame, field: FieldAttr | None = None) -> RecordsList:
     """{}."""
     field = Feature.name if field is None else field
     categoricals = categoricals_from_df(df)

lamindb/_feature_set.py

@@ -1,4 +1,6 @@
-from typing import TYPE_CHECKING, Dict, Iterable, List, Optional, Type, Union
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Iterable
 
 import lamindb_setup as ln_setup
 import numpy as np
@@ -22,7 +24,7 @@ NUMBER_TYPE = "number"
 
 
 def dict_related_model_to_related_name(orm):
-    d: Dict = {
+    d: dict = {
         i.related_model.__get_name_with_schema__(): i.related_name
         for i in orm._meta.related_objects
         if i.related_name is not None
@@ -39,7 +41,7 @@ def dict_related_model_to_related_name(orm):
 
 
 def dict_schema_name_to_model_name(orm):
-    d: Dict = {
+    d: dict = {
         i.related_model.__get_name_with_schema__(): i.related_model
         for i in orm._meta.related_objects
         if i.related_name is not None
@@ -72,7 +74,7 @@ def get_related_name(features_type: Registry):
     return candidates[0]
 
 
-def validate_features(features: List[Registry]) -> Registry:
+def validate_features(features: list[Registry]) -> Registry:
     """Validate and return feature type."""
     try:
         if len(features) == 0:
@@ -104,8 +106,8 @@ def __init__(self, *args, **kwargs):
     if len(args) > 1:
         raise ValueError("Only one non-keyword arg allowed: features")
     features: Iterable[Registry] = kwargs.pop("features") if len(args) == 0 else args[0]
-    type: Optional[Union[type, str]] = kwargs.pop("type") if "type" in kwargs else None
-    name: Optional[str] = kwargs.pop("name") if "name" in kwargs else None
+    type: str | None = kwargs.pop("type") if "type" in kwargs else None
+    name: str | None = kwargs.pop("name") if "name" in kwargs else None
     if len(kwargs) > 0:
         raise ValueError("Only features, type, name are valid keyword arguments")
     # now code
@@ -142,9 +144,9 @@ def save(self, *args, **kwargs) -> None:
         getattr(self, related_name).set(records)
 
 
-def get_type_str(type: Optional[Union[Type, str]]) -> Optional[str]:
+def get_type_str(type: str | None) -> str | None:
     if type is not None:
-        type_str = type.__name__ if not isinstance(type, str) else type
+        type_str = type.__name__ if not isinstance(type, str) else type  # type: ignore
     else:
         type_str = None
     if type == "int" or type == "float":
@@ -158,10 +160,10 @@ def from_values(
     cls,
     values: ListLike,
     field: FieldAttr = Feature.name,
-    type: Optional[Union[Type, str]] = None,
-    name: Optional[str] = None,
+    type: str | None = None,
+    name: str | None = None,
     **kwargs,
-) -> Optional["FeatureSet"]:
+) -> FeatureSet | None:
     """{}."""
     if not isinstance(field, FieldAttr):
         raise TypeError(
@@ -192,11 +194,11 @@ def from_values(
 @doc_args(FeatureSet.from_df.__doc__)
 def from_df(
     cls,
-    df: "pd.DataFrame",
+    df: pd.DataFrame,
     field: FieldAttr = Feature.name,
-    name: Optional[str] = None,
+    name: str | None = None,
     **kwargs,
-) -> Optional["FeatureSet"]:
+) -> FeatureSet | None:
     """{}."""
     registry = field.field.model
     validated = registry.validate(df.columns, field=field, **kwargs)
@@ -225,7 +227,7 @@ def from_df(
 
 @property  # type: ignore
 @doc_args(FeatureSet.members.__doc__)
-def members(self) -> "QuerySet":
+def members(self) -> QuerySet:
     """{}."""
     if self._state.adding:
         # this should return a queryset and not a list...

lamindb/_filter.py

@@ -1,4 +1,4 @@
-from typing import Type
+from __future__ import annotations
 
 from lnschema_core import Artifact, Collection, Registry
 from lnschema_core.types import VisibilityChoice
@@ -7,7 +7,7 @@ from lamindb import settings
 from lamindb._query_set import QuerySet
 
 
-def filter(Registry: Type[Registry], **expressions) -> QuerySet:
+def filter(Registry: type[Registry], **expressions) -> QuerySet:
     """See :meth:`~lamindb.core.Registry.filter`."""
     _using_key = None
     if "_using_key" in expressions:

lamindb/_finish.py

@@ -1,18 +1,24 @@
+from __future__ import annotations
+
 import os
 import shutil
 import subprocess
 from datetime import datetime, timezone
-from pathlib import Path
-from typing import Optional
+from typing import TYPE_CHECKING
 
 import lamindb_setup as ln_setup
 from lamin_utils import logger
-from lnschema_core import Run, Transform
 from lnschema_core.types import TransformType
 
-from ._query_set import QuerySet
 from .core._run_context import is_run_from_ipython, run_context
 
+if TYPE_CHECKING:
+    from pathlib import Path
+
+    from lnschema_core import Run, Transform
+
+    from ._query_set import QuerySet
+
 
 class CallFinishInLastCell(SystemExit):
     pass
@@ -34,13 +40,13 @@ def finish(i_saved_the_notebook: bool = False):
 
         if not i_saved_the_notebook and not ln_setup._TESTING:
             logger.error(
-                "Please save the notebook, pass `i_saved_the_notebook=True`, and re-run this cell."
+                "Please pass `i_saved_the_notebook=True` to `ln.finish()`, save the notebook, and re-run this cell."
             )
             return None
         notebook_content = read_notebook(run_context.path)  # type: ignore
         if not check_last_cell(notebook_content, "i_saved_the_notebook"):
             raise CallFinishInLastCell(
-                "Can only finish() from the last code cell of the notebook."
+                "Can only run `ln.finish(i_saved_the_notebook=True)` from the last code cell of the notebook."
             )
         save_run_context_core(
             run=run_context.run,
@@ -61,11 +67,11 @@ def save_run_context_core(
     run: Run,
     transform: Transform,
     filepath: Path,
-    transform_family: Optional[QuerySet] = None,
+    transform_family: QuerySet | None = None,
     is_consecutive: bool = True,
     finished_at: bool = False,
     notebook_content=None,  # nbproject.Notebook
-) -> Optional[str]:
+) -> str | None:
     import lamindb as ln
 
     ln.settings.verbosity = "success"

lamindb/_from_values.py

@@ -1,13 +1,17 @@
-from typing import Any, Dict, Iterable, List, Tuple, Union
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any, Iterable
 
 import pandas as pd
 from django.core.exceptions import FieldDoesNotExist
 from lamin_utils import colors, logger
 from lnschema_core.models import Feature, Registry, ULabel
-from lnschema_core.types import ListLike, StrField
 
 from .core._settings import settings
 
+if TYPE_CHECKING:
+    from lnschema_core.types import ListLike, StrField
+
 
 # The base function for `from_values`
 def get_or_create_records(
@@ -16,7 +20,7 @@ def get_or_create_records(
     *,
     from_public: bool = False,
     **kwargs,
-) -> List[Registry]:
+) -> list[Registry]:
     """Get or create records from iterables."""
     upon_create_search_names = settings.upon_create_search_names
     settings.upon_create_search_names = False
@@ -74,12 +78,12 @@ def get_or_create_records(
 def get_existing_records(
     iterable_idx: pd.Index,
     field: StrField,
-    kwargs: Dict = None,
+    kwargs: dict = None,
 ):
     if kwargs is None:
         kwargs = {}
     model = field.field.model
-    condition: Dict = {} if len(kwargs) == 0 else kwargs.copy()
+    condition: dict = {} if len(kwargs) == 0 else kwargs.copy()
     # existing records matching is agnostic to the bionty source
     if "public_source" in condition:
         condition.pop("public_source")
@@ -167,7 +171,7 @@ def create_records_from_public(
     **kwargs,
 ):
     model = field.field.model
-    records: List = []
+    records: list = []
     # populate additional fields from bionty
     from lnschema_bionty._bionty import get_public_source_record
 
@@ -247,7 +251,7 @@ def index_iterable(iterable: Iterable) -> pd.Index:
     return idx[(idx != "") & (~idx.isnull())]
 
 
-def _print_values(names: List, n: int = 20) -> str:
+def _print_values(names: list, n: int = 20) -> str:
     print_values = ", ".join([f"'{name}'" for name in names[:n]])
     if len(names) > n:
         print_values += ", ..."
@@ -292,8 +296,8 @@ def _filter_bionty_df_columns(model: Registry, public_ontology: Any) -> pd.DataF
 
 
 def _bulk_create_dicts_from_df(
-    keys: Union[set, List], column_name: str, df: pd.DataFrame
-) -> Tuple[Dict, str]:
+    keys: set | list, column_name: str, df: pd.DataFrame
+) -> tuple[dict, str]:
     """Get fields from a DataFrame for many rows."""
     multi_msg = ""
     if df.index.name != column_name:

lamindb/_is_versioned.py

@@ -1,4 +1,4 @@
-from typing import Optional
+from __future__ import annotations
 
 import lamindb_setup as ln_setup
 from lamin_utils import logger
@@ -12,7 +12,7 @@ from .core.versioning import get_new_path_from_uid, get_uid_from_old_version
 
 # docstring handled through attach_func_to_class_method
 def add_to_version_family(
-    self, is_new_version_of: IsVersioned, version: Optional[str] = None
+    self, is_new_version_of: IsVersioned, version: str | None = None
 ):
     old_uid = self.uid
     new_uid, version = get_uid_from_old_version(is_new_version_of, version)