SMACT 3.1.0__tar.gz → 3.2.0__tar.gz

{smact-3.1.0/SMACT.egg-info → smact-3.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: SMACT
-Version: 3.1.0
+Version: 3.2.0
 Summary: Semiconducting Materials by Analogy and Chemical Theory
 Author-email: The SMACT Developers <a.walsh@imperial.ac.uk>
 Maintainer-email: "Anthony O. Onwuli" <anthony.onwuli16@imperial.ac.uk>
@@ -81,11 +81,11 @@ Requires-Dist: pandarallel>=1.6.5; extra == "optional"
 Requires-Dist: matplotlib-venn[shapely]>=1.1.2; extra == "optional"
 Provides-Extra: strict
 Requires-Dist: pydantic==2.9.2; extra == "strict"
-Requires-Dist: mp-api==0.45.3; extra == "strict"
+Requires-Dist: mp-api==0.45.5; extra == "strict"
 Requires-Dist: pymatviz==0.15.1; extra == "strict"
-Requires-Dist: mp-api==0.45.3; extra == "strict"
+Requires-Dist: mp-api==0.45.5; extra == "strict"
 Requires-Dist: seaborn==0.13.2; extra == "strict"
-Requires-Dist: pymatgen==2025.3.10; extra == "strict"
+Requires-Dist: pymatgen==2025.4.24; extra == "strict"
 Requires-Dist: matminer==0.9.3; extra == "strict"
 Requires-Dist: umap-learn==0.5.7; extra == "strict"
 Requires-Dist: kaleido==0.2.1; extra == "strict"
@@ -107,7 +107,7 @@ Dynamic: license-file
 ![dependencies](https://img.shields.io/librariesio/release/pypi/smact)
 [![CI Status](https://github.com/WMD-group/SMACT/actions/workflows/ci.yml/badge.svg)](https://github.com/WMD-group/SMACT/actions/workflows/ci.yml)
 [![codecov](https://codecov.io/gh/WMD-group/SMACT/branch/master/graph/badge.svg?token=UtgVxjoYNP)](https://codecov.io/gh/WMD-group/SMACT)
-![PyPI - Downloads](https://img.shields.io/pypi/dm/smact)
+![PyPI - Downloads](https://img.shields.io/pypi/dm/smact) [![Ask DeepWiki](https://deepwiki.com/badge.svg)](https://deepwiki.com/WMD-group/SMACT)
 
 # SMACT
 
@@ -141,7 +141,6 @@ Use cases are available in our [examples](https://smact.readthedocs.io/en/latest
 - Element compositions can be screened through based on the heuristic filters of charge neutrality and electronegativity order. This is handled using the [screening module](https://smact.readthedocs.io/en/latest/smact.screening.html) and [this publication](<https://www.cell.com/chem/fulltext/S2451-9294(16)30155-3>) describes the underlying theory. An example procedure is [outlined in the docs](https://smact.readthedocs.io/en/latest/examples/filter.html).
 
 - Further filters can be applied to generated lists of compositions in order to screen for particular properties. These properties are either intrinsic properties of elements or are calculated for compositions using the [properties module](https://smact.readthedocs.io/en/latest/smact.properties.html). For example:
-
   - An application is shown in [this publication](https://pubs.rsc.org/en/content/articlehtml/2018/sc/c7sc03961a), in which 160,000 chemical compositions are screened based on optical band gap calculated using the [solid-state energy scale](https://www.sciencedirect.com/science/article/pii/S0022459615300888).
   - The [oxidation_states module](https://smact.readthedocs.io/en/latest/smact.oxidation_states.html) can be used to filter out compositions containing metals in unlikely oxidation states according to [a data-driven model](https://pubs.rsc.org/en/content/articlelanding/2018/fd/c8fd00032h#!divAbstract).
 

{smact-3.1.0 → smact-3.2.0}/README.md

@@ -10,7 +10,7 @@
 ![dependencies](https://img.shields.io/librariesio/release/pypi/smact)
 [![CI Status](https://github.com/WMD-group/SMACT/actions/workflows/ci.yml/badge.svg)](https://github.com/WMD-group/SMACT/actions/workflows/ci.yml)
 [![codecov](https://codecov.io/gh/WMD-group/SMACT/branch/master/graph/badge.svg?token=UtgVxjoYNP)](https://codecov.io/gh/WMD-group/SMACT)
-![PyPI - Downloads](https://img.shields.io/pypi/dm/smact)
+![PyPI - Downloads](https://img.shields.io/pypi/dm/smact) [![Ask DeepWiki](https://deepwiki.com/badge.svg)](https://deepwiki.com/WMD-group/SMACT)
 
 # SMACT
 
@@ -44,7 +44,6 @@ Use cases are available in our [examples](https://smact.readthedocs.io/en/latest
 - Element compositions can be screened through based on the heuristic filters of charge neutrality and electronegativity order. This is handled using the [screening module](https://smact.readthedocs.io/en/latest/smact.screening.html) and [this publication](<https://www.cell.com/chem/fulltext/S2451-9294(16)30155-3>) describes the underlying theory. An example procedure is [outlined in the docs](https://smact.readthedocs.io/en/latest/examples/filter.html).
 
 - Further filters can be applied to generated lists of compositions in order to screen for particular properties. These properties are either intrinsic properties of elements or are calculated for compositions using the [properties module](https://smact.readthedocs.io/en/latest/smact.properties.html). For example:
-
   - An application is shown in [this publication](https://pubs.rsc.org/en/content/articlehtml/2018/sc/c7sc03961a), in which 160,000 chemical compositions are screened based on optical band gap calculated using the [solid-state energy scale](https://www.sciencedirect.com/science/article/pii/S0022459615300888).
   - The [oxidation_states module](https://smact.readthedocs.io/en/latest/smact.oxidation_states.html) can be used to filter out compositions containing metals in unlikely oxidation states according to [a data-driven model](https://pubs.rsc.org/en/content/articlelanding/2018/fd/c8fd00032h#!divAbstract).
 

{smact-3.1.0 → smact-3.2.0/SMACT.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: SMACT
-Version: 3.1.0
+Version: 3.2.0
 Summary: Semiconducting Materials by Analogy and Chemical Theory
 Author-email: The SMACT Developers <a.walsh@imperial.ac.uk>
 Maintainer-email: "Anthony O. Onwuli" <anthony.onwuli16@imperial.ac.uk>
@@ -81,11 +81,11 @@ Requires-Dist: pandarallel>=1.6.5; extra == "optional"
 Requires-Dist: matplotlib-venn[shapely]>=1.1.2; extra == "optional"
 Provides-Extra: strict
 Requires-Dist: pydantic==2.9.2; extra == "strict"
-Requires-Dist: mp-api==0.45.3; extra == "strict"
+Requires-Dist: mp-api==0.45.5; extra == "strict"
 Requires-Dist: pymatviz==0.15.1; extra == "strict"
-Requires-Dist: mp-api==0.45.3; extra == "strict"
+Requires-Dist: mp-api==0.45.5; extra == "strict"
 Requires-Dist: seaborn==0.13.2; extra == "strict"
-Requires-Dist: pymatgen==2025.3.10; extra == "strict"
+Requires-Dist: pymatgen==2025.4.24; extra == "strict"
 Requires-Dist: matminer==0.9.3; extra == "strict"
 Requires-Dist: umap-learn==0.5.7; extra == "strict"
 Requires-Dist: kaleido==0.2.1; extra == "strict"
@@ -107,7 +107,7 @@ Dynamic: license-file
 ![dependencies](https://img.shields.io/librariesio/release/pypi/smact)
 [![CI Status](https://github.com/WMD-group/SMACT/actions/workflows/ci.yml/badge.svg)](https://github.com/WMD-group/SMACT/actions/workflows/ci.yml)
 [![codecov](https://codecov.io/gh/WMD-group/SMACT/branch/master/graph/badge.svg?token=UtgVxjoYNP)](https://codecov.io/gh/WMD-group/SMACT)
-![PyPI - Downloads](https://img.shields.io/pypi/dm/smact)
+![PyPI - Downloads](https://img.shields.io/pypi/dm/smact) [![Ask DeepWiki](https://deepwiki.com/badge.svg)](https://deepwiki.com/WMD-group/SMACT)
 
 # SMACT
 
@@ -141,7 +141,6 @@ Use cases are available in our [examples](https://smact.readthedocs.io/en/latest
 - Element compositions can be screened through based on the heuristic filters of charge neutrality and electronegativity order. This is handled using the [screening module](https://smact.readthedocs.io/en/latest/smact.screening.html) and [this publication](<https://www.cell.com/chem/fulltext/S2451-9294(16)30155-3>) describes the underlying theory. An example procedure is [outlined in the docs](https://smact.readthedocs.io/en/latest/examples/filter.html).
 
 - Further filters can be applied to generated lists of compositions in order to screen for particular properties. These properties are either intrinsic properties of elements or are calculated for compositions using the [properties module](https://smact.readthedocs.io/en/latest/smact.properties.html). For example:
-
   - An application is shown in [this publication](https://pubs.rsc.org/en/content/articlehtml/2018/sc/c7sc03961a), in which 160,000 chemical compositions are screened based on optical band gap calculated using the [solid-state energy scale](https://www.sciencedirect.com/science/article/pii/S0022459615300888).
   - The [oxidation_states module](https://smact.readthedocs.io/en/latest/smact.oxidation_states.html) can be used to filter out compositions containing metals in unlikely oxidation states according to [a data-driven model](https://pubs.rsc.org/en/content/articlelanding/2018/fd/c8fd00032h#!divAbstract).
 

{smact-3.1.0 → smact-3.2.0}/SMACT.egg-info/requires.txt

@@ -59,10 +59,10 @@ matplotlib-venn[shapely]>=1.1.2
 
 [strict]
 pydantic==2.9.2
-mp-api==0.45.3
+mp-api==0.45.5
 pymatviz==0.15.1
 seaborn==0.13.2
-pymatgen==2025.3.10
+pymatgen==2025.4.24
 matminer==0.9.3
 umap-learn==0.5.7
 kaleido==0.2.1

{smact-3.1.0 → smact-3.2.0}/pyproject.toml

@@ -6,7 +6,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "SMACT"
-version = "3.1.0"
+version = "3.2.0"
 description = "Semiconducting Materials by Analogy and Chemical Theory"
 readme = "README.md"
 authors = [
@@ -108,11 +108,11 @@ optional = [
 ]
 strict = [
     "pydantic==2.9.2",
-    "mp-api==0.45.3",
+    "mp-api==0.45.5",
     "pymatviz==0.15.1",
-    "mp-api==0.45.3",
+    "mp-api==0.45.5",
     "seaborn==0.13.2",
-    "pymatgen==2025.3.10",
+    "pymatgen==2025.4.24",
     "matminer==0.9.3",
     "umap-learn==0.5.7",
     "kaleido==0.2.1",

{smact-3.1.0 → smact-3.2.0}/smact/data_loader.py

@@ -42,11 +42,11 @@ def set_warnings(enable=True):
 
 
 def _get_data_rows(filename):
-    """Generator for datafile entries by row."""
+    """Generator for datafile entries by row for custom oxidation states lists. Skips rows with no oxidation states for performance."""
     with open(filename) as file:
         for line in file:
             line = line.strip()
-            if line[0] != "#":
+            if line[0] != "#" and any(char.isdigit() for char in line):
                 yield line.split()
 
 
@@ -58,7 +58,6 @@ def float_or_None(x):
         return None
 
 
-# Loader and cache for the element oxidation-state data.
 _el_ox_states = None
 
 
@@ -88,7 +87,6 @@ def lookup_element_oxidation_states(symbol, copy=True):
 
     if _el_ox_states is None:
         _el_ox_states = {}
-
         for items in _get_data_rows(os.path.join(data_directory, "oxidation_states.txt")):
             _el_ox_states[items[0]] = [int(oxidationState) for oxidationState in items[1:]]
 
@@ -259,7 +257,7 @@ def lookup_element_oxidation_states_custom(symbol, filepath, copy=True):
 
     Args:
     ----
-        symbol (str) : the atomic symbol of the element to look up.
+        symbol (str) : the atomic symbol of the element to look up. "all" can be used to return the list (copy=True) or dict (copy=False) for all oxidation states.
         filepath (str) : the path to the text file containing the
             oxidation states data.
         copy (Optional(bool)): if True (default), return a copy of the
@@ -279,19 +277,21 @@ def lookup_element_oxidation_states_custom(symbol, filepath, copy=True):
 
     if _el_ox_states_custom is None:
         _el_ox_states_custom = {}
-
         for items in _get_data_rows(filepath):
             _el_ox_states_custom[items[0]] = [int(oxidationState) for oxidationState in items[1:]]
-
     if symbol in _el_ox_states_custom:
         if copy:
             # _el_ox_states_custom stores lists -> if copy is set, make an implicit
             # deep copy.  The elements of the lists are integers, which are
             # "value types" in Python.
-
             return list(_el_ox_states_custom[symbol])
         else:
             return _el_ox_states_custom[symbol]
+    elif symbol == "all":
+        if copy:
+            return list(_el_ox_states_custom)
+        else:
+            return _el_ox_states_custom
     else:
         if _print_warnings:
             print(f"WARNING: Oxidation states for element {symbol} not found.")

{smact-3.1.0 → smact-3.2.0}/smact/screening.py

@@ -344,8 +344,8 @@ def smact_filter(
     Returns:
     -------
         allowed_comps (list): Allowed compositions for that chemical system
-        in the form [(elements), (oxidation states), (ratios)] if species_unique=True
-        or in the form [(elements), (ratios)] if species_unique=False.
+        in the form [(elements), (oxidation states), (ratios)] if species_unique=True and tuple=False
+        or in the form [(elements), (ratios)] if species_unique=False and tuple=False.
 
     Example usage:
         >>> from smact.screening import smact_filter
@@ -371,8 +371,6 @@ def smact_filter(
 
 
     """
-    compositions = []
-
     # Get symbols and electronegativities
     symbols = tuple(e.symbol for e in els)
     electronegs = [e.pauling_eneg for e in els]
@@ -385,32 +383,31 @@ def smact_filter(
         "pymatgen_sp": [e.oxidation_states_sp for e in els],
         "wiki": [e.oxidation_states_wiki for e in els],
     }
+
     if oxidation_states_set in oxi_set:
         ox_combos = oxi_set[oxidation_states_set]
+        if oxidation_states_set == "wiki":
+            warnings.warn(
+                "This set of oxidation states is sourced from Wikipedia. The results from using this set could be questionable and should not be used unless you know what you are doing and have inspected the oxidation states.",
+                stacklevel=2,
+            )
     elif os.path.exists(oxidation_states_set):
-        ox_combos = [oxi_custom(e.symbol, oxidation_states_set) for e in els]
+        ox_combos = (oxi_custom(e.symbol, oxidation_states_set) for e in els)
     else:
         raise (
             Exception(
                 f'{oxidation_states_set} is not valid. Enter either "smact14", "icsd", "pymatgen","wiki" or a filepath to a textfile of oxidation states.'
             )
         )
-    if oxidation_states_set == "wiki":
-        warnings.warn(
-            "This set of oxidation states is sourced from Wikipedia. The results from using this set could be questionable and should not be used unless you know what you are doing and have inspected the oxidation states.",
-            stacklevel=2,
-        )
 
+    compositions = []
     for ox_states in itertools.product(*ox_combos):
         # Test for charge balance
         cn_e, cn_r = neutral_ratios(ox_states, stoichs=stoichs, threshold=threshold)
         # Electronegativity test
-        if cn_e:
-            electroneg_OK = pauling_test(ox_states, electronegs)
-            if electroneg_OK:
-                for ratio in cn_r:
-                    compositions.append((symbols, ox_states, ratio))
-
+        if cn_e and pauling_test(ox_states, electronegs):
+            for ratio in cn_r:
+                compositions.append((symbols, ox_states, ratio))
     # Return list depending on whether we are interested in unique species combinations
     # or just unique element combinations.
     if species_unique:
@@ -429,9 +426,12 @@ def smact_validity(
     composition: pymatgen.core.Composition | str,
     use_pauling_test: bool = True,
     include_alloys: bool = True,
-    oxidation_states_set: str = "icsd24",
     check_metallicity: bool = False,
     metallicity_threshold: float = 0.7,
+    oxidation_states_set: str | None = None,
+    include_zero: bool = False,
+    consensus: int = 3,
+    commonality: str = "medium",
 ) -> bool:
     """
     Check if a composition is valid according to SMACT rules:
@@ -444,14 +444,24 @@ def smact_validity(
         composition (Composition or str): Composition to check.
         use_pauling_test (bool): Whether to apply the Pauling EN test.
         include_alloys (bool): Consider pure metals valid automatically.
-        oxidation_states_set (str): Which set of oxidation states to use.
         check_metallicity (bool): If True, consider high metallicity valid.
         metallicity_threshold (float): Score threshold for metallicity validity.
+        oxidation_states_set (str): Which set of oxidation states to use. If specified it overrides the making of the oxidation states set.
+        include_zero (bool): Include oxidation state of zero in the filtered list. Default is False.
+        consensus (int): Minimum number of occurrences in literature for an ion to be considered valid. Default is 3.
+        commonality (str): Excludes species below a certain proportion of appearances in literature with respect to the total number of reports of a given element (after the consensus threshold has been applied). "low" includes all species, "medium" excludes rare species below 10% occurrence, and "high" excludes non-majority species below 50% occurrence. "main" selects the species with the highest occurrence for a given element. Users may also specify their own threshold (float or int). Default is "medium".
 
     Returns:
         bool: True if the composition is valid, False otherwise.
     """
     from smact import _gcd_recursive, metals, neutral_ratios
+    from smact.utils.oxidation import ICSD24OxStatesFilter
+
+    if oxidation_states_set is not None and any([include_zero, consensus != 3, commonality != "medium"]):
+        warnings.warn(
+            "Parameters include_zero, consensus, and commonality are only used when oxidation_states_set is None",
+            stacklevel=2,
+        )
 
     if isinstance(composition, str):
         composition = Composition(composition)
@@ -484,7 +494,20 @@ def smact_validity(
     electronegs = [e.pauling_eneg for e in smact_elems]
 
     # Get oxidation states data
-    if oxidation_states_set == "smact14":
+    if oxidation_states_set is None:
+        ox_filter = ICSD24OxStatesFilter()
+        filtered_df = ox_filter.filter(consensus=consensus, include_zero=include_zero, commonality=commonality)
+        oxidation_dict = {
+            row["element"]: [int(x) for x in row["oxidation_state"].split()] for _, row in filtered_df.iterrows()
+        }
+        ox_combos = []
+        for el in smact_elems:
+            ox_el = oxidation_dict.get(el.symbol, None)
+            if ox_el is not None:
+                ox_combos.append(ox_el)
+            else:
+                return False
+    elif oxidation_states_set == "smact14":
         ox_combos = [el.oxidation_states_smact14 for el in smact_elems]
     elif oxidation_states_set == "icsd16":
         ox_combos = [el.oxidation_states_icsd16 for el in smact_elems]

{smact-3.1.0 → smact-3.2.0}/smact/tests/test_utils.py

@@ -133,6 +133,33 @@ class TestCrystalSpace(unittest.TestCase):
                 # Clean up
                 shutil.rmtree("data")
 
+    def test_generate_composition_with_smact_custom(self):
+        save_dir = "data/binary/df_binary_label.pkl"
+        oxidation_states_sets = ["smact14", "icsd24"]
+        oxidation_states_sets_dict = {
+            "smact14": {"smact_allowed": 388},
+            "icsd24": {"smact_allowed": 342},
+        }
+        for ox_states in oxidation_states_sets:
+            with self.subTest(ox_states=ox_states):
+                smact_df = generate_composition_with_smact.generate_composition_with_smact_custom(
+                    num_elements=2,
+                    max_stoich=3,
+                    max_atomic_num=20,
+                    save_path=save_dir,
+                    oxidation_states_set=ox_states,
+                )
+                self.assertIsInstance(smact_df, pd.DataFrame)
+                self.assertTrue(len(smact_df) == 1330)
+                self.assertTrue(
+                    smact_df["smact_allowed"].sum() == oxidation_states_sets_dict[ox_states]["smact_allowed"]
+                )
+                # Check if the data was saved to disk
+                self.assertTrue(os.path.exists(save_dir))
+
+                # Clean up
+                shutil.rmtree("data")
+
     @pytest.mark.skipif(
         (
             sys.platform == "win32"

{smact-3.1.0 → smact-3.2.0}/smact/utils/crystal_space/generate_composition_with_smact.py

@@ -13,6 +13,7 @@ from pymatgen.core import Composition
 from tqdm import tqdm
 
 from smact import Element, ordered_elements
+from smact.data_loader import lookup_element_oxidation_states_custom
 from smact.screening import smact_filter
 
 warnings.simplefilter(action="ignore", category=UserWarning)
@@ -56,7 +57,7 @@ def generate_composition_with_smact(
         max_atomic_num (int): the maximum atomic number. Defaults to 103.
         num_processes (int): the number of processes to use. Defaults to None.
         save_path (str): the path to save the results. Defaults to None.
-        oxidation_states_set (str): the oxidation states set to use. Options are "smact14", "icsd16", "icsd24", "pymatgen_sp" or a filepath to a custom oxidation states list. For reproducing the Faraday Discussions results, use "smact14".
+        oxidation_states_set (str): the oxidation states set to use. Options are "smact14", "icsd16", "icsd24", "pymatgen_sp". For reproducing the Faraday Discussions results, use "smact14". For custom oxidation states lists check generate_composition_with_smact_custom below.
 
     Returns:
         df (pd.DataFrame): A DataFrame of SMACT-generated compositions with boolean smact_allowed column.
@@ -142,3 +143,115 @@ def generate_composition_with_smact(
         print(f"Saved to {save_path}")
 
     return df
+
+
+def generate_composition_with_smact_custom(
+    num_elements: int = 2,
+    max_stoich: int = 8,
+    max_atomic_num: int = 103,
+    num_processes: int | None = None,
+    save_path: str | None = None,
+    oxidation_states_set: str | None = None,
+) -> pd.DataFrame:
+    """
+    Generate all possible compositions of a given number of elements and
+    filter them with SMACT.
+
+    Args:
+        num_elements (int): the number of elements in a compound. Defaults to 2.
+        max_stoich (int): the maximum stoichiometric coefficient. Defaults to 8.
+        max_atomic_num (int): the maximum atomic number. Defaults to 103.
+        num_processes (int): the number of processes to use. Defaults to None.
+        save_path (str): the path to save the results. Defaults to None.
+        oxidation_states_set (str): the path to the oxidation states file. Defaults to None.
+
+    Returns:
+        df (pd.DataFrame): A DataFrame of SMACT-generated compositions with boolean smact_allowed column.
+
+    """
+    # 1. generate all possible combinations of elements
+    print("#1. Generating all possible combinations of elements...")
+
+    elements = [Element(element) for element in ordered_elements(1, max_atomic_num)]
+    combinations = list(itertools.combinations(elements, num_elements))
+    print(f"Number of generated combinations: {len(combinations)}")
+
+    # 2. generate all possible stoichiometric combinations
+    print("#2. Generating all possible stoichiometric combinations...")
+
+    pool = multiprocessing.Pool(processes=(multiprocessing.cpu_count() if num_processes is None else num_processes))
+    compounds = list(
+        tqdm(
+            pool.imap_unordered(
+                partial(
+                    convert_formula,
+                    num_elements=num_elements,
+                    max_stoich=max_stoich,
+                ),
+                combinations,
+            ),
+            total=len(combinations),
+        )
+    )
+
+    pool.close()
+    pool.join()
+    # Flatten the list of lists into a single list
+    compounds = [item for sublist in compounds for item in sublist]
+
+    print(f"Number of generated compounds: {len(compounds)}")
+    compounds = list(set(compounds))
+    print(f"Number of generated compounds (unique): {len(compounds)}")
+
+    # 3. filter compounds with smact
+    print("#3. Filtering compounds with SMACT...")
+
+    ox_states_custom = lookup_element_oxidation_states_custom("all", oxidation_states_set, copy=False)
+    elements_pauling = [
+        Element(element)
+        for element in ordered_elements(1, max_atomic_num)
+        if element in ox_states_custom
+        and Element(element).pauling_eneg is not None
+        and Element(element).pauling_eneg >= Element("Fr").pauling_eneg
+    ]
+    compounds_pauling = list(itertools.combinations(elements_pauling, num_elements))
+
+    pool = multiprocessing.Pool(processes=(multiprocessing.cpu_count() if num_processes is None else num_processes))
+    results = list(
+        tqdm(
+            pool.imap_unordered(
+                partial(
+                    smact_filter,
+                    threshold=max_stoich,
+                    oxidation_states_set=oxidation_states_set,
+                ),
+                compounds_pauling,
+            ),
+            total=len(compounds_pauling),
+        )
+    )
+    pool.close()
+    pool.join()
+
+    # 4. make data frame of results
+    print("#4. Making data frame of results...")
+    # make dataframework with index is compound and columns are boolean smact results
+    smact_allowed = []
+
+    for result in results:
+        for res in result:
+            symbols_stoich = zip(res[0], res[2], strict=False)
+            composition_dict = dict(symbols_stoich)
+            smact_allowed.append(Composition(composition_dict).reduced_formula)
+    smact_allowed = list(set(smact_allowed))
+    print(f"Number of compounds allowed by SMACT: {len(smact_allowed)}")
+
+    df = pd.DataFrame(data=False, index=compounds, columns=["smact_allowed"])
+    df.loc[smact_allowed, "smact_allowed"] = True
+
+    if save_path is not None:
+        Path(save_path).parent.mkdir(parents=True, exist_ok=True)
+        df.to_pickle(save_path)
+        print(f"Saved to {save_path}")
+
+    return df

{smact-3.1.0 → smact-3.2.0}/smact/utils/oxidation.py

@@ -136,6 +136,7 @@ class ICSD24OxStatesFilter:
             species_occurrences_df = self.ox_states_df[self.ox_states_df["oxidation_state"] != 0].reset_index(drop=True)
         else:
             species_occurrences_df = self.ox_states_df
+
         species_occurrences_df = species_occurrences_df[
             (species_occurrences_df.results_count >= consensus)
         ].reset_index(drop=True)
@@ -185,7 +186,6 @@ class ICSD24OxStatesFilter:
                 final_summary.append(f"{element} {oxidation_states}".strip())
             else:
                 final_summary.append(element)
-
         # Write the filtered oxidation states list to a txt file
         if not filename.endswith(".txt"):
             filename += ".txt"