fake-bpy-module 20240516__py3-none-any.whl → 20240517__py3-none-any.whl

mathutils/__init__.pyi

@@ -56,10 +56,10 @@ class Color:
     :type: float
     """
 
-    hsv: typing.Union[typing.Sequence[float], Vector]
+    hsv: typing.Sequence[float] | Vector
     """ HSV Values in [0, 1].
 
-    :type: typing.Union[typing.Sequence[float], Vector]
+    :type: typing.Sequence[float] | Vector
     """
 
     is_frozen: bool
@@ -188,121 +188,121 @@ class Color:
         """
         ...
 
-    def __add__(self, other: typing.Union[typing.Sequence[float], Color]) -> Color:
+    def __add__(self, other: typing.Sequence[float] | Color) -> Color:
         """
 
         :param other:
-        :type other: typing.Union[typing.Sequence[float], Color]
+        :type other: typing.Sequence[float] | Color
         :return:
         :rtype: Color
         """
         ...
 
-    def __sub__(self, other: typing.Union[typing.Sequence[float], Color]) -> Color:
+    def __sub__(self, other: typing.Sequence[float] | Color) -> Color:
         """
 
         :param other:
-        :type other: typing.Union[typing.Sequence[float], Color]
+        :type other: typing.Sequence[float] | Color
         :return:
         :rtype: Color
         """
         ...
 
-    def __mul__(self, other: typing.Union[int, float]) -> Color:
+    def __mul__(self, other: int | float) -> Color:
         """
 
         :param other:
-        :type other: typing.Union[int, float]
+        :type other: int | float
         :return:
         :rtype: Color
         """
         ...
 
-    def __truediv__(self, other: typing.Union[int, float]) -> Color:
+    def __truediv__(self, other: int | float) -> Color:
         """
 
         :param other:
-        :type other: typing.Union[int, float]
+        :type other: int | float
         :return:
         :rtype: Color
         """
         ...
 
-    def __radd__(self, other: typing.Union[typing.Sequence[float], Color]) -> Color:
+    def __radd__(self, other: typing.Sequence[float] | Color) -> Color:
         """
 
         :param other:
-        :type other: typing.Union[typing.Sequence[float], Color]
+        :type other: typing.Sequence[float] | Color
         :return:
         :rtype: Color
         """
         ...
 
-    def __rsub__(self, other: typing.Union[typing.Sequence[float], Color]) -> Color:
+    def __rsub__(self, other: typing.Sequence[float] | Color) -> Color:
         """
 
         :param other:
-        :type other: typing.Union[typing.Sequence[float], Color]
+        :type other: typing.Sequence[float] | Color
         :return:
         :rtype: Color
         """
         ...
 
-    def __rmul__(self, other: typing.Union[int, float]) -> Color:
+    def __rmul__(self, other: int | float) -> Color:
         """
 
         :param other:
-        :type other: typing.Union[int, float]
+        :type other: int | float
         :return:
         :rtype: Color
         """
         ...
 
-    def __rtruediv__(self, other: typing.Union[int, float]) -> Color:
+    def __rtruediv__(self, other: int | float) -> Color:
         """
 
         :param other:
-        :type other: typing.Union[int, float]
+        :type other: int | float
         :return:
         :rtype: Color
         """
         ...
 
-    def __iadd__(self, other: typing.Union[typing.Sequence[float], Color]) -> Color:
+    def __iadd__(self, other: typing.Sequence[float] | Color) -> Color:
         """
 
         :param other:
-        :type other: typing.Union[typing.Sequence[float], Color]
+        :type other: typing.Sequence[float] | Color
         :return:
         :rtype: Color
         """
         ...
 
-    def __isub__(self, other: typing.Union[typing.Sequence[float], Color]) -> Color:
+    def __isub__(self, other: typing.Sequence[float] | Color) -> Color:
         """
 
         :param other:
-        :type other: typing.Union[typing.Sequence[float], Color]
+        :type other: typing.Sequence[float] | Color
         :return:
         :rtype: Color
         """
         ...
 
-    def __imul__(self, other: typing.Union[int, float]) -> Color:
+    def __imul__(self, other: int | float) -> Color:
         """
 
         :param other:
-        :type other: typing.Union[int, float]
+        :type other: int | float
         :return:
         :rtype: Color
         """
         ...
 
-    def __itruediv__(self, other: typing.Union[int, float]) -> Color:
+    def __itruediv__(self, other: int | float) -> Color:
         """
 
         :param other:
-        :type other: typing.Union[int, float]
+        :type other: int | float
         :return:
         :rtype: Color
         """
@@ -389,19 +389,17 @@ class Euler:
 
     def rotate(
         self,
-        other: typing.Union[
-            typing.Sequence[float],
-            Euler,
-            typing.Sequence[float],
-            Quaternion,
-            typing.Sequence[float],
-            Matrix,
-        ],
+        other: typing.Sequence[float]
+        | Euler
+        | typing.Sequence[float]
+        | Quaternion
+        | typing.Sequence[float]
+        | Matrix,
     ):
         """Rotates the euler by another mathutils value.
 
         :param other: rotation component of mathutils value
-        :type other: typing.Union[typing.Sequence[float], Euler, typing.Sequence[float], Quaternion, typing.Sequence[float], Matrix]
+        :type other: typing.Sequence[float] | Euler | typing.Sequence[float] | Quaternion | typing.Sequence[float] | Matrix
         """
         ...
 
@@ -523,11 +521,11 @@ class Matrix:
     """
 
     @classmethod
-    def Diagonal(cls, vector: typing.Union[typing.Sequence[float], Vector]) -> Matrix:
+    def Diagonal(cls, vector: typing.Sequence[float] | Vector) -> Matrix:
         """Create a diagonal (scaling) matrix using the values from the vector.
 
         :param vector: The vector of values for the diagonal.
-        :type vector: typing.Union[typing.Sequence[float], Vector]
+        :type vector: typing.Sequence[float] | Vector
         :return: A diagonal matrix.
         :rtype: Matrix
         """
@@ -547,37 +545,37 @@ class Matrix:
     @classmethod
     def LocRotScale(
         cls,
-        location: typing.Optional[typing.Union[typing.Sequence[float], Vector]],
-        rotation: typing.Optional[
-            typing.Union[
-                typing.Sequence[float], Quaternion, typing.Sequence[float], Euler
-            ]
-        ],
-        scale: typing.Optional[typing.Union[typing.Sequence[float], Vector]],
+        location: typing.Sequence[float] | Vector | None,
+        rotation: typing.Sequence[float]
+        | Quaternion
+        | typing.Sequence[float]
+        | Euler
+        | None,
+        scale: typing.Sequence[float] | Vector | None,
     ):
         """Create a matrix combining translation, rotation and scale,
         acting as the inverse of the decompose() method.Any of the inputs may be replaced with None if not needed.
 
                 :param location: The translation component.
-                :type location: typing.Optional[typing.Union[typing.Sequence[float], Vector]]
+                :type location: typing.Sequence[float] | Vector | None
                 :param rotation: The rotation component.
-                :type rotation: typing.Optional[typing.Union[typing.Sequence[float], Quaternion, typing.Sequence[float], Euler]]
+                :type rotation: typing.Sequence[float] | Quaternion | typing.Sequence[float] | Euler | None
                 :param scale: The scale component.
-                :type scale: typing.Optional[typing.Union[typing.Sequence[float], Vector]]
+                :type scale: typing.Sequence[float] | Vector | None
                 :return: Combined transformation matrix.
         """
         ...
 
     @classmethod
     def OrthoProjection(
-        cls, axis: typing.Union[str, typing.Sequence[float], Vector], size: int
+        cls, axis: str | typing.Sequence[float] | Vector, size: int
     ) -> Matrix:
         """Create a matrix to represent an orthographic projection.
 
                 :param axis: Can be any of the following: ['X', 'Y', 'XY', 'XZ', 'YZ'],
         where a single axis is for a 2D matrix.
         Or a vector for an arbitrary axis
-                :type axis: typing.Union[str, typing.Sequence[float], Vector]
+                :type axis: str | typing.Sequence[float] | Vector
                 :param size: The size of the projection matrix to construct [2, 4].
                 :type size: int
                 :return: A new projection matrix.
@@ -587,10 +585,7 @@ class Matrix:
 
     @classmethod
     def Rotation(
-        cls,
-        angle: float,
-        size: int,
-        axis: typing.Union[str, typing.Sequence[float], Vector],
+        cls, angle: float, size: int, axis: str | typing.Sequence[float] | Vector
     ) -> Matrix:
         """Create a matrix representing a rotation.
 
@@ -600,7 +595,7 @@ class Matrix:
                 :type size: int
                 :param axis: a string in ['X', 'Y', 'Z'] or a 3D Vector Object
         (optional when size is 2).
-                :type axis: typing.Union[str, typing.Sequence[float], Vector]
+                :type axis: str | typing.Sequence[float] | Vector
                 :return: A new rotation matrix.
                 :rtype: Matrix
         """
@@ -608,10 +603,7 @@ class Matrix:
 
     @classmethod
     def Scale(
-        cls,
-        factor: float,
-        size: int,
-        axis: typing.Union[typing.Sequence[float], Vector],
+        cls, factor: float, size: int, axis: typing.Sequence[float] | Vector
     ) -> Matrix:
         """Create a matrix representing a scaling.
 
@@ -620,7 +612,7 @@ class Matrix:
         :param size: The size of the scale matrix to construct [2, 4].
         :type size: int
         :param axis: Direction to influence scale. (optional).
-        :type axis: typing.Union[typing.Sequence[float], Vector]
+        :type axis: typing.Sequence[float] | Vector
         :return: A new scale matrix.
         :rtype: Matrix
         """
@@ -644,13 +636,11 @@ class Matrix:
         ...
 
     @classmethod
-    def Translation(
-        cls, vector: typing.Union[typing.Sequence[float], Vector]
-    ) -> Matrix:
+    def Translation(cls, vector: typing.Sequence[float] | Vector) -> Matrix:
         """Create a matrix representing a translation.
 
         :param vector: The translation vector.
-        :type vector: typing.Union[typing.Sequence[float], Vector]
+        :type vector: typing.Sequence[float] | Vector
         :return: An identity matrix with a translation.
         :rtype: Matrix
         """
@@ -676,11 +666,11 @@ class Matrix:
         """
         ...
 
-    def decompose(self) -> typing.Tuple[Vector, Quaternion, Vector]:
+    def decompose(self) -> tuple[Vector, Quaternion, Vector]:
         """Return the translation, rotation, and scale components of this matrix.
 
         :return: tuple of translation, rotation, and scale
-        :rtype: typing.Tuple[Vector, Quaternion, Vector]
+        :rtype: tuple[Vector, Quaternion, Vector]
         """
         ...
 
@@ -704,12 +694,12 @@ class Matrix:
         """Set the matrix to the identity matrix.`Identity matrix <https://en.wikipedia.org/wiki/Identity_matrix>`__ on Wikipedia."""
         ...
 
-    def invert(self, fallback: typing.Union[typing.Sequence[float], Matrix] = None):
+    def invert(self, fallback: typing.Sequence[float] | Matrix = None):
         """Set the matrix to its inverse.`Inverse matrix <https://en.wikipedia.org/wiki/Inverse_matrix>`__ on Wikipedia.
 
                 :param fallback: Set the matrix to this value when the inverse cannot be calculated
         (instead of raising a `ValueError` exception).
-                :type fallback: typing.Union[typing.Sequence[float], Matrix]
+                :type fallback: typing.Sequence[float] | Matrix
         """
         ...
 
@@ -742,13 +732,11 @@ class Matrix:
         """
         ...
 
-    def lerp(
-        self, other: typing.Union[typing.Sequence[float], Matrix], factor: float
-    ) -> Matrix:
+    def lerp(self, other: typing.Sequence[float] | Matrix, factor: float) -> Matrix:
         """Returns the interpolation of two matrices. Uses polar decomposition, see   "Matrix Animation and Polar Decomposition", Shoemake and Duff, 1992.
 
         :param other: value to interpolate with.
-        :type other: typing.Union[typing.Sequence[float], Matrix]
+        :type other: typing.Sequence[float] | Matrix
         :param factor: The interpolation value in [0.0, 1.0].
         :type factor: float
         :return: The interpolated matrix.
@@ -774,19 +762,17 @@ class Matrix:
 
     def rotate(
         self,
-        other: typing.Union[
-            typing.Sequence[float],
-            Euler,
-            typing.Sequence[float],
-            Quaternion,
-            typing.Sequence[float],
-            Matrix,
-        ],
+        other: typing.Sequence[float]
+        | Euler
+        | typing.Sequence[float]
+        | Quaternion
+        | typing.Sequence[float]
+        | Matrix,
     ):
         """Rotates the matrix by another mathutils value.
 
         :param other: rotation component of mathutils value
-        :type other: typing.Union[typing.Sequence[float], Euler, typing.Sequence[float], Quaternion, typing.Sequence[float], Matrix]
+        :type other: typing.Sequence[float] | Euler | typing.Sequence[float] | Quaternion | typing.Sequence[float] | Matrix
         """
         ...
 
@@ -815,7 +801,7 @@ class Matrix:
         ...
 
     def to_euler(
-        self, order: str, euler_compat: typing.Union[typing.Sequence[float], Euler]
+        self, order: str, euler_compat: typing.Sequence[float] | Euler
     ) -> Euler:
         """Return an Euler representation of the rotation matrix
         (3x3 or 4x4 matrix only).
@@ -826,7 +812,7 @@ class Matrix:
                 :param euler_compat: Optional euler argument the new euler will be made
         compatible with (no axis flipping between them).
         Useful for converting a series of matrices to animation curves.
-                :type euler_compat: typing.Union[typing.Sequence[float], Euler]
+                :type euler_compat: typing.Sequence[float] | Euler
                 :return: Euler representation of the matrix.
                 :rtype: Euler
         """
@@ -905,108 +891,105 @@ class Matrix:
         """
         ...
 
-    def __add__(self, other: typing.Union[typing.Sequence[float], Matrix]) -> Matrix:
+    def __add__(self, other: typing.Sequence[float] | Matrix) -> Matrix:
         """
 
         :param other:
-        :type other: typing.Union[typing.Sequence[float], Matrix]
+        :type other: typing.Sequence[float] | Matrix
         :return:
         :rtype: Matrix
         """
         ...
 
-    def __sub__(self, other: typing.Union[typing.Sequence[float], Matrix]) -> Matrix:
+    def __sub__(self, other: typing.Sequence[float] | Matrix) -> Matrix:
         """
 
         :param other:
-        :type other: typing.Union[typing.Sequence[float], Matrix]
+        :type other: typing.Sequence[float] | Matrix
         :return:
         :rtype: Matrix
         """
         ...
 
-    def __mul__(self, other: typing.Union[int, float]) -> Matrix:
+    def __mul__(self, other: int | float) -> Matrix:
         """
 
         :param other:
-        :type other: typing.Union[int, float]
+        :type other: int | float
         :return:
         :rtype: Matrix
         """
         ...
 
     @typing.overload
-    def __matmul__(self, other: typing.Union[typing.Sequence[float], Matrix]) -> Matrix:
+    def __matmul__(self, other: typing.Sequence[float] | Matrix) -> Matrix:
         """
 
         :param other:
-        :type other: typing.Union[typing.Sequence[float], Matrix]
+        :type other: typing.Sequence[float] | Matrix
         :return:
         :rtype: Matrix
         """
         ...
 
     @typing.overload
-    def __matmul__(self, other: typing.Union[typing.Sequence[float], Vector]) -> Vector:
+    def __matmul__(self, other: typing.Sequence[float] | Vector) -> Vector:
         """
 
         :param other:
-        :type other: typing.Union[typing.Sequence[float], Vector]
+        :type other: typing.Sequence[float] | Vector
         :return:
         :rtype: Vector
         """
         ...
 
     def __matmul__(
-        self,
-        other: typing.Union[
-            typing.Sequence[float], Matrix, typing.Sequence[float], Vector
-        ],
-    ) -> typing.Union[Matrix, Vector]:
+        self, other: typing.Sequence[float] | Matrix | typing.Sequence[float] | Vector
+    ) -> Matrix | Vector:
         """
 
         :param other:
-        :type other: typing.Union[typing.Sequence[float], Matrix, typing.Sequence[float], Vector]
+        :type other: typing.Sequence[float] | Matrix | typing.Sequence[float] | Vector
         :return:
-        :rtype: typing.Union[Matrix, Vector]
+        :rtype: Matrix | Vector
         """
         ...
 
-    def __radd__(self, other: typing.Union[typing.Sequence[float], Matrix]) -> Matrix:
+    def __radd__(self, other: typing.Sequence[float] | Matrix) -> Matrix:
         """
 
         :param other:
-        :type other: typing.Union[typing.Sequence[float], Matrix]
+        :type other: typing.Sequence[float] | Matrix
         :return:
         :rtype: Matrix
         """
         ...
 
-    def __rsub__(self, other: typing.Union[typing.Sequence[float], Matrix]) -> Matrix:
+    def __rsub__(self, other: typing.Sequence[float] | Matrix) -> Matrix:
         """
 
         :param other:
-        :type other: typing.Union[typing.Sequence[float], Matrix]
+        :type other: typing.Sequence[float] | Matrix
         :return:
         :rtype: Matrix
         """
         ...
 
-    def __rmul__(self, other: typing.Union[int, float]) -> Matrix:
+    def __rmul__(self, other: int | float) -> Matrix:
         """
 
         :param other:
-        :type other: typing.Union[int, float]
+        :type other: int | float
         :return:
         :rtype: Matrix
         """
         ...
 
-    def __imul__(self, other: typing.Union[int, float]) -> Matrix:
+    def __imul__(self, other: int | float) -> Matrix:
         """
 
         :param other:
-        :type other: typing.Union[int, float]
+        :type other: int | float
         :return:
         :rtype: Matrix
         """
@@ -1021,10 +1004,10 @@ class Quaternion:
     :type: float
     """
 
-    axis: typing.Union[typing.Sequence[float], Vector]
+    axis: typing.Sequence[float] | Vector
     """ Quaternion axis as a vector.
 
-    :type: typing.Union[typing.Sequence[float], Vector]
+    :type: typing.Sequence[float] | Vector
     """
 
     is_frozen: bool
@@ -1098,23 +1081,21 @@ class Quaternion:
         """
         ...
 
-    def cross(
-        self, other: typing.Union[typing.Sequence[float], Quaternion]
-    ) -> Quaternion:
+    def cross(self, other: typing.Sequence[float] | Quaternion) -> Quaternion:
         """Return the cross product of this quaternion and another.
 
         :param other: The other quaternion to perform the cross product with.
-        :type other: typing.Union[typing.Sequence[float], Quaternion]
+        :type other: typing.Sequence[float] | Quaternion
         :return: The cross product.
         :rtype: Quaternion
         """
         ...
 
-    def dot(self, other: typing.Union[typing.Sequence[float], Quaternion]) -> float:
+    def dot(self, other: typing.Sequence[float] | Quaternion) -> float:
         """Return the dot product of this quaternion and another.
 
         :param other: The other quaternion to perform the dot product with.
-        :type other: typing.Union[typing.Sequence[float], Quaternion]
+        :type other: typing.Sequence[float] | Quaternion
         :return: The dot product.
         :rtype: float
         """
@@ -1170,41 +1151,39 @@ class Quaternion:
 
     def rotate(
         self,
-        other: typing.Union[
-            typing.Sequence[float],
-            Euler,
-            typing.Sequence[float],
-            Quaternion,
-            typing.Sequence[float],
-            Matrix,
-        ],
+        other: typing.Sequence[float]
+        | Euler
+        | typing.Sequence[float]
+        | Quaternion
+        | typing.Sequence[float]
+        | Matrix,
     ):
         """Rotates the quaternion by another mathutils value.
 
         :param other: rotation component of mathutils value
-        :type other: typing.Union[typing.Sequence[float], Euler, typing.Sequence[float], Quaternion, typing.Sequence[float], Matrix]
+        :type other: typing.Sequence[float] | Euler | typing.Sequence[float] | Quaternion | typing.Sequence[float] | Matrix
         """
         ...
 
     def rotation_difference(
-        self, other: typing.Union[typing.Sequence[float], Quaternion]
+        self, other: typing.Sequence[float] | Quaternion
     ) -> Quaternion:
         """Returns a quaternion representing the rotational difference.
 
         :param other: second quaternion.
-        :type other: typing.Union[typing.Sequence[float], Quaternion]
+        :type other: typing.Sequence[float] | Quaternion
         :return: the rotational difference between the two quat rotations.
         :rtype: Quaternion
         """
         ...
 
     def slerp(
-        self, other: typing.Union[typing.Sequence[float], Quaternion], factor: float
+        self, other: typing.Sequence[float] | Quaternion, factor: float
     ) -> Quaternion:
         """Returns the interpolation of two quaternions.
 
         :param other: value to interpolate with.
-        :type other: typing.Union[typing.Sequence[float], Quaternion]
+        :type other: typing.Sequence[float] | Quaternion
         :param factor: The interpolation value in [0.0, 1.0].
         :type factor: float
         :return: The interpolated rotation.
@@ -1212,16 +1191,16 @@ class Quaternion:
         """
         ...
 
-    def to_axis_angle(self) -> typing.Tuple[Vector, float]:
+    def to_axis_angle(self) -> tuple[Vector, float]:
         """Return the axis, angle representation of the quaternion.
 
         :return: axis, angle.
-        :rtype: typing.Tuple[Vector, float]
+        :rtype: tuple[Vector, float]
         """
         ...
 
     def to_euler(
-        self, order: str, euler_compat: typing.Union[typing.Sequence[float], Euler]
+        self, order: str, euler_compat: typing.Sequence[float] | Euler
     ) -> Euler:
         """Return Euler representation of the quaternion.
 
@@ -1231,7 +1210,7 @@ class Quaternion:
                 :param euler_compat: Optional euler argument the new euler will be made
         compatible with (no axis flipping between them).
         Useful for converting a series of matrices to animation curves.
-                :type euler_compat: typing.Union[typing.Sequence[float], Euler]
+                :type euler_compat: typing.Sequence[float] | Euler
                 :return: Euler representation of the quaternion.
                 :rtype: Euler
         """
@@ -1253,13 +1232,13 @@ class Quaternion:
         """
         ...
 
-    def to_swing_twist(self, axis) -> typing.Tuple[Quaternion, float]:
+    def to_swing_twist(self, axis) -> tuple[Quaternion, float]:
         """Split the rotation into a swing quaternion with the specified
         axis fixed at zero, and the remaining twist rotation angle.
 
                 :param axis: twist axis as a string in ['X', 'Y', 'Z']
                 :return: swing, twist angle.
-                :rtype: typing.Tuple[Quaternion, float]
+                :rtype: tuple[Quaternion, float]
         """
         ...
 
@@ -1300,61 +1279,55 @@ class Quaternion:
         """
         ...
 
-    def __add__(
-        self, other: typing.Union[typing.Sequence[float], Quaternion]
-    ) -> Quaternion:
+    def __add__(self, other: typing.Sequence[float] | Quaternion) -> Quaternion:
         """
 
         :param other:
-        :type other: typing.Union[typing.Sequence[float], Quaternion]
+        :type other: typing.Sequence[float] | Quaternion
         :return:
         :rtype: Quaternion
         """
         ...
 
-    def __sub__(
-        self, other: typing.Union[typing.Sequence[float], Quaternion]
-    ) -> Quaternion:
+    def __sub__(self, other: typing.Sequence[float] | Quaternion) -> Quaternion:
         """
 
         :param other:
-        :type other: typing.Union[typing.Sequence[float], Quaternion]
+        :type other: typing.Sequence[float] | Quaternion
         :return:
         :rtype: Quaternion
         """
         ...
 
     def __mul__(
-        self, other: typing.Union[int, float, typing.Sequence[float], Quaternion]
+        self, other: int | float | typing.Sequence[float] | Quaternion
     ) -> Quaternion:
         """
 
         :param other:
-        :type other: typing.Union[int, float, typing.Sequence[float], Quaternion]
+        :type other: int | float | typing.Sequence[float] | Quaternion
         :return:
         :rtype: Quaternion
         """
         ...
 
     @typing.overload
-    def __matmul__(
-        self, other: typing.Union[typing.Sequence[float], Quaternion]
-    ) -> Quaternion:
+    def __matmul__(self, other: typing.Sequence[float] | Quaternion) -> Quaternion:
         """
 
         :param other:
-        :type other: typing.Union[typing.Sequence[float], Quaternion]
+        :type other: typing.Sequence[float] | Quaternion
         :return:
         :rtype: Quaternion
         """
         ...
 
     @typing.overload
-    def __matmul__(self, other: typing.Union[typing.Sequence[float], Vector]) -> Vector:
+    def __matmul__(self, other: typing.Sequence[float] | Vector) -> Vector:
         """
 
         :param other:
-        :type other: typing.Union[typing.Sequence[float], Vector]
+        :type other: typing.Sequence[float] | Vector
         :return:
         :rtype: Vector
         """
@@ -1362,62 +1335,56 @@ class Quaternion:
 
     def __matmul__(
         self,
-        other: typing.Union[
-            typing.Sequence[float], Vector, typing.Sequence[float], Quaternion
-        ],
-    ) -> typing.Union[Vector, Quaternion]:
+        other: typing.Sequence[float] | Vector | typing.Sequence[float] | Quaternion,
+    ) -> Vector | Quaternion:
         """
 
         :param other:
-        :type other: typing.Union[typing.Sequence[float], Vector, typing.Sequence[float], Quaternion]
+        :type other: typing.Sequence[float] | Vector | typing.Sequence[float] | Quaternion
         :return:
-        :rtype: typing.Union[Vector, Quaternion]
+        :rtype: Vector | Quaternion
         """
         ...
 
-    def __radd__(
-        self, other: typing.Union[typing.Sequence[float], Quaternion]
-    ) -> Quaternion:
+    def __radd__(self, other: typing.Sequence[float] | Quaternion) -> Quaternion:
         """
 
         :param other:
-        :type other: typing.Union[typing.Sequence[float], Quaternion]
+        :type other: typing.Sequence[float] | Quaternion
         :return:
         :rtype: Quaternion
         """
         ...
 
-    def __rsub__(
-        self, other: typing.Union[typing.Sequence[float], Quaternion]
-    ) -> Quaternion:
+    def __rsub__(self, other: typing.Sequence[float] | Quaternion) -> Quaternion:
         """
 
         :param other:
-        :type other: typing.Union[typing.Sequence[float], Quaternion]
+        :type other: typing.Sequence[float] | Quaternion
         :return:
         :rtype: Quaternion
         """
         ...
 
     def __rmul__(
-        self, other: typing.Union[int, float, typing.Sequence[float], Quaternion]
+        self, other: int | float | typing.Sequence[float] | Quaternion
     ) -> Quaternion:
         """
 
         :param other:
-        :type other: typing.Union[int, float, typing.Sequence[float], Quaternion]
+        :type other: int | float | typing.Sequence[float] | Quaternion
         :return:
         :rtype: Quaternion
         """
         ...
 
     def __imul__(
-        self, other: typing.Union[int, float, typing.Sequence[float], Quaternion]
+        self, other: int | float | typing.Sequence[float] | Quaternion
     ) -> Quaternion:
         """
 
         :param other:
-        :type other: typing.Union[int, float, typing.Sequence[float], Quaternion]
+        :type other: int | float | typing.Sequence[float] | Quaternion
         :return:
         :rtype: Quaternion
         """
@@ -2545,14 +2512,12 @@ class Vector:
         ...
 
     def angle(
-        self,
-        other: typing.Union[typing.Sequence[float], Vector],
-        fallback: typing.Any = None,
+        self, other: typing.Sequence[float] | Vector, fallback: typing.Any = None
     ) -> float:
         """Return the angle between two vectors.
 
                 :param other: another vector to compare the angle with
-                :type other: typing.Union[typing.Sequence[float], Vector]
+                :type other: typing.Sequence[float] | Vector
                 :param fallback: return this when the angle can't be calculated (zero length vector),
         (instead of raising a `ValueError`).
                 :type fallback: typing.Any
@@ -2562,12 +2527,12 @@ class Vector:
         ...
 
     def angle_signed(
-        self, other: typing.Union[typing.Sequence[float], Vector], fallback: typing.Any
+        self, other: typing.Sequence[float] | Vector, fallback: typing.Any
     ) -> float:
         """Return the signed angle between two 2D vectors (clockwise is positive).
 
                 :param other: another vector to compare the angle with
-                :type other: typing.Union[typing.Sequence[float], Vector]
+                :type other: typing.Sequence[float] | Vector
                 :param fallback: return this when the angle can't be calculated (zero length vector),
         (instead of raising a `ValueError`).
                 :type fallback: typing.Any
@@ -2584,21 +2549,21 @@ class Vector:
         """
         ...
 
-    def cross(self, other: typing.Union[typing.Sequence[float], Vector]) -> Vector:
+    def cross(self, other: typing.Sequence[float] | Vector) -> Vector:
         """Return the cross product of this vector and another.
 
         :param other: The other vector to perform the cross product with.
-        :type other: typing.Union[typing.Sequence[float], Vector]
+        :type other: typing.Sequence[float] | Vector
         :return: The cross product.
         :rtype: Vector
         """
         ...
 
-    def dot(self, other: typing.Union[typing.Sequence[float], Vector]) -> float:
+    def dot(self, other: typing.Sequence[float] | Vector) -> float:
         """Return the dot product of this vector and another.
 
         :param other: The other vector to perform the dot product with.
-        :type other: typing.Union[typing.Sequence[float], Vector]
+        :type other: typing.Sequence[float] | Vector
         :return: The dot product.
         :rtype: float
         """
@@ -2612,13 +2577,11 @@ class Vector:
         """
         ...
 
-    def lerp(
-        self, other: typing.Union[typing.Sequence[float], Vector], factor: float
-    ) -> Vector:
+    def lerp(self, other: typing.Sequence[float] | Vector, factor: float) -> Vector:
         """Returns the interpolation of two vectors.
 
         :param other: value to interpolate with.
-        :type other: typing.Union[typing.Sequence[float], Vector]
+        :type other: typing.Sequence[float] | Vector
         :param factor: The interpolation value in [0.0, 1.0].
         :type factor: float
         :return: The interpolated vector.
@@ -2650,21 +2613,21 @@ class Vector:
         """
         ...
 
-    def project(self, other: typing.Union[typing.Sequence[float], Vector]) -> Vector:
+    def project(self, other: typing.Sequence[float] | Vector) -> Vector:
         """Return the projection of this vector onto the other.
 
         :param other: second vector.
-        :type other: typing.Union[typing.Sequence[float], Vector]
+        :type other: typing.Sequence[float] | Vector
         :return: the parallel projection vector
         :rtype: Vector
         """
         ...
 
-    def reflect(self, mirror: typing.Union[typing.Sequence[float], Vector]) -> Vector:
+    def reflect(self, mirror: typing.Sequence[float] | Vector) -> Vector:
         """Return the reflection vector from the mirror argument.
 
         :param mirror: This vector could be a normal from the reflecting surface.
-        :type mirror: typing.Union[typing.Sequence[float], Vector]
+        :type mirror: typing.Sequence[float] | Vector
         :return: The reflected vector matching the size of this vector.
         :rtype: Vector
         """
@@ -2700,30 +2663,26 @@ class Vector:
 
     def rotate(
         self,
-        other: typing.Union[
-            typing.Sequence[float],
-            Euler,
-            typing.Sequence[float],
-            Quaternion,
-            typing.Sequence[float],
-            Matrix,
-        ],
+        other: typing.Sequence[float]
+        | Euler
+        | typing.Sequence[float]
+        | Quaternion
+        | typing.Sequence[float]
+        | Matrix,
     ):
         """Rotate the vector by a rotation value.
 
         :param other: rotation component of mathutils value
-        :type other: typing.Union[typing.Sequence[float], Euler, typing.Sequence[float], Quaternion, typing.Sequence[float], Matrix]
+        :type other: typing.Sequence[float] | Euler | typing.Sequence[float] | Quaternion | typing.Sequence[float] | Matrix
         """
         ...
 
-    def rotation_difference(
-        self, other: typing.Union[typing.Sequence[float], Vector]
-    ) -> Quaternion:
+    def rotation_difference(self, other: typing.Sequence[float] | Vector) -> Quaternion:
         """Returns a quaternion representing the rotational difference between this
         vector and another.
 
                 :param other: second vector.
-                :type other: typing.Union[typing.Sequence[float], Vector]
+                :type other: typing.Sequence[float] | Vector
                 :return: the rotational difference between the two vectors.
                 :rtype: Quaternion
         """
@@ -2731,14 +2690,14 @@ class Vector:
 
     def slerp(
         self,
-        other: typing.Union[typing.Sequence[float], Vector],
+        other: typing.Sequence[float] | Vector,
         factor: float,
         fallback: typing.Any = None,
     ) -> Vector:
         """Returns the interpolation of two non-zero vectors (spherical coordinates).
 
                 :param other: value to interpolate with.
-                :type other: typing.Union[typing.Sequence[float], Vector]
+                :type other: typing.Sequence[float] | Vector
                 :param factor: The interpolation value typically in [0.0, 1.0].
                 :type factor: float
                 :param fallback: return this when the vector can't be calculated (zero length vector or direct opposites),
@@ -2785,13 +2744,13 @@ class Vector:
         """
         ...
 
-    def to_tuple(self, precision: int = -1) -> typing.Tuple:
+    def to_tuple(self, precision: int = -1) -> tuple:
         """Return this vector as a tuple with.
 
         :param precision: The number to round the value to in [-1, 21].
         :type precision: int
         :return: the values of the vector rounded by precision
-        :rtype: typing.Tuple
+        :rtype: tuple
         """
         ...
 
@@ -2844,158 +2803,155 @@ class Vector:
         """
         ...
 
-    def __add__(self, other: typing.Union[typing.Sequence[float], Vector]) -> Vector:
+    def __add__(self, other: typing.Sequence[float] | Vector) -> Vector:
         """
 
         :param other:
-        :type other: typing.Union[typing.Sequence[float], Vector]
+        :type other: typing.Sequence[float] | Vector
         :return:
         :rtype: Vector
         """
         ...
 
-    def __sub__(self, other: typing.Union[typing.Sequence[float], Vector]) -> Vector:
+    def __sub__(self, other: typing.Sequence[float] | Vector) -> Vector:
         """
 
         :param other:
-        :type other: typing.Union[typing.Sequence[float], Vector]
+        :type other: typing.Sequence[float] | Vector
         :return:
         :rtype: Vector
         """
         ...
 
-    def __mul__(self, other: typing.Union[int, float]) -> Vector:
+    def __mul__(self, other: int | float) -> Vector:
         """
 
         :param other:
-        :type other: typing.Union[int, float]
+        :type other: int | float
         :return:
         :rtype: Vector
         """
         ...
 
-    def __truediv__(self, other: typing.Union[int, float]) -> Vector:
+    def __truediv__(self, other: int | float) -> Vector:
         """
 
         :param other:
-        :type other: typing.Union[int, float]
+        :type other: int | float
         :return:
         :rtype: Vector
         """
         ...
 
     @typing.overload
-    def __matmul__(self, other: typing.Union[typing.Sequence[float], Vector]) -> float:
+    def __matmul__(self, other: typing.Sequence[float] | Vector) -> float:
         """
 
         :param other:
-        :type other: typing.Union[typing.Sequence[float], Vector]
+        :type other: typing.Sequence[float] | Vector
         :return:
         :rtype: float
         """
         ...
 
     @typing.overload
-    def __matmul__(self, other: typing.Union[typing.Sequence[float], Matrix]) -> Vector:
+    def __matmul__(self, other: typing.Sequence[float] | Matrix) -> Vector:
         """
 
         :param other:
-        :type other: typing.Union[typing.Sequence[float], Matrix]
+        :type other: typing.Sequence[float] | Matrix
         :return:
         :rtype: Vector
         """
         ...
 
     def __matmul__(
-        self,
-        other: typing.Union[
-            typing.Sequence[float], Vector, typing.Sequence[float], Matrix
-        ],
-    ) -> typing.Union[Vector, float]:
+        self, other: typing.Sequence[float] | Vector | typing.Sequence[float] | Matrix
+    ) -> Vector | float:
         """
 
         :param other:
-        :type other: typing.Union[typing.Sequence[float], Vector, typing.Sequence[float], Matrix]
+        :type other: typing.Sequence[float] | Vector | typing.Sequence[float] | Matrix
         :return:
-        :rtype: typing.Union[Vector, float]
+        :rtype: Vector | float
         """
         ...
 
-    def __radd__(self, other: typing.Union[typing.Sequence[float], Vector]) -> Vector:
+    def __radd__(self, other: typing.Sequence[float] | Vector) -> Vector:
         """
 
         :param other:
-        :type other: typing.Union[typing.Sequence[float], Vector]
+        :type other: typing.Sequence[float] | Vector
         :return:
         :rtype: Vector
         """
         ...
 
-    def __rsub__(self, other: typing.Union[typing.Sequence[float], Vector]) -> Vector:
+    def __rsub__(self, other: typing.Sequence[float] | Vector) -> Vector:
         """
 
         :param other:
-        :type other: typing.Union[typing.Sequence[float], Vector]
+        :type other: typing.Sequence[float] | Vector
         :return:
         :rtype: Vector
         """
         ...
 
-    def __rmul__(self, other: typing.Union[int, float]) -> Vector:
+    def __rmul__(self, other: int | float) -> Vector:
         """
 
         :param other:
-        :type other: typing.Union[int, float]
+        :type other: int | float
         :return:
         :rtype: Vector
         """
         ...
 
-    def __rtruediv__(self, other: typing.Union[int, float]) -> Vector:
+    def __rtruediv__(self, other: int | float) -> Vector:
         """
 
         :param other:
-        :type other: typing.Union[int, float]
+        :type other: int | float
         :return:
         :rtype: Vector
         """
         ...
 
-    def __iadd__(self, other: typing.Union[typing.Sequence[float], Vector]) -> Vector:
+    def __iadd__(self, other: typing.Sequence[float] | Vector) -> Vector:
         """
 
         :param other:
-        :type other: typing.Union[typing.Sequence[float], Vector]
+        :type other: typing.Sequence[float] | Vector
         :return:
         :rtype: Vector
         """
         ...
 
-    def __isub__(self, other: typing.Union[typing.Sequence[float], Vector]) -> Vector:
+    def __isub__(self, other: typing.Sequence[float] | Vector) -> Vector:
         """
 
         :param other:
-        :type other: typing.Union[typing.Sequence[float], Vector]
+        :type other: typing.Sequence[float] | Vector
         :return:
         :rtype: Vector
         """
         ...
 
-    def __imul__(self, other: typing.Union[int, float]) -> Vector:
+    def __imul__(self, other: int | float) -> Vector:
         """
 
         :param other:
-        :type other: typing.Union[int, float]
+        :type other: int | float
         :return:
         :rtype: Vector
         """
         ...
 
-    def __itruediv__(self, other: typing.Union[int, float]) -> Vector:
+    def __itruediv__(self, other: int | float) -> Vector:
         """
 
         :param other:
-        :type other: typing.Union[int, float]
+        :type other: int | float
         :return:
         :rtype: Vector
         """