lamindb 1.1.0__py3-none-any.whl → 1.2.0__py3-none-any.whl

lamindb/models/__init__.py

@@ -0,0 +1,79 @@
+"""Models library.
+
+.. autosummary::
+   :toctree: .
+
+   BasicRecord
+   Record
+   Registry
+   QuerySet
+   QueryManager
+   RecordList
+   FeatureManager
+   ParamManager
+   LabelManager
+   IsVersioned
+   CanCurate
+   HasParents
+   TracksRun
+   TracksUpdates
+   ParamValue
+   FeatureValue
+   InspectResult
+   ValidateFields
+
+"""
+
+# ruff: noqa: I001
+from lamin_utils._inspect import InspectResult
+from ._is_versioned import IsVersioned
+from .can_curate import CanCurate
+from .record import (
+    BasicRecord,
+    Record,
+    Registry,
+    Space,
+    ValidateFields,
+    format_field_value,
+    record_repr,
+    LinkORM,
+)
+from .core import Storage
+from .transform import Transform
+from .run import Run, TracksRun, TracksUpdates, current_run, Param, ParamValue, User
+from .feature import Feature, FeatureValue
+from .schema import Schema
+from .ulabel import ULabel
+
+# should come last as it needs everything else
+from .artifact import Artifact
+from ._feature_manager import FeatureManager
+from .run import ParamManager
+from ._label_manager import LabelManager
+from .collection import Collection, CollectionArtifact
+from .project import Person, Project, Reference
+from .flextable import FlexTable, RunData
+from .query_manager import QueryManager
+from .query_set import QuerySet, RecordList
+from .has_parents import HasParents
+from datetime import datetime as _datetime
+
+FeatureSet = Schema  # backward compat
+
+# link models
+from .artifact import ArtifactFeatureValue, ArtifactParamValue
+from .flextable import FlexTableData
+from .project import (
+    ArtifactProject,
+    TransformProject,
+    CollectionProject,
+    ULabelProject,
+    FeatureProject,
+    SchemaProject,
+    ArtifactReference,
+    CollectionReference,
+)
+from .record import Migration
+from .run import RunParamValue
+from .schema import SchemaFeature, SchemaParam, ArtifactSchema, SchemaComponent
+from .ulabel import ArtifactULabel, TransformULabel, RunULabel, CollectionULabel

lamindb/{core → models}/_describe.py

@@ -7,7 +7,7 @@ from lamin_utils import logger
 from rich.text import Text
 from rich.tree import Tree
 
-from ._context import is_run_from_ipython
+from ..core._context import is_run_from_ipython
 
 if TYPE_CHECKING:
     from lamindb.models import Artifact, Collection, Run
@@ -73,9 +73,9 @@ def describe_header(self: Artifact | Collection | Run) -> Tree:
             f"This is not the latest version of the {self.__class__.__name__}."
         )
     if hasattr(self, "_branch_code"):
-        if self._branch_code == 0:
+        if self._branch_code == 0:  # type: ignore
             logger.warning("This artifact is hidden.")
-        elif self._branch_code == -1:
+        elif self._branch_code == -1:  # type: ignore
             logger.warning("This artifact is in the trash.")
     # initialize tree
     suffix = self.suffix if hasattr(self, "suffix") and self.suffix else ""

lamindb/{core → models}/_django.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 from functools import reduce
+from typing import TYPE_CHECKING
 
 from django.contrib.postgres.aggregates import ArrayAgg
 from django.db import connection
@@ -9,9 +10,12 @@ from django.db.models.fields.related import ForeignKey, ManyToManyField
 from django.db.models.fields.reverse_related import ManyToManyRel, ManyToOneRel
 from django.db.models.functions import JSONObject
 
-from lamindb.models import Artifact, Record, Schema
+from ._relations import dict_related_model_to_related_name, get_schema_modules
+from .schema import Schema
 
-from .relations import dict_related_model_to_related_name, get_schema_modules
+if TYPE_CHECKING:
+    from .artifact import Artifact
+    from .record import Record
 
 
 def get_related_model(model, field_name):
@@ -38,9 +42,8 @@ def get_artifact_with_related(
     include_schema: bool = False,
 ) -> dict:
     """Fetch an artifact with its related data."""
-    from lamindb._can_curate import get_name_field
-
     from ._label_manager import EXCLUDE_LABELS
+    from .can_curate import get_name_field
 
     model = artifact.__class__
     schema_modules = get_schema_modules(artifact._state.db)
@@ -177,7 +180,7 @@ def get_artifact_with_related(
 
 def get_schema_m2m_relations(artifact: Artifact, slot_schema: dict, limit: int = 20):
     """Fetch all many-to-many relationships for given feature sets."""
-    from lamindb._can_curate import get_name_field
+    from .can_curate import get_name_field
 
     m2m_relations = [
         v

lamindb/{core → models}/_feature_manager.py

@@ -1,6 +1,6 @@
+# ruff: noqa: TC004
 from __future__ import annotations
 
-import warnings
 from collections import defaultdict
 from collections.abc import Iterable
 from datetime import date, datetime
@@ -20,38 +20,23 @@ from lamindb_setup.core.upath import create_path
 from rich.table import Column, Table
 from rich.text import Text
 
-from lamindb._feature import (
+from lamindb.core.storage import LocalPathClasses
+from lamindb.errors import DoesNotExist, ValidationError
+from lamindb.models._from_values import _format_values
+from lamindb.models.feature import (
     convert_pandas_dtype_to_lamin_dtype,
     suggest_categorical_for_str_iterable,
 )
-from lamindb._from_values import _format_values
-from lamindb._record import (
+from lamindb.models.record import (
     REGISTRY_UNIQUE_FIELD,
     get_name_field,
     transfer_fk_to_default_db_bulk,
     transfer_to_default_db,
 )
-from lamindb._save import save
-from lamindb._schema import DICT_KEYS_TYPE, Schema
-from lamindb.core.storage import LocalPathClasses
-from lamindb.errors import DoesNotExist, ValidationError
-from lamindb.models import (
-    Artifact,
-    Collection,
-    Feature,
-    FeatureManager,
-    FeatureValue,
-    LinkORM,
-    Param,
-    ParamManager,
-    ParamManagerArtifact,
-    ParamManagerRun,
-    ParamValue,
-    Record,
-    Run,
-    ULabel,
-)
+from lamindb.models.save import save
+from lamindb.models.schema import DICT_KEYS_TYPE, Schema
 
+from ..base import deprecated
 from ._describe import (
     NAME_WIDTH,
     TYPE_WIDTH,
@@ -61,24 +46,24 @@ from ._describe import (
 )
 from ._django import get_artifact_with_related
 from ._label_manager import _get_labels, describe_labels
-from ._settings import settings
-from .relations import (
+from ._relations import (
     dict_related_model_to_related_name,
 )
+from .feature import Feature, FeatureValue
+from .record import Record
+from .run import Param, ParamManager, ParamManagerRun, ParamValue, Run
+from .ulabel import ULabel
 
 if TYPE_CHECKING:
     from rich.tree import Tree
 
-    from lamindb._query_set import QuerySet
     from lamindb.base.types import FieldAttr
-
-
-def get_host_id_field(host: Artifact | Collection) -> str:
-    if isinstance(host, Artifact):
-        host_id_field = "artifact_id"
-    else:
-        host_id_field = "collection_id"
-    return host_id_field
+    from lamindb.models import (
+        Artifact,
+        Collection,
+        LinkORM,
+    )
+    from lamindb.models.query_set import QuerySet
 
 
 def get_accessor_by_registry_(host: Artifact | Collection) -> dict:
@@ -91,9 +76,7 @@ def get_accessor_by_registry_(host: Artifact | Collection) -> dict:
     return dictionary
 
 
-def get_schema_by_slot_(host: Artifact | Collection) -> dict:
-    if isinstance(host, Collection):
-        return {}
+def get_schema_by_slot_(host: Artifact) -> dict:
     # if the host is not yet saved
     if host._state.adding:
         if hasattr(host, "_staged_feature_sets"):
@@ -101,8 +84,7 @@ def get_schema_by_slot_(host: Artifact | Collection) -> dict:
         else:
             return {}
     host_db = host._state.db
-    host_id_field = get_host_id_field(host)
-    kwargs = {host_id_field: host.id}
+    kwargs = {"artifact_id": host.id}
     # otherwise, we need a query
     links_schema = (
         host.feature_sets.through.objects.using(host_db)
@@ -115,8 +97,7 @@ def get_schema_by_slot_(host: Artifact | Collection) -> dict:
 def get_label_links(
     host: Artifact | Collection, registry: str, feature: Feature
 ) -> QuerySet:
-    host_id_field = get_host_id_field(host)
-    kwargs = {host_id_field: host.id, "feature_id": feature.id}
+    kwargs = {"artifact_id": host.id, "feature_id": feature.id}
     link_records = (
         getattr(host, host.features._accessor_by_registry[registry])  # type: ignore
         .through.objects.using(host._state.db)
@@ -126,8 +107,7 @@ def get_label_links(
 
 
 def get_schema_links(host: Artifact | Collection) -> QuerySet:
-    host_id_field = get_host_id_field(host)
-    kwargs = {host_id_field: host.id}
+    kwargs = {"artifact_id": host.id}
     links_schema = host.feature_sets.through.objects.filter(**kwargs)
     return links_schema
 
@@ -232,6 +212,9 @@ def _get_non_categoricals(
     print_params: bool = False,
 ) -> dict[tuple[str, str], set[Any]]:
     """Get non-categorical features and their values."""
+    from .artifact import Artifact
+    from .run import Run
+
     non_categoricals = {}
 
     if self.id is not None and isinstance(self, (Artifact, Run)):
@@ -299,21 +282,15 @@ def _create_feature_table(
 
 
 def describe_features(
-    self: Artifact | Collection,
+    self: Artifact,
     related_data: dict | None = None,
-    print_types: bool = False,
     to_dict: bool = False,
     print_params: bool = False,
     tree: Tree | None = None,
     with_labels: bool = False,
 ):
     """Describe features of an artifact or collection."""
-    if print_types:
-        warnings.warn(
-            "`print_types` parameter is deprecated and will be removed in a future version. Types are now always printed.",
-            DeprecationWarning,
-            stacklevel=2,
-        )
+    from .artifact import Artifact
 
     # initialize tree
     if tree is None:
@@ -466,7 +443,7 @@ def describe_features(
             Text.assemble(
                 ("Dataset features", "bold bright_magenta"),
                 ("/", "dim"),
-                ("schema", "dim bold"),
+                (".feature_sets", "dim bold"),
             )
         )
         for child in int_features_tree_children:
@@ -511,6 +488,7 @@ def parse_staged_feature_sets_from_anndata(
     if not isinstance(adata, AnnData):  # is a path
         filepath = create_path(adata)  # returns Path for local
         if not isinstance(filepath, LocalPathClasses):
+            from lamindb import settings
             from lamindb.core.storage._backed_access import backed_access
 
             using_key = settings._using_key
@@ -631,9 +609,21 @@ def infer_feature_type_convert_json(
     return "?", value, message
 
 
+class FeatureManager:
+    """Feature manager."""
+
+    pass
+
+
+class ParamManagerArtifact(ParamManager):
+    """Param manager."""
+
+    pass
+
+
 def __init__(self, host: Artifact | Collection | Run):
     self._host = host
-    self._schema_by_slot_ = None
+    self._slots = None
     self._accessor_by_registry_ = None
 
 
@@ -649,19 +639,22 @@ def get_values(self) -> dict[str, Any]:
     )  # type: ignore
 
 
+@deprecated("slots[slot].members")
 def __getitem__(self, slot) -> QuerySet:
-    if slot not in self._schema_by_slot:
+    if slot not in self.slots:
         raise ValueError(
             f"No linked feature set for slot: {slot}\nDid you get validation"
             " warnings? Only features that match registered features get validated"
             " and linked."
         )
-    schema = self._schema_by_slot[slot]
+    schema = self.slots[slot]
     orm_name = schema.itype
     return getattr(schema, self._accessor_by_registry[orm_name]).all()
 
 
 def filter_base(cls, **expression):
+    from .artifact import Artifact
+
     if cls is FeatureManager:
         model = Feature
         value_model = FeatureValue
@@ -748,11 +741,17 @@ def get(cls, **expression) -> Record:
 
 
 @property  # type: ignore
-def _schema_by_slot(self):
-    """Feature sets by slot."""
-    if self._schema_by_slot_ is None:
-        self._schema_by_slot_ = get_schema_by_slot_(self._host)
-    return self._schema_by_slot_
+def slots(self) -> dict[str, Schema]:
+    """Schema by slot.
+
+    Example:
+
+        >>> artifact.features.slots
+        {'var': <Schema: var>, 'obs': <Schema: obs>}
+    """
+    if self._slots is None:
+        self._slots = get_schema_by_slot_(self._host)
+    return self._slots
 
 
 @property  # type: ignore
@@ -819,6 +818,7 @@ def _add_values(
             dictionary.
     """
     from .._tracked import get_current_tracked_run
+    from .artifact import Artifact
 
     # rename to distinguish from the values inside the dict
     features_values = values
@@ -1019,6 +1019,8 @@ def remove_values(
         value: An optional value to restrict removal to a single value.
 
     """
+    from .artifact import Artifact
+
     if isinstance(feature, str):
         feature = Feature.get(name=feature)
     filter_kwargs = {"feature": feature}
@@ -1059,7 +1061,7 @@ def remove_values(
         # we can clean the FeatureValue registry periodically if we want to
 
 
-def add_schema(self, schema: Schema, slot: str) -> None:
+def _add_schema(self, schema: Schema, slot: str) -> None:
     """Annotate artifact with a schema.
 
     Args:
@@ -1074,9 +1076,8 @@ def add_schema(self, schema: Schema, slot: str) -> None:
         )
     host_db = self._host._state.db
     schema.save(using=host_db)
-    host_id_field = get_host_id_field(self._host)
     kwargs = {
-        host_id_field: self._host.id,
+        "artifact_id": self._host.id,
         "schema": schema,
         "slot": slot,
     }
@@ -1087,9 +1088,9 @@ def add_schema(self, schema: Schema, slot: str) -> None:
     )
     if link_record is None:
         self._host.feature_sets.through(**kwargs).save(using=host_db)
-        if slot in self._schema_by_slot:
+        if slot in self.slots:
             logger.debug(f"replaced existing {slot} feature set")
-        self._schema_by_slot_[slot] = schema  # type: ignore
+        self._slots[slot] = schema  # type: ignore
 
 
 def _add_set_from_df(
@@ -1099,11 +1100,7 @@ def _add_set_from_df(
     mute: bool = False,
 ):
     """Add feature set corresponding to column names of DataFrame."""
-    if isinstance(self._host, Artifact):
-        assert self._host.otype == "DataFrame"  # noqa: S101
-    else:
-        # Collection
-        assert self._host.artifact.otype == "DataFrame"  # noqa: S101
+    assert self._host.otype == "DataFrame"  # noqa: S101
     df = self._host.load()
     schema = Schema.from_df(
         df=df,
@@ -1117,16 +1114,13 @@ def _add_set_from_df(
 
 def _add_set_from_anndata(
     self,
-    var_field: FieldAttr,
+    var_field: FieldAttr | None = None,
     obs_field: FieldAttr | None = Feature.name,
     mute: bool = False,
     organism: str | Record | None = None,
 ):
     """Add features from AnnData."""
-    if isinstance(self._host, Artifact):
-        assert self._host.otype == "AnnData"  # noqa: S101
-    else:
-        raise NotImplementedError()
+    assert self._host.otype == "AnnData"  # noqa: S101
 
     # parse and register features
     adata = self._host.load()
@@ -1153,10 +1147,7 @@ def _add_set_from_mudata(
     """Add features from MuData."""
     if obs_fields is None:
         obs_fields = {}
-    if isinstance(self._host, Artifact):
-        assert self._host.otype == "MuData"  # noqa: S101
-    else:
-        raise NotImplementedError()
+    assert self._host.otype == "MuData"  # noqa: S101
 
     # parse and register features
     mdata = self._host.load()
@@ -1197,8 +1188,10 @@ def _add_from(self, data: Artifact | Collection, transfer_logs: dict = None):
     # This only covers feature sets
     if transfer_logs is None:
         transfer_logs = {"mapped": [], "transferred": [], "run": None}
+    from lamindb import settings
+
     using_key = settings._using_key
-    for slot, schema in data.features._schema_by_slot.items():  # type: ignore
+    for slot, schema in data.features.slots.items():  # type: ignore
         members = schema.members
         if len(members) == 0:
             continue
@@ -1246,7 +1239,7 @@ def _add_from(self, data: Artifact | Collection, transfer_logs: dict = None):
         if schema_self.hash == schema.hash:
             schema_self.uid = schema.uid
         logger.info(f"saving {slot} schema: {schema_self}")
-        self._host.features.add_schema(schema_self, slot)
+        self._host.features._add_schema(schema_self, slot)
 
 
 def make_external(self, feature: Feature) -> None:
@@ -1279,6 +1272,27 @@ def make_external(self, feature: Feature) -> None:
             fs.delete()
 
 
+@deprecated("_add_schema")
+def add_schema(self, schema: Schema, slot: str) -> None:
+    return self._add_schema(schema, slot)
+
+
+@deprecated("_add_schema")
+def add_feature_set(self, schema: Schema, slot: str) -> None:
+    return self._add_schema(schema, slot)
+
+
+@property
+@deprecated("slots")
+def _schema_by_slot(self):
+    return self.slots
+
+
+@property
+def _feature_set_by_slot(self):
+    return self.slots
+
+
 # mypy: ignore-errors
 FeatureManager.__init__ = __init__
 ParamManager.__init__ = __init__
@@ -1286,12 +1300,14 @@ FeatureManager.__repr__ = __repr__
 ParamManager.__repr__ = __repr__
 FeatureManager.__getitem__ = __getitem__
 FeatureManager.get_values = get_values
-FeatureManager._schema_by_slot = _schema_by_slot
-FeatureManager._feature_set_by_slot = _schema_by_slot
-FeatureManager._accessor_by_registry = _accessor_by_registry
+FeatureManager.slots = slots
 FeatureManager.add_values = add_values_features
-FeatureManager.add_schema = add_schema
-FeatureManager.add_feature_set = add_schema  # backward compat, will raise warning soon
+FeatureManager._add_schema = _add_schema
+FeatureManager.add_schema = add_schema  # deprecated
+FeatureManager.add_feature_set = add_feature_set  # deprecated
+FeatureManager._schema_by_slot = _schema_by_slot  # deprecated
+FeatureManager._feature_set_by_slot = _feature_set_by_slot  # deprecated
+FeatureManager._accessor_by_registry = _accessor_by_registry
 FeatureManager._add_set_from_df = _add_set_from_df
 FeatureManager._add_set_from_anndata = _add_set_from_anndata
 FeatureManager._add_set_from_mudata = _add_set_from_mudata

lamindb/{_from_values.py → models/_from_values.py}

@@ -6,14 +6,15 @@ import pandas as pd
 from django.core.exceptions import FieldDoesNotExist
 from lamin_utils import colors, logger
 
-from lamindb._query_set import RecordList
-from lamindb.models import Record
+from .record import Record
 
 if TYPE_CHECKING:
     from collections.abc import Iterable
 
     from lamindb.base.types import ListLike, StrField
 
+    from .query_set import RecordList
+
 
 # The base function for `from_values`
 def get_or_create_records(
@@ -27,6 +28,8 @@ def get_or_create_records(
     mute: bool = False,
 ) -> RecordList:
     """Get or create records from iterables."""
+    from .query_set import RecordList
+
     registry = field.field.model  # type: ignore
     if create:
         return RecordList([registry(**{field.field.name: value}) for value in iterable])  # type: ignore