precomit

Author: esoteric-ephemera

mp_api/client/core/client.py

@@ -49,6 +49,7 @@
     from typing import Any, Callable
 
     from pydantic.fields import FieldInfo
+
     from mp_api.client.core.utils import LazyImport
 
 try:
@@ -1353,6 +1354,7 @@ def __str__(self):  # pragma: no cover
             f"Available fields: {', '.join(self.available_fields)}\n\n"
         )
 
+
 class CoreRester(BaseRester):
     """Define a BaseRester with extra features for core resters.
 
@@ -1361,7 +1363,8 @@ class CoreRester(BaseRester):
     of endpoints names to LazyImport objects.
 
     """
-    _sub_resters : dict[str,LazyImport] = {}
+
+    _sub_resters: dict[str, LazyImport] = {}
 
     def __getattr__(self, v: str):
         if v in self._sub_resters:

mp_api/client/core/utils.py

@@ -77,7 +77,7 @@ def validate_ids(id_list: list[str]) -> list[str]:
 
 class LazyImport:
     """Lazily import and load an object.
-    
+
     This class is super lazy, in that it lazily imports and caches an object.
     If the object is a function, the function itself will be cached.
 
@@ -90,38 +90,52 @@ class LazyImport:
         A dot-separated, import-like string.
     """
 
-    __slots__ = ["_module_name", "_class_name", "_obj","_imported"]
+    __slots__ = ["_module_name", "_class_name", "_obj", "_imported"]
+
+    def __init__(
+        self,
+        import_str: str,
+    ) -> None:
+        """Initialize a lazily imported object.
 
-    def __init__(self, import_str: str,) -> None:
-        if len(
-            splitted := import_str.rsplit(".",1)
-        ) > 1:
-            self._module_name, self._class_name = splitted
+        Parameters
+        -----------
+        import_str : str
+            A dot-separated, import-like string.
+        """
+        if len(split_import_str := import_str.rsplit(".", 1)) > 1:
+            self._module_name, self._class_name = split_import_str
         else:
-            self._module_name = splitted[0]
+            self._module_name = split_import_str[0]
             self._class_name = None
 
-        self._imported : Any | None = None
-        self._obj : Any | None = None
+        self._imported: Any | None = None
+        self._obj: Any | None = None
 
     def __str__(self) -> str:
-        return f"LazyImport of {self._module_name}" + (f".{self._class_name}" if self._class_name else "")
+        return f"LazyImport of {self._module_name}" + (
+            f".{self._class_name}" if self._class_name else ""
+        )
 
     def __repr__(self) -> str:
         return self.__str__()
 
-    def _load(self,) -> None:
+    def _load(
+        self,
+    ) -> None:
         try:
             _imported = import_module(self._module_name)
             if self._class_name:
                 _imported = getattr(_imported, self._class_name)
             self._imported = _imported
         except Exception as exc:
-            raise ImportError(f"Failed to import {self._module_name}.{self._class_name}:\n{exc}")
+            raise ImportError(
+                f"Failed to import {self._module_name}.{self._class_name}:\n{exc}"
+            )
 
     def __call__(self, *args, **kwargs) -> Any:
         """Call a function or (re-)initialize a class.
-        
+
         If the object itself has not been imported, this will first import it.
 
         If the object is a class, it will be initialized, cached, and returned.
@@ -132,20 +146,19 @@ def __call__(self, *args, **kwargs) -> Any:
         if self._imported is None:
             self._load()
 
-        if isinstance(self._imported,type):
+        if isinstance(self._imported, type):
             self._obj = self._imported(*args, **kwargs)
             return self._obj
         else:
             self._obj = self._imported
-            return self._obj(*args,**kwargs)
+            return self._obj(*args, **kwargs)
 
-    def __getattr__(self, v : str) -> Any:
+    def __getattr__(self, v: str) -> Any:
         """Get an attribute on a super lazy object."""
         if self._obj is not None and hasattr(self._obj, v):
             return getattr(self._obj, v)
 
         if self._imported is None:
             self._load()
-        if hasattr(self._imported,v):
-            return getattr(self._imported,v)
-        
+        if hasattr(self._imported, v):
+            return getattr(self._imported, v)

mp_api/client/mprester.py

@@ -31,7 +31,6 @@
 from mp_api.client.routes.materials import MATERIALS_RESTERS
 from mp_api.client.routes.molecules import MOLECULES_RESTERS
 
-
 if TYPE_CHECKING:
     from typing import Any, Literal
 
@@ -43,7 +42,9 @@
 DEFAULT_THERMOTYPE_CRITERIA = {"thermo_types": ["GGA_GGA+U"]}
 
 RESTER_LAYOUT = {
-    "molecules/core": LazyImport("mp_api.client.routes.molecules.molecules.MoleculeRester"),
+    "molecules/core": LazyImport(
+        "mp_api.client.routes.molecules.molecules.MoleculeRester"
+    ),
     "materials/core": MATERIALS_RESTERS["materials"],
     **{
         f"materials/{k}": v
@@ -54,7 +55,10 @@
     **{
         f"molecules/{k}": v
         for k, v in MOLECULES_RESTERS.items()
-        if k not in {"molecules",}
+        if k
+        not in {
+            "molecules",
+        }
     },
     **GENERIC_RESTERS,
 }

mp_api/client/routes/molecules/__init__.py

@@ -3,10 +3,10 @@
 from mp_api.client.core.utils import LazyImport
 
 MOLECULES_RESTERS = {
-    k : LazyImport(f"mp_api.client.routes.molecules.{k}.{v}")
+    k: LazyImport(f"mp_api.client.routes.molecules.{k}.{v}")
     for k, v in (
         ("molecules", "MoleculeRester"),
         ("jcser", "JcesrMoleculesRester"),
-        ("summary", "MoleculesSummaryRester")
+        ("summary", "MoleculesSummaryRester"),
     )
-}
+}

tests/core/test_utils.py

@@ -1,8 +1,7 @@
-
 from mp_api.client.core.utils import LazyImport
 
-def test_lazy_import_function():
 
+def test_lazy_import_function():
     import_str = "json.dumps"
     lazy_func = LazyImport(import_str)
     assert lazy_func._module_name == "json"
@@ -11,24 +10,21 @@ def test_lazy_import_function():
 
     jsonables = [
         {"apple": "pineapple", "banana": "orange"},
-        [1,2,3,4,5],
-        [{"nothing": {"of": {"grand": "import"}}}]
+        [1, 2, 3, 4, 5],
+        [{"nothing": {"of": {"grand": "import"}}}],
     ]
 
-    dumped = [
-        lazy_func(jsonable) for jsonable in jsonables
-    ]
+    dumped = [lazy_func(jsonable) for jsonable in jsonables]
 
     import json as _real_json
-    
+
     assert lazy_func._imported == _real_json.dumps
     assert all(
-        dumped[i] == _real_json.dumps(jsonable)
-        for i, jsonable in enumerate(jsonables)
+        dumped[i] == _real_json.dumps(jsonable) for i, jsonable in enumerate(jsonables)
     )
 
-def test_lazy_import_class():
 
+def test_lazy_import_class():
     import_str = "pymatgen.core.Structure"
     lazy_class = LazyImport(import_str)
     assert lazy_class._module_name == "pymatgen.core"
@@ -45,12 +41,15 @@ def test_lazy_import_class():
 direct
    0.8750000000000000    0.8750000000000000    0.8750000000000000 Si
    0.1250000000000000    0.1250000000000000    0.1250000000000000 Si"""
-   
+
     # test construction from classmethod
-    struct_from_str = lazy_class.from_str(structure_str, fmt = "poscar")
+    struct_from_str = lazy_class.from_str(structure_str, fmt="poscar")
     # test re-init
-    struct_from_init = lazy_class(struct_from_str.lattice,struct_from_str.species,struct_from_str.frac_coords)
+    struct_from_init = lazy_class(
+        struct_from_str.lattice, struct_from_str.species, struct_from_str.frac_coords
+    )
     assert struct_from_str == struct_from_init
 
     from pymatgen.core.structure import Structure
-    assert Structure.from_str(structure_str,fmt="poscar") == struct_from_str
+
+    assert Structure.from_str(structure_str, fmt="poscar") == struct_from_str

tests/test_client.py

@@ -49,9 +49,12 @@
 
 # Temporarily ignore molecules resters while molecules query operators are changed
 resters_to_test = [
-    rester for rester in mpr._all_resters if "molecule" not in rester._class_name.lower()
+    rester
+    for rester in mpr._all_resters
+    if "molecule" not in rester._class_name.lower()
 ]
 
+
 @pytest.mark.skipif(os.getenv("MP_API_KEY") is None, reason="No API key found.")
 @pytest.mark.parametrize("rester", resters_to_test)
 def test_generic_get_methods(rester):
@@ -65,7 +68,7 @@ def test_generic_get_methods(rester):
         monty_decode=rester not in [TaskRester, ProvenanceRester],
         use_document_model=True,
     )
-    
+
     name = rester.suffix.replace("/", "_")
 
     docs_check = lambda _docs: all(