lamindb 0.77.3__py3-none-any.whl → 1.0rc1__py3-none-any.whl

lamindb/_run.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from lnschema_core.models import ParamManager, Run, Transform
+from lamindb.models import ParamManager, Run, Transform
 
 
 def __init__(run: Run, *args, **kwargs):
@@ -18,7 +18,7 @@ def __init__(run: Run, *args, **kwargs):
     reference_type: str | None = (
         kwargs.pop("reference_type") if "reference_type" in kwargs else None
     )
-    parent: Run | None = kwargs.pop("parent", None)
+    initiated_by_run: Run | None = kwargs.pop("initiated_by_run", None)
     if transform is None:
         raise TypeError("Pass transform parameter")
     if transform._state.adding:
@@ -27,7 +27,7 @@ def __init__(run: Run, *args, **kwargs):
     super(Run, run).__init__(
         transform=transform,
         reference=reference,
-        parent=parent,
+        initiated_by_run=initiated_by_run,
         reference_type=reference_type,
     )
 

lamindb/_save.py

@@ -5,15 +5,14 @@ import shutil
 import traceback
 from collections import defaultdict
 from datetime import datetime
-from functools import partial
-from typing import TYPE_CHECKING, overload
+from typing import TYPE_CHECKING
 
-import lamindb_setup
-from django.db import IntegrityError, transaction
+from django.db import transaction
 from django.utils.functional import partition
 from lamin_utils import logger
 from lamindb_setup.core.upath import LocalPathClasses
-from lnschema_core.models import Artifact, Record
+
+from lamindb.models import Artifact, Record
 
 from .core._settings import settings
 from .core.storage.paths import (
@@ -64,7 +63,7 @@ def save(records: Iterable[Record], ignore_conflicts: bool | None = False) -> No
         Update a single existing record:
 
         >>> transform = ln.Transform.get("0Cb86EZj")
-        >>> transform.name = "New name"
+        >>> transform.description = "New description"
         >>> transform.save()
 
     """

lamindb/{_feature_set.py → _schema.py}

@@ -7,14 +7,16 @@ import numpy as np
 from lamin_utils import logger
 from lamindb_setup.core._docs import doc_args
 from lamindb_setup.core.hashing import hash_set
-from lnschema_core import Feature, FeatureSet, Record, ids
-from lnschema_core.types import FieldAttr, ListLike
+
+from lamindb.base import ids
+from lamindb.base.types import FieldAttr, ListLike
+from lamindb.models import Feature, Record, Schema
 
 from ._feature import convert_pandas_dtype_to_lamin_dtype
 from ._record import init_self_from_db
 from ._utils import attach_func_to_class_method
 from .core.exceptions import ValidationError
-from .core.schema import (
+from .core.relations import (
     dict_related_model_to_related_name,
     get_related_name,
 )
@@ -47,7 +49,7 @@ def validate_features(features: list[Record]) -> Record:
         )
     feature_types = {feature.__class__ for feature in features}
     if len(feature_types) > 1:
-        raise TypeError("feature_set can only contain a single type")
+        raise TypeError("schema can only contain a single type")
     for feature in features:
         if feature._state.adding:
             raise ValueError("Can only construct feature sets from validated features")
@@ -56,7 +58,7 @@ def validate_features(features: list[Record]) -> Record:
 
 def __init__(self, *args, **kwargs):
     if len(args) == len(self._meta.concrete_fields):
-        super(FeatureSet, self).__init__(*args, **kwargs)
+        super(Schema, self).__init__(*args, **kwargs)
         return None
     # now we proceed with the user-facing constructor
     if len(args) > 1:
@@ -72,29 +74,29 @@ def __init__(self, *args, **kwargs):
         dtype = None if features_registry == Feature else NUMBER_TYPE
     n_features = len(features)
     features_hash = hash_set({feature.uid for feature in features})
-    feature_set = FeatureSet.filter(hash=features_hash).one_or_none()
-    if feature_set is not None:
-        logger.debug(f"loaded: {feature_set}")
-        init_self_from_db(self, feature_set)
+    schema = Schema.filter(hash=features_hash).one_or_none()
+    if schema is not None:
+        logger.debug(f"loaded: {schema}")
+        init_self_from_db(self, schema)
         return None
     else:
         hash = features_hash
     self._features = (get_related_name(features_registry), features)
 
-    super(FeatureSet, self).__init__(
+    super(Schema, self).__init__(
         uid=ids.base62_20(),
         name=name,
         dtype=get_type_str(dtype),
         n=n_features,
-        registry=features_registry.__get_name_with_schema__(),
+        registry=features_registry.__get_name_with_module__(),
         hash=hash,
     )
 
 
-@doc_args(FeatureSet.save.__doc__)
-def save(self, *args, **kwargs) -> FeatureSet:
+@doc_args(Schema.save.__doc__)
+def save(self, *args, **kwargs) -> Schema:
     """{}"""  # noqa: D415
-    super(FeatureSet, self).save(*args, **kwargs)
+    super(Schema, self).save(*args, **kwargs)
     if hasattr(self, "_features"):
         related_name, records = self._features
         getattr(self, related_name).set(records)
@@ -110,7 +112,7 @@ def get_type_str(dtype: str | None) -> str | None:
 
 
 @classmethod  # type:ignore
-@doc_args(FeatureSet.from_values.__doc__)
+@doc_args(Schema.from_values.__doc__)
 def from_values(
     cls,
     values: ListLike,
@@ -121,7 +123,7 @@ def from_values(
     organism: Record | str | None = None,
     source: Record | None = None,
     raise_validation_error: bool = True,
-) -> FeatureSet:
+) -> Schema:
     """{}"""  # noqa: D415
     if not isinstance(field, FieldAttr):
         raise TypeError("Argument `field` must be a Record field, e.g., `Feature.name`")
@@ -152,16 +154,16 @@ def from_values(
         organism=organism,
         source=source,
     )
-    feature_set = FeatureSet(
+    schema = Schema(
         features=validated_features,
         name=name,
         dtype=get_type_str(type),
     )
-    return feature_set
+    return schema
 
 
 @classmethod  # type:ignore
-@doc_args(FeatureSet.from_df.__doc__)
+@doc_args(Schema.from_df.__doc__)
 def from_df(
     cls,
     df: pd.DataFrame,
@@ -170,7 +172,7 @@ def from_df(
     mute: bool = False,
     organism: Record | str | None = None,
     source: Record | None = None,
-) -> FeatureSet | None:
+) -> Schema | None:
     """{}"""  # noqa: D415
     registry = field.field.model
     validated = registry.validate(df.columns, field=field, mute=mute, organism=organism)
@@ -182,7 +184,7 @@ def from_df(
         validated_features = Feature.from_values(
             df.columns, field=field, organism=organism
         )
-        feature_set = FeatureSet(validated_features, name=name, dtype=None)
+        schema = Schema(validated_features, name=name, dtype=None)
     else:
         dtypes = [col.dtype for (_, col) in df.loc[:, validated].items()]
         if len(set(dtypes)) != 1:
@@ -194,16 +196,16 @@ def from_df(
             organism=organism,
             source=source,
         )
-        feature_set = FeatureSet(
+        schema = Schema(
             features=validated_features,
             name=name,
             dtype=get_type_str(dtype),
         )
-    return feature_set
+    return schema
 
 
 @property  # type: ignore
-@doc_args(FeatureSet.members.__doc__)
+@doc_args(Schema.members.__doc__)
 def members(self) -> QuerySet:
     """{}"""  # noqa: D415
     if self._state.adding:
@@ -216,11 +218,11 @@ def members(self) -> QuerySet:
     return self.__getattribute__(related_name).all()
 
 
-def _get_related_name(self: FeatureSet) -> str:
-    feature_sets_related_models = dict_related_model_to_related_name(
+def _get_related_name(self: Schema) -> str:
+    _schemas_m2m_related_models = dict_related_model_to_related_name(
         self, instance=self._state.db
     )
-    related_name = feature_sets_related_models.get(self.registry)
+    related_name = _schemas_m2m_related_models.get(self.itype)
     return related_name
 
 
@@ -235,13 +237,14 @@ if ln_setup._TESTING:
     from inspect import signature
 
     SIGS = {
-        name: signature(getattr(FeatureSet, name))
+        name: signature(getattr(Schema, name))
         for name in METHOD_NAMES
         if name != "__init__"
     }
 
 for name in METHOD_NAMES:
-    attach_func_to_class_method(name, FeatureSet, globals())
+    attach_func_to_class_method(name, Schema, globals())
 
-FeatureSet.members = members
-FeatureSet._get_related_name = _get_related_name
+Schema.members = members
+Schema._get_related_name = _get_related_name
+Schema.feature_sets = Schema._artifacts_m2m  # backward compat

lamindb/_storage.py

@@ -1,6 +1,7 @@
 from lamindb_setup.core._docs import doc_args
 from lamindb_setup.core.upath import UPath, create_path
-from lnschema_core import Storage
+
+from lamindb.models import Storage
 
 
 @property  # type: ignore

lamindb/_transform.py

@@ -1,26 +1,31 @@
 from __future__ import annotations
 
+import warnings
 from typing import TYPE_CHECKING
 
 from lamin_utils import logger
 from lamindb_setup.core._docs import doc_args
-from lnschema_core.models import Run, Transform
+
+from lamindb.models import Run, Transform
 
 from ._parents import _view_parents
 from ._run import delete_run_artifacts
+from .core._settings import settings
 from .core.exceptions import InconsistentKey
 from .core.versioning import message_update_key_in_version_family, process_revises
 
 if TYPE_CHECKING:
-    from lnschema_core.types import TransformType
+    from lamindb.base.types import TransformType
 
 
 def __init__(transform: Transform, *args, **kwargs):
     if len(args) == len(transform._meta.concrete_fields):
         super(Transform, transform).__init__(*args, **kwargs)
         return None
-    name: str | None = kwargs.pop("name") if "name" in kwargs else None
     key: str | None = kwargs.pop("key") if "key" in kwargs else None
+    description: str | None = (
+        kwargs.pop("description") if "description" in kwargs else None
+    )
     revises: Transform | None = kwargs.pop("revises") if "revises" in kwargs else None
     version: str | None = kwargs.pop("version") if "version" in kwargs else None
     type: TransformType | None = kwargs.pop("type") if "type" in kwargs else "pipeline"
@@ -28,47 +33,77 @@ def __init__(transform: Transform, *args, **kwargs):
     reference_type: str | None = (
         kwargs.pop("reference_type") if "reference_type" in kwargs else None
     )
-    if "is_new_version_of" in kwargs:
-        logger.warning("`is_new_version_of` will be removed soon, please use `revises`")
-        revises = kwargs.pop("is_new_version_of")
+    using_key = (
+        kwargs.pop("using_key") if "using_key" in kwargs else settings._using_key
+    )
+    if "name" in kwargs:
+        if key is None:
+            key = kwargs.pop("name")
+            warnings.warn(
+                f"`name` will be removed soon, please pass '{key}' to `key` instead",
+                FutureWarning,
+                stacklevel=2,
+            )
+        else:
+            # description wasn't exist, so no check necessary
+            description = kwargs.pop("name")
+            warnings.warn(
+                f"`name` will be removed soon, please pass '{description}' to `description` instead",
+                FutureWarning,
+                stacklevel=2,
+            )
     # below is internal use that we'll hopefully be able to eliminate
     uid: str | None = kwargs.pop("uid") if "uid" in kwargs else None
     if not len(kwargs) == 0:
         raise ValueError(
-            "Only name, key, version, type, revises, reference, "
+            "Only key, description, version, type, revises, reference, "
             f"reference_type can be passed, but you passed: {kwargs}"
         )
     if revises is None:
         # need to check uid before checking key
         if uid is not None:
             revises = (
-                Transform.filter(uid__startswith=uid[:-4], is_latest=True)
+                Transform.objects.using(using_key)
+                .filter(uid__startswith=uid[:-4], is_latest=True)
                 .order_by("-created_at")
                 .first()
             )
         elif key is not None:
-            revises = (
-                Transform.filter(key=key, is_latest=True)
+            candidate_for_revises = (
+                Transform.objects.using(using_key)
+                .filter(key=key, is_latest=True)
                 .order_by("-created_at")
                 .first()
             )
+            if candidate_for_revises is not None:
+                revises = candidate_for_revises
+                if candidate_for_revises.source_code is None:
+                    # no source code was yet saved, return the same transform
+                    logger.important(
+                        "no source code was yet saved, returning existing transform with same key"
+                    )
+                    uid = revises.uid
     if revises is not None and uid is not None and uid == revises.uid:
         from ._record import init_self_from_db, update_attributes
 
+        if revises.key != key:
+            logger.warning("ignoring inconsistent key")
         init_self_from_db(transform, revises)
-        update_attributes(transform, {"name": name})
+        update_attributes(transform, {"description": description})
         return None
     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",
+            registry="Transform",
         )
         raise InconsistentKey(
-            f"`key` is {key}, but `revises.key` is '{revises.key}'\n\nEither do *not* pass `key`.\n\n{note}"
+            f"`key` is '{key}', but `revises.key` is '{revises.key}'\n\nEither do *not* pass `key`.\n\n{note}"
         )
-    new_uid, version, name, revises = process_revises(revises, version, name, Transform)
+    new_uid, version, key, description, revises = process_revises(
+        revises, version, key, description, Transform
+    )
     # this is only because the user-facing constructor allows passing a uid
     # most others don't
     if uid is None:
@@ -78,7 +113,7 @@ def __init__(transform: Transform, *args, **kwargs):
         has_consciously_provided_uid = True
     super(Transform, transform).__init__(
         uid=uid,
-        name=name,
+        description=description,
         key=key,
         type=type,
         version=version,
@@ -90,13 +125,6 @@ def __init__(transform: Transform, *args, **kwargs):
 
 
 def delete(self) -> None:
-    _source_code_artifact = None
-    if self._source_code_artifact is not None:
-        _source_code_artifact = self._source_code_artifact
-        self._source_code_artifact = None
-        self.save()
-    if _source_code_artifact is not None:
-        _source_code_artifact.delete(permanent=True)
     # query all runs and delete their artifacts
     runs = Run.filter(transform=self)
     for run in runs:
@@ -116,7 +144,7 @@ def latest_run(self) -> Run:
 def view_lineage(self, with_successors: bool = False, distance: int = 5):
     return _view_parents(
         record=self,
-        field="name",
+        field="key",
         with_children=with_successors,
         distance=distance,
         attr_name="predecessors",

lamindb/_ulabel.py

@@ -1,15 +1,11 @@
 from __future__ import annotations
 
-from typing import TYPE_CHECKING
-
 import lamindb_setup as ln_setup
-from lamindb_setup.core._docs import doc_args
-from lnschema_core import ULabel
+from lamin_utils import logger
 
-from ._utils import attach_func_to_class_method
+from lamindb.models import ULabel
 
-if TYPE_CHECKING:
-    from lnschema_core.types import ListLike
+from ._utils import attach_func_to_class_method
 
 
 def __init__(self, *args, **kwargs):
@@ -19,7 +15,9 @@ def __init__(self, *args, **kwargs):
     # now we proceed with the user-facing constructor
     if len(args) > 0:
         raise ValueError("Only one non-keyword arg allowed")
-    name: str | None = kwargs.pop("name") if "name" in kwargs else None
+    name: str = kwargs.pop("name") if "name" in kwargs else None
+    type: str | None = kwargs.pop("type") if "type" in kwargs else None
+    is_type: str | None = kwargs.pop("is_type") if "is_type" in kwargs else None
     description: str | None = (
         kwargs.pop("description") if "description" in kwargs else None
     )
@@ -31,8 +29,19 @@ def __init__(self, *args, **kwargs):
         raise ValueError(
             "Only name, description, reference, reference_type are valid keyword arguments"
         )
+    if is_type:
+        if name.endswith("s"):
+            logger.warning(
+                "`name` ends with 's', in case you're naming with plural, consider the singular for a type name"
+            )
+        if name[0].islower():
+            logger.warning(
+                "`name` starts with lowercase, in case you're naming a type, consider starting with uppercase"
+            )
     super(ULabel, self).__init__(
         name=name,
+        type=type,
+        is_type=is_type,
         description=description,
         reference=reference,
         reference_type=reference_type,

lamindb/_view.py

@@ -8,9 +8,9 @@ from typing import TYPE_CHECKING
 from lamin_utils import colors, logger
 from lamindb_setup import settings
 from lamindb_setup._init_instance import get_schema_module_name
-from lnschema_core import Feature, Record
 
 from lamindb.core import FeatureValue, ParamValue
+from lamindb.models import Feature, Record
 
 from ._feature import convert_pandas_dtype_to_lamin_dtype
 
@@ -97,7 +97,7 @@ def display_df_with_descriptions(
 def view(
     df: pd.DataFrame | None = None,
     limit: int = 7,
-    schema: str | None = None,
+    modules: str | None = None,
     registries: list[str] | None = None,
 ) -> None:
     """View metadata.
@@ -105,8 +105,8 @@ def view(
     Args:
         df: A DataFrame to display.
         limit: Display the latest `n` records
-        schema: Schema module to view. Default's to
-            `None` and displays all schema modules.
+        modules: schema module to view. Default's to
+            `None` and displays all registry modules.
         registries: List of Record names. Defaults to
             `None` and lists all registries.
 
@@ -128,13 +128,13 @@ def view(
     else:
         show = logger.print
 
-    if schema is not None:
-        schema_names = [schema]
+    if modules is not None:
+        module_names = [modules]
     else:
-        schema_names = ["core"] + list(settings.instance.schema)
+        module_names = ["core"] + list(settings.instance.modules)
 
-    for schema_name in schema_names:
-        schema_module = importlib.import_module(get_schema_module_name(schema_name))
+    for module_name in module_names:
+        schema_module = importlib.import_module(get_schema_module_name(module_name))
         # the below is necessary because a schema module might not have been
         # explicitly accessed
         importlib.reload(schema_module)
@@ -146,7 +146,7 @@ def view(
             and issubclass(registry, Record)
             and registry is not Record
         }
-        if schema_name == "core":
+        if module_name == "core":
             all_registries.update({FeatureValue, ParamValue})
         if registries is not None:
             filtered_registries = {
@@ -156,9 +156,9 @@ def view(
             }
         else:
             filtered_registries = all_registries
-        if len(schema_names) > 1:
-            section = f"* module: {colors.green(colors.bold(schema_name))} *"
-            section_no_color = f"* module: {schema_name} *"
+        if len(module_names) > 1:
+            section = f"* module: {colors.green(colors.bold(module_name))} *"
+            section_no_color = f"* module: {module_name} *"
             logger.print("*" * len(section_no_color))
             logger.print(section)
             logger.print("*" * len(section_no_color))

lamindb/base/__init__.py

@@ -0,0 +1,24 @@
+"""Base library.
+
+Is available also when no instance is connected.
+
+Modules:
+
+.. autosummary::
+   :toctree: .
+
+   types
+
+Utils:
+
+.. autosummary::
+   :toctree: .
+
+   doc_args
+   deprecated
+
+"""
+
+from lamindb_setup.core import deprecated, doc_args
+
+from . import types