draft lazy loading

Author: esoteric-ephemera

mp_api/client/core/utils.py

@@ -1,17 +1,18 @@
 from __future__ import annotations
 
-import re
+from importlib import import_module
 from typing import TYPE_CHECKING, Literal
 
 import orjson
 from emmet.core import __version__ as _EMMET_CORE_VER
+from emmet.core.mpid_ext import validate_identifier
 from monty.json import MontyDecoder
 from packaging.version import parse as parse_version
 
 from mp_api.client.core.settings import MAPIClientSettings
 
 if TYPE_CHECKING:
-    from monty.json import MSONable
+    from typing import Any
 
 
 def _compare_emmet_ver(
@@ -23,6 +24,10 @@ def _compare_emmet_ver(
         _compare_emmet_ver("0.84.0rc0","<") returns
         emmet.core.__version__ < "0.84.0rc0"
 
+    This function may not be used anywhere in the client, but it should
+    be preserved for future use, in case some degree of backwards
+    compatibility or feature buy-in is needed.
+
     Parameters
     -----------
     ref_version : str
@@ -36,41 +41,17 @@ def _compare_emmet_ver(
     )(parse_version(ref_version))
 
 
-if _compare_emmet_ver("0.85.0", ">="):
-    from emmet.core.mpid_ext import validate_identifier
-else:
-    validate_identifier = None
-
-
-def load_json(json_like: str | bytes, deser: bool = False, encoding: str = "utf-8"):
+def load_json(
+    json_like: str | bytes, deser: bool = False, encoding: str = "utf-8"
+) -> Any:
     """Utility to load json in consistent manner."""
     data = orjson.loads(
         json_like if isinstance(json_like, bytes) else json_like.encode(encoding)
     )
     return MontyDecoder().process_decoded(data) if deser else data
 
 
-def _legacy_id_validation(id_list: list[str]) -> list[str]:
-    """Legacy utility to validate IDs, pre-AlphaID transition.
-
-    This function is temporarily maintained to allow for
-    backwards compatibility with older versions of emmet, and will
-    not be preserved.
-    """
-    pattern = "(mp|mvc|mol|mpcule)-.*"
-    if malformed_ids := {
-        entry for entry in id_list if re.match(pattern, entry) is None
-    }:
-        raise ValueError(
-            f"{'Entry' if len(malformed_ids) == 1 else 'Entries'}"
-            f" {', '.join(malformed_ids)}"
-            f"{'is' if len(malformed_ids) == 1 else 'are'} not formatted correctly!"
-        )
-
-    return id_list
-
-
-def validate_ids(id_list: list[str]):
+def validate_ids(id_list: list[str]) -> list[str]:
     """Function to validate material and task IDs.
 
     Args:
@@ -91,36 +72,38 @@ def validate_ids(id_list: list[str]):
     # TODO: after the transition to AlphaID in the document models,
     # The following line should be changed to
     # return [validate_identifier(idx,serialize=True) for idx in id_list]
-    if validate_identifier:
-        return [str(validate_identifier(idx)) for idx in id_list]
-    return _legacy_id_validation(id_list)
-
-
-def allow_msonable_dict(monty_cls: type[MSONable]):
-    """Patch Monty to allow for dict values for MSONable."""
-
-    def validate_monty(cls, v, _):
-        """Stub validator for MSONable as a dictionary only."""
-        if isinstance(v, cls):
-            return v
-        elif isinstance(v, dict):
-            # Just validate the simple Monty Dict Model
-            errors = []
-            if v.get("@module", "") != monty_cls.__module__:
-                errors.append("@module")
-
-            if v.get("@class", "") != monty_cls.__name__:
-                errors.append("@class")
-
-            if len(errors) > 0:
-                raise ValueError(
-                    "Missing Monty seriailzation fields in dictionary: {errors}"
+    return [str(validate_identifier(idx)) for idx in id_list]
+
+class LazyImport:
+
+    __slots__ = ["_module_name", "_class_name", "_obj"]
+
+    def __init__(self, module_name : str, class_name : str,) -> None:
+        self._module_name = module_name
+        self._class_name = class_name
+        self._obj = None
+    
+    def __str__(self) -> str:
+        return f"LazyImport of {self._module_name}.{self._class_name}"
+    
+    def __repr__(self) -> str:
+        return self.__str__()
+
+    def __call__(self, *args, **kwargs):
+        if self._obj is None:
+            try:
+                self._obj = getattr(
+                    import_module(self._module_name),
+                    self._class_name
+                )(
+                    *args,
+                    **kwargs,
                 )
-
-            return v
-        else:
-            raise ValueError(f"Must provide {cls.__name__} or MSONable dictionary")
-
-    monty_cls.validate_monty_v2 = classmethod(validate_monty)
-
-    return monty_cls
+            except Exception as exc:
+                raise ImportError(
+                    f"Failed to import {self._class_name}:\n{exc}"
+                )
+        return self._obj
+    
+    def __getattr__(self,v):
+        return getattr(self._obj,v)