lamindb 0.69.4__py3-none-any.whl → 0.69.5__py3-none-any.whl

lamindb/__init__.py

@@ -40,7 +40,7 @@ Modules & settings:
 
 """
 
-__version__ = "0.69.4"  # denote a release candidate for 0.1.0 with 0.1rc1
+__version__ = "0.69.5"  # denote a release candidate for 0.1.0 with 0.1rc1
 
 import os as _os
 

lamindb/_annotate.py

@@ -15,15 +15,34 @@ class ValidationError(ValueError):
 
 
 class AnnotateLookup:
-    """Lookup features and labels from the reference instance."""
+    """Lookup categories from the reference instance."""
 
     def __init__(
-        self, fields: Dict[str, FieldAttr], using: Optional[str] = None
+        self,
+        categorials: Dict[str, FieldAttr],
+        slots: Dict[str, FieldAttr] = None,
+        using: Optional[str] = None,
     ) -> None:
-        self._fields = fields
+        if slots is None:
+            slots = {}
+        if slots is None:
+            slots = {}
+        self._fields = {**categorials, **slots}
         self._using = None if using == "default" else using
-        self._using_name = using or ln_setup.settings.instance.slug
-        logger.debug(f"Lookup objects from the {colors.italic(self._using_name)}")
+        self._using_name = self._using or ln_setup.settings.instance.slug
+        debug_message = f"Lookup objects from the " f"{colors.italic(self._using_name)}"
+        logger.debug(debug_message)
+
+    def __getattr__(self, name):
+        if name in self._fields:
+            registry = self._fields[name].field.model
+            if self._using == "public":
+                return registry.public().lookup()
+            else:
+                return get_registry_instance(registry, self._using).lookup()
+        raise AttributeError(
+            f"'{self.__class__.__name__}' object has no attribute '{name}'"
+        )
 
     def __getitem__(self, name):
         if name in self._fields:
@@ -38,10 +57,17 @@ class AnnotateLookup:
 
     def __repr__(self) -> str:
         if len(self._fields) > 0:
-            fields = "\n ".join([str([key]) for key in self._fields.keys()])
+            getattr_keys = "\n ".join(
+                [f".{key}" for key in self._fields if key.isidentifier()]
+            )
+            getitem_keys = "\n ".join(
+                [str([key]) for key in self._fields if not key.isidentifier()]
+            )
             return (
-                f"Lookup objects from the {colors.italic(self._using_name)}:\n {colors.green(fields)}\n\n"
-                "Example:\n    → categories = validator.lookup().['cell_type']\n"
+                f"Lookup objects from the {colors.italic(self._using_name)}:\n "
+                f"{colors.green(getattr_keys)}\n "
+                f"{colors.green(getitem_keys)}\n\n"
+                "Example:\n    → categories = validator.lookup().cell_type\n"
                 "    → categories.alveolar_type_1_fibroblast_cell"
             )
         else:
@@ -53,10 +79,10 @@ class DataFrameAnnotator:
 
     Args:
         df: The DataFrame object to annotate.
-        fields: A dictionary mapping column to registry_field.
+        columns: The field attribute for the feature column.
+        categoricals: A dictionary mapping column names to registry_field.
             For example:
-            {"cell_type_ontology_id": bt.CellType.ontology_id, "donor_id": ln.ULabel.name}
-        feature_field: The field attribute for the feature column.
+            ``{"cell_type_ontology_id": bt.CellType.ontology_id, "donor_id": ln.ULabel.name}``.
         using: The reference instance containing registries to validate against.
         verbosity: The verbosity level.
     """
@@ -64,8 +90,8 @@ class DataFrameAnnotator:
     def __init__(
         self,
         df: pd.DataFrame,
-        fields: Optional[Dict[str, FieldAttr]] = None,
-        feature_field: FieldAttr = Feature.name,
+        columns: FieldAttr = Feature.name,
+        categoricals: Optional[Dict[str, FieldAttr]] = None,
         using: Optional[str] = None,
         verbosity: str = "hint",
         **kwargs,
@@ -73,15 +99,15 @@ class DataFrameAnnotator:
         from lamindb.core._settings import settings
 
         self._df = df
-        self._fields = fields or {}
-        self._feature_field = feature_field
+        self._fields = categoricals or {}
+        self._columns_field = columns
         self._using = using
         settings.verbosity = verbosity
         self._artifact = None
         self._collection = None
         self._validated = False
         self._kwargs: Dict = kwargs
-        self.save_features()
+        self._save_columns()
 
     @property
     def fields(self) -> Dict:
@@ -96,69 +122,89 @@ class DataFrameAnnotator:
                 if None (default), the lookup is performed on the instance specified in "using" parameter of the validator.
                 if "public", the lookup is performed on the public reference.
         """
-        fields = {**{"feature": self._feature_field}, **self.fields}
-        return AnnotateLookup(fields=fields, using=using or self._using)
+        return AnnotateLookup(
+            categorials=self._fields,
+            slots={"columns": self._columns_field},
+            using=using or self._using,
+        )
 
-    def save_features(self, validated_only: bool = True) -> None:
-        """Register features records."""
+    def _save_columns(self, validated_only: bool = True) -> None:
+        """Save column name records."""
         missing_columns = set(self.fields.keys()) - set(self._df.columns)
         if missing_columns:
             raise ValueError(
                 f"Columns {missing_columns} are not found in the data object!"
             )
 
-        # Always register features specified as the fields keys
+        # Always save features specified as the fields keys
         update_registry(
             values=list(self.fields.keys()),
-            field=self._feature_field,
-            feature_name="feature",
+            field=self._columns_field,
+            key="columns",
+            save_function="add_new_from_columns",
             using=self._using,
             validated_only=False,
             kwargs=self._kwargs,
         )
 
-        # Register the rest of the columns based on validated_only
+        # Save the rest of the columns based on validated_only
         additional_columns = set(self._df.columns) - set(self.fields.keys())
         if additional_columns:
             update_registry(
                 values=list(additional_columns),
-                field=self._feature_field,
-                feature_name="feature",
+                field=self._columns_field,
+                key="columns",
+                save_function="add_new_from_columns",
                 using=self._using,
                 validated_only=validated_only,
                 df=self._df,  # Get the Feature type from df
                 kwargs=self._kwargs,
             )
 
-    def update_registry(self, feature: str, validated_only: bool = True, **kwargs):
-        """Register labels for a feature.
+    def add_validated_from(self, key: str, **kwargs):
+        """Add validated categories.
+
+        Args:
+            key: The key referencing the slot in the DataFrame.
+            **kwargs: Additional keyword arguments.
+        """
+        self._update_registry(key, validated_only=True, **kwargs)
+
+    def add_new_from(self, key: str, **kwargs):
+        """Add validated & new categories.
 
         Args:
-            feature: The name of the feature to register.
-            validated_only: Whether to register only validated labels.
+            key: The key referencing the slot in the DataFrame from which to draw terms.
             **kwargs: Additional keyword arguments.
         """
-        if feature == "all":
+        self._update_registry(key, validated_only=False, **kwargs)
+
+    def add_new_from_columns(self, **kwargs):
+        """Add validated & new column names to its registry."""
+        self._save_columns(validated_only=False, **kwargs)
+
+    def _update_registry(self, categorical: str, validated_only: bool = True, **kwargs):
+        if categorical == "all":
             self._update_registry_all(validated_only=validated_only, **kwargs)
-        elif feature == "feature":
-            self.save_features(validated_only=validated_only)
+        elif categorical == "columns":
+            self._save_columns(validated_only=validated_only)
         else:
-            if feature not in self.fields:
-                raise ValueError(f"Feature {feature} is not part of the fields!")
+            if categorical not in self.fields:
+                raise ValueError(f"Feature {categorical} is not part of the fields!")
             update_registry(
-                values=self._df[feature].unique().tolist(),
-                field=self.fields[feature],
-                feature_name=feature,
+                values=self._df[categorical].unique().tolist(),
+                field=self.fields[categorical],
+                key=categorical,
                 using=self._using,
                 validated_only=validated_only,
                 kwargs=kwargs,
             )
 
     def _update_registry_all(self, validated_only: bool = True, **kwargs):
-        """Register labels for all features."""
+        """Save labels for all features."""
         for name in self.fields.keys():
-            logger.info(f"registering labels for '{name}'")
-            self.update_registry(feature=name, validated_only=validated_only, **kwargs)
+            logger.info(f"saving labels for '{name}'")
+            self._update_registry(name, validated_only=validated_only, **kwargs)
 
     def validate(self, **kwargs) -> bool:
         """Validate variables and categorical observations.
@@ -176,14 +222,14 @@ class DataFrameAnnotator:
         return self._validated
 
     def save_artifact(self, description: str, **kwargs) -> Artifact:
-        """Register the validated DataFrame and metadata.
+        """Save the validated DataFrame and metadata.
 
         Args:
             description: Description of the DataFrame object.
             **kwargs: Object level metadata.
 
         Returns:
-            A registered artifact record.
+            A saved artifact record.
         """
         from lamindb.core._settings import settings
 
@@ -193,17 +239,18 @@ class DataFrameAnnotator:
                 f"Data object is not validated, please run {colors.yellow('validate()')}!"
             )
 
-        # Make sure all labels are registered in the current instance
+        # Make sure all labels are saved in the current instance
         verbosity = settings.verbosity
         try:
             settings.verbosity = "warning"
-            self.update_registry("all")
+            # save all validated records to the current instance
+            self.add_validated_from("all")
 
             self._artifact = save_artifact(
                 self._df,
                 description=description,
                 fields=self.fields,
-                feature_field=self._feature_field,
+                columns_field=self._columns_field,
                 **self._kwargs,
             )
         finally:
@@ -219,10 +266,10 @@ class DataFrameAnnotator:
         reference: Optional[str] = None,
         reference_type: Optional[str] = None,
     ) -> Collection:
-        """Register a collection from artifact/artifacts.
+        """Save a collection from artifact/artifacts.
 
         Args:
-            artifact: One or several registered Artifacts.
+            artifact: One or several saved Artifacts.
             name: Title of the publication.
             description: Description of the publication.
             reference: Accession number (e.g. GSE#, E-MTAB#, etc.).
@@ -238,17 +285,16 @@ class DataFrameAnnotator:
         slug = ln_setup.settings.instance.slug
         if collection._state.adding:
             collection.save()
-            logger.success(f"registered collection in {colors.italic(slug)}")
         else:
             collection.save()
             logger.warning(f"collection already exists in {colors.italic(slug)}!")
         if ln_setup.settings.instance.is_remote:
-            logger.print(f"🔗 https://lamin.ai/{slug}/collection/{collection.uid}")
+            logger.print(f"go to https://lamin.ai/{slug}/collection/{collection.uid}")
         self._collection = collection
         return collection
 
     def clean_up_failed_runs(self):
-        """Clean up previous failed runs that don't register any outputs."""
+        """Clean up previous failed runs that don't save any outputs."""
         from lamindb.core._run_context import run_context
 
         if run_context.transform is not None:
@@ -258,95 +304,93 @@ class DataFrameAnnotator:
 
 
 class AnnDataAnnotator(DataFrameAnnotator):
-    """Annotation flow for an AnnData object.
+    """Annotation flow for an ``AnnData`` object.
 
     Args:
         adata: The AnnData object to annotate.
-        var_field: The registry field to validate variables index against.
-        obs_fields: A dictionary mapping obs_column to registry_field.
+        var_index: The registry field for mapping the ``.var`` index.
+        categoricals: A dictionary mapping ``.obs.columns`` to a registry field.
             For example:
-            {"cell_type_ontology_id": bt.CellType.ontology_id, "donor_id": ln.ULabel.name}
-        using: The reference instance containing registries to validate against.
+            ``{"cell_type_ontology_id": bt.CellType.ontology_id, "donor_id": ln.ULabel.name}``
+        using: A reference LaminDB instance.
     """
 
     def __init__(
         self,
         adata: ad.AnnData,
-        var_field: FieldAttr,
-        obs_fields: Dict[str, FieldAttr],
+        var_index: FieldAttr,
+        categoricals: Dict[str, FieldAttr],
         using: str = "default",
         verbosity: str = "hint",
         **kwargs,
     ) -> None:
         self._adata = adata
-        self._var_field = var_field
+        self._var_field = var_index
         super().__init__(
             df=self._adata.obs,
-            fields=obs_fields,
+            categoricals=categoricals,
             using=using,
             verbosity=verbosity,
             **kwargs,
         )
-        self._obs_fields = obs_fields
-        self._save_variables()
+        self._obs_fields = categoricals
+        self._save_from_var_index()
 
     @property
-    def var_field(self) -> FieldAttr:
+    def var_index(self) -> FieldAttr:
         """Return the registry field to validate variables index against."""
         return self._var_field
 
     @property
-    def obs_fields(self) -> Dict:
+    def categoricals(self) -> Dict:
         """Return the obs fields to validate against."""
         return self._obs_fields
 
     def lookup(self, using: Optional[str] = None) -> AnnotateLookup:
         """Lookup features and labels."""
-        fields = {
-            **{"feature": Feature.name, "variables": self.var_field},
-            **self.obs_fields,
-        }
-        return AnnotateLookup(fields=fields, using=using or self._using)
-
-    def _save_variables(self, validated_only: bool = True, **kwargs):
-        """Register variable records."""
+        return AnnotateLookup(
+            categorials=self._obs_fields,
+            slots={"columns": self._columns_field, "var_index": self._var_field},
+            using=using or self._using,
+        )
+
+    def _save_from_var_index(self, validated_only: bool = True, **kwargs):
+        """Save variable records."""
         self._kwargs.update(kwargs)
         update_registry(
-            values=self._adata.var_names,
-            field=self.var_field,
-            feature_name="variables",
+            values=self._adata.var.index,
+            field=self.var_index,
+            key="var_index",
+            save_function="add_new_from_var_index",
             using=self._using,
             validated_only=validated_only,
             kwargs=self._kwargs,
         )
 
+    def add_new_from_var_index(self, **kwargs):
+        """Update variable records."""
+        self._save_from_var_index(validated_only=False, **kwargs)
+
     def validate(self, **kwargs) -> bool:
-        """Validate variables and categorical observations."""
+        """Validate categories."""
         self._kwargs.update(kwargs)
         self._validated = validate_anndata(
             self._adata,
-            var_field=self.var_field,
-            obs_fields=self.obs_fields,
+            var_field=self.var_index,
+            obs_fields=self.categoricals,
             **self._kwargs,
         )
         return self._validated
 
-    def update_registry(self, feature: str, validated_only: bool = True, **kwargs):
-        """Register labels for a feature."""
-        if feature == "variables":
-            self._save_variables(validated_only=validated_only, **kwargs)
-        else:
-            super().update_registry(feature, validated_only, **kwargs)
-
     def save_artifact(self, description: str, **kwargs) -> Artifact:
-        """Register the validated AnnData and metadata.
+        """Save the validated AnnData and metadata.
 
         Args:
             description: Description of the AnnData object.
             **kwargs: Object level metadata.
 
         Returns:
-            A registered artifact record.
+            A saved artifact record.
         """
         self._kwargs.update(kwargs)
         if not self._validated:
@@ -355,8 +399,8 @@ class AnnDataAnnotator(DataFrameAnnotator):
         self._artifact = save_artifact(
             self._adata,
             description=description,
-            feature_field=self.var_field,
-            fields=self.obs_fields,
+            columns_field=self.var_index,
+            fields=self.categoricals,
             **self._kwargs,
         )
         return self._artifact
@@ -369,16 +413,16 @@ class Annotate:
     def from_df(
         cls,
         df: pd.DataFrame,
-        fields: Optional[Dict[str, FieldAttr]] = None,
-        feature_field: FieldAttr = Feature.name,
+        categoricals: Optional[Dict[str, FieldAttr]] = None,
+        columns: FieldAttr = Feature.name,
         using: Optional[str] = None,
         verbosity: str = "hint",
         **kwargs,
     ) -> DataFrameAnnotator:
         return DataFrameAnnotator(
             df=df,
-            fields=fields,
-            feature_field=feature_field,
+            categoricals=categoricals,
+            columns=columns,
             using=using,
             verbosity=verbosity,
             **kwargs,
@@ -388,16 +432,16 @@ class Annotate:
     def from_anndata(
         cls,
         adata: ad.AnnData,
-        var_field: FieldAttr,
-        obs_fields: Dict[str, FieldAttr],
+        var_index: FieldAttr,
+        categoricals: Dict[str, FieldAttr],
         using: str = "default",
         verbosity: str = "hint",
         **kwargs,
     ) -> AnnDataAnnotator:
         return AnnDataAnnotator(
             adata=adata,
-            var_field=var_field,
-            obs_fields=obs_fields,
+            var_index=var_index,
+            categoricals=categoricals,
             using=using,
             verbosity=verbosity,
             **kwargs,
@@ -439,18 +483,17 @@ def check_registry_organism(
 def validate_categories(
     values: Iterable[str],
     field: FieldAttr,
-    feature_name: str,
+    key: str,
     using: Optional[str] = None,
     **kwargs,
 ) -> bool:
     """Validate ontology terms in a pandas series using LaminDB registries."""
     from lamindb._from_values import _print_values
+    from lamindb.core._settings import settings
 
     model_field = f"{field.field.model.__name__}.{field.field.name}"
     logger.indent = ""
-    logger.info(
-        f"inspecting '{colors.bold(feature_name)}' by {colors.italic(model_field)}"
-    )
+    logger.info(f"mapping {colors.italic(key)} on {colors.italic(model_field)}")
     logger.indent = "   "
 
     registry = field.field.model
@@ -465,6 +508,7 @@ def validate_categories(
     )
     non_validated = inspect_result.non_validated
 
+    values_validated = []
     if using is not None and using != "default" and non_validated:
         registry = get_registry_instance(registry, using)
         # Inspect the using instance
@@ -472,19 +516,42 @@ def validate_categories(
             values=non_validated, field=field, registry=registry, **filter_kwargs
         )
         non_validated = inspect_result.non_validated
+        values_validated += inspect_result.validated
 
+    # Inspect from public (bionty only)
+    if hasattr(registry, "public"):
+        verbosity = settings.verbosity
+        try:
+            settings.verbosity = "error"
+            public_records = registry.from_values(
+                non_validated, field=field, **filter_kwargs
+            )
+            values_validated += [getattr(r, field.field.name) for r in public_records]
+        finally:
+            settings.verbosity = verbosity
+
+    validated_hint_print = f".add_validated_from('{key}')"
+    n_validated = len(values_validated)
+    if n_validated > 0:
+        logger.warning(
+            f"found {colors.yellow(f'{n_validated} terms')} validated terms: "
+            f"{colors.yellow(values_validated)}\n      → save terms via "
+            f"{colors.yellow(validated_hint_print)}"
+        )
+
+    non_validated_hint_print = f".add_new_from('{key}')"
+    non_validated = [i for i in non_validated if i not in values_validated]
     n_non_validated = len(non_validated)
     if n_non_validated == 0:
-        logger.success(f"all {feature_name}s are validated")
+        logger.success(f"{key} validated")
         return True
     else:
         are = "are" if n_non_validated > 1 else "is"
         print_values = _print_values(non_validated)
-        feature_name_print = f".update_registry('{feature_name}')"
         warning_message = (
             f"{colors.yellow(f'{n_non_validated} terms')} {are} not validated: "
-            f"{colors.yellow(print_values)}\n      → register terms via "
-            f"{colors.yellow(feature_name_print)}"
+            f"{colors.yellow(print_values)}\n      → save terms via "
+            f"{colors.yellow(non_validated_hint_print)}"
         )
         logger.warning(warning_message)
         logger.indent = ""
@@ -499,11 +566,11 @@ def validate_categories_in_df(
 ) -> bool:
     """Validate categories in DataFrame columns using LaminDB registries."""
     validated = True
-    for feature_name, field in fields.items():
+    for key, field in fields.items():
         validated &= validate_categories(
-            df[feature_name],
+            df[key],
             field=field,
-            feature_name=feature_name,
+            key=key,
             using=using,
             **kwargs,
         )
@@ -526,7 +593,7 @@ def validate_anndata(
     validated_var = validate_categories(
         adata.var.index,
         field=var_field,
-        feature_name="variables",
+        key="var_index",
         using=using,
         **kwargs,
     )
@@ -540,20 +607,20 @@ def save_artifact(
     data: Union[pd.DataFrame, ad.AnnData],
     description: str,
     fields: Dict[str, FieldAttr],
-    feature_field: FieldAttr,
+    columns_field: FieldAttr,
     **kwargs,
 ) -> Artifact:
-    """Register all metadata with an Artifact.
+    """Save all metadata with an Artifact.
 
     Args:
-        data: The DataFrame or AnnData object to register.
+        data: The DataFrame or AnnData object to save.
         description: A description of the artifact.
         fields: A dictionary mapping obs_column to registry_field.
-        feature_field: The registry field to validate variables index against.
+        columns_field: The registry field to validate variables index against.
         kwargs: Additional keyword arguments to pass to the registry model.
 
     Returns:
-        The registered Artifact.
+        The saved Artifact.
     """
     if isinstance(data, ad.AnnData):
         artifact = Artifact.from_anndata(data, description=description)
@@ -566,63 +633,61 @@ def save_artifact(
 
     feature_kwargs: Dict = {}
     organism = check_registry_organism(
-        feature_field.field.model, kwargs.pop("organism", None)
+        columns_field.field.model, kwargs.pop("organism", None)
     )
     if organism is not None:
         feature_kwargs["organism"] = organism
 
     if isinstance(data, ad.AnnData):
-        artifact.features.add_from_anndata(var_field=feature_field, **feature_kwargs)
+        artifact.features.add_from_anndata(var_field=columns_field, **feature_kwargs)
     else:
-        artifact.features.add_from_df(field=feature_field, **feature_kwargs)
+        artifact.features.add_from_df(field=columns_field, **feature_kwargs)
 
     features = Feature.lookup().dict()
-    for feature_name, field in fields.items():
-        feature = features.get(feature_name)
+    for key, field in fields.items():
+        feature = features.get(key)
         registry = field.field.model
         filter_kwargs = kwargs.copy()
         organism = check_registry_organism(registry, organism)
         if organism is not None:
             filter_kwargs["organism"] = organism
         df = data.obs if isinstance(data, ad.AnnData) else data
-        labels = registry.from_values(df[feature_name], field=field, **filter_kwargs)
+        labels = registry.from_values(df[key], field=field, **filter_kwargs)
         artifact.labels.add(labels, feature)
 
     slug = ln_setup.settings.instance.slug
-    logger.success(f"registered artifact in {colors.italic(slug)}")
     if ln_setup.settings.instance.is_remote:
-        logger.info(f"🔗 https://lamin.ai/{slug}/artifact/{artifact.uid}")
-
+        logger.important(f"go to https://lamin.ai/{slug}/artifact/{artifact.uid}")
     return artifact
 
 
 def update_registry(
     values: List[str],
     field: FieldAttr,
-    feature_name: str,
+    key: str,
+    save_function: str = "add_new_from",
     using: Optional[str] = None,
     validated_only: bool = True,
     kwargs: Optional[Dict] = None,
     df: Optional[pd.DataFrame] = None,
 ) -> None:
-    """Register features or labels records in the default instance from the using instance.
+    """Save features or labels records in the default instance from the using instance.
 
     Args:
-        values: A list of values to be registered as labels.
-        field: The FieldAttr object representing the field for which labels are being registered.
-        feature_name: The name of the feature to register.
+        values: A list of values to be saved as labels.
+        field: The FieldAttr object representing the field for which labels are being saved.
+        key: The name of the feature to save.
+        save_function: The name of the function to save the labels.
         using: The name of the instance from which to transfer labels (if applicable).
-        validated_only: If True, only register validated labels.
+        validated_only: If True, only save validated labels.
         kwargs: Additional keyword arguments to pass to the registry model.
-        df: A DataFrame to register labels from.
+        df: A DataFrame to save labels from.
     """
     from lamindb._save import save as ln_save
     from lamindb.core._settings import settings
 
     filter_kwargs = {} if kwargs is None else kwargs.copy()
     registry = field.field.model
-    if registry == ULabel:
-        validated_only = False
 
     organism = check_registry_organism(registry, filter_kwargs.pop("organism", None))
     if organism is not None:
@@ -638,10 +703,10 @@ def update_registry(
             settings.verbosity = verbosity
             return
 
-        labels_registered: Dict = {"from public": [], "without reference": []}
+        labels_saved: Dict = {"from public": [], "without reference": []}
 
         (
-            labels_registered[f"from {using}"],
+            labels_saved[f"from {using}"],
             non_validated_labels,
         ) = update_registry_from_using_instance(
             inspect_result_current.non_validated,
@@ -656,11 +721,11 @@ def update_registry(
             else []
         )
         ln_save(public_records)
-        labels_registered["from public"] = [
+        labels_saved["from public"] = [
             getattr(r, field.field.name) for r in public_records
         ]
-        labels_registered["without reference"] = [
-            i for i in non_validated_labels if i not in labels_registered["from public"]
+        labels_saved["without reference"] = [
+            i for i in non_validated_labels if i not in labels_saved["from public"]
         ]
 
         if not validated_only:
@@ -670,7 +735,7 @@ def update_registry(
             else:
                 if "organism" in filter_kwargs:
                     filter_kwargs["organism"] = _save_organism(name=organism)
-                for value in labels_registered["without reference"]:
+                for value in labels_saved["without reference"]:
                     filter_kwargs[field.field.name] = value
                     if registry == Feature:
                         filter_kwargs["type"] = "category"
@@ -678,60 +743,66 @@ def update_registry(
             ln_save(non_validated_records)
 
         if registry == ULabel and field.field.name == "name":
-            save_ulabels_with_parent(values, field=field, feature_name=feature_name)
+            save_ulabels_with_parent(values, field=field, key=key)
     finally:
         settings.verbosity = verbosity
 
-    log_registered_labels(
-        labels_registered,
-        feature_name=feature_name,
+    log_saved_labels(
+        labels_saved,
+        key=key,
+        save_function=save_function,
         model_field=f"{registry.__name__}.{field.field.name}",
         validated_only=validated_only,
     )
 
 
-def log_registered_labels(
-    labels_registered: Dict,
-    feature_name: str,
+def log_saved_labels(
+    labels_saved: Dict,
+    key: str,
+    save_function: str,
     model_field: str,
     validated_only: bool = True,
 ) -> None:
-    """Log the registered labels."""
-    labels_type = "features" if feature_name == "feature" else "labels"
+    """Log the saved labels."""
     model_field = colors.italic(model_field)
-    for key, labels in labels_registered.items():
+    for k, labels in labels_saved.items():
         if not labels:
             continue
 
-        if key == "without reference" and validated_only:
+        if k == "without reference" and validated_only:
             msg = colors.yellow(
-                f"{len(labels)} non-validated {labels_type} are not registered with {model_field}: {labels}!"
+                f"{len(labels)} non-validated categories are not saved in {model_field}: {labels}!"
+            )
+            lookup_print = (
+                f"lookup().{key}" if key.isidentifier() else f".lookup()['{key}']"
             )
-            lookup_print = f".lookup().['{feature_name}']"
+
+            hint = f".add_new_from('{key}')"
             msg += f"\n      → to lookup categories, use {lookup_print}"
             msg += (
-                f"\n      → to register, run {colors.yellow('save_features(validated_only=False)')}"
-                if labels_type == "features"
-                else f"\n      → to register, set {colors.yellow('validated_only=False')}"
+                f"\n      → to save, run {colors.yellow(hint)}"
+                if save_function == "add_new_from"
+                else f"\n      → to save, run {colors.yellow(save_function)}"
             )
             logger.warning(msg)
         else:
-            key = "" if key == "without reference" else f"{colors.green(key)} "
+            k = "" if k == "without reference" else f"{colors.green(k)} "
+            # the term "transferred" stresses that this is always in the context of transferring
+            # labels from a public ontology or a different instance to the present instance
+            s = "s" if len(labels) > 1 else ""
             logger.success(
-                f"registered {len(labels)} {labels_type} {key}with {model_field}: {labels}"
+                f"added {len(labels)} record{s} {k}with {model_field} for {colors.italic(key)}: {labels}"
             )
 
 
-def save_ulabels_with_parent(
-    values: List[str], field: FieldAttr, feature_name: str
-) -> None:
-    """Register a parent label for the given labels."""
+def save_ulabels_with_parent(values: List[str], field: FieldAttr, key: str) -> None:
+    """Save a parent label for the given labels."""
     registry = field.field.model
     assert registry == ULabel
     all_records = registry.from_values(values, field=field)
-    is_feature = registry.filter(name=f"is_{feature_name}").one_or_none()
+    is_feature = registry.filter(name=f"is_{key}").one_or_none()
     if is_feature is None:
-        is_feature = registry(name=f"is_{feature_name}")
+        is_feature = registry(name=f"is_{key}")
         is_feature.save()
     is_feature.children.add(*all_records)
 
@@ -742,20 +813,20 @@ def update_registry_from_using_instance(
     using: Optional[str] = None,
     kwargs: Optional[Dict] = None,
 ) -> Tuple[List[str], List[str]]:
-    """Register features or labels records from the using instance.
+    """Save features or labels records from the using instance.
 
     Args:
-        values: A list of values to be registered as labels.
-        field: The FieldAttr object representing the field for which labels are being registered.
+        values: A list of values to be saved as labels.
+        field: The FieldAttr object representing the field for which labels are being saved.
         using: The name of the instance from which to transfer labels (if applicable).
         kwargs: Additional keyword arguments to pass to the registry model.
 
     Returns:
-        A tuple containing the list of registered labels and the list of non-registered labels.
+        A tuple containing the list of saved labels and the list of non-saved labels.
     """
     kwargs = kwargs or {}
-    labels_registered = []
-    not_registered = values
+    labels_saved = []
+    not_saved = values
 
     if using is not None and using != "default":
         registry = field.field.model
@@ -768,14 +839,14 @@ def update_registry_from_using_instance(
         ).all()
         for label_using in labels_using:
             label_using.save()
-            labels_registered.append(getattr(label_using, field.field.name))
-        not_registered = inspect_result_using.non_validated
+            labels_saved.append(getattr(label_using, field.field.name))
+        not_saved = inspect_result_using.non_validated
 
-    return labels_registered, not_registered
+    return labels_saved, not_saved
 
 
 def _save_organism(name: str):
-    """Register an organism record."""
+    """Save an organism record."""
     import bionty as bt
 
     organism = bt.Organism.filter(name=name).one_or_none()
@@ -784,7 +855,7 @@ def _save_organism(name: str):
         if organism is None:
             raise ValueError(
                 f"Organism '{name}' not found\n"
-                f"      → please register it: bt.Organism(name='{name}').save()"
+                f"      → please save it: bt.Organism(name='{name}').save()"
             )
         organism.save()
     return organism

lamindb/_finish.py

@@ -8,6 +8,7 @@ from typing import Optional
 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
@@ -69,7 +70,7 @@ def save_run_context_core(
 
     ln.settings.verbosity = "success"
 
-    if transform.type == "notebook":
+    if transform.type == TransformType.notebook:
         try:
             import nbstripout
             from nbproject.dev import (
@@ -187,7 +188,7 @@ def save_run_context_core(
         run.environment = artifact
         logger.success(f"saved run.environment: {run.environment}")
     # save report file
-    if not transform.type == "notebook":
+    if not transform.type == TransformType.notebook:
         run.save()
     else:
         if run.report_id is not None:
@@ -212,7 +213,7 @@ def save_run_context_core(
         run.save()
         transform.latest_report = run.report
     transform.save()
-    if transform.type == "notebook":
+    if transform.type == TransformType.notebook:
         logger.success(f"saved transform.latest_report: {transform.latest_report}")
     identifier = ln_setup.settings.instance.slug
     logger.success(f"go to: https://lamin.ai/{identifier}/transform/{transform.uid}")

lamindb/integrations/_vitessce.py

@@ -26,11 +26,14 @@ def save_vitessce_config(vitessce_config, description: str) -> Artifact:
     artifact = Artifact(vitesse_export, description=description)
     artifact.save()
     config_dict = vitessce_config.to_dict(base_url=artifact.path.to_url())
+    logger.important(f"base url: {artifact.path.to_url()}")
     config_filename = "vitessce_config.json"
     config_file_local_path = f"{vitesse_export}/{config_filename}"
     with open(config_file_local_path, "w") as file:
         json.dump(config_dict, file)
-    (artifact.path / config_filename).upload_from(config_file_local_path)
+    config_file_path = artifact.path / config_filename
+    config_file_path.upload_from(config_file_local_path)
+    logger.important(f"config url: {config_file_path.to_url()}")
     slug = ln_setup.settings.instance.slug
     logger.important(f"go to: https://lamin.ai/{slug}/artifact/{artifact.uid}")
     return artifact

{lamindb-0.69.4.dist-info → lamindb-0.69.5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: lamindb
-Version: 0.69.4
+Version: 0.69.5
 Summary: A data framework for biology.
 Author-email: Lamin Labs <open-source@lamin.ai>
 Requires-Python: >=3.8
@@ -9,10 +9,10 @@ Classifier: Programming Language :: Python :: 3.8
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
-Requires-Dist: lnschema_core==0.64.1
-Requires-Dist: lamindb_setup==0.68.2
+Requires-Dist: lnschema_core==0.64.4
+Requires-Dist: lamindb_setup==0.68.3
 Requires-Dist: lamin_utils==0.13.1
-Requires-Dist: lamin_cli==0.10.2
+Requires-Dist: lamin_cli==0.11.0
 Requires-Dist: rapidfuzz
 Requires-Dist: pyarrow
 Requires-Dist: typing_extensions!=4.6.0

{lamindb-0.69.4.dist-info → lamindb-0.69.5.dist-info}/RECORD

@@ -1,12 +1,12 @@
-lamindb/__init__.py,sha256=3kVakyBIty4I2C-69S114uW3z9lnEOgpnOz3LsZb2ro,2163
-lamindb/_annotate.py,sha256=BopvJvzUlNKiTzOELg6MXeXQNUVMUTk-FcRoV9mfZdo,27682
+lamindb/__init__.py,sha256=cWnU0vX4YUkRJTNOMNyjJHRQzTAWQDAj5R7Vp_6EB4M,2163
+lamindb/_annotate.py,sha256=mM-GCej7i9eUH0cU5AcxWZ916k8NRI41WF84dfjJfu4,29955
 lamindb/_artifact.py,sha256=RV36tcHMZ6wH6u65jOAQ_H4rfmFiIzZmAr8IY7kFhm0,35817
 lamindb/_can_validate.py,sha256=w7lrUGTWldpvwaRiXBRrjfU_ZRidA7CooOu_r5MbocY,14569
 lamindb/_collection.py,sha256=SdNNhhMh2O4q0hG4Hf_y1bcwcbkMF_sqk6MIYc-hLZo,14525
 lamindb/_feature.py,sha256=ahRv87q1tcRLQ0UM5FA3KtcMQvIjW__fZq1yAdRAV7s,6728
 lamindb/_feature_set.py,sha256=G_Ss6mKh4D0Eji-xSfLRbKVFXwgUE82YOqIUmkV0CAA,8767
 lamindb/_filter.py,sha256=_PjyQWQBR3ohDAvJbR3hMvZ-2p2GvzFxLfKGC-gPnHI,1320
-lamindb/_finish.py,sha256=it-fSpSmMW9ybdsylBV5Lbugh6iXRGWgIiSLwPaow_8,8590
+lamindb/_finish.py,sha256=8lfJzRedTDCA_XXBUf4ECOevpPhVxKqMMj9qgVkmF8M,8672
 lamindb/_from_values.py,sha256=Ei11ml77Q1xubVekt2C4-mbox2-qnC7kP18B-LhCdSc,11886
 lamindb/_is_versioned.py,sha256=DXp5t-1DwErpqqMc9eb08kpQPCHOC2fNzaozMoBunR4,1337
 lamindb/_parents.py,sha256=pTDsW8HjQ_txFbPKrBU0WjjtCNH6sx2LASUuGWpJuYE,14742
@@ -45,10 +45,10 @@ lamindb/core/storage/_zarr.py,sha256=bMQSCsTOCtQy4Yo3KwCVpbUkKdWRApN9FM1rM-d2_G0
 lamindb/core/storage/file.py,sha256=WTeC4ENn_O6HEoinmTviB89W81UrJT3bSGtnpqPpIyE,7242
 lamindb/core/storage/object.py,sha256=MPUb2M8Fleq2j9x1Ryqr3BETmvsDKyf11Ifvbxd3NpA,1097
 lamindb/integrations/__init__.py,sha256=aH2PmO2m4-vwIifMYTB0Fyyr_gZWtVnV71jT0tVWSw0,123
-lamindb/integrations/_vitessce.py,sha256=NHOiDJzn2QtzfkThhHEuDJuTTcSkem9x5d_wrQ-8nPI,1474
+lamindb/integrations/_vitessce.py,sha256=n85g8YRP8Y2sfU5DPJdbU84BGPrTfU3Dg2jStdmBBRI,1637
 lamindb/setup/__init__.py,sha256=OwZpZzPDv5lPPGXZP7-zK6UdO4FHvvuBh439yZvIp3A,410
 lamindb/setup/core/__init__.py,sha256=LqIIvJNcONxkqjbnP6CUaP4d45Lbd6TSMAcXFp4C7_8,231
-lamindb-0.69.4.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-lamindb-0.69.4.dist-info/WHEEL,sha256=EZbGkh7Ie4PoZfRQ8I0ZuP9VklN_TvcZ6DSE5Uar4z4,81
-lamindb-0.69.4.dist-info/METADATA,sha256=lGw_OTGbviwuQbwwav9IVSHfblR8bwUNC1weeEx6Eok,2856
-lamindb-0.69.4.dist-info/RECORD,,
+lamindb-0.69.5.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+lamindb-0.69.5.dist-info/WHEEL,sha256=EZbGkh7Ie4PoZfRQ8I0ZuP9VklN_TvcZ6DSE5Uar4z4,81
+lamindb-0.69.5.dist-info/METADATA,sha256=meDN6DOhRAnUt2jbDcykj9Hclhos_uyO_UbtSPNukG4,2856
+lamindb-0.69.5.dist-info/RECORD,,