lamindb 0.48a2__py3-none-any.whl → 0.48.1__py3-none-any.whl

lamindb/_file.py

@@ -8,7 +8,7 @@ import pandas as pd
 from anndata import AnnData
 from appdirs import AppDirs
 from django.db.models.query_utils import DeferredAttribute as Field
-from lamin_logger import colors, logger
+from lamin_utils import colors, logger
 from lamindb_setup import settings as setup_settings
 from lamindb_setup._init_instance import register_storage
 from lamindb_setup.dev import StorageSettings
@@ -17,6 +17,7 @@ from lnschema_core import Feature, FeatureSet, File, Run, ids
 from lnschema_core.types import AnnDataLike, DataLike, PathLike
 
 from lamindb._context import context
+from lamindb.dev import FeatureManager
 from lamindb.dev._settings import settings
 from lamindb.dev.hashing import b16_to_b64, hash_file
 from lamindb.dev.storage import (
@@ -27,24 +28,15 @@ from lamindb.dev.storage import (
     size_adata,
     write_to_file,
 )
+from lamindb.dev.storage._backed_access import AnnDataAccessor, BackedAccessor
 from lamindb.dev.storage.file import auto_storage_key_from_file, filepath_from_file
 from lamindb.dev.utils import attach_func_to_class_method
 
 from . import _TESTING
+from ._feature import convert_numpy_dtype_to_lamin_feature_type
 from .dev._view_parents import view_lineage
 from .dev.storage.file import AUTO_KEY_PREFIX
 
-try:
-    from lamindb.dev.storage._backed_access import AnnDataAccessor, BackedAccessor
-except ImportError:
-
-    class AnnDataAccessor:  # type: ignore
-        pass
-
-    class BackedAccessor:  # type: ignore
-        pass
-
-
 DIRS = AppDirs("lamindb", "laminlabs")
 
 
@@ -362,6 +354,19 @@ def data_is_anndata(data: DataLike):
     return False
 
 
+def data_is_mudata(data: DataLike):
+    try:
+        from mudata import MuData
+    except ModuleNotFoundError:
+        return False
+
+    if isinstance(data, MuData):
+        return True
+    if isinstance(data, (str, Path, UPath)):
+        return Path(data).suffix in {".h5mu"}
+    return False
+
+
 def __init__(file: File, *args, **kwargs):
     # Below checks for the Django-internal call in from_db()
     # it'd be better if we could avoid this, but not being able to create a File
@@ -383,9 +388,6 @@ def __init__(file: File, *args, **kwargs):
     description: Optional[str] = (
         kwargs.pop("description") if "description" in kwargs else None
     )
-    feature_sets: Optional[List[FeatureSet]] = (
-        kwargs.pop("feature_sets") if "feature_sets" in kwargs else None
-    )
     name: Optional[str] = kwargs.pop("name") if "name" in kwargs else None
     format = kwargs.pop("format") if "format" in kwargs else None
     log_hint = kwargs.pop("log_hint") if "log_hint" in kwargs else True
@@ -394,9 +396,7 @@ def __init__(file: File, *args, **kwargs):
     )
 
     if not len(kwargs) == 0:
-        raise ValueError(
-            "Only data, key, run, description & feature_sets can be passed."
-        )
+        raise ValueError("Only data, key, run, description can be passed.")
 
     if name is not None and description is not None:
         raise ValueError("Only pass description, do not pass a name")
@@ -404,21 +404,8 @@ def __init__(file: File, *args, **kwargs):
         logger.warning("Argument `name` is deprecated, please use `description`")
         description = name
 
-    if feature_sets is None:
-        feature_sets = []
-        if isinstance(data, pd.DataFrame) and log_hint:
-            logger.hint(
-                "This is a dataframe, consider using File.from_df() to link column"
-                " names as features!"
-            )
-        elif data_is_anndata(data) and log_hint:
-            logger.hint(
-                "This is AnnDataLike, consider using File.from_anndata() to link var"
-                " and obs.columns as features!"
-            )
-
     provisional_id = ids.base62_20()
-    kwargs, privates = get_file_kwargs_from_data(
+    kwargs_or_file, privates = get_file_kwargs_from_data(
         data=data,
         key=key,
         run=run,
@@ -426,17 +413,38 @@ def __init__(file: File, *args, **kwargs):
         provisional_id=provisional_id,
         skip_check_exists=skip_check_exists,
     )
+
     # an object with the same hash already exists
-    if isinstance(kwargs, File):
+    if isinstance(kwargs_or_file, File):
         # this is the way Django instantiates from the DB internally
         # https://github.com/django/django/blob/549d6ffeb6d626b023acc40c3bb2093b4b25b3d6/django/db/models/base.py#LL488C1-L491C51
         new_args = [
-            getattr(kwargs, field.attname) for field in file._meta.concrete_fields
+            getattr(kwargs_or_file, field.attname)
+            for field in file._meta.concrete_fields
         ]
         super(File, file).__init__(*new_args)
         file._state.adding = False
         file._state.db = "default"
         return None
+    else:
+        kwargs = kwargs_or_file
+
+    if isinstance(data, pd.DataFrame):
+        if log_hint:
+            logger.hint(
+                "This is a dataframe, consider using File.from_df() to link column"
+                " names as features!"
+            )
+        kwargs["accessor"] = "DataFrame"
+    elif data_is_anndata(data):
+        if log_hint:
+            logger.hint(
+                "This is AnnDataLike, consider using File.from_anndata() to link"
+                " var_names and obs.columns as features!"
+            )
+        kwargs["accessor"] = "AnnData"
+    elif data_is_mudata(data):
+        kwargs["accessor"] = "MuData"
 
     kwargs["id"] = provisional_id
     kwargs["description"] = description
@@ -465,9 +473,6 @@ def __init__(file: File, *args, **kwargs):
         file._cloud_filepath = privates["cloud_filepath"]
         file._memory_rep = privates["memory_rep"]
         file._to_store = not privates["check_path_in_storage"]
-        file._feature_sets = (
-            feature_sets if isinstance(feature_sets, list) else [feature_sets]
-        )
 
     super(File, file).__init__(**kwargs)
 
@@ -484,9 +489,8 @@ def from_df(
 ) -> "File":
     """{}"""
     file = File(data=df, key=key, run=run, description=description, log_hint=False)
-    features = Feature.from_df(df)
-    feature_set = FeatureSet(features)
-    file._feature_sets = [feature_set]
+    feature_set = FeatureSet.from_df(df)
+    file._feature_sets = {"columns": feature_set}
     return file
 
 
@@ -512,9 +516,25 @@ def from_anndata(
             data_parse = backed_access(filepath)
         else:
             data_parse = ad.read(filepath, backed="r")
-    feature_sets = []
-    feature_sets.append(FeatureSet.from_values(data_parse.var.index, var_ref))
-    feature_sets.append(FeatureSet.from_values(data_parse.obs.columns))
+        type = "float"
+    else:
+        type = convert_numpy_dtype_to_lamin_feature_type(adata.X.dtype)
+    feature_sets = {}
+    logger.info("Parsing feature names of X, stored in slot .var")
+    logger.indent = "   "
+    feature_set_x = FeatureSet.from_values(
+        data_parse.var.index,
+        var_ref,
+        type=type,
+    )
+    feature_sets["var"] = feature_set_x
+    logger.indent = ""
+    if len(data_parse.obs.columns) > 0:
+        logger.info("Parsing feature names of slot .obs")
+        logger.indent = "   "
+        feature_set_obs = FeatureSet.from_df(data_parse.obs)
+        feature_sets["obs"] = feature_set_obs
+        logger.indent = ""
     file._feature_sets = feature_sets
     return file
 
@@ -526,19 +546,13 @@ def from_dir(
     path: PathLike,
     *,
     run: Optional[Run] = None,
+    storage_root: Optional[PathLike] = None,
 ) -> List["File"]:
     """{}"""
     folderpath = UPath(path)
-    check_path_in_storage = check_path_in_default_storage(folderpath)
-
-    if check_path_in_storage:
-        folder_key = get_relative_path_to_root(path=folderpath).as_posix()
-    else:
-        raise RuntimeError(
-            "Currently, only directories in default storage can be registered!\n"
-            "You can either move your folder into the current default storage"
-            "or add a new default storage through `ln.settings.storage`"
-        )
+    folder_key = get_relative_path_to_root(
+        path=folderpath, root=storage_root
+    ).as_posix()
     # always sanitize by stripping a trailing slash
     folder_key = folder_key.rstrip("/")
     logger.hint(f"using storage prefix = {folder_key}/")
@@ -617,17 +631,18 @@ def backed(
             " one of the following suffixes for the object name:"
             f" {', '.join(suffixes)}."
         )
-    _track_run_input(self, is_run_input)
-    # consider the case where an object is already locally cached
-    local_path = setup_settings.instance.storage.cloud_to_local_no_update(
-        filepath_from_file(self)
-    )
-    if local_path.exists() and self.suffix == ".h5ad":
-        return ad.read_h5ad(local_path, backed="r")
 
     from lamindb.dev.storage._backed_access import backed_access
 
-    return backed_access(self)
+    _track_run_input(self, is_run_input)
+
+    filepath = filepath_from_file(self)
+    # consider the case where an object is already locally cached
+    localpath = setup_settings.instance.storage.cloud_to_local_no_update(filepath)
+    if localpath.exists():
+        return backed_access(localpath)
+    else:
+        return backed_access(filepath)
 
 
 def _track_run_input(file: File, is_run_input: Optional[bool] = None):
@@ -638,9 +653,14 @@ def _track_run_input(file: File, is_run_input: Optional[bool] = None):
             # avoid cycles (a file is both input and output)
             if file.run != context.run:
                 if settings.track_run_inputs:
+                    transform_note = ""
+                    if file.transform is not None:
+                        transform_note = (
+                            f", adding parent transform {file.transform.id}"
+                        )
                     logger.info(
-                        f"Adding file {file.id} as input for run {context.run.id},"
-                        f" adding parent transform {file.transform.id}"
+                        f"Adding file {file.id} as input for run"
+                        f" {context.run.id}{transform_note}"
                     )
                     track_run_input = True
                 else:
@@ -659,7 +679,7 @@ def _track_run_input(file: File, is_run_input: Optional[bool] = None):
         if context.run is None:
             raise ValueError(
                 "No global run context set. Call ln.context.track() or link input to a"
-                " run object via `run.inputs.append(file)`"
+                " run object via `run.input_files.append(file)`"
             )
         # avoid adding the same run twice
         # avoid cycles (a file is both input and output)
@@ -671,6 +691,8 @@ def _track_run_input(file: File, is_run_input: Optional[bool] = None):
 
 def load(self, is_run_input: Optional[bool] = None, stream: bool = False) -> DataLike:
     _track_run_input(self, is_run_input)
+    if hasattr(self, "_memory_rep") and self._memory_rep is not None:
+        return self._memory_rep
     return load_to_memory(filepath_from_file(self), stream=stream)
 
 
@@ -718,14 +740,21 @@ def _save_skip_storage(file, *args, **kwargs) -> None:
     if file.run is not None:
         file.run.save()
     if hasattr(file, "_feature_sets"):
-        for feature_set in file._feature_sets:
+        for feature_set in file._feature_sets.values():
             feature_set.save()
-    if hasattr(file, "_feature_values"):
-        for feature_value in file._feature_values:
-            feature_value.save()
     super(File, file).save(*args, **kwargs)
     if hasattr(file, "_feature_sets"):
-        file.feature_sets.set(file._feature_sets)
+        links = []
+        for slot, feature_set in file._feature_sets.items():
+            links.append(
+                File.feature_sets.through(
+                    file_id=file.id, feature_set_id=feature_set.id, slot=slot
+                )
+            )
+
+        from lamindb._save import bulk_create
+
+        bulk_create(links)
 
 
 def path(self) -> Union[Path, UPath]:
@@ -801,13 +830,13 @@ def inherit_relations(self, file: File, fields: Optional[List[str]] = None):
         >>> file1.save()
         >>> file2 = ln.File(pd.DataFrame(index=[2,3]))
         >>> file2.save()
-        >>> ln.save(ln.Tag.from_values(["Tag1", "Tag2", "Tag3"], field="name"))
-        >>> tags = ln.Tag.select(name__icontains = "tag").all()
-        >>> file1.tags.set(tags)
-        >>> file2.inherit_relations(file1, ["tags"])
-        💬 Inheriting 1 field: ['tags']
-        >>> file2.tags.list("name")
-        ['Tag1', 'Tag2', 'Tag3']
+        >>> ln.save(ln.Label.from_values(["Label1", "Label2", "Label3"], field="name"))
+        >>> labels = ln.Label.select(name__icontains = "label").all()
+        >>> file1.labels.set(labels)
+        >>> file2.inherit_relations(file1, ["labels"])
+        💬 Inheriting 1 field: ['labels']
+        >>> file2.labels.list("name")
+        ['Label1', 'Label2', 'Label3']
     """
     if fields is None:
         # fields in the model definition
@@ -822,6 +851,9 @@ def inherit_relations(self, file: File, fields: Optional[List[str]] = None):
             else:
                 raise KeyError(f"No many-to-many relationship is found with '{field}'")
 
+    if None in related_names:
+        related_names.remove(None)
+
     inherit_names = [
         related_name
         for related_name in related_names
@@ -836,6 +868,15 @@ def inherit_relations(self, file: File, fields: Optional[List[str]] = None):
         )
 
 
+@property  # type: ignore
+@doc_args(File.features.__doc__)
+def features(self) -> "FeatureManager":
+    """{}"""
+    from lamindb._feature_manager import FeatureManager
+
+    return FeatureManager(self)
+
+
 METHOD_NAMES = [
     "__init__",
     "from_anndata",
@@ -866,5 +907,8 @@ for name in METHOD_NAMES:
 # privates currently dealt with separately
 File._delete_skip_storage = _delete_skip_storage
 File._save_skip_storage = _save_skip_storage
+# TODO: move these to METHOD_NAMES
 setattr(File, "view_lineage", view_lineage)
 setattr(File, "inherit_relations", inherit_relations)
+# property signature is not tested:
+setattr(File, "features", features)

lamindb/_from_values.py

@@ -1,10 +1,11 @@
-from typing import Any, Dict, Iterable, List, Tuple, Union
+from typing import Any, Dict, Iterable, List, Optional, Tuple, Union
 
 import pandas as pd
 from django.core.exceptions import FieldDoesNotExist
+from django.db.models import Case, When
 from django.db.models.query_utils import DeferredAttribute as Field
-from lamin_logger import colors, logger
-from lnschema_core.models import ORM
+from lamin_utils import colors, logger
+from lnschema_core.models import ORM, Feature
 from lnschema_core.types import ListLike
 
 from .dev._settings import settings
@@ -17,15 +18,26 @@ def get_or_create_records(
     *,
     from_bionty: bool = False,
     **kwargs,
-) -> List:
+) -> List[ORM]:
     """Get or create records from iterables."""
     upon_create_search_names = settings.upon_create_search_names
     settings.upon_create_search_names = False
+    feature: Feature = None
+    if "feature" in kwargs:
+        feature = kwargs.pop("feature")
+        kwargs["feature_id"] = feature.id
+    types: Optional[Dict] = None
+    if "types" in kwargs:
+        types = kwargs.pop("types")
     try:
         field_name = field.field.name
-        model = field.field.model
+        ORM = field.field.model
         iterable_idx = index_iterable(iterable)
 
+        if isinstance(ORM, Feature):
+            if types is None:
+                raise ValueError("Please pass types as {} or use FeatureSet.from_df()")
+
         # returns existing records & non-existing values
         records, nonexist_values = get_existing_records(
             iterable_idx=iterable_idx, field=field, kwargs=kwargs
@@ -43,15 +55,42 @@ def get_or_create_records(
             # unmapped new_ids will only create records with field and kwargs
             if len(unmapped_values) > 0:
                 for value in unmapped_values:
-                    records.append(model(**{field_name: value}, **kwargs))
+                    params = {field_name: value}
+                    if types is not None:
+                        params["type"] = str(types[value])
+                    records.append(ORM(**params, **kwargs))
                 s = "" if len(unmapped_values) == 1 else "s"
-                print_unmapped_values = ", ".join(unmapped_values[:7])
-                if len(unmapped_values) > 7:
+                print_unmapped_values = ", ".join(unmapped_values[:10])
+                if len(unmapped_values) > 10:
                     print_unmapped_values += ", ..."
+                additional_info = " "
+                if feature is not None:
+                    additional_info = f" Feature {feature.name} and "
                 logger.warning(
-                    f"Created {colors.yellow(f'{len(unmapped_values)} {model.__name__} record{s}')} setting"  # noqa
-                    f" field {colors.yellow(f'{field_name}')} to: {print_unmapped_values}"  # noqa
+                    f"Created {colors.yellow(f'{len(unmapped_values)} {ORM.__name__} record{s}')} for{additional_info}"  # noqa
+                    f"{colors.yellow(f'{field_name}{s}')}: {print_unmapped_values}"  # noqa
                 )
+        if ORM.__module__.startswith("lnschema_bionty."):
+            if isinstance(iterable, pd.Series):
+                feature = iterable.name
+            else:
+                logger.warning(
+                    "Did not receive values as pd.Series, inferring feature from"
+                    f" reference ORM: {ORM.__name__}"
+                )
+                feature = ORM.__name__.lower()
+            if isinstance(feature, str):
+                feature_name = feature
+                feature = Feature.select(name=feature).one_or_none()
+            elif feature is not None:
+                feature_name = feature.name
+            if feature is not None:
+                for record in records:
+                    record._feature = feature
+            if feature_name is not None:
+                for record in records:
+                    record._feature = feature_name
+            logger.info(f"Mapping records to feature '{feature_name}'")
         return records
     finally:
         settings.upon_create_search_names = upon_create_search_names
@@ -80,10 +119,14 @@ def get_existing_records(iterable_idx: pd.Index, field: Field, kwargs: Dict = {}
     syn_msg = ""
     if len(syn_mapper) > 0:
         s = "" if len(syn_mapper) == 1 else "s"
+        names = list(syn_mapper.keys())
+        print_values = ", ".join(names[:10])
+        if len(names) > 10:
+            print_values += ", ..."
         syn_msg = (
             "Loaded"
             f" {colors.green(f'{len(syn_mapper)} {model.__name__} record{s}')} that"  # noqa
-            f" matched {colors.green('synonyms')}"
+            f" matched {colors.green('synonyms')}: {print_values}"
         )
         iterable_idx = iterable_idx.to_frame().rename(index=syn_mapper).index
 
@@ -95,22 +138,37 @@ def get_existing_records(iterable_idx: pd.Index, field: Field, kwargs: Dict = {}
 
     from ._select import select
 
-    stmt = select(model, **condition)
+    query_set = select(model, **condition)
+
+    # new we have to sort the list of queried records
+    preserved = Case(
+        *[
+            When(**{field_name: value}, then=pos)
+            for pos, value in enumerate(iterable_idx)
+        ]
+    )
+    records = query_set.order_by(preserved).list()
 
-    records = stmt.list()  # existing records
     n_name = len(records) - len(syn_mapper)
+    names = [getattr(record, field_name) for record in records]
+    names = [name for name in names if name not in syn_mapper.values()]
     if n_name > 0:
         s = "" if n_name == 1 else "s"
+        print_values = ", ".join(names[:10])
+        if len(names) > 10:
+            print_values += ", ..."
         logger.info(
             "Loaded"
             f" {colors.green(f'{n_name} {model.__name__} record{s}')} that"
-            f" matched field {colors.green(f'{field_name}')}"
+            f" matched {colors.green(f'{field_name}')}: {print_values}"
         )
     # make sure that synonyms logging appears after the field logging
     if len(syn_msg) > 0:
         logger.info(syn_msg)
 
-    existing_values = iterable_idx.intersection(stmt.values_list(field_name, flat=True))
+    existing_values = iterable_idx.intersection(
+        query_set.values_list(field_name, flat=True)
+    )
     nonexist_values = iterable_idx.difference(existing_values)
 
     return records, nonexist_values
@@ -144,10 +202,14 @@ def create_records_from_bionty(
     msg_syn: str = ""
     if len(syn_mapper) > 0:
         s = "" if len(syn_mapper) == 1 else "s"
+        names = list(syn_mapper.keys())
+        print_values = ", ".join(names[:10])
+        if len(names) > 10:
+            print_values += ", ..."
         msg_syn = (
-            "Created"
+            "Loaded"
             f" {colors.purple(f'{len(syn_mapper)} {model.__name__} record{s} from Bionty')} that"  # noqa
-            f" matched {colors.purple('synonyms')}"
+            f" matched {colors.purple('synonyms')}: {print_values}"
         )
 
         iterable_idx = iterable_idx.to_frame().rename(index=syn_mapper).index
@@ -162,26 +224,24 @@ def create_records_from_bionty(
         for bk in bionty_kwargs:
             records.append(model(**bk, **kwargs))
 
-        # logging of BiontySource linking
-        source_msg = (
-            ""
-            if kwargs.get("bionty_source") is None
-            else f" (bionty_source_id={kwargs.get('bionty_source').id})"  # type:ignore # noqa
-        )
-
         # number of records that matches field (not synonyms)
         n_name = len(records) - len(syn_mapper)
+        names = [getattr(record, field_name) for record in records]
+        names = [name for name in names if name not in syn_mapper.values()]
         if n_name > 0:
             s = "" if n_name == 1 else "s"
+            print_values = ", ".join(names[:10])
+            if len(names) > 10:
+                print_values += ", ..."
             msg = (
-                "Created"
+                "Loaded"
                 f" {colors.purple(f'{n_name} {model.__name__} record{s} from Bionty')} that"  # noqa
-                f" matched {colors.purple(f'{field_name}')} field"
+                f" matched {colors.purple(f'{field_name}')}: {print_values}"
             )
-            logger.info(msg + source_msg)
+            logger.info(msg)
         # make sure that synonyms logging appears after the field logging
         if len(msg_syn) > 0:
-            logger.info(msg_syn + source_msg)
+            logger.info(msg_syn)
         # warning about multi matches
         if len(multi_msg) > 0:
             logger.warning(multi_msg)

lamindb/_label.py

@@ -0,0 +1,85 @@
+from typing import List, Optional, Union
+
+import pandas as pd
+from lamin_utils import logger
+from lamindb_setup.dev._docs import doc_args
+from lnschema_core import Feature, Label
+from lnschema_core.types import ListLike
+
+from lamindb.dev.utils import attach_func_to_class_method
+
+from . import _TESTING
+from ._from_values import get_or_create_records, index_iterable
+
+
+def __init__(self, *args, **kwargs):
+    if len(args) == len(self._meta.concrete_fields):
+        super(Label, self).__init__(*args, **kwargs)
+        return None
+    # now we proceed with the user-facing constructor
+    if len(args) > 0:
+        raise ValueError("Only one non-keyword arg allowed")
+    name: Optional[str] = kwargs.pop("name") if "name" in kwargs else None
+    description: Optional[str] = (
+        kwargs.pop("description") if "description" in kwargs else None
+    )
+    feature: Optional[str] = kwargs.pop("feature") if "feature" in kwargs else None
+    feature_id: Optional[str] = (
+        kwargs.pop("feature_id") if "feature_id" in kwargs else None
+    )
+    if len(kwargs) > 0:
+        raise ValueError("Only name, description, feature are valid keyword arguments")
+    # continue
+    if feature is None and feature_id is None:
+        logger.warning("Consider passing a corresponding feature for your label!")
+    if isinstance(feature, str):
+        feature = Feature.select(name=feature).one_or_none()
+        if feature is None:
+            raise ValueError(
+                f"Feature with name {feature} does not exist, please create it:"
+                f" ln.Feature(name={feature}, type='float')"
+            )
+        else:
+            feature_id = feature.id
+    super(Label, self).__init__(
+        name=name, description=description, feature_id=feature_id
+    )
+
+
+@classmethod  # type:ignore
+@doc_args(Label.from_values.__doc__)
+def from_values(
+    cls, values: ListLike, feature: Optional[Union[Feature, str]] = None, **kwargs
+) -> List["Label"]:
+    """{}"""
+    iterable_idx = index_iterable(values)
+    if feature is None and isinstance(values, pd.Series):
+        feature = values.name
+    if isinstance(feature, str):
+        feature = Feature.select(name=feature).one()
+    records = get_or_create_records(
+        iterable=iterable_idx,
+        field=Label.name,
+        # here, feature_id is a kwarg, which is an additional condition
+        # in queries for potentially existing records
+        feature=feature,
+    )
+    return records
+
+
+METHOD_NAMES = [
+    "__init__",
+    "from_values",
+]
+
+if _TESTING:
+    from inspect import signature
+
+    SIGS = {
+        name: signature(getattr(Label, name))
+        for name in METHOD_NAMES
+        if name != "__init__"
+    }
+
+for name in METHOD_NAMES:
+    attach_func_to_class_method(name, Label, globals())

lamindb/_logger.py

@@ -1 +1 @@
-from lamin_logger import colors, logger  # noqa
+from lamin_utils import colors, logger  # noqa