structuretoolkit 0.0.35__tar.gz → 0.0.37__tar.gz

{structuretoolkit-0.0.35 → structuretoolkit-0.0.37}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: structuretoolkit
-Version: 0.0.35
+Version: 0.0.37
 Summary: build, analyse and visualise atomistic structures for materials science
 Project-URL: Homepage, https://github.com/pyiron/structuretoolkit
 Project-URL: Documentation, https://github.com/pyiron/structuretoolkit
@@ -41,37 +41,35 @@ Classifier: Development Status :: 5 - Production/Stable
 Classifier: Intended Audience :: Science/Research
 Classifier: License :: OSI Approved :: BSD License
 Classifier: Operating System :: OS Independent
-Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
 Classifier: Topic :: Scientific/Engineering :: Physics
-Requires-Python: <3.13,>=3.9
+Requires-Python: <3.14,>=3.10
 Requires-Dist: ase<=3.26.0,>=3.20.1
-Requires-Dist: numpy<=2.3.3,>=1.23.5
-Requires-Dist: scipy<=1.16.2,>=1.9.3
+Requires-Dist: numpy<=2.3.4,>=1.23.5
+Requires-Dist: scipy<=1.16.3,>=1.15.0
 Provides-Extra: clusters
-Requires-Dist: scikit-learn==1.6.1; extra == 'clusters'
+Requires-Dist: scikit-learn==1.7.2; extra == 'clusters'
 Provides-Extra: dscribe
 Requires-Dist: dscribe==2.1.2; extra == 'dscribe'
 Provides-Extra: grainboundary
 Requires-Dist: aimsgb<=1.1.1,>=1.0.2; extra == 'grainboundary'
-Requires-Dist: pymatgen<=2025.3.10,>=2022.2.1; extra == 'grainboundary'
+Requires-Dist: pymatgen<=2025.6.14,>=2022.2.1; extra == 'grainboundary'
 Provides-Extra: matplotlib
-Requires-Dist: matplotlib==3.10.3; extra == 'matplotlib'
+Requires-Dist: matplotlib==3.10.7; extra == 'matplotlib'
 Provides-Extra: nglview
 Requires-Dist: nglview<=3.1.4,>=2.7.7; extra == 'nglview'
 Provides-Extra: phonopy
-Requires-Dist: phonopy<=2.43.2,>=2.16.2; extra == 'phonopy'
+Requires-Dist: phonopy<=2.43.6,>=2.16.2; extra == 'phonopy'
 Requires-Dist: spglib<=2.6.0,>=1.16.5; extra == 'phonopy'
 Provides-Extra: plotly
-Requires-Dist: plotly<=6.3.0,>=4.14.3; extra == 'plotly'
+Requires-Dist: plotly<=6.3.1,>=4.14.3; extra == 'plotly'
 Provides-Extra: pyscal
 Requires-Dist: pyscal3<=3.3.0,>=3.2.5; extra == 'pyscal'
-Provides-Extra: pyxtal
-Requires-Dist: pyxtal<=1.1.1,>=0.5.5; extra == 'pyxtal'
 Provides-Extra: surface
-Requires-Dist: pymatgen<=2025.3.10,>=2022.2.1; extra == 'surface'
+Requires-Dist: pymatgen<=2025.6.14,>=2022.2.1; extra == 'surface'
 Requires-Dist: spglib<=2.6.0,>=1.16.5; extra == 'surface'
 Provides-Extra: symmetry
 Requires-Dist: spglib<=2.6.0,>=1.16.5; extra == 'symmetry'
@@ -127,7 +125,6 @@ stk.plot3d(structure)
 * `stk.build.high_index_surface()`
 * `stk.build.get_high_index_surface_info()`
 * `stk.build.sqs_structures()`
-* `stk.build.pyxtal()`
 * `stk.build.B2()`
 * `stk.build.C14()`
 * `stk.build.C15()`

{structuretoolkit-0.0.35 → structuretoolkit-0.0.37}/README.md

@@ -48,7 +48,6 @@ stk.plot3d(structure)
 * `stk.build.high_index_surface()`
 * `stk.build.get_high_index_surface_info()`
 * `stk.build.sqs_structures()`
-* `stk.build.pyxtal()`
 * `stk.build.B2()`
 * `stk.build.C14()`
 * `stk.build.C15()`

{structuretoolkit-0.0.35 → structuretoolkit-0.0.37}/pyproject.toml

@@ -11,22 +11,22 @@ authors = [
 readme = "README.md"
 license = { file = "LICENSE" }
 keywords = ["pyiron"]
-requires-python = ">=3.9, <3.13"
+requires-python = ">=3.10, <3.14"
 classifiers = [
     "Development Status :: 5 - Production/Stable",
     "Topic :: Scientific/Engineering :: Physics",
     "License :: OSI Approved :: BSD License",
     "Intended Audience :: Science/Research",
     "Operating System :: OS Independent",
-    "Programming Language :: Python :: 3.9",
     "Programming Language :: Python :: 3.10",
     "Programming Language :: Python :: 3.11",
     "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
 ]
 dependencies = [
     "ase>=3.20.1,<=3.26.0",
-    "numpy>=1.23.5,<=2.3.3",
-    "scipy>=1.9.3,<=1.16.2",
+    "numpy>=1.23.5,<=2.3.4",
+    "scipy>=1.15.0,<=1.16.3",
 ]
 dynamic = ["version"]
 
@@ -39,23 +39,22 @@ Repository = "https://github.com/pyiron/structuretoolkit"
 dscribe = ["dscribe==2.1.2"]
 grainboundary = [
     "aimsgb>=1.0.2,<=1.1.1",
-    "pymatgen>=2022.2.1,<=2025.3.10",
+    "pymatgen>=2022.2.1,<=2025.6.14",
 ]
 pyscal = ["pyscal3>=3.2.5,<=3.3.0"]
 nglview = ["nglview>=2.7.7,<=3.1.4"]
-matplotlib = ["matplotlib==3.10.3"]
-plotly = ["plotly>=4.14.3,<=6.3.0"]
-clusters = ["scikit-learn==1.6.1"]
+matplotlib = ["matplotlib==3.10.7"]
+plotly = ["plotly>=4.14.3,<=6.3.1"]
+clusters = ["scikit-learn==1.7.2"]
 symmetry = ["spglib>=1.16.5,<=2.6.0"]
 surface = [
     "spglib>=1.16.5,<=2.6.0",
-    "pymatgen>=2022.2.1,<=2025.3.10",
+    "pymatgen>=2022.2.1,<=2025.6.14",
 ]
 phonopy = [
-    "phonopy>=2.16.2,<=2.43.2",
+    "phonopy>=2.16.2,<=2.43.6",
     "spglib>=1.16.5,<=2.6.0",
 ]
-pyxtal = ["pyxtal>=0.5.5,<=1.1.1"]
 
 [tool.ruff]
 exclude = [".ci_support", "tests", "setup.py", "_version.py"]

{structuretoolkit-0.0.35 → structuretoolkit-0.0.37}/structuretoolkit/_version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '0.0.35'
-__version_tuple__ = version_tuple = (0, 0, 35)
+__version__ = version = '0.0.37'
+__version_tuple__ = version_tuple = (0, 0, 37)
 
 __commit_id__ = commit_id = None

{structuretoolkit-0.0.35 → structuretoolkit-0.0.37}/structuretoolkit/analyse/distance.py

@@ -1,13 +1,11 @@
-from typing import Optional
-
 import numpy as np
 from ase.atoms import Atoms
 
 
 def get_distances_array(
     structure: Atoms,
-    p1: Optional[np.ndarray] = None,
-    p2: Optional[np.ndarray] = None,
+    p1: np.ndarray | None = None,
+    p2: np.ndarray | None = None,
     mic: bool = True,
     vectors: bool = False,
 ) -> np.ndarray:

{structuretoolkit-0.0.35 → structuretoolkit-0.0.37}/structuretoolkit/analyse/dscribe.py

@@ -1,24 +1,22 @@
-from typing import Optional
-
 import numpy as np
 from ase.atoms import Atoms
 
 
 def soap_descriptor_per_atom(
     structure: Atoms,
-    r_cut: Optional[float] = None,
-    n_max: Optional[int] = None,
-    l_max: Optional[int] = None,
-    sigma: Optional[float] = 1.0,
+    r_cut: float | None = None,
+    n_max: int | None = None,
+    l_max: int | None = None,
+    sigma: float | None = 1.0,
     rbf: str = "gto",
-    weighting: Optional[np.ndarray] = None,
+    weighting: np.ndarray | None = None,
     average: str = "off",
     compression: dict = None,
-    species: Optional[list] = None,
+    species: list | None = None,
     periodic: bool = True,
     sparse: bool = False,
     dtype: str = "float64",
-    centers: Optional[np.ndarray] = None,
+    centers: np.ndarray | None = None,
     n_jobs: int = 1,
     only_physical_cores: bool = False,
     verbose: bool = False,

{structuretoolkit-0.0.35 → structuretoolkit-0.0.37}/structuretoolkit/analyse/neighbors.py

@@ -3,14 +3,13 @@
 
 import itertools
 import warnings
-from typing import Optional, Union
 
 import numpy as np
 from ase.atoms import Atoms
 from scipy.sparse import coo_matrix
 from scipy.spatial import cKDTree
 from scipy.spatial.transform import Rotation
-from scipy.special import gamma, sph_harm
+from scipy.special import gamma, sph_harm_y
 
 from structuretoolkit.common.helper import (
     get_average_of_unique_labels,
@@ -149,8 +148,8 @@ class Tree:
     def _reshape(
         self,
         value: np.ndarray,
-        key: Optional[str] = None,
-        ref_vector: Optional[np.ndarray] = None,
+        key: str | None = None,
+        ref_vector: np.ndarray | None = None,
     ) -> np.ndarray:
         """
         Reshape the given value based on the specified key and reference vector.
@@ -258,7 +257,7 @@ class Tree:
             + " with the correct norm_order value"
         )
 
-    def _get_max_length(self, ref_vector: Optional[np.ndarray] = None) -> int:
+    def _get_max_length(self, ref_vector: np.ndarray | None = None) -> int:
         """
         Get the maximum length of the reference vector.
 
@@ -279,7 +278,7 @@ class Tree:
         return max(len(dd[dd < np.inf]) for dd in ref_vector)
 
     def _contract(
-        self, value: np.ndarray, ref_vector: Optional[np.ndarray] = None
+        self, value: np.ndarray, ref_vector: np.ndarray | None = None
     ) -> np.ndarray:
         """
         Contract the given value based on the specified reference vector.
@@ -295,7 +294,7 @@ class Tree:
             return value
         return [
             vv[: np.sum(dist < np.inf)]
-            for vv, dist in zip(value, self.filled.distances)
+            for vv, dist in zip(value, self.filled.distances, strict=True)
         ]
 
     def _allow_ragged_to_mode(self, new_bool: bool) -> str:
@@ -362,7 +361,7 @@ class Tree:
     def _get_distances_and_indices(
         self,
         positions: np.ndarray,
-        num_neighbors: Optional[int] = None,
+        num_neighbors: int | None = None,
         cutoff_radius: float = np.inf,
         width_buffer: float = 1.2,
     ) -> tuple[np.ndarray, np.ndarray]:
@@ -431,10 +430,10 @@ class Tree:
     def _get_vectors(
         self,
         positions: np.ndarray,
-        num_neighbors: Optional[int] = None,
+        num_neighbors: int | None = None,
         cutoff_radius: float = np.inf,
-        distances: Optional[np.ndarray] = None,
-        indices: Optional[np.ndarray] = None,
+        distances: np.ndarray | None = None,
+        indices: np.ndarray | None = None,
         width_buffer: float = 1.2,
     ) -> np.ndarray:
         """
@@ -470,7 +469,7 @@ class Tree:
 
     def _estimate_num_neighbors(
         self,
-        num_neighbors: Optional[int] = None,
+        num_neighbors: int | None = None,
         cutoff_radius: float = np.inf,
         width_buffer: float = 1.2,
     ) -> int:
@@ -515,7 +514,7 @@ class Tree:
 
     def _estimate_width(
         self,
-        num_neighbors: Optional[int] = None,
+        num_neighbors: int | None = None,
         cutoff_radius: float = np.inf,
         width_buffer: float = 1.2,
     ) -> float:
@@ -551,7 +550,7 @@ class Tree:
     def get_neighborhood(
         self,
         positions: np.ndarray,
-        num_neighbors: Optional[int] = None,
+        num_neighbors: int | None = None,
         cutoff_radius: float = np.inf,
         width_buffer: float = 1.2,
     ) -> "Tree":
@@ -647,7 +646,7 @@ class Tree:
         l: np.ndarray,
         m: np.ndarray,
         cutoff_radius: float = np.inf,
-        rotation: Optional[np.ndarray] = None,
+        rotation: np.ndarray | None = None,
     ) -> np.ndarray:
         """
         Args:
@@ -668,7 +667,7 @@ class Tree:
         The angles are calculated based on `self.vecs`, where the azimuthal angle is defined on the
         xy-plane and the polar angle is along the z-axis.
 
-        See more on: scipy.special.sph_harm
+        See more on: scipy.special.sph_harm_y
 
         """
         vecs = self.filled.vecs
@@ -685,7 +684,7 @@ class Tree:
         phi[within_cutoff] = np.arctan2(
             np.linalg.norm(vecs[within_cutoff, :2], axis=-1), vecs[within_cutoff, 2]
         )
-        return np.sum(sph_harm(m, l, theta, phi) * within_cutoff, axis=-1) / np.sum(
+        return np.sum(sph_harm_y(l, m, phi, theta) * within_cutoff, axis=-1) / np.sum(
             within_cutoff, axis=-1
         )
 
@@ -868,8 +867,8 @@ class Neighbors(Tree):
 
     def get_local_shells(
         self,
-        mode: Optional[str] = None,
-        tolerance: Optional[int] = None,
+        mode: str | None = None,
+        tolerance: int | None = None,
         cluster_by_distances: bool = False,
         cluster_by_vecs: bool = False,
     ) -> np.ndarray:
@@ -947,8 +946,8 @@ class Neighbors(Tree):
 
     def get_global_shells(
         self,
-        mode: Optional[str] = None,
-        tolerance: Optional[int] = None,
+        mode: str | None = None,
+        tolerance: int | None = None,
         cluster_by_distances: bool = False,
         cluster_by_vecs: bool = False,
     ) -> np.ndarray:
@@ -1008,7 +1007,7 @@ class Neighbors(Tree):
 
     def get_shell_matrix(
         self,
-        chemical_pair: Optional[list[str]] = None,
+        chemical_pair: list[str] | None = None,
         cluster_by_distances: bool = False,
         cluster_by_vecs: bool = False,
     ):
@@ -1107,8 +1106,8 @@ class Neighbors(Tree):
 
     def cluster_by_vecs(
         self,
-        distance_threshold: Optional[float] = None,
-        n_clusters: Optional[int] = None,
+        distance_threshold: float | None = None,
+        n_clusters: int | None = None,
         linkage: str = "complete",
         metric: str = "euclidean",
     ):
@@ -1152,8 +1151,8 @@ class Neighbors(Tree):
 
     def cluster_by_distances(
         self,
-        distance_threshold: Optional[float] = None,
-        n_clusters: Optional[int] = None,
+        distance_threshold: float | None = None,
+        n_clusters: int | None = None,
         linkage: str = "complete",
         metric: str = "euclidean",
         use_vecs: bool = False,
@@ -1225,7 +1224,7 @@ class Neighbors(Tree):
 
     def cluster_analysis(
         self, id_list: list, return_cluster_sizes: bool = False
-    ) -> Union[dict[int, list[int]], tuple[dict[int, list[int]], list[int]]]:
+    ) -> dict[int, list[int]] | tuple[dict[int, list[int]], list[int]]:
         """
         Perform cluster analysis on a list of atom IDs.
 
@@ -1283,7 +1282,7 @@ class Neighbors(Tree):
     def get_bonds(
         self,
         radius: float = np.inf,
-        max_shells: Optional[int] = None,
+        max_shells: int | None = None,
         prec: float = 0.1,
     ) -> list[dict[str, list[list[int]]]]:
         """
@@ -1322,7 +1321,7 @@ class Neighbors(Tree):
         el_list = self._ref_structure.get_chemical_symbols()
 
         ind_shell = []
-        for d, i in zip(dist, ind):
+        for d, i in zip(dist, ind, strict=True):
             id_list = get_cluster(d[d < radius], i[d < radius])
             ia_shells_dict = {}
             for i_shell_list in id_list:
@@ -1361,7 +1360,7 @@ def get_neighbors(
     structure: Atoms,
     num_neighbors: int = 12,
     tolerance: int = 2,
-    id_list: Optional[list] = None,
+    id_list: list | None = None,
     cutoff_radius: float = np.inf,
     width_buffer: float = 1.2,
     mode: str = "filled",
@@ -1400,12 +1399,12 @@ def _get_neighbors(
     structure: Atoms,
     num_neighbors: int = 12,
     tolerance: int = 2,
-    id_list: Optional[list] = None,
+    id_list: list | None = None,
     cutoff_radius: float = np.inf,
     width_buffer: float = 1.2,
     get_tree: bool = False,
     norm_order: int = 2,
-) -> Union[Neighbors, Tree]:
+) -> Neighbors | Tree:
     """
     Get the neighbors of atoms in a structure.
 

{structuretoolkit-0.0.35 → structuretoolkit-0.0.37}/structuretoolkit/analyse/pyscal.py

@@ -1,7 +1,7 @@
 # Copyright (c) Max-Planck-Institut für Eisenforschung GmbH - Computational Materials Design (CM) Department
 # Distributed under the terms of "New BSD License", see the LICENSE file.
 
-from typing import Any, Optional, Union
+from typing import Any
 
 import numpy as np
 from ase.atoms import Atoms
@@ -24,10 +24,10 @@ def get_steinhardt_parameters(
     structure: Atoms,
     neighbor_method: str = "cutoff",
     cutoff: float = 0.0,
-    n_clusters: Optional[int] = 2,
-    q: Optional[tuple] = None,
+    n_clusters: int | None = 2,
+    q: tuple | None = None,
     averaged: bool = False,
-) -> Union[tuple[np.ndarray], tuple[np.ndarray, np.ndarray]]:
+) -> tuple[np.ndarray] | tuple[np.ndarray, np.ndarray]:
     """
     Calculate Steinhardts parameters
 
@@ -55,7 +55,7 @@ def get_steinhardt_parameters(
 
         cl = cluster.KMeans(n_clusters=n_clusters)
 
-        ind = cl.fit(list(zip(*sysq))).labels_
+        ind = cl.fit(list(zip(*sysq, strict=True))).labels_
         return sysq, ind
     else:
         return sysq
@@ -80,7 +80,7 @@ def get_centro_symmetry_descriptors(
 
 def get_diamond_structure_descriptors(
     structure: Atoms, mode: str = "total", ovito_compatibility: bool = False
-) -> Union[dict[str, int], np.ndarray]:
+) -> dict[str, int] | np.ndarray:
     """
     Analyse diamond structure
 
@@ -197,7 +197,10 @@ def get_adaptive_cna_descriptors(
         if not ovito_compatibility:
             return cna
         else:
-            return {o: cna[p] for o, p in zip(ovito_parameter, pyscal_parameter)}
+            return {
+                o: cna[p]
+                for o, p in zip(ovito_parameter, pyscal_parameter, strict=True)
+            }
     else:
         cnalist = np.array(sys.atoms.structure)
         if mode == "numeric":
@@ -241,7 +244,7 @@ def find_solids(
     q: int = 6,
     right: bool = True,
     return_sys: bool = False,
-) -> Union[int, Any]:
+) -> int | Any:
     """
     Get the number of solids or the corresponding pyscal system.
     Calls necessary pyscal methods as described in https://pyscal.org/en/latest/methods/03_solidliquid.html.

{structuretoolkit-0.0.35 → structuretoolkit-0.0.37}/structuretoolkit/analyse/snap.py

@@ -1,5 +1,4 @@
 from ctypes import POINTER, c_double, c_int, cast
-from typing import Optional, Union
 
 import numpy as np
 from ase.atoms import Atoms
@@ -70,7 +69,7 @@ def get_snap_descriptors_per_atom(
     rmin0: float = 0.0,
     bzeroflag: bool = False,
     quadraticflag: bool = False,
-    weights: Optional[Union[list, np.ndarray]] = None,
+    weights: list | np.ndarray | None = None,
     cutoff: float = 10.0,
 ) -> np.ndarray:
     """
@@ -121,7 +120,7 @@ def get_snap_descriptor_derivatives(
     rmin0: float = 0.0,
     bzeroflag: bool = False,
     quadraticflag: bool = False,
-    weights: Optional[Union[list, np.ndarray]] = None,
+    weights: list | np.ndarray | None = None,
     cutoff: float = 10.0,
 ):
     """
@@ -525,7 +524,7 @@ def _set_computes_snap(lmp, bispec_options: dict):
     kw_substrings = [f"{k} {v}" for k, v in kw_options.items()]
     kwargs = " ".join(kw_substrings)
 
-    for _op, base in zip(("b", "db", "vb"), (base_b, base_db, base_vb)):
+    for _op, base in zip(("b", "db", "vb"), (base_b, base_db, base_vb), strict=True):
         command = f"{base} {radelem} {wj} {kwargs}"
         lmp.command(command)
 
@@ -659,7 +658,7 @@ def _get_default_parameters(
     rmin0: float = 0.0,
     bzeroflag: bool = False,
     quadraticflag: bool = False,
-    weights: Optional[Union[list, np.ndarray]] = None,
+    weights: list | np.ndarray | None = None,
     cutoff: float = 10.0,
 ):
     """

{structuretoolkit-0.0.35 → structuretoolkit-0.0.37}/structuretoolkit/analyse/spatial.py

@@ -1,7 +1,7 @@
 # Copyright (c) Max-Planck-Institut für Eisenforschung GmbH - Computational Materials Design (CM) Department
 # Distributed under the terms of "New BSD License", see the LICENSE file.
 
-from typing import Callable, Optional
+from collections.abc import Callable
 
 import numpy as np
 from ase.atoms import Atoms
@@ -225,7 +225,7 @@ class Interstitials:
         l_values: np.ndarray = np.arange(2, 13),
         q_eps: float = 0.3,
         var_ratio: float = 5.0,
-        min_samples: Optional[int] = None,
+        min_samples: int | None = None,
         neigh_args: dict = None,
         **kwargs,
     ):
@@ -294,7 +294,7 @@ class Interstitials:
         self.structure = structure
 
     def run_workflow(
-        self, positions: Optional[np.ndarray] = None, steps: int = -1
+        self, positions: np.ndarray | None = None, steps: int = -1
     ) -> np.ndarray:
         """
         Run the workflow to obtain the interstitial positions.
@@ -407,7 +407,7 @@ def get_interstitials(
     l_values: np.ndarray = np.arange(2, 13),
     q_eps: float = 0.3,
     var_ratio: float = 5.0,
-    min_samples: Optional[int] = None,
+    min_samples: int | None = None,
     neigh_args: dict = None,
     **kwargs,
 ) -> Interstitials:
@@ -457,7 +457,7 @@ get_interstitials.__doc__ = (
 def get_layers(
     structure: Atoms,
     distance_threshold: float = 0.01,
-    id_list: Optional[list[int]] = None,
+    id_list: list[int] | None = None,
     wrap_atoms: bool = True,
     planes: np.ndarray = None,
     cluster_method: str = None,
@@ -690,9 +690,9 @@ def get_delaunay_neighbors(structure: Atoms, width_buffer: float = 10.0) -> np.n
 
 def get_cluster_positions(
     structure: Atoms,
-    positions: Optional[np.ndarray] = None,
+    positions: np.ndarray | None = None,
     eps: float = 1.0,
-    buffer_width: Optional[float] = None,
+    buffer_width: float | None = None,
     return_labels: bool = False,
 ) -> np.ndarray:
     """

{structuretoolkit-0.0.35 → structuretoolkit-0.0.37}/structuretoolkit/analyse/strain.py

@@ -1,5 +1,3 @@
-from typing import Optional
-
 import numpy as np
 from ase.atoms import Atoms
 from scipy.spatial.transform import Rotation
@@ -30,7 +28,7 @@ class Strain:
         self,
         structure: Atoms,
         ref_structure: Atoms,
-        num_neighbors: Optional[int] = None,
+        num_neighbors: int | None = None,
         only_bulk_type: bool = False,
     ):
         """
@@ -85,7 +83,7 @@ class Strain:
         )
 
     def _get_perpendicular_unit_vectors(
-        self, vec: np.ndarray, vec_axis: Optional[np.ndarray] = None
+        self, vec: np.ndarray, vec_axis: np.ndarray | None = None
     ) -> np.ndarray:
         """
         Get the perpendicular unit vectors of the given vectors.
@@ -146,7 +144,7 @@ class Strain:
         self,
         vec_before: np.ndarray,
         vec_after: np.ndarray,
-        vec_axis: Optional[np.ndarray] = None,
+        vec_axis: np.ndarray | None = None,
     ) -> np.ndarray:
         """
         Calculate the rotation matrix that transforms the `vec_before` vectors to the `vec_after` vectors.
@@ -319,7 +317,7 @@ class Strain:
 def get_strain(
     structure: Atoms,
     ref_structure: Atoms,
-    num_neighbors: Optional[int] = None,
+    num_neighbors: int | None = None,
     only_bulk_type: bool = False,
     return_object: bool = False,
 ):

{structuretoolkit-0.0.35 → structuretoolkit-0.0.37}/structuretoolkit/analyse/symmetry.py

@@ -4,7 +4,6 @@
 import ast
 import dataclasses
 import string
-from typing import Optional
 
 import numpy as np
 import spglib
@@ -263,7 +262,7 @@ class Symmetry(dict):
         ) / len(self.rotations)
 
     def _get_spglib_cell(
-        self, use_elements: Optional[bool] = None, use_magmoms: Optional[bool] = None
+        self, use_elements: bool | None = None, use_magmoms: bool | None = None
     ) -> tuple:
         """
         Get the cell information in the format required by spglib.
@@ -380,8 +379,8 @@ class Symmetry(dict):
     def get_primitive_cell(
         self,
         standardize: bool = False,
-        use_elements: Optional[bool] = None,
-        use_magmoms: Optional[bool] = None,
+        use_elements: bool | None = None,
+        use_magmoms: bool | None = None,
     ) -> Atoms:
         """
         Get primitive cell of a given structure.

{structuretoolkit-0.0.35 → structuretoolkit-0.0.37}/structuretoolkit/build/__init__.py

@@ -1,7 +1,6 @@
 from structuretoolkit.build.aimsgb import get_grainboundary_info, grainboundary
 from structuretoolkit.build.compound import B2, C14, C15, C36, D03
 from structuretoolkit.build.mesh import create_mesh
-from structuretoolkit.build.random import pyxtal
 from structuretoolkit.build.sqs import sqs_structures
 from structuretoolkit.build.surface import (
     get_high_index_surface_info,
@@ -17,7 +16,6 @@ __all__ = [
     "C36",
     "D03",
     "create_mesh",
-    "pyxtal",
     "sqs_structures",
     "get_high_index_surface_info",
     "high_index_surface",

{structuretoolkit-0.0.35 → structuretoolkit-0.0.37}/structuretoolkit/build/aimsgb.py

@@ -1,7 +1,6 @@
 # Copyright (c) Max-Planck-Institut für Eisenforschung GmbH - Computational Materials Design (CM) Department
 # Distributed under the terms of "New BSD License", see the LICENSE file.
 
-from typing import Optional
 from warnings import warn
 
 import numpy as np
@@ -59,7 +58,7 @@ def grainboundary(
     delete_layer: str = "0b0t0b0t",
     tol: float = 0.25,
     to_primitive: bool = False,
-    add_if_dist: Optional[float] = None,
+    add_if_dist: float | None = None,
 ):
     """
     Generate a grain boundary structure based on aimsgb.

{structuretoolkit-0.0.35 → structuretoolkit-0.0.37}/structuretoolkit/build/compound.py

@@ -1,5 +1,3 @@
-from typing import Optional
-
 import numpy as np
 from ase.atoms import Atoms
 from ase.build import bulk
@@ -8,7 +6,7 @@ from ase.spacegroup import crystal
 from structuretoolkit.analyse.neighbors import get_neighbors
 
 
-def B2(element_a: str, element_b: str, a: Optional[float] = None):
+def B2(element_a: str, element_b: str, a: float | None = None):
     """
     Builds a cubic $AB$ B2 structure of interpenetrating simple cubic lattices.
 
@@ -33,7 +31,7 @@ def B2(element_a: str, element_b: str, a: Optional[float] = None):
 def C14(
     element_a: str,
     element_b: str,
-    a: Optional[float] = None,
+    a: float | None = None,
     c_over_a: float = 1.626,
     x1: float = 0.1697,
     z1: float = 0.5629,
@@ -83,7 +81,7 @@ def C14(
     return s
 
 
-def C15(element_a: str, element_b: str, a: Optional[float] = None) -> Atoms:
+def C15(element_a: str, element_b: str, a: float | None = None) -> Atoms:
     """
     Builds a cubic $A B_2$ C15 Laves phase cell.
 
@@ -125,7 +123,7 @@ def C15(element_a: str, element_b: str, a: Optional[float] = None) -> Atoms:
 def C36(
     element_a: str,
     element_b: str,
-    a: Optional[float] = None,
+    a: float | None = None,
     c_over_a: float = 3.252,
     x1: float = 0.16429,
     z1: float = 0.09400,
@@ -186,7 +184,7 @@ def C36(
     return s
 
 
-def D03(element_a: str, element_b: str, a: Optional[float] = None) -> Atoms:
+def D03(element_a: str, element_b: str, a: float | None = None) -> Atoms:
     """
     Builds a cubic $A B_3$ D03 cubic cell.
 

{structuretoolkit-0.0.35 → structuretoolkit-0.0.37}/structuretoolkit/build/sqs.py

@@ -3,7 +3,6 @@ import random
 import warnings
 from collections.abc import Iterable
 from multiprocessing import cpu_count
-from typing import Optional, Union
 
 import numpy as np
 from ase.atoms import Atoms
@@ -127,7 +126,7 @@ def remap_sro(species: Iterable[str], array: np.ndarray) -> dict[str, list]:
 
 
 def remap_sqs_results(
-    result: dict[str, Union[Atoms, np.ndarray]],
+    result: dict[str, Atoms | np.ndarray],
 ) -> tuple[Atoms, dict[str, list]]:
     """
     Remap the results of SQS optimization.
@@ -155,28 +154,28 @@ def transpose(it: Iterable[Iterable]) -> Iterable[tuple]:
         Iterable[tuple]: The transposed iterable.
 
     """
-    return zip(*it)
+    return zip(*it, strict=True)
 
 
 def sqs_structures(
     structure: Atoms,
-    mole_fractions: dict[str, Union[float, int]],
-    weights: Optional[dict[int, float]] = None,
-    objective: Union[float, np.ndarray] = 0.0,
-    iterations: Union[float, int] = 1e6,
+    mole_fractions: dict[str, float | int],
+    weights: dict[int, float] | None = None,
+    objective: float | np.ndarray = 0.0,
+    iterations: float | int = 1e6,
     output_structures: int = 10,
     mode: str = "random",
-    num_threads: Optional[int] = None,
-    prefactors: Optional[Union[float, np.ndarray]] = None,
-    pair_weights: Optional[np.ndarray] = None,
-    rtol: Optional[float] = None,
-    atol: Optional[float] = None,
-    which: Optional[Iterable[int]] = None,
-    shell_distances: Optional[Iterable[int]] = None,
-    minimal: Optional[bool] = True,
-    similar: Optional[bool] = True,
-    return_statistics: Optional[bool] = False,
-) -> Union[Atoms, tuple[Atoms, dict[str, list], int, float]]:
+    num_threads: int | None = None,
+    prefactors: float | np.ndarray | None = None,
+    pair_weights: np.ndarray | None = None,
+    rtol: float | None = None,
+    atol: float | None = None,
+    which: Iterable[int] | None = None,
+    shell_distances: Iterable[int] | None = None,
+    minimal: bool | None = True,
+    similar: bool | None = True,
+    return_statistics: bool | None = False,
+) -> Atoms | tuple[Atoms, dict[str, list], int, float]:
     """
     Generate SQS structures.
 

{structuretoolkit-0.0.35 → structuretoolkit-0.0.37}/structuretoolkit/build/surface.py

@@ -1,5 +1,3 @@
-from typing import Optional
-
 import numpy as np
 from ase.atoms import Atoms
 from ase.build import bulk, surface
@@ -12,10 +10,10 @@ def get_high_index_surface_info(
     element: str,
     crystal_structure: str,
     lattice_constant: float,
-    terrace_orientation: Optional[list] = None,
-    step_orientation: Optional[list] = None,
-    kink_orientation: Optional[list] = None,
-    step_down_vector: Optional[list] = None,
+    terrace_orientation: list | None = None,
+    step_orientation: list | None = None,
+    kink_orientation: list | None = None,
+    step_down_vector: list | None = None,
     length_step: int = 3,
     length_terrace: int = 3,
     length_kink: int = 1,
@@ -99,10 +97,10 @@ def high_index_surface(
     element: str,
     crystal_structure: str,
     lattice_constant: float,
-    terrace_orientation: Optional[list] = None,
-    step_orientation: Optional[list] = None,
-    kink_orientation: Optional[list] = None,
-    step_down_vector: Optional[list] = None,
+    terrace_orientation: list | None = None,
+    step_orientation: list | None = None,
+    kink_orientation: list | None = None,
+    step_down_vector: list | None = None,
     length_step: int = 3,
     length_terrace: int = 3,
     length_kink: int = 1,

{structuretoolkit-0.0.35 → structuretoolkit-0.0.37}/structuretoolkit/common/helper.py

@@ -1,5 +1,3 @@
-from typing import Optional, Union
-
 import numpy as np
 from ase.atoms import Atoms
 from scipy.sparse import coo_matrix
@@ -24,7 +22,7 @@ def get_extended_positions(
     width: float,
     return_indices: bool = False,
     norm_order: int = 2,
-    positions: Optional[np.ndarray] = None,
+    positions: np.ndarray | None = None,
 ):
     """
     Get all atoms in the boundary around the supercell which have a distance
@@ -276,7 +274,7 @@ def apply_strain(
         return structure_copy
 
 
-def get_cell(cell: Union[Atoms, list, tuple, np.ndarray, float]):
+def get_cell(cell: Atoms | list | tuple | np.ndarray | float):
     """
     Get cell of an ase structure, or convert a float or a (3,)-array into a
     orthogonal cell.

{structuretoolkit-0.0.35 → structuretoolkit-0.0.37}/structuretoolkit/common/phonopy.py

@@ -11,9 +11,9 @@ def phonopy_to_atoms(ph_atoms) -> Atoms:
 
     """
     return Atoms(
-        symbols=list(ph_atoms.get_chemical_symbols()),
-        positions=list(ph_atoms.get_positions()),
-        cell=list(ph_atoms.get_cell()),
+        symbols=list(ph_atoms.symbols),
+        positions=list(ph_atoms.positions),
+        cell=list(ph_atoms.cell),
         pbc=True,
     )
 

{structuretoolkit-0.0.35 → structuretoolkit-0.0.37}/structuretoolkit/visualize.py

@@ -2,7 +2,7 @@
 # Distributed under the terms of "New BSD License", see the LICENSE file.
 
 import warnings
-from typing import Any, Optional
+from typing import Any
 
 import numpy as np
 from ase.atoms import Atoms
@@ -30,21 +30,21 @@ def plot3d(
     camera: str = "orthographic",
     spacefill: bool = True,
     particle_size: float = 1.0,
-    select_atoms: Optional[np.ndarray] = None,
+    select_atoms: np.ndarray | None = None,
     background: str = "white",
-    color_scheme: Optional[str] = None,
-    colors: Optional[np.ndarray] = None,
-    scalar_field: Optional[np.ndarray] = None,
-    scalar_start: Optional[float] = None,
-    scalar_end: Optional[float] = None,
-    scalar_cmap: Optional[Any] = None,
-    vector_field: Optional[np.ndarray] = None,
-    vector_color: Optional[np.ndarray] = None,
+    color_scheme: str | None = None,
+    colors: np.ndarray | None = None,
+    scalar_field: np.ndarray | None = None,
+    scalar_start: float | None = None,
+    scalar_end: float | None = None,
+    scalar_cmap: Any | None = None,
+    vector_field: np.ndarray | None = None,
+    vector_color: np.ndarray | None = None,
     magnetic_moments: bool = False,
     view_plane: np.ndarray = np.array([0, 0, 1]),
     distance_from_camera: float = 1.0,
     opacity: float = 1.0,
-    height: Optional[float] = None,
+    height: float | None = None,
 ):
     """
     Plot3d relies on NGLView or plotly to visualize atomic structures. Here, we construct a string in the "protein database"
@@ -195,7 +195,7 @@ def _draw_box_plotly(fig: Any, structure: Atoms, px: Any, go: Any) -> Any:
     cell = get_cell(structure)
     data = fig.data
     for lines in _get_box_skeleton(cell):
-        fig = px.line_3d(**dict(zip(["x", "y", "z"], lines.T)))
+        fig = px.line_3d(**dict(zip(["x", "y", "z"], lines.T, strict=True)))
         fig.update_traces(line_color="#000000")
         data = fig.data + data
     return go.Figure(data=data)
@@ -204,14 +204,14 @@ def _draw_box_plotly(fig: Any, structure: Atoms, px: Any, go: Any) -> Any:
 def _plot3d_plotly(
     structure: Atoms,
     show_cell: bool = True,
-    scalar_field: Optional[np.ndarray] = None,
-    select_atoms: Optional[np.ndarray] = None,
+    scalar_field: np.ndarray | None = None,
+    select_atoms: np.ndarray | None = None,
     particle_size: float = 1.0,
     camera: str = "orthographic",
     view_plane: np.ndarray = np.array([1, 1, 1]),
     distance_from_camera: float = 1.0,
     opacity: float = 1.0,
-    height: Optional[float] = None,
+    height: float | None = None,
 ):
     """
     Make a 3D plot of the atomic structure.
@@ -284,16 +284,16 @@ def _plot3d(
     camera: str = "orthographic",
     spacefill: bool = True,
     particle_size: float = 1.0,
-    select_atoms: Optional[np.ndarray] = None,
+    select_atoms: np.ndarray | None = None,
     background: str = "white",
-    color_scheme: Optional[str] = None,
-    colors: Optional[np.ndarray] = None,
-    scalar_field: Optional[np.ndarray] = None,
-    scalar_start: Optional[float] = None,
-    scalar_end: Optional[float] = None,
-    scalar_cmap: Optional[Any] = None,
-    vector_field: Optional[np.ndarray] = None,
-    vector_color: Optional[np.ndarray] = None,
+    color_scheme: str | None = None,
+    colors: np.ndarray | None = None,
+    scalar_field: np.ndarray | None = None,
+    scalar_start: float | None = None,
+    scalar_end: float | None = None,
+    scalar_cmap: Any | None = None,
+    vector_field: np.ndarray | None = None,
+    vector_color: np.ndarray | None = None,
     magnetic_moments: bool = False,
     view_plane: np.ndarray = np.array([0, 0, 1]),
     distance_from_camera: float = 1.0,
@@ -462,7 +462,7 @@ def _plot3d(
             vector_color = np.ones((len(structure), 3)) * vector_color
 
     if vector_field is not None:
-        for arr, pos, col in zip(vector_field, positions, vector_color):
+        for arr, pos, col in zip(vector_field, positions, vector_color, strict=True):
             view.shape.add_arrow(list(pos), list(pos + arr), list(col), 0.2)
 
     if show_axes:  # Add axes
@@ -576,8 +576,8 @@ def _ngl_write_atom(
     x: float,
     y: float,
     z: float,
-    group: Optional[str] = None,
-    num2: Optional[int] = None,
+    group: str | None = None,
+    num2: int | None = None,
     occupancy: float = 1.0,
     temperature_factor: float = 0.0,
 ) -> str:
@@ -689,7 +689,7 @@ def _add_colorscheme_spacefill(
     Returns:
         (nglview.NGLWidget): The modified widget.
     """
-    for elem, num in set(zip(elements, atomic_numbers)):
+    for elem, num in set(zip(elements, atomic_numbers, strict=True)):
         view.add_spacefill(
             selection="#" + elem,
             radius_type="vdw",
@@ -726,8 +726,8 @@ def _add_custom_color_spacefill(
 
 def _scalars_to_hex_colors(
     scalar_field: np.ndarray,
-    start: Optional[float] = None,
-    end: Optional[float] = None,
+    start: float | None = None,
+    end: float | None = None,
     cmap=None,
 ):
     """

structuretoolkit-0.0.35/structuretoolkit/build/random.py

@@ -1,107 +0,0 @@
-# Copyright (c) Max-Planck-Institut für Eisenforschung GmbH - Computational Materials Design (CM) Department
-# Distributed under the terms of "New BSD License", see the LICENSE file.
-
-import warnings
-from typing import Union
-
-try:
-    from tqdm.auto import tqdm
-except ImportError:
-
-    def tqdm(x):
-        return x
-
-
-from ase import Atoms
-
-from structuretoolkit.common.helper import center_coordinates_in_unit_cell
-
-
-def pyxtal(
-    group: Union[int, list[int]],
-    species: tuple[str],
-    num_ions: tuple[int],
-    dim=3,
-    repeat=1,
-    allow_exceptions=True,
-    **kwargs,
-) -> Union[Atoms, list[dict]]:
-    """
-    Generate random crystal structures with PyXtal.
-
-    `group` must be between 1 and the largest possible value for the given dimensionality:
-        dim=3 => 1 - 230 (space groups)
-        dim=2 => 1 -  80 (layer groups)
-        dim=1 => 1 -  75 (rod groups)
-        dim=0 => 1 -  58 (point groups)
-
-    When `group` is passed as a list of integers or `repeat>1`, generate multiple structures and return them in a list
-    of dicts containing the keys `atoms`, `symmetry` and `repeat` for the ASE structure, the symmetry group
-    number and which iteration it is, respectively.
-
-    Args:
-        group (list of int, or int): the symmetry group to generate or a list of them
-        species (tuple of str): which species to include, defines the stoichiometry together with `num_ions`
-        num_ions (tuple of int): how many of each species to include, defines the stoichiometry together with `species`
-        dim (int): dimensionality of the symmetry group, 0 is point groups, 1 is rod groups, 2 is layer groups and 3 is space groups
-        repeat (int): how many random structures to generate
-        allow_exceptions (bool): when generating multiple structures, silence errors when the requested stoichiometry and symmetry group are incompatible
-        **kwargs: passed to `pyxtal.pyxtal` function verbatim
-
-    Returns:
-        :class:`~.Atoms`: the generated structure, if repeat==1 and only one symmetry group is requested
-        list of dict of all generated structures, if repeat>1 or multiple symmetry groups are requested
-
-    Raises:
-        ValueError: if `species` and `num_ions` are not of the same length
-        ValueError: if stoichiometry and symmetry group are incompatible and allow_exceptions==False or only one structure is requested
-    """
-    from pyxtal import pyxtal as _pyxtal
-    from pyxtal.msg import Comp_CompatibilityError
-
-    if len(species) != len(num_ions):
-        raise ValueError(
-            "species and num_ions must be of same length, "
-            f"not {species} and {num_ions}!"
-        )
-    stoich = "".join(f"{s}{n}" for s, n in zip(species, num_ions))
-
-    def generate(group):
-        s = _pyxtal()
-        try:
-            s.from_random(
-                dim=dim, group=group, species=species, numIons=num_ions, **kwargs
-            )
-        except Comp_CompatibilityError:
-            if not allow_exceptions:
-                raise ValueError(
-                    f"Symmetry group {group} incompatible with stoichiometry {stoich}!"
-                ) from None
-            else:
-                return None
-        s = s.to_ase()
-        s = center_coordinates_in_unit_cell(structure=s)
-        return s
-
-    # return a single structure
-    if repeat == 1 and isinstance(group, int):
-        allow_exceptions = False
-        return generate(group)
-    else:
-        structures = []
-        if isinstance(group, int):
-            group = [group]
-        failed_groups = []
-        for g in tqdm(group, desc="Spacegroups"):
-            for i in range(repeat):
-                s = generate(g)
-                if s is None:
-                    failed_groups.append(g)
-                    continue
-                structures.append({"atoms": s, "symmetry": g, "repeat": i})
-        if len(failed_groups) > 0:
-            warnings.warn(
-                f"Groups [{', '.join(map(str, failed_groups))}] could not be generated with stoichiometry {stoich}!",
-                stacklevel=2,
-            )
-        return structures