emmet-builders 0.78.3__py3-none-any.whl → 0.86.0__py3-none-any.whl

emmet/builders/materials/provenance.py

@@ -1,7 +1,5 @@
 from collections import defaultdict
-from typing import Dict, Iterable, List, Optional, Tuple
 from math import ceil
-from datetime import datetime
 
 from maggma.core import Builder, Store
 from maggma.utils import grouper
@@ -10,7 +8,12 @@ from pymatgen.core.structure import Structure
 
 from emmet.builders.settings import EmmetBuildSettings
 from emmet.core.provenance import ProvenanceDoc, SNLDict
-from emmet.core.utils import get_sg, jsanitize
+from emmet.core.utils import get_sg, jsanitize, utcnow
+
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from collections.abc import Iterable
 
 
 class ProvenanceBuilder(Builder):
@@ -18,9 +21,9 @@ class ProvenanceBuilder(Builder):
         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 +62,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 +104,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:
@@ -168,7 +171,7 @@ class ProvenanceBuilder(Builder):
             for snl in snls:
                 struc = Structure.from_dict(snl)
                 snl_sg = get_sg(struc)
-                struc.snl = SNLDict(**snl)
+                struc.snl = SNLDict(**snl)  # type: ignore[attr-defined]
                 snl_groups[snl_sg].append(struc)
 
             mat_sg = get_sg(Structure.from_dict(mat["structure"]))
@@ -178,7 +181,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:
@@ -203,15 +206,15 @@ class ProvenanceBuilder(Builder):
                 deprecated=mat["deprecated"],
             )
         else:
-            doc = ProvenanceDoc(
+            doc = ProvenanceDoc(  # type: ignore[call-arg]
                 material_id=mat["material_id"],
                 structure=Structure.from_dict(mat["structure"]),
                 deprecated=mat["deprecated"],
-                created_at=datetime.utcnow(),
+                created_at=utcnow(),
             )
 
         doc.authors.append(self.settings.DEFAULT_AUTHOR)
-        doc.history.append(self.settings.DEFAULT_HISTORY)
+        doc.history.append(self.settings.DEFAULT_HISTORY)  # type: ignore[union-attr]
         doc.references.append(self.settings.DEFAULT_REFERENCE)
 
         snl_doc = jsanitize(doc.dict(exclude_none=False), allow_bson=True)

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 AlphaID
 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 [
@@ -107,7 +108,7 @@ class SubstratesBuilder(Builder):
             dict: a diffraction dict
         """
 
-        mpid = MPID(item["material_id"])
+        mpid = AlphaID(item["material_id"])
         elastic_tensor = item.get("elastic_tensor", None)
         elastic_tensor = (
             ElasticTensor.from_voigt(elastic_tensor) if elastic_tensor else None

emmet/builders/materials/summary.py

@@ -3,10 +3,10 @@ from math import ceil
 from maggma.builders import Builder
 from maggma.utils import grouper
 
-from emmet.core.mpid import MPID
+from emmet.core.mpid import AlphaID
 from emmet.core.summary import SummaryDoc, HasProps
 from emmet.core.utils import jsanitize
-from emmet.core.thermo import ThermoType
+from emmet.core.types.enums import ThermoType
 
 
 class SummaryBuilder(Builder):
@@ -214,7 +214,7 @@ class SummaryBuilder(Builder):
             yield {"query": {self.materials.key: {"$in": list(split)}}}
 
     def process_item(self, item):
-        material_id = MPID(item[HasProps.materials.value]["material_id"])
+        material_id = AlphaID(item[HasProps.materials.value]["material_id"])
         doc = SummaryDoc.from_docs(material_id=material_id, **item)
         return jsanitize(doc.model_dump(exclude_none=False), allow_bson=True)
 

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,

emmet/builders/settings.py

@@ -1,14 +1,13 @@
 """
 Settings for defaults in the build pipelines for the Materials Project
 """
-from typing import List
 
 from pydantic.fields import Field
 
 from emmet.core.provenance import Author, History
+from emmet.core.qchem.calc_types import TaskType as QChemTaskType
 from emmet.core.settings import EmmetSettings
 from emmet.core.vasp.calc_types import TaskType as VaspTaskType
-from emmet.core.qchem.calc_types import TaskType as QChemTaskType
 
 
 class EmmetBuildSettings(EmmetSettings):
@@ -18,35 +17,40 @@ class EmmetBuildSettings(EmmetSettings):
     EMMET_CONFIG_FILE to point to the json with emmet settings
     """
 
-    BUILD_TAGS: List[str] = Field(
+    BUILD_TAGS: list[str] = Field(
         [], description="Tags for calculations to build materials"
     )
-    EXCLUDED_TAGS: List[str] = Field(
+    EXCLUDED_TAGS: list[str] = Field(
         [],
         description="Tags to exclude from materials",
     )
 
-    DEPRECATED_TAGS: List[str] = Field(
+    DEPRECATED_TAGS: list[str] = Field(
         [], description="Tags for calculations to deprecate"
     )
 
-    NON_COMMERCIAL_TAGS: List[str] = Field(
+    NON_COMMERCIAL_TAGS: list[str] = Field(
         [], description="Tages for which to add BY-NC as license data in builder_meta"
     )
 
-    VASP_ALLOWED_VASP_TYPES: List[VaspTaskType] = Field(
-        [t.value for t in VaspTaskType],
+    VASP_ALLOWED_VASP_TYPES: list[VaspTaskType] = Field(
+        list(VaspTaskType),
         description="Allowed task_types to build materials from",
     )
 
-    QCHEM_ALLOWED_TASK_TYPES: List[QChemTaskType] = Field(
-        [
-            "Single Point",
-            "Force",
-            "Geometry Optimization",
-            "Frequency Analysis",
-            "Frequency Flattening Geometry Optimization",
-        ],
+    QCHEM_ALLOWED_TASK_TYPES: list[QChemTaskType] = Field(
+        list(
+            map(
+                QChemTaskType,
+                [
+                    "Single Point",
+                    "Force",
+                    "Geometry Optimization",
+                    "Frequency Analysis",
+                    "Frequency Flattening Geometry Optimization",
+                ],
+            )
+        ),
         description="Allowed task_types to build molecules from",
     )
 
@@ -71,7 +75,7 @@ class EmmetBuildSettings(EmmetSettings):
     )
 
     DEFAULT_HISTORY: History = Field(
-        History(
+        History(  # type: ignore[call-arg]
             name="Materials Project Optimized Structure",
             url="http://www.materialsproject.org",
         ),

emmet/builders/utils.py

@@ -1,18 +1,30 @@
-from typing import Set, Union, Any
-import sys
+from __future__ import annotations
+
+import json
 import os
+import sys
 from gzip import GzipFile
-import orjson
-import json
 from io import BytesIO
-from monty.serialization import MontyDecoder
-from botocore.exceptions import ClientError
 from itertools import chain, combinations
-from pymatgen.core import Structure
+
+import orjson
+from botocore.exceptions import ClientError
+from monty.serialization import MontyDecoder
 from pymatgen.analysis.diffusion.neb.full_path_mapper import MigrationGraph
+from pymatgen.core import Structure
+from pymatgen.io.vasp.inputs import PotcarSingle
+
+from emmet.core.types.typing import FSPathType
 
+from emmet.builders.settings import EmmetBuildSettings
 
-def maximal_spanning_non_intersecting_subsets(sets) -> Set[Set]:
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from typing import Any, Literal
+
+
+def maximal_spanning_non_intersecting_subsets(sets) -> set[set[Any]]:
     """
     Finds the maximal spanning non intersecting subsets of a group of sets
     This is usefull for parsing out the sandboxes and figuring out how to group
@@ -40,7 +52,7 @@ def maximal_spanning_non_intersecting_subsets(sets) -> Set[Set]:
     return set(to_return_subsets)
 
 
-def chemsys_permutations(chemsys) -> Set:
+def chemsys_permutations(chemsys) -> set[str]:
     # Function to get all relevant chemical subsystems
     # e.g. for Li-Mn-O returns Li, Li-Mn, Li-Mn-O, Li-O, Mn, Mn-O, O
     elements = chemsys.split("-")
@@ -58,7 +70,7 @@ def get_hop_cutoff(
     algorithm: str = "min_distance",
     min_hop_distance: float = 1,
     max_hop_distance: float = 7,
-) -> Union[float, None]:
+) -> float | None:
     """
     A function to get an appropriate hop distance cutoff for a given migration
     graph structure which can be used for MigrationGraph.with_distance()
@@ -158,7 +170,7 @@ def query_open_data(
     key: str,
     monty_decode: bool = True,
     s3_resource: Any = None,
-) -> Union[dict, None]:
+) -> dict | None:
     """Query a Materials Project AWS S3 Open Data bucket directly with boto3
 
     Args:
@@ -166,7 +178,7 @@ def query_open_data(
         prefix (str): Full set of file prefixes
         key (str): Key for file
         monty_decode (bool): Whether to monty decode or keep as dictionary. Defaults to True.
-        s3_resource (Optional[Any]): S3 resource. One will be instantiated if none are provided
+        s3_resource (Any | None): S3 resource. One will be instantiated if none are provided
 
     Returns:
         dict: MontyDecoded data or None
@@ -211,3 +223,80 @@ class HiddenPrints:
     def __exit__(self, exc_type, exc_val, exc_tb):
         sys.stdout.close()
         sys.stdout = self._original_stdout
+
+
+def get_potcar_stats(
+    method: Literal["potcar", "pymatgen", "stored"] = "potcar",
+    path_to_stored_stats: FSPathType | None = None,
+) -> dict[str, Any]:
+    """
+    Get the POTCAR stats used in MP calculations to validate POTCARs.
+
+    Args:
+        method : Literal[str : "potcar","pymatgen","stored"] = "potcar"
+            Method to generate the POTCAR stats:
+            - "potcar": regenerate stats from a user's POTCAR library.
+            - "pymatgen": regenerate stats from the stored pymatgen
+              summary stats dict. This has the downside of the possibility
+              of finding multiple matching POTCAR stats for older POTCAR
+              releases. As of 25 March, 2024, it does not appear that the
+              MP POTCARs have duplicates
+            - "stored": load a stored dict of POTCAR stats.
+        path_to_stored_stats : FSPathType or None
+            If FSPathType, the path to the stored summary stats file.
+            If None, defaults to
+              `importlib.resources.file("emmet.builders.vasp") / "mp_potcar_stats.json.gz"`
+    Returns:
+        dict, of POTCAR summary stats.
+    """
+    default_settings = EmmetBuildSettings()
+
+    stats: dict[str, dict] = {}  # type: ignore
+
+    if method == "stored":
+        from monty.serialization import loadfn
+
+        if path_to_stored_stats is None:
+            from importlib.resources import files
+
+            path_to_stored_stats = str(
+                files("emmet.builders.vasp") / "mp_potcar_stats.json.gz"
+            )
+        return loadfn(path_to_stored_stats)  # type: ignore
+
+    for (
+        calc_type,
+        input_set,
+    ) in default_settings.VASP_DEFAULT_INPUT_SETS.items():
+        _input = input_set()
+
+        stats[calc_type] = {}
+        functional = _input._config_dict["POTCAR_FUNCTIONAL"]
+
+        for potcar_symbol in _input.CONFIG["POTCAR"].values():
+            if method == "potcar":
+                potcar = PotcarSingle.from_symbol_and_functional(
+                    symbol=potcar_symbol, functional=functional
+                )
+                summary_stats = potcar._summary_stats.copy()
+                # fallback method for validation - use header hash and symbol
+                # note that the potcar_spec assigns PotcarSingle.symbol to "titel"
+                # whereas the ***correct*** field is `header`
+                summary_stats["titel"] = potcar.header  # type: ignore[assignment]
+                summary_stats["hash"] = potcar.md5_header_hash  # type: ignore[assignment]
+                summary_stats = [summary_stats]  # type: ignore[assignment]
+
+            elif method == "pymatgen":
+                summary_stats = []  # type: ignore[assignment]
+                for _, entries in PotcarSingle._potcar_summary_stats[
+                    functional
+                ].items():
+                    summary_stats += [  # type: ignore[operator]
+                        {**entry, "titel": None, "hash": None}
+                        for entry in entries
+                        if entry["symbol"] == potcar_symbol
+                    ]
+
+            stats[calc_type].update({potcar_symbol: summary_stats})
+
+    return stats