Merge branch '286-python-typehints-use-standard-types-instead-of-typing-module' into 'development'

typing.{Tuple,Dict,List} not needed anymore

Closes #286

See merge request damask/DAMASK!1010

Author: dmentock

python/damask/_configmaterial.py

@@ -1,4 +1,4 @@
-from typing import Optional, Union, Sequence, Dict, Any, List
+from typing import Optional, Union, Sequence, Any
 
 import numpy as np
 import h5py
@@ -25,10 +25,10 @@ class ConfigMaterial(YAML):
     """
 
     def __init__(self,
-                 config: Optional[Union[str,Dict[str,Any]]] = None,*,
-                 homogenization: Optional[Dict[str,Dict]] = None,
-                 phase: Optional[Dict[str,Dict]] = None,
-                 material: Optional[List[Dict[str,Any]]] = None):
+                 config: Optional[Union[str,dict[str,Any]]] = None,*,
+                 homogenization: Optional[dict[str,dict]] = None,
+                 phase: Optional[dict[str,dict]] = None,
+                 material: Optional[list[dict[str,Any]]] = None):
         """
         New material configuration.
 
@@ -46,7 +46,7 @@ def __init__(self,
             Materialpoint configuration.
             Defaults to an empty list if 'config' is not given.
         """
-        kwargs: Dict[str,Union[Dict[str,Dict],List[Dict[str,Any]]]] = {}
+        kwargs: dict[str,Union[dict[str,dict],list[dict[str,Any]]]] = {}
         for arg,value in zip(['homogenization','phase','material'],[homogenization,phase,material]):
             if value is None and config is None:
                 kwargs[arg] = [] if arg == 'material' else {}
@@ -358,7 +358,7 @@ def is_valid(self) -> bool:
 
 
     def material_rename_phase(self,
-                              mapping: Dict[str, str],
+                              mapping: dict[str, str],
                               ID: Optional[Sequence[int]] = None,
                               constituent: Optional[Sequence[int]] = None) -> 'ConfigMaterial':
         """
@@ -391,7 +391,7 @@ def material_rename_phase(self,
 
 
     def material_rename_homogenization(self,
-                                       mapping: Dict[str, str],
+                                       mapping: dict[str, str],
                                        ID: Optional[Sequence[int]] = None) -> 'ConfigMaterial':
         """
         Change homogenization name in material.

python/damask/_crystal.py

@@ -1,4 +1,4 @@
-from typing import Optional, Union, Dict, List, Tuple, Literal
+from typing import Optional, Union, Literal
 
 import numpy as np
 
@@ -7,7 +7,7 @@
 from . import Rotation
 
 
-_kinematics: Dict[BravaisLattice, Dict[CrystalKinematics, List[np.ndarray]]] = {
+_kinematics: dict[BravaisLattice, dict[CrystalKinematics, list[np.ndarray]]] = {
     'cF': {
         'slip': [np.array([
                    [ 0,+1,-1, +1,+1,+1],
@@ -244,7 +244,7 @@
 }
 
 
-lattice_symmetries: Dict[Optional[BravaisLattice], CrystalFamily] = {
+lattice_symmetries: dict[Optional[BravaisLattice], CrystalFamily] = {
                 'aP': 'triclinic',
 
                 'mP': 'monoclinic',
@@ -265,7 +265,7 @@
                 'cF': 'cubic',
                }
 
-orientation_relationships: Dict[str, Dict[str,List[np.ndarray]]] = {
+orientation_relationships: dict[str, dict[str,list[np.ndarray]]] = {
   'KS': { # https://doi.org/10.1016/j.jallcom.2012.02.004
     'cF-->cI' : [
         np.repeat(np.array([
@@ -800,17 +800,17 @@ def __eq__(self,
                 self.family == other.family)
 
     @property
-    def parameters(self) -> Optional[Dict]:
+    def parameters(self) -> Optional[dict]:
         """Return lattice parameters a, b, c, alpha, beta, gamma."""
         has_parameters = all([hasattr(self,p) for p in ['a','b','c','alpha','beta','gamma']])
         return dict(a=self.a,b=self.b,c=self.c,
                     alpha=self.alpha,beta=self.beta,gamma=self.gamma) if has_parameters else None
 
     @property
-    def immutable(self) -> Dict[str, float]:
+    def immutable(self) -> dict[str, float]:
         """Return immutable lattice parameters."""
         # ToDo: use pattern matching in Python 3.10
-        _immutable: Dict[CrystalFamily, Dict[str,float]] = {
+        _immutable: dict[CrystalFamily, dict[str,float]] = {
             'cubic': {
                          'b': 1.0,
                          'c': 1.0,
@@ -845,13 +845,13 @@ def immutable(self) -> Dict[str, float]:
 
 
     @property
-    def orientation_relationships(self) -> List[str]:
+    def orientation_relationships(self) -> list[str]:
         """Return labels of orientation relationships."""
         return [k for k,v in orientation_relationships.items() if np.any([m.startswith(str(self.lattice)) for m in v])]
 
 
     @property
-    def standard_triangle(self) -> Union[Dict[str, np.ndarray], None]:
+    def standard_triangle(self) -> Union[dict[str, np.ndarray], None]:
         """
         Corners of the standard triangle.
 
@@ -878,7 +878,7 @@ def standard_triangle(self) -> Union[Dict[str, np.ndarray], None]:
         ...                                            [0.,1.,0.]]).T),                      #              blue
         ...    }
         """
-        _basis: Dict[CrystalFamily, Dict[str, np.ndarray]]  = {
+        _basis: dict[CrystalFamily, dict[str, np.ndarray]]  = {
             'cubic':    {'improper':np.array([ [-1.            ,  0.            ,  1. ],
                                                [ np.sqrt(2.)   , -np.sqrt(2.)   ,  0. ],
                                                [ 0.            ,  np.sqrt(3.)   ,  0. ] ]),
@@ -944,7 +944,7 @@ def symmetry_operations(self) -> Rotation:
 
         https://en.wikipedia.org/wiki/Crystal_system#Crystal_classes
         """
-        _symmetry_operations: Dict[CrystalFamily, List]  = {
+        _symmetry_operations: dict[CrystalFamily, list]  = {
             'cubic':         [
                               [ 1.0,            0.0,            0.0,            0.0            ],
                               [ 0.0,            1.0,            0.0,            0.0            ],
@@ -1058,7 +1058,7 @@ def basis_reciprocal(self) -> np.ndarray:
     @property
     def lattice_points(self) -> np.ndarray:
         """Return lattice points."""
-        _lattice_points: Dict[str, List] = {
+        _lattice_points: dict[str, list] = {
                 'P': [
                      ],
                 'S': [
@@ -1152,7 +1152,7 @@ def to_frame(self, *,
 
 
     def kinematics(self,
-                   mode: CrystalKinematics) -> Dict[str, List[np.ndarray]]:
+                   mode: CrystalKinematics) -> dict[str, list[np.ndarray]]:
         """
         Return crystal kinematics systems.
 
@@ -1189,7 +1189,7 @@ def kinematics(self,
 
 
     def characteristic_shear_twin(self,
-                                  N_twin: Union[List[int], Literal['*']] = '*') -> np.ndarray:
+                                  N_twin: Union[list[int], Literal['*']] = '*') -> np.ndarray:
         """
         Return characteristic shear for twinning.
 
@@ -1229,7 +1229,7 @@ def characteristic_shear_twin(self,
 
     def relation_operations(self,
                             model: str,
-                            target = None) -> Tuple[BravaisLattice, Rotation]:
+                            target = None) -> tuple[BravaisLattice, Rotation]:
         """
         Crystallographic orientation relationships for phase transformations.
 

python/damask/_geomgrid.py

@@ -2,7 +2,7 @@
 import copy
 import multiprocessing as mp
 from functools import partial
-from typing import Optional, Union, Sequence, Dict
+from typing import Optional, Union, Sequence
 from pathlib import Path
 
 import numpy as np
@@ -40,7 +40,7 @@ def __init__(self,
                  material: np.ndarray,
                  size: FloatSequence,
                  origin: FloatSequence = np.zeros(3),
-                 initial_conditions: Optional[Dict[str,np.ndarray]] = None,
+                 initial_conditions: Optional[dict[str,np.ndarray]] = None,
                  comments: Union[None, str, Sequence[str]] = None):
         """
         New geometry definition for grid solvers.
@@ -163,7 +163,7 @@ def origin(self,
         self._origin = np.array(origin,np.float64)
 
     @property
-    def initial_conditions(self) -> Dict[str,np.ndarray]:
+    def initial_conditions(self) -> dict[str,np.ndarray]:
         """Fields of initial conditions."""
         self._ic = dict(zip(self._ic.keys(),                                                        # type: ignore[has-type]
                         [v if isinstance(v,np.ndarray) else
@@ -172,7 +172,7 @@ def initial_conditions(self) -> Dict[str,np.ndarray]:
 
     @initial_conditions.setter
     def initial_conditions(self,
-                           ic: Dict[str,np.ndarray]):
+                           ic: dict[str,np.ndarray]):
         if not isinstance(ic,dict):
             raise TypeError('initial conditions is not a dictionary')
 

python/damask/_loadcasegrid.py

@@ -1,4 +1,4 @@
-from typing import Optional, Union, Dict, Any, List
+from typing import Optional, Union, Any
 
 from numpy import ma
 
@@ -20,10 +20,10 @@ class LoadcaseGrid(YAML):
     """Load case for grid solver."""
 
     def __init__(self,
-                 config: Optional[Union[str,Dict[str,Any]]] = None,
+                 config: Optional[Union[str,dict[str,Any]]] = None,
                  *,
-                 solver: Optional[Dict[str,str]] = None,
-                 loadstep: Optional[List[Dict[str,Any]]] = None):
+                 solver: Optional[dict[str,str]] = None,
+                 loadstep: Optional[list[dict[str,Any]]] = None):
         """
         New grid solver load case.
 
@@ -38,8 +38,8 @@ def __init__(self,
             Load step configuration.
             Defaults to an empty list if 'config' is not given.
         """
-        kwargs: Dict[str,Union[Dict[str,str],List[Dict[str,Any]]]] = {}
-        default: Union[List,Dict]
+        kwargs: dict[str,Union[dict[str,str],list[dict[str,Any]]]] = {}
+        default: Union[list,dict]
         for arg,value,default in [('solver',solver,{}),('loadstep',loadstep,[])]:                   # type: ignore[assignment]
             if value is not None:
                 kwargs[arg] = value