lamindb 1.3.2__py3-none-any.whl → 1.4.0__py3-none-any.whl

lamindb/models/artifact.py

@@ -9,6 +9,7 @@ from typing import TYPE_CHECKING, Any, Union, overload
 
 import fsspec
 import lamindb_setup as ln_setup
+import numpy as np
 import pandas as pd
 from anndata import AnnData
 from django.db import connections, models
@@ -38,7 +39,6 @@ from lamindb.errors import FieldValidationError
 from lamindb.models.query_set import QuerySet
 
 from ..base.users import current_user_id
-from ..core._compat import is_package_installed
 from ..core.loaders import load_to_memory
 from ..core.storage import (
     LocalPathClasses,
@@ -61,7 +61,6 @@ from ..core.storage.paths import (
 from ..errors import IntegrityError, InvalidArgument, ValidationError
 from ..models._is_versioned import (
     create_uid,
-    message_update_key_in_version_family,
 )
 from ._django import get_artifact_with_related
 from ._feature_manager import (
@@ -69,6 +68,7 @@ from ._feature_manager import (
     ParamManager,
     ParamManagerArtifact,
     add_label_feature_links,
+    filter_base,
     get_label_links,
 )
 from ._is_versioned import IsVersioned
@@ -86,7 +86,7 @@ from .record import (
     _get_record_kwargs,
     record_repr,
 )
-from .run import ParamValue, Run, TracksRun, TracksUpdates, User
+from .run import Param, ParamValue, Run, TracksRun, TracksUpdates, User
 from .schema import Schema
 from .ulabel import ULabel
 
@@ -210,17 +210,6 @@ def process_data(
 
     if not overwritten, data gets stored in default storage
     """
-    supported_data_types = [pd.DataFrame, AnnData]
-    if is_package_installed("mudata"):
-        from mudata import MuData
-
-        supported_data_types.append(MuData)
-    if is_package_installed("spatialdata"):
-        from spatialdata import SpatialData
-
-        supported_data_types.append(SpatialData)
-    supported_data_types = tuple(supported_data_types)  # type: ignore
-
     if key is not None:
         key_suffix = extract_suffix_from_path(PurePosixPath(key), arg_name="key")
         # use suffix as the (adata) format if the format is not provided
@@ -228,7 +217,8 @@ def process_data(
             format = key_suffix[1:]
     else:
         key_suffix = None
-    if isinstance(data, (str, Path, UPath)):  # UPathStr, spelled out
+
+    if isinstance(data, (str, Path, UPath)):
         access_token = (
             default_storage._access_token
             if hasattr(default_storage, "_access_token")
@@ -239,6 +229,7 @@ def process_data(
         # for example into a temporary url
         if path.protocol not in {"http", "https"}:
             path = path.resolve()
+
         storage, use_existing_storage_key = process_pathlike(
             path,
             default_storage=default_storage,
@@ -247,28 +238,37 @@ def process_data(
         )
         suffix = extract_suffix_from_path(path)
         memory_rep = None
-    elif isinstance(data, supported_data_types):
+    elif (
+        isinstance(data, pd.DataFrame)
+        or isinstance(data, AnnData)
+        or data_is_mudata(data)
+        or data_is_spatialdata(data)
+    ):
         storage = default_storage
         memory_rep = data
         suffix = infer_suffix(data, format)
     else:
         raise NotImplementedError(
-            f"Do not know how to create a artifact object from {data}, pass a path instead!"
+            f"Do not know how to create an Artifact from {data}, pass a path instead."
         )
+
+    # Check for suffix consistency
     if key_suffix is not None and key_suffix != suffix and not is_replace:
         # consciously omitting a trailing period
-        if isinstance(data, (str, Path, UPath)):
+        if isinstance(data, (str, Path, UPath)):  # UPathStr, spelled out
             message = f"The suffix '{suffix}' of the provided path is inconsistent, it should be '{key_suffix}'"
         else:
             message = f"The suffix '{key_suffix}' of the provided key is inconsistent, it should be '{suffix}'"
         raise InvalidArgument(message)
+
     # in case we have an in-memory representation, we need to write it to disk
-    from lamindb import settings
+    if memory_rep is not None:
+        from lamindb import settings
 
-    if isinstance(data, supported_data_types):
         path = settings.cache_dir / f"{provisional_uid}{suffix}"
         write_to_disk(data, path)
         use_existing_storage_key = False
+
     return memory_rep, path, suffix, storage, use_existing_storage_key
 
 
@@ -533,28 +533,24 @@ def data_is_anndata(data: AnnData | UPathStr) -> bool:
 
 
 def data_is_mudata(data: MuData | UPathStr) -> bool:
-    if is_package_installed("mudata"):
-        from mudata import MuData
-
-        if isinstance(data, MuData):
-            return True
+    # We are not importing MuData here to keep loaded modules minimal
+    if hasattr(data, "__class__") and data.__class__.__name__ == "MuData":
+        return True
     if isinstance(data, (str, Path)):
         return UPath(data).suffix == ".h5mu"
     return False
 
 
 def data_is_spatialdata(data: SpatialData | UPathStr) -> bool:
-    if is_package_installed("spatialdata"):
-        from spatialdata import SpatialData
-
-        if isinstance(data, SpatialData):
-            return True
-        if isinstance(data, (str, Path)):
-            if UPath(data).suffix == ".zarr":
-                # TODO: inconsistent with anndata, where we run the storage
-                # check only for local, expensive for cloud
-                return identify_zarr_type(data, check=False) == "spatialdata"
-        return False
+    # We are not importing SpatialData here to keep loaded modules minimal
+    if hasattr(data, "__class__") and data.__class__.__name__ == "SpatialData":
+        return True
+    if isinstance(data, (str, Path)):
+        if UPath(data).suffix == ".zarr":
+            # TODO: inconsistent with anndata, where we run the storage
+            # check only for local, expensive for cloud
+            return identify_zarr_type(data, check=False) == "spatialdata"
+    return False
 
 
 def _check_otype_artifact(
@@ -962,53 +958,27 @@ class Artifact(Record, IsVersioned, TracksRun, TracksUpdates):
         revises: `Artifact | None = None` Previous version of the artifact. Is an alternative way to passing `key` to trigger a new version.
         run: `Run | None = None` The run that creates the artifact.
 
-    .. dropdown:: Typical storage formats & their API accessors
-
-        Arrays:
-
-        - Table: `.csv`, `.tsv`, `.parquet`, `.ipc` ⟷ `DataFrame`, `pyarrow.Table`
-        - Annotated matrix: `.h5ad`, `.h5mu`, `.zrad` ⟷ `AnnData`, `MuData`
-        - Generic array: HDF5 group, zarr group, TileDB store ⟷ HDF5, zarr, TileDB loaders
-
-        Non-arrays:
-
-        - Image: `.jpg`, `.png` ⟷ `np.ndarray`, ...
-        - Fastq: `.fastq` ⟷ /
-        - VCF: `.vcf` ⟷ /
-        - QC: `.html` ⟷ /
-
-        You'll find these values in the `suffix` & `accessor` fields.
-
-        LaminDB makes some default choices (e.g., serialize a `DataFrame` as a `.parquet` file).
-
-    See Also:
-        :class:`~lamindb.Storage`
-            Storage locations for artifacts.
-        :class:`~lamindb.Collection`
-            Collections of artifacts.
-        :meth:`~lamindb.Artifact.from_df`
-            Create an artifact from a `DataFrame`.
-        :meth:`~lamindb.Artifact.from_anndata`
-            Create an artifact from an `AnnData`.
-
     Examples:
 
-        Create an artifact by passing `key`:
+        Create an artifact **from a local file or folder**::
 
-        >>> artifact = ln.Artifact("./my_file.parquet", key="example_datasets/my_file.parquet").save()
-        >>> artifact = ln.Artifact("./my_folder", key="project1/my_folder").save()
+            artifact = ln.Artifact("./my_file.parquet", key="example_datasets/my_file.parquet").save()
+            artifact = ln.Artifact("./my_folder", key="project1/my_folder").save()
 
-        Calling `.save()` uploads the file to the default storage location of your lamindb instance.
-        (If it's a local instance, the "upload" is a mere copy operation.)
+        Calling `.save()` copies or uploads the file to the default storage location of your lamindb instance.
+        If you create an artifact **from a remote file or folder**, lamindb merely registers the S3 `key` and avoids copying the data::
 
-        If your artifact is already in the cloud, lamindb auto-populates the `key` field based on the S3 key and there is no upload:
+            artifact = ln.Artifact("s3://my_bucket/my_folder/my_file.csv").save()
 
-        >>> artifact = ln.Artifact("s3://my_bucket/my_folder/my_file.csv").save()
+        If you want to **validate & annotate** an array, pass a `schema` to one of the `.from_df()`, `.from_anndata()`, ... constructors::
 
-        You can make a new version of the artifact with `key = "example_datasets/my_file.parquet"`
+            schema = ln.Schema(itype=ln.Feature)  # a schema that merely enforces that feature names exist in the Feature registry
+            artifact = ln.Artifact.from_df("./my_file.parquet", key="my_dataset.parquet", schema=schema).save()  # validated and annotated
 
-        >>> artifact_v2 = ln.Artifact("./my_file.parquet", key="example_datasets/my_file.parquet").save()
-        >>> artifact_v2.versions.df()  # see all versions
+        You can make a **new version** of an artifact by passing an existing `key`::
+
+            artifact_v2 = ln.Artifact("./my_file.parquet", key="example_datasets/my_file.parquet").save()
+            artifact_v2.versions.df()  # see all versions
 
         .. dropdown:: Why does the API look this way?
 
@@ -1031,18 +1001,48 @@ class Artifact(Record, IsVersioned, TracksRun, TracksUpdates):
                 bucket = quilt3.Bucket('mybucket')
                 bucket.put_file('hello.txt', '/tmp/hello.txt')
 
-        Sometimes you want to avoid mapping the artifact into a file hierarchy, and you can then _just_ populate `description` instead:
+        Sometimes you want to **avoid mapping the artifact into a path hierarchy**, and you only pass `description`::
+
+            artifact = ln.Artifact("./my_folder", description="My folder").save()
+            artifact_v2 = ln.Artifact("./my_folder", revises=old_artifact).save()  # need to version based on `revises`, a shared description does not trigger a new version
+
+    Notes:
+
+        .. dropdown:: Typical storage formats & their API accessors
+
+            Arrays:
+
+            - Table: `.csv`, `.tsv`, `.parquet`, `.ipc` ⟷ `DataFrame`, `pyarrow.Table`
+            - Annotated matrix: `.h5ad`, `.h5mu`, `.zrad` ⟷ `AnnData`, `MuData`
+            - Generic array: HDF5 group, zarr group, TileDB store ⟷ HDF5, zarr, TileDB loaders
 
-        >>> artifact = ln.Artifact("s3://my_bucket/my_folder", description="My folder").save()
-        >>> artifact = ln.Artifact("./my_local_folder", description="My local folder").save()
+            Non-arrays:
 
-        Because you can then not use `key`-based versioning you have to pass `revises` to make a new artifact version:
+            - Image: `.jpg`, `.png` ⟷ `np.ndarray`, ...
+            - Fastq: `.fastq` ⟷ /
+            - VCF: `.vcf` ⟷ /
+            - QC: `.html` ⟷ /
 
-        >>> artifact_v2 = ln.Artifact("./my_file.parquet", revises=old_artifact).save()
+            You'll find these values in the `suffix` & `accessor` fields.
 
-        If an artifact with the exact same hash already exists, `Artifact()` returns the existing artifact. In concurrent workloads where
-        the same artifact is created multiple times, `Artifact()` doesn't yet return the existing artifact but creates a new one; `.save()` however
-        detects the duplication and will return the existing artifact.
+            LaminDB makes some default choices (e.g., serialize a `DataFrame` as a `.parquet` file).
+
+        .. dropdown:: Will artifacts get duplicated?
+
+            If an artifact with the exact same hash already exists, `Artifact()` returns the existing artifact.
+
+            In concurrent workloads where the same artifact is created repeatedly at the exact same time, `.save()`
+            detects the duplication and will return the existing artifact.
+
+    See Also:
+        :class:`~lamindb.Storage`
+            Storage locations for artifacts.
+        :class:`~lamindb.Collection`
+            Collections of artifacts.
+        :meth:`~lamindb.Artifact.from_df`
+            Create an artifact from a `DataFrame`.
+        :meth:`~lamindb.Artifact.from_anndata`
+            Create an artifact from an `AnnData`.
 
     """
 
@@ -1055,6 +1055,8 @@ class Artifact(Record, IsVersioned, TracksRun, TracksUpdates):
     params: ParamManager = ParamManagerArtifact  # type: ignore
     """Param manager.
 
+    What features are for dataset-like artifacts, parameters are for model-like artifacts & runs.
+
     Example::
 
         artifact.params.add_values({
@@ -1071,20 +1073,20 @@ class Artifact(Record, IsVersioned, TracksRun, TracksUpdates):
     features: FeatureManager = FeatureManager  # type: ignore
     """Feature manager.
 
-    Features denote dataset dimensions, i.e., the variables that measure labels & numbers.
+    Typically, you annotate a dataset with features by defining a `Schema` and passing it to the `Artifact` constructor.
 
-    Annotate with features & values::
+    Here is how to do annotate an artifact ad hoc::
 
        artifact.features.add_values({
             "species": organism,  # here, organism is an Organism record
             "scientist": ['Barbara McClintock', 'Edgar Anderson'],
             "temperature": 27.6,
-            "study": "Candidate marker study"
+            "experiment": "Experiment 1"
        })
 
-    Query for features & values::
+    Query artifacts by features::
 
-        ln.Artifact.features.filter(scientist="Barbara McClintock")
+        ln.Artifact.filter(scientist="Barbara McClintock")
 
     Features may or may not be part of the artifact content in storage. For
     instance, the :class:`~lamindb.Curator` flow validates the columns of a
@@ -1100,22 +1102,22 @@ class Artifact(Record, IsVersioned, TracksRun, TracksUpdates):
         To annotate with labels, you typically use the registry-specific accessors,
         for instance :attr:`~lamindb.Artifact.ulabels`::
 
-            candidate_marker_study = ln.ULabel(name="Candidate marker study").save()
-            artifact.ulabels.add(candidate_marker_study)
+            experiment = ln.ULabel(name="Experiment 1").save()
+            artifact.ulabels.add(experiment)
 
         Similarly, you query based on these accessors::
 
-            ln.Artifact.filter(ulabels__name="Candidate marker study").all()
+            ln.Artifact.filter(ulabels__name="Experiment 1").all()
 
         Unlike the registry-specific accessors, the `.labels` accessor provides
         a way of associating labels with features::
 
-            study = ln.Feature(name="study", dtype="cat").save()
-            artifact.labels.add(candidate_marker_study, feature=study)
+            experiment = ln.Feature(name="experiment", dtype="cat").save()
+            artifact.labels.add(experiment, feature=study)
 
         Note that the above is equivalent to::
 
-            artifact.features.add_values({"study": candidate_marker_study})
+            artifact.features.add_values({"experiment": experiment})
         """
         from ._label_manager import LabelManager
 
@@ -1343,15 +1345,7 @@ class Artifact(Record, IsVersioned, TracksRun, TracksUpdates):
                 f"Only {valid_keywords} can be passed, you passed: {kwargs}"
             )
         if revises is not None and key is not None and revises.key != key:
-            note = message_update_key_in_version_family(
-                suid=revises.stem_uid,
-                existing_key=revises.key,
-                new_key=key,
-                registry="Artifact",
-            )
-            raise ValueError(
-                f"`key` is {key}, but `revises.key` is '{revises.key}'\n\n Either do *not* pass `key`.\n\n{note}"
-            )
+            logger.warning(f"renaming artifact from '{revises.key}' to {key}")
         if revises is not None:
             if not isinstance(revises, Artifact):
                 raise TypeError("`revises` has to be of type `Artifact`")
@@ -1431,11 +1425,7 @@ class Artifact(Record, IsVersioned, TracksRun, TracksUpdates):
             kwargs["uid"] = uid
 
         # only set key now so that we don't do a look-up on it in case revises is passed
-        if revises is not None and revises.key is not None:
-            assert revises.key.endswith(kwargs["suffix"]), (  # noqa: S101
-                revises.key,
-                kwargs["suffix"],
-            )
+        if revises is not None and revises.key is not None and kwargs["key"] is None:
             kwargs["key"] = revises.key
 
         kwargs["kind"] = kind
@@ -1530,15 +1520,84 @@ class Artifact(Record, IsVersioned, TracksRun, TracksUpdates):
             - Guide: :doc:`docs:registries`
             - Method in `Record` base class: :meth:`~lamindb.models.Record.get`
 
-        Examples::
+        Examples:
 
-            artifact = ln.Artifact.get("tCUkRcaEjTjhtozp0000")
-            artifact = ln.Arfifact.get(key="my_datasets/my_file.parquet")
+            ::
+
+                artifact = ln.Artifact.get("tCUkRcaEjTjhtozp0000")
+                artifact = ln.Arfifact.get(key="my_datasets/my_file.parquet")
         """
         from .query_set import QuerySet
 
         return QuerySet(model=cls).get(idlike, **expressions)
 
+    @classmethod
+    def filter(
+        cls,
+        *queries,
+        **expressions,
+    ) -> QuerySet:
+        """Query a set of artifacts.
+
+        Args:
+            *queries: `Q` expressions.
+            **expressions: Features, params, fields via the Django query syntax.
+
+        See Also:
+            - Guide: :doc:`docs:registries`
+
+        Examples:
+
+            Query by fields::
+
+                ln.Arfifact.filter(key="my_datasets/my_file.parquet")
+
+            Query by features::
+
+                ln.Arfifact.filter(cell_type_by_model__name="T cell")
+
+            Query by params::
+
+                ln.Arfifact.filter(hyperparam_x=100)
+        """
+        from .query_set import QuerySet
+
+        if expressions:
+            keys_normalized = [key.split("__")[0] for key in expressions]
+            field_or_feature_or_param = keys_normalized[0].split("__")[0]
+            if field_or_feature_or_param in Artifact.__get_available_fields__():
+                return QuerySet(model=cls).filter(*queries, **expressions)
+            elif all(
+                features_validated := Feature.validate(
+                    keys_normalized, field="name", mute=True
+                )
+            ):
+                return filter_base(FeatureManager, **expressions)
+            elif all(
+                params_validated := Param.validate(
+                    keys_normalized, field="name", mute=True
+                )
+            ):
+                return filter_base(ParamManagerArtifact, **expressions)
+            else:
+                if sum(features_validated) < sum(params_validated):
+                    params = ", ".join(
+                        sorted(np.array(keys_normalized)[~params_validated])
+                    )
+                    message = f"param names: {params}"
+                else:
+                    features = ", ".join(
+                        sorted(np.array(keys_normalized)[~params_validated])
+                    )
+                    message = f"feature names: {features}"
+                fields = ", ".join(sorted(cls.__get_available_fields__()))
+                raise InvalidArgument(
+                    f"You can query either by available fields: {fields}\n"
+                    f"Or fix invalid {message}"
+                )
+        else:
+            return QuerySet(model=cls).filter(*queries, **expressions)
+
     @classmethod
     def from_df(
         cls,
@@ -1548,6 +1607,7 @@ class Artifact(Record, IsVersioned, TracksRun, TracksUpdates):
         description: str | None = None,
         run: Run | None = None,
         revises: Artifact | None = None,
+        schema: Schema | None = None,
         **kwargs,
     ) -> Artifact:
         """Create from `DataFrame`, validate & link features.
@@ -1559,6 +1619,7 @@ class Artifact(Record, IsVersioned, TracksRun, TracksUpdates):
             description: A description.
             revises: An old version of the artifact.
             run: The run that creates the artifact.
+            schema: A schema to validate & annotate.
 
         See Also:
             :meth:`~lamindb.Collection`
@@ -1591,6 +1652,13 @@ class Artifact(Record, IsVersioned, TracksRun, TracksUpdates):
             **kwargs,
         )
         artifact.n_observations = len(df)
+        if schema is not None:
+            from ..curators import DataFrameCurator
+
+            curator = DataFrameCurator(artifact, schema)
+            curator.validate()
+            artifact.schema = schema
+            artifact._curator = curator
         return artifact
 
     @classmethod
@@ -1602,6 +1670,7 @@ class Artifact(Record, IsVersioned, TracksRun, TracksUpdates):
         description: str | None = None,
         run: Run | None = None,
         revises: Artifact | None = None,
+        schema: Schema | None = None,
         **kwargs,
     ) -> Artifact:
         """Create from ``AnnData``, validate & link features.
@@ -1613,6 +1682,7 @@ class Artifact(Record, IsVersioned, TracksRun, TracksUpdates):
             description: A description.
             revises: An old version of the artifact.
             run: The run that creates the artifact.
+            schema: A schema to validate & annotate.
 
         See Also:
 
@@ -1654,6 +1724,13 @@ class Artifact(Record, IsVersioned, TracksRun, TracksUpdates):
             # and the proper path through create_path for cloud paths
             obj_for_obs = artifact.path
         artifact.n_observations = _anndata_n_observations(obj_for_obs)
+        if schema is not None:
+            from ..curators import AnnDataCurator
+
+            curator = AnnDataCurator(artifact, schema)
+            curator.validate()
+            artifact.schema = schema
+            artifact._curator = curator
         return artifact
 
     @classmethod
@@ -1665,6 +1742,7 @@ class Artifact(Record, IsVersioned, TracksRun, TracksUpdates):
         description: str | None = None,
         run: Run | None = None,
         revises: Artifact | None = None,
+        schema: Schema | None = None,
         **kwargs,
     ) -> Artifact:
         """Create from ``MuData``, validate & link features.
@@ -1676,6 +1754,7 @@ class Artifact(Record, IsVersioned, TracksRun, TracksUpdates):
             description: A description.
             revises: An old version of the artifact.
             run: The run that creates the artifact.
+            schema: A schema to validate & annotate.
 
         See Also:
             :meth:`~lamindb.Collection`
@@ -1704,6 +1783,13 @@ class Artifact(Record, IsVersioned, TracksRun, TracksUpdates):
         )
         if not isinstance(mdata, UPathStr):
             artifact.n_observations = mdata.n_obs
+        if schema is not None:
+            from ..curators import MuDataCurator
+
+            curator = MuDataCurator(artifact, schema)
+            curator.validate()
+            artifact.schema = schema
+            artifact._curator = curator
         return artifact
 
     @classmethod
@@ -1715,6 +1801,7 @@ class Artifact(Record, IsVersioned, TracksRun, TracksUpdates):
         description: str | None = None,
         run: Run | None = None,
         revises: Artifact | None = None,
+        schema: Schema | None = None,
         **kwargs,
     ) -> Artifact:
         """Create from ``SpatialData``, validate & link features.
@@ -1726,6 +1813,7 @@ class Artifact(Record, IsVersioned, TracksRun, TracksUpdates):
             description: A description.
             revises: An old version of the artifact.
             run: The run that creates the artifact.
+             schema: A schema to validate & annotate.
 
         See Also:
             :meth:`~lamindb.Collection`
@@ -1755,6 +1843,13 @@ class Artifact(Record, IsVersioned, TracksRun, TracksUpdates):
         )
         # ill-defined https://scverse.zulipchat.com/#narrow/channel/315824-spatial/topic/How.20to.20calculate.20the.20number.20of.20observations.3F
         # artifact.n_observations = ...
+        if schema is not None:
+            from ..curators import SpatialDataCurator
+
+            curator = SpatialDataCurator(artifact, schema)
+            curator.validate()
+            artifact.schema = schema
+            artifact._curator = curator
         return artifact
 
     @classmethod
@@ -2466,6 +2561,10 @@ class Artifact(Record, IsVersioned, TracksRun, TracksUpdates):
                 local_path_cache,
             )
             logger.important(f"moved local artifact to cache: {local_path_cache}")
+        if hasattr(self, "_curator"):
+            curator = self._curator
+            delattr(self, "_curator")
+            curator.save_artifact()
         return self
 
     def restore(self) -> None:

lamindb/models/can_curate.py

@@ -57,6 +57,7 @@ def _inspect(
     mute: bool = False,
     organism: str | Record | None = None,
     source: Record | None = None,
+    from_source: bool = True,
     strict_source: bool = False,
 ) -> pd.DataFrame | dict[str, list[str]]:
     """{}"""  # noqa: D415
@@ -94,7 +95,7 @@ def _inspect(
     )
     nonval = set(result_db.non_validated).difference(result_db.synonyms_mapper.keys())
 
-    if len(nonval) > 0 and hasattr(registry, "source_id"):
+    if from_source and len(nonval) > 0 and hasattr(registry, "source_id"):
         try:
             public_result = registry.public(
                 organism=organism_record, source=source
@@ -463,6 +464,7 @@ class CanCurate:
         mute: bool = False,
         organism: Union[str, Record, None] = None,
         source: Record | None = None,
+        from_source: bool = True,
         strict_source: bool = False,
     ) -> InspectResult:
         """Inspect if values are mappable to a field.
@@ -506,6 +508,7 @@ class CanCurate:
             strict_source=strict_source,
             organism=organism,
             source=source,
+            from_source=from_source,
         )
 
     @classmethod

lamindb/models/collection.py

@@ -325,11 +325,13 @@ class Collection(Record, IsVersioned, TracksRun, TracksUpdates):
             artifact: An artifact to add to the collection.
             run: The run that creates the new version of the collection.
 
-        Examples::
+        Examples:
+
+            ::
 
-            collection_v1 = ln.Collection(artifact, key="My collection").save()
-            collection_v2 = collection.append(another_artifact)  # returns a new version of the collection
-            collection_v2.save()  # save the new version
+                collection_v1 = ln.Collection(artifact, key="My collection").save()
+                collection_v2 = collection.append(another_artifact)  # returns a new version of the collection
+                collection_v2.save()  # save the new version
 
         """
         return Collection(  # type: ignore