emmet-builders 0.84.7rc4__py3-none-any.whl → 0.84.9__py3-none-any.whl

emmet/builders/materials/electrodes.py

@@ -4,7 +4,6 @@ from datetime import datetime
 from functools import lru_cache
 from itertools import chain
 from math import ceil
-from typing import Any, Dict, Iterator, List, Optional
 
 from maggma.builders import Builder
 from maggma.stores import MongoStore
@@ -18,6 +17,12 @@ from emmet.core.electrode import ConversionElectrodeDoc, InsertionElectrodeDoc
 from emmet.core.structure_group import StructureGroupDoc, _get_id_lexi
 from emmet.core.utils import jsanitize
 
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from typing import Any
+    from collections.abc import Iterator
+
 
 def s_hash(el):
     return el.data["comp_delith"]
@@ -85,7 +90,7 @@ class StructureGroupBuilder(Builder):
         materials: MongoStore,
         sgroups: MongoStore,
         working_ion: str,
-        query: Optional[dict] = None,
+        query: dict | None = None,
         ltol: float = default_build_settings.LTOL,
         stol: float = default_build_settings.STOL,
         angle_tol: float = default_build_settings.ANGLE_TOL,
@@ -115,15 +120,15 @@ class StructureGroupBuilder(Builder):
         self.check_newer = check_newer
         self.chunk_size = chunk_size
 
-        self.query[
-            "deprecated"
-        ] = False  # Ensure only non-deprecated materials are chosen
+        self.query["deprecated"] = (
+            False  # Ensure only non-deprecated materials are chosen
+        )
 
         super().__init__(
             sources=[materials], targets=[sgroups], chunk_size=chunk_size, **kwargs
         )
 
-    def prechunk(self, number_splits: int) -> Iterator[Dict]:  # pragma: no cover
+    def prechunk(self, number_splits: int) -> Iterator[dict]:  # pragma: no cover
         """
         Prechunk method to perform chunking by the key field
         """
@@ -268,7 +273,7 @@ class StructureGroupBuilder(Builder):
             else:
                 yield {"chemsys": chemsys, "materials": all_mats_in_chemsys}
 
-    def update_targets(self, items: List):
+    def update_targets(self, items: list):
         items = list(filter(None, chain.from_iterable(items)))
         if len(items) > 0:
             self.logger.info("Updating {} sgroups documents".format(len(items)))
@@ -319,7 +324,7 @@ class InsertionElectrodeBuilder(Builder):
         grouped_materials: MongoStore,
         thermo: MongoStore,
         insertion_electrode: MongoStore,
-        query: Optional[Dict] = None,
+        query: dict | None = None,
         strip_structures: bool = False,
         **kwargs,
     ):
@@ -335,7 +340,7 @@ class InsertionElectrodeBuilder(Builder):
             **kwargs,
         )
 
-    def prechunk(self, number_splits: int) -> Iterator[Dict]:
+    def prechunk(self, number_splits: int) -> Iterator[dict]:
         """
         Prechunk method to perform chunking by the key field
         """
@@ -418,7 +423,7 @@ class InsertionElectrodeBuilder(Builder):
             else:
                 yield None
 
-    def process_item(self, item) -> Dict:
+    def process_item(self, item) -> dict:
         """
         - Add volume information to each entry to create the insertion electrode document
         - Add the host structure
@@ -460,14 +465,14 @@ class InsertionElectrodeBuilder(Builder):
             # {"failed_reason": "unable to create InsertionElectrode document"}
         return jsanitize(ie.model_dump())
 
-    def update_targets(self, items: List):
+    def update_targets(self, items: list):
         items = list(filter(None, items))
         if len(items) > 0:
             self.logger.info("Updating {} battery documents".format(len(items)))
             for struct_group_dict in items:
-                struct_group_dict[
-                    self.grouped_materials.last_updated_field
-                ] = datetime.utcnow()
+                struct_group_dict[self.grouped_materials.last_updated_field] = (
+                    datetime.utcnow()
+                )
             self.insertion_electrode.update(docs=items, key=["battery_id"])
         else:
             self.logger.info("No items to update")
@@ -480,7 +485,7 @@ class ConversionElectrodeBuilder(Builder):
         conversion_electrode_store: MongoStore,
         working_ion: str,
         thermo_type: str,
-        query: Optional[dict] = None,
+        query: dict | None = None,
         **kwargs,
     ):
         self.phase_diagram_store = phase_diagram_store
@@ -499,7 +504,7 @@ class ConversionElectrodeBuilder(Builder):
             **kwargs,
         )
 
-    def prechunk(self, number_splits: int) -> Iterator[Dict]:
+    def prechunk(self, number_splits: int) -> Iterator[dict]:
         """
         Prechunk method to perform chunking by the key field
         """
@@ -532,7 +537,7 @@ class ConversionElectrodeBuilder(Builder):
         for phase_diagram_doc in self.phase_diagram_store.query(criteria=q):
             yield phase_diagram_doc
 
-    def process_item(self, item) -> Dict:
+    def process_item(self, item) -> dict:
         """
         - For each phase diagram doc, find all possible conversion electrodes and create conversion electrode docs
         """
@@ -611,7 +616,7 @@ class ConversionElectrodeBuilder(Builder):
 
         return new_docs  # type: ignore
 
-    def update_targets(self, items: List):
+    def update_targets(self, items: list):
         combined_items = []
         for _items in items:
             _items = list(filter(None, _items))

emmet/builders/materials/electronic_structure.py

@@ -1,28 +1,28 @@
-from collections import defaultdict
-from math import ceil
 import itertools
 import re
+from collections import defaultdict
+from math import ceil
+
 import boto3
 import numpy as np
 from botocore.handlers import disable_signing
 from maggma.builders import Builder
 from maggma.utils import grouper
 from pymatgen.analysis.magnetism.analyzer import CollinearMagneticStructureAnalyzer
+from pymatgen.analysis.structure_matcher import StructureMatcher
 from pymatgen.core import Structure
-from pymatgen.electronic_structure.core import Spin
 from pymatgen.electronic_structure.bandstructure import BandStructureSymmLine
+from pymatgen.electronic_structure.core import Spin
 from pymatgen.electronic_structure.dos import CompleteDos
-from pymatgen.symmetry.bandstructure import HighSymmKpath
-from pymatgen.analysis.structure_matcher import StructureMatcher
-from pymatgen.symmetry.analyzer import SpacegroupAnalyzer
 from pymatgen.io.vasp.sets import MPStaticSet
+from pymatgen.symmetry.analyzer import SpacegroupAnalyzer
+from pymatgen.symmetry.bandstructure import HighSymmKpath
 
-from emmet.core.settings import EmmetSettings
+from emmet.builders.utils import query_open_data
 from emmet.core.electronic_structure import ElectronicStructureDoc
+from emmet.core.settings import EmmetSettings
 from emmet.core.utils import jsanitize
 
-from emmet.builders.utils import query_open_data
-
 SETTINGS = EmmetSettings()
 
 
@@ -297,7 +297,7 @@ class ElectronicStructureBuilder(Builder):
         Inserts electronic structure documents into the electronic_structure collection
 
         Args:
-            items ([Dict]): A list of ElectronicStructureDoc dictionaries to update
+            items ([dict]): A list of ElectronicStructureDoc dictionaries to update
         """
 
         items = list(filter(None, items))
@@ -577,9 +577,9 @@ class ElectronicStructureBuilder(Builder):
 
                 other_calcs.append(
                     {
-                        "is_static": True
-                        if "Static" in mat["task_types"][task_id]
-                        else False,
+                        "is_static": (
+                            True if "Static" in mat["task_types"][task_id] else False
+                        ),
                         "task_id": task_id,
                         "is_hubbard": int(is_hubbard),
                         "nkpoints": int(nkpoints),
@@ -640,9 +640,9 @@ class ElectronicStructureBuilder(Builder):
                     bs_obj["data"] if bs_obj is not None else None
                 )
 
-                materials_doc["bandstructure"][bs_type][
-                    "output_structure"
-                ] = sorted_bs_data[0]["output_structure"]
+                materials_doc["bandstructure"][bs_type]["output_structure"] = (
+                    sorted_bs_data[0]["output_structure"]
+                )
 
                 materials_doc["origins"].append(
                     {

emmet/builders/materials/magnetism.py

@@ -1,5 +1,6 @@
+from __future__ import annotations
+
 from math import ceil
-from typing import Dict, Iterator, Optional
 
 from maggma.builders import Builder
 from maggma.stores import Store
@@ -9,6 +10,11 @@ from pymatgen.core.structure import Structure
 from emmet.core.magnetism import MagnetismDoc
 from emmet.core.utils import jsanitize
 
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from collections.abc import Iterator
+
 __author__ = "Shyam Dwaraknath <shyamd@lbl.gov>, Matthew Horton <mkhorton@lbl.gov>"
 
 
@@ -18,7 +24,7 @@ class MagneticBuilder(Builder):
         materials: Store,
         magnetism: Store,
         tasks: Store,
-        query: Optional[Dict] = None,
+        query: dict | None = None,
         **kwargs,
     ):
         """
@@ -42,7 +48,7 @@ class MagneticBuilder(Builder):
 
         super().__init__(sources=[materials, tasks], targets=[magnetism], **kwargs)
 
-    def prechunk(self, number_splits: int) -> Iterator[Dict]:  # pragma: no cover
+    def prechunk(self, number_splits: int) -> Iterator[dict]:  # pragma: no cover
         """
         Prechunk method to perform chunking by the key field
         """

emmet/builders/materials/ml.py

@@ -1,5 +1,4 @@
 from importlib.metadata import version
-from typing import TYPE_CHECKING, Optional, Union
 
 from maggma.builders.map_builder import MapBuilder
 from maggma.core import Store
@@ -16,13 +15,12 @@ from pymatgen.core import Structure
 from emmet.core.ml import MLDoc
 from emmet.core.utils import jsanitize
 
-if TYPE_CHECKING:
-    try:
-        from ase.calculators.calculator import Calculator
+try:
+    from ase.calculators.calculator import Calculator
 
-        ase_installed = True
-    except ImportError:
-        ase_installed = False
+    ase_installed = True
+except ImportError:
+    ase_installed = False
 
 
 class MLBuilder(MapBuilder):
@@ -30,10 +28,10 @@ class MLBuilder(MapBuilder):
         self,
         materials: Store,
         ml_potential: Store,
-        model: Union[str, "Calculator"],
-        model_kwargs: Optional[dict] = None,
-        prop_kwargs: Optional[dict] = None,
-        provenance: Optional[dict] = None,
+        model: str | Calculator,
+        model_kwargs: dict | None = None,
+        prop_kwargs: dict | None = None,
+        provenance: dict | None = None,
         **kwargs,
     ):
         """Machine learning interatomic potential builder.

emmet/builders/materials/optimade.py

@@ -1,5 +1,4 @@
 from math import ceil
-from typing import Dict, Iterator, Optional
 
 from maggma.builders import Builder
 from maggma.core import Store
@@ -9,6 +8,11 @@ from pymatgen.core.structure import Structure
 from emmet.core.optimade import OptimadeMaterialsDoc
 from emmet.core.utils import jsanitize
 
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from collections.abc import Iterator
+
 
 class OptimadeMaterialsBuilder(Builder):
     def __init__(
@@ -16,7 +20,7 @@ class OptimadeMaterialsBuilder(Builder):
         materials: Store,
         thermo: Store,
         optimade: Store,
-        query: Optional[Dict] = None,
+        query: dict | None = None,
         **kwargs,
     ):
         """
@@ -42,7 +46,7 @@ class OptimadeMaterialsBuilder(Builder):
 
         super().__init__(sources=[materials, thermo], targets=optimade, **kwargs)
 
-    def prechunk(self, number_splits: int) -> Iterator[Dict]:  # pragma: no cover
+    def prechunk(self, number_splits: int) -> Iterator[dict]:  # pragma: no cover
         """
         Prechunk method to perform chunking by the key field
         """

emmet/builders/materials/piezoelectric.py

@@ -1,5 +1,4 @@
 from math import ceil
-from typing import Dict, Optional
 
 import numpy as np
 from maggma.builders import Builder
@@ -17,7 +16,7 @@ class PiezoelectricBuilder(Builder):
         materials: Store,
         tasks: Store,
         piezoelectric: Store,
-        query: Optional[Dict] = None,
+        query: dict | None = None,
         **kwargs,
     ):
         self.materials = materials

emmet/builders/materials/provenance.py

@@ -1,7 +1,6 @@
 from collections import defaultdict
 from datetime import datetime
 from math import ceil
-from typing import Dict, Iterable, List, Optional, Tuple
 
 from maggma.core import Builder, Store
 from maggma.utils import grouper
@@ -12,15 +11,20 @@ from emmet.builders.settings import EmmetBuildSettings
 from emmet.core.provenance import ProvenanceDoc, SNLDict
 from emmet.core.utils import get_sg, jsanitize
 
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from collections.abc import Iterable
+
 
 class ProvenanceBuilder(Builder):
     def __init__(
         self,
         materials: Store,
         provenance: Store,
-        source_snls: List[Store],
-        settings: Optional[EmmetBuildSettings] = None,
-        query: Optional[Dict] = None,
+        source_snls: list[Store],
+        settings: EmmetBuildSettings | None = None,
+        query: dict | None = None,
         **kwargs,
     ):
         """
@@ -59,7 +63,7 @@ class ProvenanceBuilder(Builder):
             s.ensure_index("snl_id")
             s.ensure_index("formula_pretty")
 
-    def prechunk(self, number_splits: int) -> Iterable[Dict]:  # pragma: no cover
+    def prechunk(self, number_splits: int) -> Iterable[dict]:  # pragma: no cover
         self.ensure_indicies()
 
         # Find all formulas for materials that have been updated since this
@@ -101,7 +105,7 @@ class ProvenanceBuilder(Builder):
         for chunk in grouper(mat_ids, N):
             yield {"query": {"material_id": {"$in": chunk}}}
 
-    def get_items(self) -> Tuple[List[Dict], List[Dict]]:  # type: ignore
+    def get_items(self) -> tuple[list[dict], list[dict]]:  # type: ignore
         """
         Gets all materials to assocaite with SNLs
         Returns:
@@ -178,7 +182,7 @@ class ProvenanceBuilder(Builder):
             self.logger.debug(f"Found {len(snl_structs)} potential snls for {mat_id}")
             yield mat, snl_structs
 
-    def process_item(self, item) -> Dict:
+    def process_item(self, item) -> dict:
         """
         Matches SNLS and Materials
         Args:

emmet/builders/materials/robocrys.py

@@ -1,8 +1,7 @@
-from typing import Dict, Optional
 from maggma.builders.map_builder import MapBuilder
 from maggma.core import Store
-
 from pymatgen.core.structure import Structure
+
 from emmet.core.robocrys import RobocrystallogapherDoc
 from emmet.core.utils import jsanitize
 
@@ -12,7 +11,7 @@ class RobocrystallographerBuilder(MapBuilder):
         self,
         oxidation_states: Store,
         robocrys: Store,
-        query: Optional[Dict] = None,
+        query: dict | None = None,
         **kwargs
     ):
         self.oxidation_states = oxidation_states

emmet/builders/materials/substrates.py

@@ -1,14 +1,15 @@
-from typing import Optional, Dict, Iterable
-from emmet.core.mpid import MPID
-from maggma.core.store import Store
+from typing import Iterable
+
 from maggma.core.builder import Builder
-from pymatgen.core.structure import Structure
+from maggma.core.store import Store
+from maggma.utils import grouper
 from pymatgen.analysis.elasticity.elastic import ElasticTensor
+from pymatgen.core.structure import Structure
 from pymatgen.symmetry.analyzer import SpacegroupAnalyzer
 
+from emmet.core.mpid import MPID
 from emmet.core.substrates import SubstratesDoc
 from emmet.core.utils import jsanitize
-from maggma.utils import grouper
 
 
 class SubstratesBuilder(Builder):
@@ -17,7 +18,7 @@ class SubstratesBuilder(Builder):
         materials: Store,
         substrates: Store,
         elasticity: Store,
-        query: Optional[Dict] = None,
+        query: dict | None = None,
         **kwargs,
     ):
         """
@@ -47,7 +48,7 @@ class SubstratesBuilder(Builder):
             **kwargs,
         )
 
-    def prechunk(self, number_splits: int) -> Iterable[Dict]:  # pragma: no cover
+    def prechunk(self, number_splits: int) -> Iterable[dict]:  # pragma: no cover
         to_process_mat_ids = self._find_to_process()
 
         return [

emmet/builders/materials/thermo.py

@@ -1,8 +1,9 @@
-from math import ceil
+from __future__ import annotations
+
 import warnings
-from itertools import chain
-from typing import Dict, Iterator, List, Optional, Set
 from datetime import datetime
+from itertools import chain
+from math import ceil
 
 from maggma.core import Builder, Store
 from maggma.stores import S3Store
@@ -12,18 +13,23 @@ from pymatgen.analysis.phase_diagram import PhaseDiagramError
 from pymatgen.entries.computed_entries import ComputedStructureEntry
 
 from emmet.builders.utils import HiddenPrints
-from emmet.core.thermo import ThermoDoc, PhaseDiagramDoc
+from emmet.core.thermo import PhaseDiagramDoc, ThermoDoc
 from emmet.core.utils import jsanitize
 
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from collections.abc import Iterator
+
 
 class ThermoBuilder(Builder):
     def __init__(
         self,
         thermo: Store,
         corrected_entries: Store,
-        phase_diagram: Optional[Store] = None,
-        query: Optional[Dict] = None,
-        num_phase_diagram_eles: Optional[int] = None,
+        phase_diagram: Store | None = None,
+        query: dict | None = None,
+        num_phase_diagram_eles: int | None = None,
         chunk_size: int = 1000,
         **kwargs,
     ):
@@ -49,7 +55,7 @@ class ThermoBuilder(Builder):
         self.phase_diagram = phase_diagram
         self.num_phase_diagram_eles = num_phase_diagram_eles
         self.chunk_size = chunk_size
-        self._completed_tasks: Set[str] = set()
+        self._completed_tasks: set[str] = set()
 
         if self.thermo.key != "thermo_id":
             warnings.warn(
@@ -111,7 +117,7 @@ class ThermoBuilder(Builder):
             coll.ensure_index("chemsys")
             coll.ensure_index("phase_diagram_id")
 
-    def prechunk(self, number_splits: int) -> Iterator[Dict]:  # pragma: no cover
+    def prechunk(self, number_splits: int) -> Iterator[dict]:  # pragma: no cover
         to_process_chemsys = self._get_chemsys_to_process()
 
         N = ceil(len(to_process_chemsys) / number_splits)
@@ -119,7 +125,7 @@ class ThermoBuilder(Builder):
         for chemsys_chunk in grouper(to_process_chemsys, N):
             yield {"query": {"chemsys": {"$in": list(chemsys_chunk)}}}
 
-    def get_items(self) -> Iterator[List[Dict]]:
+    def get_items(self) -> Iterator[list[dict]]:
         """
         Gets whole chemical systems of entries to process
         """
@@ -224,7 +230,7 @@ class ThermoBuilder(Builder):
         """
         Inserts the thermo and phase diagram docs into the thermo collection
         Args:
-            items ([[tuple(List[dict],List[dict])]]): a list of a list of thermo and phase diagram dict pairs to update
+            items ([[tuple(list[dict],list[dict])]]): a list of a list of thermo and phase diagram dict pairs to update
         """
 
         thermo_docs = [pair[0] for pair_list in items for pair in pair_list]

emmet/builders/matscholar/missing_compositions.py

@@ -1,13 +1,17 @@
-from itertools import combinations
 import itertools
+from itertools import combinations
 from math import ceil
-from typing import Dict, List, Iterator, Optional
 
 from maggma.core import Builder
-from maggma.stores import S3Store, MongoURIStore, MongoStore
+from maggma.stores import MongoStore, MongoURIStore, S3Store
 from maggma.utils import grouper
 from pymatgen.core import Composition, Element
 
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from collections.abc import Iterator
+
 
 class MissingCompositionsBuilder(Builder):
     """
@@ -21,7 +25,7 @@ class MissingCompositionsBuilder(Builder):
         phase_diagram: S3Store,
         mpcontribs: MongoURIStore,
         missing_compositions: MongoStore,
-        query: Optional[Dict] = None,
+        query: dict | None = None,
         **kwargs,
     ):
         """
@@ -47,7 +51,7 @@ class MissingCompositionsBuilder(Builder):
             **kwargs,
         )
 
-    def prechunk(self, number_splits: int) -> Iterator[Dict]:  # pragma: no cover
+    def prechunk(self, number_splits: int) -> Iterator[dict]:  # pragma: no cover
         """
         Prechunk method to perform chunking by the key field
         """
@@ -61,7 +65,7 @@ class MissingCompositionsBuilder(Builder):
         for split in grouper(keys, N):
             yield {"query": {self.phase_diagram.key: {"$in": list(split)}}}
 
-    def get_items(self) -> Iterator[Dict]:
+    def get_items(self) -> Iterator[dict]:
         """
         Returns all chemical systems (combinations of elements)
         to process.
@@ -112,7 +116,7 @@ class MissingCompositionsBuilder(Builder):
                 self.logger.error(f"Erro looking for phase diagram for {sys}: {ex}")
                 continue
 
-    def process_item(self, item: Dict) -> Dict:
+    def process_item(self, item: dict) -> dict:
         """
         Processes a chemical system and finds missing c
         ompositions for that system.
@@ -195,7 +199,7 @@ class MissingCompositionsBuilder(Builder):
         else:
             self.logger.info("No items to update")
 
-    def _get_entries_in_chemsys(self, chemsys) -> List:
+    def _get_entries_in_chemsys(self, chemsys) -> list:
         """Queries the MPContribs Store for entries in a chemical system."""
         # get sub-systems
         chemsys_subsystems = []

emmet/builders/mobility/migration_graph.py

@@ -1,10 +1,10 @@
 from maggma.builders.map_builder import MapBuilder
 from maggma.stores import MongoStore
-from typing import Tuple
-from emmet.core.mobility.migrationgraph import MigrationGraphDoc
-from emmet.builders.utils import get_hop_cutoff
-from pymatgen.apps.battery.insertion_battery import InsertionElectrode
 from pymatgen.analysis.diffusion.neb.full_path_mapper import MigrationGraph
+from pymatgen.apps.battery.insertion_battery import InsertionElectrode
+
+from emmet.builders.utils import get_hop_cutoff
+from emmet.core.mobility.migrationgraph import MigrationGraphDoc
 from emmet.core.utils import jsanitize
 
 
@@ -18,7 +18,7 @@ class MigrationGraphBuilder(MapBuilder):
         max_hop_distance: float = 7,
         populate_sc_fields: bool = True,
         min_length_sc: float = 8,
-        minmax_num_atoms: Tuple[int, int] = (80, 120),
+        minmax_num_atoms: tuple[int, int] = (80, 120),
         ltol: float = 0.2,
         stol: float = 0.3,
         angle_tol: float = 5,