fake-bge-module 20250103__py3-none-any.whl → 20250201__py3-none-any.whl

mathutils/__init__.pyi

@@ -171,10 +171,11 @@ class Color:
         :rtype: typing_extensions.Self
         """
 
-    def __init__(self, rgb=(0.0, 0.0, 0.0)):
+    def __init__(self, rgb: collections.abc.Sequence[float] = (0.0, 0.0, 0.0)):
         """
 
         :param rgb:
+        :type rgb: collections.abc.Sequence[float]
         """
 
     def __get__(self, instance, owner) -> typing_extensions.Self:
@@ -347,13 +348,13 @@ class Color:
         """
 
     @typing.overload
-    def __setitem__(self, key: slice, value: collections.abc.Iterable[float]):
+    def __setitem__(self, key: slice, value: collections.abc.Iterable[float] | Color):
         """
 
         :param key:
         :type key: slice
         :param value:
-        :type value: collections.abc.Iterable[float]
+        :type value: collections.abc.Iterable[float] | Color
         """
 
 class Euler:
@@ -422,10 +423,18 @@ class Euler:
                 :param other:
         """
 
-    def rotate(self, other):
+    def rotate(
+        self,
+        other: Matrix
+        | Quaternion
+        | collections.abc.Sequence[collections.abc.Sequence[float]]
+        | collections.abc.Sequence[float]
+        | typing_extensions.Self,
+    ):
         """Rotates the euler by another mathutils value.
 
         :param other: rotation component of mathutils value
+        :type other: Matrix | Quaternion | collections.abc.Sequence[collections.abc.Sequence[float]] | collections.abc.Sequence[float] | typing_extensions.Self
         """
 
     def rotate_axis(self, axis: str, angle: float):
@@ -455,11 +464,17 @@ class Euler:
     def zero(self):
         """Set all values to zero."""
 
-    def __init__(self, angles=(0.0, 0.0, 0.0), order="XYZ"):
+    def __init__(
+        self,
+        angles: collections.abc.Sequence[float] = (0.0, 0.0, 0.0),
+        order: str = "XYZ",
+    ):
         """
 
         :param angles:
+        :type angles: collections.abc.Sequence[float]
         :param order:
+        :type order: str
         """
 
     def __get__(self, instance, owner) -> typing_extensions.Self:
@@ -512,13 +527,13 @@ class Euler:
         """
 
     @typing.overload
-    def __setitem__(self, key: slice, value: collections.abc.Iterable[float]):
+    def __setitem__(self, key: slice, value: collections.abc.Iterable[float] | Euler):
         """
 
         :param key:
         :type key: slice
         :param value:
-        :type value: collections.abc.Iterable[float]
+        :type value: collections.abc.Iterable[float] | Euler
         """
 
 class Matrix:
@@ -612,24 +627,40 @@ class Matrix:
         """
 
     @classmethod
-    def LocRotScale(cls, location, rotation, scale) -> typing_extensions.Self:
+    def LocRotScale(
+        cls,
+        location: None | Vector | collections.abc.Sequence[float],
+        rotation: Euler
+        | None
+        | Quaternion
+        | collections.abc.Sequence[collections.abc.Sequence[float]]
+        | collections.abc.Sequence[float]
+        | typing_extensions.Self,
+        scale: None | Vector | collections.abc.Sequence[float],
+    ) -> typing_extensions.Self:
         """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: None | Vector | collections.abc.Sequence[float]
                 :param rotation: The rotation component as a 3x3 matrix, quaternion, euler or None for no rotation.
+                :type rotation: Euler | None | Quaternion | collections.abc.Sequence[collections.abc.Sequence[float]] | collections.abc.Sequence[float] | typing_extensions.Self
                 :param scale: The scale component.
+                :type scale: None | Vector | collections.abc.Sequence[float]
                 :return: Combined transformation as a 4x4 matrix.
                 :rtype: typing_extensions.Self
         """
 
     @classmethod
-    def OrthoProjection(cls, axis, size: int) -> typing_extensions.Self:
+    def OrthoProjection(
+        cls, axis: Vector | collections.abc.Sequence[float] | str, size: int
+    ) -> typing_extensions.Self:
         """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: Vector | collections.abc.Sequence[float] | str
                 :param size: The size of the projection matrix to construct [2, 4].
                 :type size: int
                 :return: A new projection matrix.
@@ -637,7 +668,12 @@ class Matrix:
         """
 
     @classmethod
-    def Rotation(cls, angle: float, size: int, axis) -> typing_extensions.Self:
+    def Rotation(
+        cls,
+        angle: float,
+        size: int,
+        axis: Vector | collections.abc.Sequence[float] | str | None = "",
+    ) -> typing_extensions.Self:
         """Create a matrix representing a rotation.
 
                 :param angle: The angle of rotation desired, in radians.
@@ -646,6 +682,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: Vector | collections.abc.Sequence[float] | str | None
                 :return: A new rotation matrix.
                 :rtype: typing_extensions.Self
         """
@@ -670,7 +707,9 @@ class Matrix:
         """
 
     @classmethod
-    def Shear(cls, plane: str, size: int, factor) -> typing_extensions.Self:
+    def Shear(
+        cls, plane: str, size: int, factor: collections.abc.Sequence[float] | float
+    ) -> typing_extensions.Self:
         """Create a matrix to represent an shear transformation.
 
                 :param plane: Can be any of the following: ['X', 'Y', 'XY', 'XZ', 'YZ'],
@@ -679,6 +718,7 @@ class Matrix:
                 :param size: The size of the shear matrix to construct [2, 4].
                 :type size: int
                 :param factor: The factor of shear to apply. For a 2 size matrix use a single float. For a 3 or 4 size matrix pass a pair of floats corresponding with the plane axis.
+                :type factor: collections.abc.Sequence[float] | float
                 :return: A new shear matrix.
                 :rtype: typing_extensions.Self
         """
@@ -712,11 +752,11 @@ class Matrix:
         :rtype: typing_extensions.Self
         """
 
-    def decompose(self) -> Quaternion:
+    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: Quaternion
+        :rtype: tuple[Vector, Quaternion, Vector]
         """
 
     def determinant(self) -> float:
@@ -756,12 +796,16 @@ class Matrix:
 
         """
 
-    def inverted(self, fallback=None):
+    def inverted(
+        self, fallback: typing.Any | None = None
+    ) -> typing.Any | typing_extensions.Self:
         """Return an inverted copy of the matrix.
 
                 :param fallback: return this when the inverse can't be calculated
         (instead of raising a `ValueError`).
+                :type fallback: typing.Any | None
                 :return: The inverted matrix or fallback when given.
+                :rtype: typing.Any | typing_extensions.Self
         """
 
     def inverted_safe(self) -> typing_extensions.Self:
@@ -802,10 +846,18 @@ class Matrix:
     def resize_4x4(self):
         """Resize the matrix to 4x4."""
 
-    def rotate(self, other):
+    def rotate(
+        self,
+        other: Euler
+        | Quaternion
+        | collections.abc.Sequence[collections.abc.Sequence[float]]
+        | collections.abc.Sequence[float]
+        | typing_extensions.Self,
+    ):
         """Rotates the matrix by another mathutils value.
 
         :param other: rotation component of mathutils value
+        :type other: Euler | Quaternion | collections.abc.Sequence[collections.abc.Sequence[float]] | collections.abc.Sequence[float] | typing_extensions.Self
         """
 
     def to_2x2(self) -> typing_extensions.Self:
@@ -884,7 +936,7 @@ class Matrix:
 
     def __init__(
         self,
-        rows=(
+        rows: collections.abc.Sequence[collections.abc.Sequence[float]] = (
             (1.0, 0.0, 0.0, 0.0),
             (0.0, 1.0, 0.0, 0.0),
             (0.0, 0.0, 1.0, 0.0),
@@ -894,6 +946,7 @@ class Matrix:
         """
 
         :param rows:
+        :type rows: collections.abc.Sequence[collections.abc.Sequence[float]]
         """
 
     def __get__(self, instance, owner) -> typing_extensions.Self:
@@ -952,14 +1005,15 @@ class Matrix:
     def __setitem__(
         self,
         key: slice,
-        value: collections.abc.Iterable[Vector | collections.abc.Iterable[float]],
+        value: collections.abc.Iterable[Vector | collections.abc.Iterable[float]]
+        | Matrix,
     ):
         """
 
         :param key:
         :type key: slice
         :param value:
-        :type value: collections.abc.Iterable[Vector | collections.abc.Iterable[float]]
+        :type value: collections.abc.Iterable[Vector | collections.abc.Iterable[float]] | Matrix
         """
 
     def __len__(self) -> int:
@@ -1217,10 +1271,18 @@ class Quaternion:
         :rtype: typing_extensions.Self
         """
 
-    def rotate(self, other):
+    def rotate(
+        self,
+        other: Euler
+        | Matrix
+        | collections.abc.Sequence[collections.abc.Sequence[float]]
+        | collections.abc.Sequence[float]
+        | typing_extensions.Self,
+    ):
         """Rotates the quaternion by another mathutils value.
 
         :param other: rotation component of mathutils value
+        :type other: Euler | Matrix | collections.abc.Sequence[collections.abc.Sequence[float]] | collections.abc.Sequence[float] | typing_extensions.Self
         """
 
     def rotation_difference(
@@ -1249,10 +1311,11 @@ class Quaternion:
         :rtype: typing_extensions.Self
         """
 
-    def to_axis_angle(self):
+    def to_axis_angle(self) -> tuple[Vector, float]:
         """Return the axis, angle representation of the quaternion.
 
         :return: Axis, angle.
+        :rtype: tuple[Vector, float]
         """
 
     def to_euler(
@@ -1287,19 +1350,27 @@ class Quaternion:
         :rtype: Matrix
         """
 
-    def to_swing_twist(self, axis: str):
+    def to_swing_twist(self, axis: str) -> 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'].
                 :type axis: str
                 :return: Swing, twist angle.
+                :rtype: tuple[Quaternion, float]
         """
 
-    def __init__(self, seq=(1.0, 0.0, 0.0, 0.0)):
+    def __init__(
+        self,
+        seq: Vector | collections.abc.Sequence[float] = (1.0, 0.0, 0.0, 0.0),
+        angle: float = 0.0,
+    ):
         """
 
         :param seq:
+        :type seq: Vector | collections.abc.Sequence[float]
+        :param angle:
+        :type angle: float
         """
 
     def __get__(self, instance, owner) -> typing_extensions.Self:
@@ -1359,13 +1430,15 @@ class Quaternion:
         """
 
     @typing.overload
-    def __setitem__(self, key: slice, value: collections.abc.Iterable[float]):
+    def __setitem__(
+        self, key: slice, value: collections.abc.Iterable[float] | Quaternion
+    ):
         """
 
         :param key:
         :type key: slice
         :param value:
-        :type value: collections.abc.Iterable[float]
+        :type value: collections.abc.Iterable[float] | Quaternion
         """
 
     def __add__(
@@ -3598,29 +3671,33 @@ class Vector:
     def angle(
         self,
         other: collections.abc.Sequence[float] | typing_extensions.Self,
-        fallback=None,
-    ):
+        fallback: typing.Any | None = None,
+    ) -> float | typing.Any:
         """Return the angle between two vectors.
 
                 :param other: another vector to compare the angle with
                 :type other: collections.abc.Sequence[float] | typing_extensions.Self
                 :param fallback: return this when the angle can't be calculated (zero length vector),
         (instead of raising a `ValueError`).
+                :type fallback: typing.Any | None
                 :return: angle in radians or fallback when given
+                :rtype: float | typing.Any
         """
 
     def angle_signed(
         self,
         other: collections.abc.Sequence[float] | typing_extensions.Self,
-        fallback=None,
-    ):
+        fallback: typing.Any | None = None,
+    ) -> float | typing.Any:
         """Return the signed angle between two 2D vectors (clockwise is positive).
 
                 :param other: another vector to compare the angle with
                 :type other: collections.abc.Sequence[float] | typing_extensions.Self
                 :param fallback: return this when the angle can't be calculated (zero length vector),
         (instead of raising a `ValueError`).
+                :type fallback: typing.Any | None
                 :return: angle in radians or fallback when given
+                :rtype: float | typing.Any
         """
 
     def copy(self) -> typing_extensions.Self:
@@ -3630,12 +3707,15 @@ class Vector:
         :rtype: typing_extensions.Self
         """
 
-    def cross(self, other: collections.abc.Sequence[float] | typing_extensions.Self):
+    def cross(
+        self, other: collections.abc.Sequence[float] | typing_extensions.Self
+    ) -> float | typing_extensions.Self:
         """Return the cross product of this vector and another.
 
         :param other: The other vector to perform the cross product with.
         :type other: collections.abc.Sequence[float] | typing_extensions.Self
         :return: The cross product as a vector or a float when 2D vectors are used.
+        :rtype: float | typing_extensions.Self
         """
 
     def dot(
@@ -3736,10 +3816,18 @@ class Vector:
         :rtype: typing_extensions.Self
         """
 
-    def rotate(self, other):
+    def rotate(
+        self,
+        other: Euler
+        | Matrix
+        | Quaternion
+        | collections.abc.Sequence[collections.abc.Sequence[float]]
+        | collections.abc.Sequence[float],
+    ):
         """Rotate the vector by a rotation value.
 
         :param other: rotation component of mathutils value
+        :type other: Euler | Matrix | Quaternion | collections.abc.Sequence[collections.abc.Sequence[float]] | collections.abc.Sequence[float]
         """
 
     def rotation_difference(
@@ -3758,7 +3846,7 @@ class Vector:
         self,
         other: collections.abc.Sequence[float] | typing_extensions.Self,
         factor: float,
-        fallback=None,
+        fallback: typing.Any | None = None,
     ) -> typing_extensions.Self:
         """Returns the interpolation of two non-zero vectors (spherical coordinates).
 
@@ -3768,6 +3856,7 @@ class Vector:
                 :type factor: float
                 :param fallback: return this when the vector can't be calculated (zero length vector or direct opposites),
         (instead of raising a `ValueError`).
+                :type fallback: typing.Any | None
                 :return: The interpolated vector.
                 :rtype: typing_extensions.Self
         """
@@ -3804,21 +3893,23 @@ class Vector:
         :rtype: Quaternion
         """
 
-    def to_tuple(self, precision: int = -1):
+    def to_tuple(self, precision: int = -1) -> tuple[float, ...]:
         """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: tuple[float, ...]
         """
 
     def zero(self):
         """Set all values to zero."""
 
-    def __init__(self, seq=(0.0, 0.0, 0.0)):
+    def __init__(self, seq: collections.abc.Sequence[float] = (0.0, 0.0, 0.0)):
         """
 
         :param seq:
+        :type seq: collections.abc.Sequence[float]
         """
 
     def __get__(self, instance, owner) -> typing_extensions.Self:
@@ -3878,13 +3969,13 @@ class Vector:
         """
 
     @typing.overload
-    def __setitem__(self, key: slice, value: collections.abc.Iterable[float]):
+    def __setitem__(self, key: slice, value: collections.abc.Iterable[float] | Vector):
         """
 
         :param key:
         :type key: slice
         :param value:
-        :type value: collections.abc.Iterable[float]
+        :type value: collections.abc.Iterable[float] | Vector
         """
 
     def __neg__(self) -> typing_extensions.Self:

mathutils/bvhtree/__init__.pyi

@@ -48,19 +48,29 @@ class BVHTree:
 
     @classmethod
     def FromPolygons(
-        cls, vertices, polygons, all_triangles: bool = False, epsilon: float = 0.0
+        cls,
+        vertices: collections.abc.Sequence[collections.abc.Sequence[float]],
+        polygons: collections.abc.Sequence[collections.abc.Sequence[int]],
+        all_triangles: bool = False,
+        epsilon: float = 0.0,
     ):
         """BVH tree constructed geometry passed in as arguments.
 
         :param vertices: float triplets each representing (x, y, z)
+        :type vertices: collections.abc.Sequence[collections.abc.Sequence[float]]
         :param polygons: Sequence of polygons, each containing indices to the vertices argument.
+        :type polygons: collections.abc.Sequence[collections.abc.Sequence[int]]
         :param all_triangles: Use when all polygons are triangles for more efficient conversion.
         :type all_triangles: bool
         :param epsilon: Increase the threshold for detecting overlap and raycast hits.
         :type epsilon: float
         """
 
-    def find_nearest(self, origin, distance: float = 1.84467e19):
+    def find_nearest(
+        self, origin, distance: float = 1.84467e19
+    ) -> tuple[
+        mathutils.Vector | None, mathutils.Vector | None, int | None, float | None
+    ]:
         """Find the nearest element (typically face index) to a point.
 
                 :param origin:
@@ -68,26 +78,28 @@ class BVHTree:
                 :type distance: float
                 :return: Returns a tuple: (position, normal, index, distance),
         Values will all be None if no hit is found.
+                :rtype: tuple[mathutils.Vector | None, mathutils.Vector | None, int | None, float | None]
         """
 
     def find_nearest_range(
         self, origin, distance: float = 1.84467e19
-    ) -> int | mathutils.Vector:
+    ) -> list[tuple[mathutils.Vector, mathutils.Vector, int, float]]:
         """Find the nearest elements (typically face index) to a point in the distance range.
 
         :param origin:
         :param distance: Maximum distance threshold.
         :type distance: float
         :return: Returns a list of tuples (position, normal, index, distance)
-        :rtype: int | mathutils.Vector
+        :rtype: list[tuple[mathutils.Vector, mathutils.Vector, int, float]]
         """
 
-    def overlap(self, other_tree: typing_extensions.Self):
+    def overlap(self, other_tree: typing_extensions.Self) -> list[tuple[int, int]]:
         """Find overlapping indices between 2 trees.
 
         :param other_tree: Other tree to perform overlap test on.
         :type other_tree: typing_extensions.Self
         :return: Returns a list of unique index pairs,      the first index referencing this tree, the second referencing the other_tree.
+        :rtype: list[tuple[int, int]]
         """
 
     def ray_cast(
@@ -95,7 +107,9 @@ class BVHTree:
         origin: collections.abc.Sequence[float] | mathutils.Vector,
         direction: collections.abc.Sequence[float] | mathutils.Vector,
         distance: float = sys.float_info.max,
-    ):
+    ) -> tuple[
+        mathutils.Vector | None, mathutils.Vector | None, int | None, float | None
+    ]:
         """Cast a ray onto the mesh.
 
                 :param origin: Start location of the ray in object space.
@@ -106,6 +120,7 @@ class BVHTree:
                 :type distance: float
                 :return: Returns a tuple: (position, normal, index, distance),
         Values will all be None if no hit is found.
+                :rtype: tuple[mathutils.Vector | None, mathutils.Vector | None, int | None, float | None]
         """
 
     def __init__(self, size):