fake-bpy-module 20240528__py3-none-any.whl → 20240529__py3-none-any.whl

mathutils/__init__.pyi

@@ -58,10 +58,10 @@ class Color:
     :type: float
     """
 
-    hsv: typing.Sequence[float] | Vector
+    hsv: collections.abc.Sequence[float] | Vector
     """ HSV Values in [0, 1].
 
-    :type: typing.Sequence[float] | Vector
+    :type: collections.abc.Sequence[float] | Vector
     """
 
     is_frozen: bool
@@ -190,21 +190,21 @@ class Color:
         """
         ...
 
-    def __add__(self, other: typing.Sequence[float] | Color) -> Color:
+    def __add__(self, other: collections.abc.Sequence[float] | Color) -> Color:
         """
 
         :param other:
-        :type other: typing.Sequence[float] | Color
+        :type other: collections.abc.Sequence[float] | Color
         :return:
         :rtype: Color
         """
         ...
 
-    def __sub__(self, other: typing.Sequence[float] | Color) -> Color:
+    def __sub__(self, other: collections.abc.Sequence[float] | Color) -> Color:
         """
 
         :param other:
-        :type other: typing.Sequence[float] | Color
+        :type other: collections.abc.Sequence[float] | Color
         :return:
         :rtype: Color
         """
@@ -230,21 +230,21 @@ class Color:
         """
         ...
 
-    def __radd__(self, other: typing.Sequence[float] | Color) -> Color:
+    def __radd__(self, other: collections.abc.Sequence[float] | Color) -> Color:
         """
 
         :param other:
-        :type other: typing.Sequence[float] | Color
+        :type other: collections.abc.Sequence[float] | Color
         :return:
         :rtype: Color
         """
         ...
 
-    def __rsub__(self, other: typing.Sequence[float] | Color) -> Color:
+    def __rsub__(self, other: collections.abc.Sequence[float] | Color) -> Color:
         """
 
         :param other:
-        :type other: typing.Sequence[float] | Color
+        :type other: collections.abc.Sequence[float] | Color
         :return:
         :rtype: Color
         """
@@ -270,21 +270,21 @@ class Color:
         """
         ...
 
-    def __iadd__(self, other: typing.Sequence[float] | Color) -> Color:
+    def __iadd__(self, other: collections.abc.Sequence[float] | Color) -> Color:
         """
 
         :param other:
-        :type other: typing.Sequence[float] | Color
+        :type other: collections.abc.Sequence[float] | Color
         :return:
         :rtype: Color
         """
         ...
 
-    def __isub__(self, other: typing.Sequence[float] | Color) -> Color:
+    def __isub__(self, other: collections.abc.Sequence[float] | Color) -> Color:
         """
 
         :param other:
-        :type other: typing.Sequence[float] | Color
+        :type other: collections.abc.Sequence[float] | Color
         :return:
         :rtype: Color
         """
@@ -391,17 +391,17 @@ class Euler:
 
     def rotate(
         self,
-        other: typing.Sequence[float]
+        other: collections.abc.Sequence[float]
         | Euler
-        | typing.Sequence[float]
+        | collections.abc.Sequence[float]
         | Quaternion
-        | typing.Sequence[float]
+        | collections.abc.Sequence[float]
         | Matrix,
     ):
         """Rotates the euler by another mathutils value.
 
         :param other: rotation component of mathutils value
-        :type other: typing.Sequence[float] | Euler | typing.Sequence[float] | Quaternion | typing.Sequence[float] | Matrix
+        :type other: collections.abc.Sequence[float] | Euler | collections.abc.Sequence[float] | Quaternion | collections.abc.Sequence[float] | Matrix
         """
         ...
 
@@ -523,11 +523,11 @@ class Matrix:
     """
 
     @classmethod
-    def Diagonal(cls, vector: typing.Sequence[float] | Vector) -> Matrix:
+    def Diagonal(cls, vector: collections.abc.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.Sequence[float] | Vector
+        :type vector: collections.abc.Sequence[float] | Vector
         :return: A diagonal matrix.
         :rtype: Matrix
         """
@@ -547,23 +547,23 @@ class Matrix:
     @classmethod
     def LocRotScale(
         cls,
-        location: typing.Sequence[float] | Vector | None,
-        rotation: typing.Sequence[float]
+        location: collections.abc.Sequence[float] | Vector | None,
+        rotation: collections.abc.Sequence[float]
         | Quaternion
-        | typing.Sequence[float]
+        | collections.abc.Sequence[float]
         | Euler
         | None,
-        scale: typing.Sequence[float] | Vector | None,
+        scale: collections.abc.Sequence[float] | Vector | None,
     ) -> Matrix:
         """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.Sequence[float] | Vector | None
+                :type location: collections.abc.Sequence[float] | Vector | None
                 :param rotation: The rotation component.
-                :type rotation: typing.Sequence[float] | Quaternion | typing.Sequence[float] | Euler | None
+                :type rotation: collections.abc.Sequence[float] | Quaternion | collections.abc.Sequence[float] | Euler | None
                 :param scale: The scale component.
-                :type scale: typing.Sequence[float] | Vector | None
+                :type scale: collections.abc.Sequence[float] | Vector | None
                 :return: Combined transformation matrix.
                 :rtype: Matrix
         """
@@ -571,14 +571,14 @@ class Matrix:
 
     @classmethod
     def OrthoProjection(
-        cls, axis: str | typing.Sequence[float] | Vector, size: int
+        cls, axis: str | collections.abc.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: str | typing.Sequence[float] | Vector
+                :type axis: str | collections.abc.Sequence[float] | Vector
                 :param size: The size of the projection matrix to construct [2, 4].
                 :type size: int
                 :return: A new projection matrix.
@@ -588,7 +588,10 @@ class Matrix:
 
     @classmethod
     def Rotation(
-        cls, angle: float, size: int, axis: str | typing.Sequence[float] | Vector
+        cls,
+        angle: float,
+        size: int,
+        axis: str | collections.abc.Sequence[float] | Vector | None,
     ) -> Matrix:
         """Create a matrix representing a rotation.
 
@@ -598,7 +601,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: str | typing.Sequence[float] | Vector
+                :type axis: str | collections.abc.Sequence[float] | Vector | None
                 :return: A new rotation matrix.
                 :rtype: Matrix
         """
@@ -606,7 +609,10 @@ class Matrix:
 
     @classmethod
     def Scale(
-        cls, factor: float, size: int, axis: typing.Sequence[float] | Vector
+        cls,
+        factor: float,
+        size: int,
+        axis: collections.abc.Sequence[float] | Vector | None,
     ) -> Matrix:
         """Create a matrix representing a scaling.
 
@@ -615,7 +621,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.Sequence[float] | Vector
+        :type axis: collections.abc.Sequence[float] | Vector | None
         :return: A new scale matrix.
         :rtype: Matrix
         """
@@ -639,11 +645,11 @@ class Matrix:
         ...
 
     @classmethod
-    def Translation(cls, vector: typing.Sequence[float] | Vector) -> Matrix:
+    def Translation(cls, vector: collections.abc.Sequence[float] | Vector) -> Matrix:
         """Create a matrix representing a translation.
 
         :param vector: The translation vector.
-        :type vector: typing.Sequence[float] | Vector
+        :type vector: collections.abc.Sequence[float] | Vector
         :return: An identity matrix with a translation.
         :rtype: Matrix
         """
@@ -697,12 +703,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.Sequence[float] | Matrix = None):
+    def invert(self, fallback: collections.abc.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.Sequence[float] | Matrix
+                :type fallback: collections.abc.Sequence[float] | Matrix
         """
         ...
 
@@ -735,11 +741,13 @@ class Matrix:
         """
         ...
 
-    def lerp(self, other: typing.Sequence[float] | Matrix, factor: float) -> Matrix:
+    def lerp(
+        self, other: collections.abc.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.Sequence[float] | Matrix
+        :type other: collections.abc.Sequence[float] | Matrix
         :param factor: The interpolation value in [0.0, 1.0].
         :type factor: float
         :return: The interpolated matrix.
@@ -765,17 +773,17 @@ class Matrix:
 
     def rotate(
         self,
-        other: typing.Sequence[float]
+        other: collections.abc.Sequence[float]
         | Euler
-        | typing.Sequence[float]
+        | collections.abc.Sequence[float]
         | Quaternion
-        | typing.Sequence[float]
+        | collections.abc.Sequence[float]
         | Matrix,
     ):
         """Rotates the matrix by another mathutils value.
 
         :param other: rotation component of mathutils value
-        :type other: typing.Sequence[float] | Euler | typing.Sequence[float] | Quaternion | typing.Sequence[float] | Matrix
+        :type other: collections.abc.Sequence[float] | Euler | collections.abc.Sequence[float] | Quaternion | collections.abc.Sequence[float] | Matrix
         """
         ...
 
@@ -804,18 +812,20 @@ class Matrix:
         ...
 
     def to_euler(
-        self, order: str, euler_compat: typing.Sequence[float] | Euler
+        self,
+        order: str | None,
+        euler_compat: collections.abc.Sequence[float] | Euler | None,
     ) -> Euler:
         """Return an Euler representation of the rotation matrix
         (3x3 or 4x4 matrix only).
 
                 :param order: Optional rotation order argument in
         ['XYZ', 'XZY', 'YXZ', 'YZX', 'ZXY', 'ZYX'].
-                :type order: str
+                :type order: str | None
                 :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.Sequence[float] | Euler
+                :type euler_compat: collections.abc.Sequence[float] | Euler | None
                 :return: Euler representation of the matrix.
                 :rtype: Euler
         """
@@ -894,21 +904,21 @@ class Matrix:
         """
         ...
 
-    def __add__(self, other: typing.Sequence[float] | Matrix) -> Matrix:
+    def __add__(self, other: collections.abc.Sequence[float] | Matrix) -> Matrix:
         """
 
         :param other:
-        :type other: typing.Sequence[float] | Matrix
+        :type other: collections.abc.Sequence[float] | Matrix
         :return:
         :rtype: Matrix
         """
         ...
 
-    def __sub__(self, other: typing.Sequence[float] | Matrix) -> Matrix:
+    def __sub__(self, other: collections.abc.Sequence[float] | Matrix) -> Matrix:
         """
 
         :param other:
-        :type other: typing.Sequence[float] | Matrix
+        :type other: collections.abc.Sequence[float] | Matrix
         :return:
         :rtype: Matrix
         """
@@ -925,54 +935,58 @@ class Matrix:
         ...
 
     @typing.overload
-    def __matmul__(self, other: typing.Sequence[float] | Matrix) -> Matrix:
+    def __matmul__(self, other: collections.abc.Sequence[float] | Matrix) -> Matrix:
         """
 
         :param other:
-        :type other: typing.Sequence[float] | Matrix
+        :type other: collections.abc.Sequence[float] | Matrix
         :return:
         :rtype: Matrix
         """
         ...
 
     @typing.overload
-    def __matmul__(self, other: typing.Sequence[float] | Vector) -> Vector:
+    def __matmul__(self, other: collections.abc.Sequence[float] | Vector) -> Vector:
         """
 
         :param other:
-        :type other: typing.Sequence[float] | Vector
+        :type other: collections.abc.Sequence[float] | Vector
         :return:
         :rtype: Vector
         """
         ...
 
     def __matmul__(
-        self, other: typing.Sequence[float] | Matrix | typing.Sequence[float] | Vector
+        self,
+        other: collections.abc.Sequence[float]
+        | Matrix
+        | collections.abc.Sequence[float]
+        | Vector,
     ) -> Matrix | Vector:
         """
 
         :param other:
-        :type other: typing.Sequence[float] | Matrix | typing.Sequence[float] | Vector
+        :type other: collections.abc.Sequence[float] | Matrix | collections.abc.Sequence[float] | Vector
         :return:
         :rtype: Matrix | Vector
         """
         ...
 
-    def __radd__(self, other: typing.Sequence[float] | Matrix) -> Matrix:
+    def __radd__(self, other: collections.abc.Sequence[float] | Matrix) -> Matrix:
         """
 
         :param other:
-        :type other: typing.Sequence[float] | Matrix
+        :type other: collections.abc.Sequence[float] | Matrix
         :return:
         :rtype: Matrix
         """
         ...
 
-    def __rsub__(self, other: typing.Sequence[float] | Matrix) -> Matrix:
+    def __rsub__(self, other: collections.abc.Sequence[float] | Matrix) -> Matrix:
         """
 
         :param other:
-        :type other: typing.Sequence[float] | Matrix
+        :type other: collections.abc.Sequence[float] | Matrix
         :return:
         :rtype: Matrix
         """
@@ -1007,10 +1021,10 @@ class Quaternion:
     :type: float
     """
 
-    axis: typing.Sequence[float] | Vector
+    axis: collections.abc.Sequence[float] | Vector
     """ Quaternion axis as a vector.
 
-    :type: typing.Sequence[float] | Vector
+    :type: collections.abc.Sequence[float] | Vector
     """
 
     is_frozen: bool
@@ -1084,21 +1098,21 @@ class Quaternion:
         """
         ...
 
-    def cross(self, other: typing.Sequence[float] | Quaternion) -> Quaternion:
+    def cross(self, other: collections.abc.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.Sequence[float] | Quaternion
+        :type other: collections.abc.Sequence[float] | Quaternion
         :return: The cross product.
         :rtype: Quaternion
         """
         ...
 
-    def dot(self, other: typing.Sequence[float] | Quaternion) -> float:
+    def dot(self, other: collections.abc.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.Sequence[float] | Quaternion
+        :type other: collections.abc.Sequence[float] | Quaternion
         :return: The dot product.
         :rtype: float
         """
@@ -1154,39 +1168,39 @@ class Quaternion:
 
     def rotate(
         self,
-        other: typing.Sequence[float]
+        other: collections.abc.Sequence[float]
         | Euler
-        | typing.Sequence[float]
+        | collections.abc.Sequence[float]
         | Quaternion
-        | typing.Sequence[float]
+        | collections.abc.Sequence[float]
         | Matrix,
     ):
         """Rotates the quaternion by another mathutils value.
 
         :param other: rotation component of mathutils value
-        :type other: typing.Sequence[float] | Euler | typing.Sequence[float] | Quaternion | typing.Sequence[float] | Matrix
+        :type other: collections.abc.Sequence[float] | Euler | collections.abc.Sequence[float] | Quaternion | collections.abc.Sequence[float] | Matrix
         """
         ...
 
     def rotation_difference(
-        self, other: typing.Sequence[float] | Quaternion
+        self, other: collections.abc.Sequence[float] | Quaternion
     ) -> Quaternion:
         """Returns a quaternion representing the rotational difference.
 
         :param other: second quaternion.
-        :type other: typing.Sequence[float] | Quaternion
+        :type other: collections.abc.Sequence[float] | Quaternion
         :return: the rotational difference between the two quat rotations.
         :rtype: Quaternion
         """
         ...
 
     def slerp(
-        self, other: typing.Sequence[float] | Quaternion, factor: float
+        self, other: collections.abc.Sequence[float] | Quaternion, factor: float
     ) -> Quaternion:
         """Returns the interpolation of two quaternions.
 
         :param other: value to interpolate with.
-        :type other: typing.Sequence[float] | Quaternion
+        :type other: collections.abc.Sequence[float] | Quaternion
         :param factor: The interpolation value in [0.0, 1.0].
         :type factor: float
         :return: The interpolated rotation.
@@ -1203,17 +1217,19 @@ class Quaternion:
         ...
 
     def to_euler(
-        self, order: str, euler_compat: typing.Sequence[float] | Euler
+        self,
+        order: str | None,
+        euler_compat: collections.abc.Sequence[float] | Euler | None,
     ) -> Euler:
         """Return Euler representation of the quaternion.
 
                 :param order: Optional rotation order argument in
         ['XYZ', 'XZY', 'YXZ', 'YZX', 'ZXY', 'ZYX'].
-                :type order: str
+                :type order: str | None
                 :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.Sequence[float] | Euler
+                :type euler_compat: collections.abc.Sequence[float] | Euler | None
                 :return: Euler representation of the quaternion.
                 :rtype: Euler
         """
@@ -1282,55 +1298,61 @@ class Quaternion:
         """
         ...
 
-    def __add__(self, other: typing.Sequence[float] | Quaternion) -> Quaternion:
+    def __add__(
+        self, other: collections.abc.Sequence[float] | Quaternion
+    ) -> Quaternion:
         """
 
         :param other:
-        :type other: typing.Sequence[float] | Quaternion
+        :type other: collections.abc.Sequence[float] | Quaternion
         :return:
         :rtype: Quaternion
         """
         ...
 
-    def __sub__(self, other: typing.Sequence[float] | Quaternion) -> Quaternion:
+    def __sub__(
+        self, other: collections.abc.Sequence[float] | Quaternion
+    ) -> Quaternion:
         """
 
         :param other:
-        :type other: typing.Sequence[float] | Quaternion
+        :type other: collections.abc.Sequence[float] | Quaternion
         :return:
         :rtype: Quaternion
         """
         ...
 
     def __mul__(
-        self, other: int | float | typing.Sequence[float] | Quaternion
+        self, other: int | float | collections.abc.Sequence[float] | Quaternion
     ) -> Quaternion:
         """
 
         :param other:
-        :type other: int | float | typing.Sequence[float] | Quaternion
+        :type other: int | float | collections.abc.Sequence[float] | Quaternion
         :return:
         :rtype: Quaternion
         """
         ...
 
     @typing.overload
-    def __matmul__(self, other: typing.Sequence[float] | Quaternion) -> Quaternion:
+    def __matmul__(
+        self, other: collections.abc.Sequence[float] | Quaternion
+    ) -> Quaternion:
         """
 
         :param other:
-        :type other: typing.Sequence[float] | Quaternion
+        :type other: collections.abc.Sequence[float] | Quaternion
         :return:
         :rtype: Quaternion
         """
         ...
 
     @typing.overload
-    def __matmul__(self, other: typing.Sequence[float] | Vector) -> Vector:
+    def __matmul__(self, other: collections.abc.Sequence[float] | Vector) -> Vector:
         """
 
         :param other:
-        :type other: typing.Sequence[float] | Vector
+        :type other: collections.abc.Sequence[float] | Vector
         :return:
         :rtype: Vector
         """
@@ -1338,56 +1360,63 @@ class Quaternion:
 
     def __matmul__(
         self,
-        other: typing.Sequence[float] | Vector | typing.Sequence[float] | Quaternion,
+        other: collections.abc.Sequence[float]
+        | Vector
+        | collections.abc.Sequence[float]
+        | Quaternion,
     ) -> Vector | Quaternion:
         """
 
         :param other:
-        :type other: typing.Sequence[float] | Vector | typing.Sequence[float] | Quaternion
+        :type other: collections.abc.Sequence[float] | Vector | collections.abc.Sequence[float] | Quaternion
         :return:
         :rtype: Vector | Quaternion
         """
         ...
 
-    def __radd__(self, other: typing.Sequence[float] | Quaternion) -> Quaternion:
+    def __radd__(
+        self, other: collections.abc.Sequence[float] | Quaternion
+    ) -> Quaternion:
         """
 
         :param other:
-        :type other: typing.Sequence[float] | Quaternion
+        :type other: collections.abc.Sequence[float] | Quaternion
         :return:
         :rtype: Quaternion
         """
         ...
 
-    def __rsub__(self, other: typing.Sequence[float] | Quaternion) -> Quaternion:
+    def __rsub__(
+        self, other: collections.abc.Sequence[float] | Quaternion
+    ) -> Quaternion:
         """
 
         :param other:
-        :type other: typing.Sequence[float] | Quaternion
+        :type other: collections.abc.Sequence[float] | Quaternion
         :return:
         :rtype: Quaternion
         """
         ...
 
     def __rmul__(
-        self, other: int | float | typing.Sequence[float] | Quaternion
+        self, other: int | float | collections.abc.Sequence[float] | Quaternion
     ) -> Quaternion:
         """
 
         :param other:
-        :type other: int | float | typing.Sequence[float] | Quaternion
+        :type other: int | float | collections.abc.Sequence[float] | Quaternion
         :return:
         :rtype: Quaternion
         """
         ...
 
     def __imul__(
-        self, other: int | float | typing.Sequence[float] | Quaternion
+        self, other: int | float | collections.abc.Sequence[float] | Quaternion
     ) -> Quaternion:
         """
 
         :param other:
-        :type other: int | float | typing.Sequence[float] | Quaternion
+        :type other: int | float | collections.abc.Sequence[float] | Quaternion
         :return:
         :rtype: Quaternion
         """
@@ -2515,12 +2544,14 @@ class Vector:
         ...
 
     def angle(
-        self, other: typing.Sequence[float] | Vector, fallback: typing.Any = None
+        self,
+        other: collections.abc.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.Sequence[float] | Vector
+                :type other: collections.abc.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
@@ -2530,12 +2561,12 @@ class Vector:
         ...
 
     def angle_signed(
-        self, other: typing.Sequence[float] | Vector, fallback: typing.Any
+        self, other: collections.abc.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.Sequence[float] | Vector
+                :type other: collections.abc.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
@@ -2552,21 +2583,21 @@ class Vector:
         """
         ...
 
-    def cross(self, other: typing.Sequence[float] | Vector) -> Vector:
+    def cross(self, other: collections.abc.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.Sequence[float] | Vector
+        :type other: collections.abc.Sequence[float] | Vector
         :return: The cross product.
         :rtype: Vector
         """
         ...
 
-    def dot(self, other: typing.Sequence[float] | Vector) -> float:
+    def dot(self, other: collections.abc.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.Sequence[float] | Vector
+        :type other: collections.abc.Sequence[float] | Vector
         :return: The dot product.
         :rtype: float
         """
@@ -2580,11 +2611,13 @@ class Vector:
         """
         ...
 
-    def lerp(self, other: typing.Sequence[float] | Vector, factor: float) -> Vector:
+    def lerp(
+        self, other: collections.abc.Sequence[float] | Vector, factor: float
+    ) -> Vector:
         """Returns the interpolation of two vectors.
 
         :param other: value to interpolate with.
-        :type other: typing.Sequence[float] | Vector
+        :type other: collections.abc.Sequence[float] | Vector
         :param factor: The interpolation value in [0.0, 1.0].
         :type factor: float
         :return: The interpolated vector.
@@ -2616,21 +2649,21 @@ class Vector:
         """
         ...
 
-    def project(self, other: typing.Sequence[float] | Vector) -> Vector:
+    def project(self, other: collections.abc.Sequence[float] | Vector) -> Vector:
         """Return the projection of this vector onto the other.
 
         :param other: second vector.
-        :type other: typing.Sequence[float] | Vector
+        :type other: collections.abc.Sequence[float] | Vector
         :return: the parallel projection vector
         :rtype: Vector
         """
         ...
 
-    def reflect(self, mirror: typing.Sequence[float] | Vector) -> Vector:
+    def reflect(self, mirror: collections.abc.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.Sequence[float] | Vector
+        :type mirror: collections.abc.Sequence[float] | Vector
         :return: The reflected vector matching the size of this vector.
         :rtype: Vector
         """
@@ -2666,26 +2699,28 @@ class Vector:
 
     def rotate(
         self,
-        other: typing.Sequence[float]
+        other: collections.abc.Sequence[float]
         | Euler
-        | typing.Sequence[float]
+        | collections.abc.Sequence[float]
         | Quaternion
-        | typing.Sequence[float]
+        | collections.abc.Sequence[float]
         | Matrix,
     ):
         """Rotate the vector by a rotation value.
 
         :param other: rotation component of mathutils value
-        :type other: typing.Sequence[float] | Euler | typing.Sequence[float] | Quaternion | typing.Sequence[float] | Matrix
+        :type other: collections.abc.Sequence[float] | Euler | collections.abc.Sequence[float] | Quaternion | collections.abc.Sequence[float] | Matrix
         """
         ...
 
-    def rotation_difference(self, other: typing.Sequence[float] | Vector) -> Quaternion:
+    def rotation_difference(
+        self, other: collections.abc.Sequence[float] | Vector
+    ) -> Quaternion:
         """Returns a quaternion representing the rotational difference between this
         vector and another.
 
                 :param other: second vector.
-                :type other: typing.Sequence[float] | Vector
+                :type other: collections.abc.Sequence[float] | Vector
                 :return: the rotational difference between the two vectors.
                 :rtype: Quaternion
         """
@@ -2693,14 +2728,14 @@ class Vector:
 
     def slerp(
         self,
-        other: typing.Sequence[float] | Vector,
+        other: collections.abc.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.Sequence[float] | Vector
+                :type other: collections.abc.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),
@@ -2806,21 +2841,21 @@ class Vector:
         """
         ...
 
-    def __add__(self, other: typing.Sequence[float] | Vector) -> Vector:
+    def __add__(self, other: collections.abc.Sequence[float] | Vector) -> Vector:
         """
 
         :param other:
-        :type other: typing.Sequence[float] | Vector
+        :type other: collections.abc.Sequence[float] | Vector
         :return:
         :rtype: Vector
         """
         ...
 
-    def __sub__(self, other: typing.Sequence[float] | Vector) -> Vector:
+    def __sub__(self, other: collections.abc.Sequence[float] | Vector) -> Vector:
         """
 
         :param other:
-        :type other: typing.Sequence[float] | Vector
+        :type other: collections.abc.Sequence[float] | Vector
         :return:
         :rtype: Vector
         """
@@ -2847,54 +2882,58 @@ class Vector:
         ...
 
     @typing.overload
-    def __matmul__(self, other: typing.Sequence[float] | Vector) -> float:
+    def __matmul__(self, other: collections.abc.Sequence[float] | Vector) -> float:
         """
 
         :param other:
-        :type other: typing.Sequence[float] | Vector
+        :type other: collections.abc.Sequence[float] | Vector
         :return:
         :rtype: float
         """
         ...
 
     @typing.overload
-    def __matmul__(self, other: typing.Sequence[float] | Matrix) -> Vector:
+    def __matmul__(self, other: collections.abc.Sequence[float] | Matrix) -> Vector:
         """
 
         :param other:
-        :type other: typing.Sequence[float] | Matrix
+        :type other: collections.abc.Sequence[float] | Matrix
         :return:
         :rtype: Vector
         """
         ...
 
     def __matmul__(
-        self, other: typing.Sequence[float] | Vector | typing.Sequence[float] | Matrix
+        self,
+        other: collections.abc.Sequence[float]
+        | Vector
+        | collections.abc.Sequence[float]
+        | Matrix,
     ) -> Vector | float:
         """
 
         :param other:
-        :type other: typing.Sequence[float] | Vector | typing.Sequence[float] | Matrix
+        :type other: collections.abc.Sequence[float] | Vector | collections.abc.Sequence[float] | Matrix
         :return:
         :rtype: Vector | float
         """
         ...
 
-    def __radd__(self, other: typing.Sequence[float] | Vector) -> Vector:
+    def __radd__(self, other: collections.abc.Sequence[float] | Vector) -> Vector:
         """
 
         :param other:
-        :type other: typing.Sequence[float] | Vector
+        :type other: collections.abc.Sequence[float] | Vector
         :return:
         :rtype: Vector
         """
         ...
 
-    def __rsub__(self, other: typing.Sequence[float] | Vector) -> Vector:
+    def __rsub__(self, other: collections.abc.Sequence[float] | Vector) -> Vector:
         """
 
         :param other:
-        :type other: typing.Sequence[float] | Vector
+        :type other: collections.abc.Sequence[float] | Vector
         :return:
         :rtype: Vector
         """
@@ -2920,21 +2959,21 @@ class Vector:
         """
         ...
 
-    def __iadd__(self, other: typing.Sequence[float] | Vector) -> Vector:
+    def __iadd__(self, other: collections.abc.Sequence[float] | Vector) -> Vector:
         """
 
         :param other:
-        :type other: typing.Sequence[float] | Vector
+        :type other: collections.abc.Sequence[float] | Vector
         :return:
         :rtype: Vector
         """
         ...
 
-    def __isub__(self, other: typing.Sequence[float] | Vector) -> Vector:
+    def __isub__(self, other: collections.abc.Sequence[float] | Vector) -> Vector:
         """
 
         :param other:
-        :type other: typing.Sequence[float] | Vector
+        :type other: collections.abc.Sequence[float] | Vector
         :return:
         :rtype: Vector
         """