fake-bpy-module-latest 20251003__py3-none-any.whl → 20260113__py3-none-any.whl

mathutils/__init__.pyi

@@ -409,8 +409,11 @@ class Euler:
     :type: bool
     """
 
-    order: typing.Any
-    """ Euler rotation order."""
+    order: typing.Literal["XYZ", "XZY", "YXZ", "YZX", "ZXY", "ZYX"]
+    """ Euler rotation order.
+
+    :type: typing.Literal['XYZ', 'XZY', 'YXZ', 'YZX', 'ZXY', 'ZYX']
+    """
 
     owner: typing.Any
     """ The item this is wrapping or None  (read-only)."""
@@ -476,7 +479,7 @@ class Euler:
 
     def rotate_axis(
         self,
-        axis,
+        axis: typing.Literal["X", "Y", "Z"],
         angle: float,
         /,
     ) -> None:
@@ -484,6 +487,7 @@ class Euler:
         (no 720 degree pitches).
 
                 :param axis: An axis string.
+                :type axis: typing.Literal['X', 'Y', 'Z']
                 :param angle: angle in radians.
                 :type angle: float
         """
@@ -704,7 +708,9 @@ class Matrix:
     @classmethod
     def OrthoProjection(
         cls,
-        axis: Vector | collections.abc.Sequence[float],
+        axis: Vector
+        | collections.abc.Sequence[float]
+        | typing.Literal["X", "Y", "XY", "XZ", "YZ"],
         size: int,
         /,
     ) -> typing_extensions.Self:
@@ -713,7 +719,7 @@ class Matrix:
                 :param axis: An axis string,
         where a single axis is for a 2D matrix.
         Or a vector for an arbitrary axis
-                :type axis: Vector | collections.abc.Sequence[float]
+                :type axis: Vector | collections.abc.Sequence[float] | typing.Literal['X', 'Y', 'XY', 'XZ', 'YZ']
                 :param size: The size of the projection matrix to construct [2, 4].
                 :type size: int
                 :return: A new projection matrix.
@@ -725,7 +731,10 @@ class Matrix:
         cls,
         angle: float,
         size: int,
-        axis: Vector | collections.abc.Sequence[float] | None = [],
+        axis: Vector
+        | collections.abc.Sequence[float]
+        | typing.Literal["X", "Y", "Z"]
+        | None = [],
         /,
     ) -> typing_extensions.Self:
         """Create a matrix representing a rotation.
@@ -736,7 +745,7 @@ class Matrix:
                 :type size: int
                 :param axis: an axis string or a 3D Vector Object
         (optional when size is 2).
-                :type axis: Vector | collections.abc.Sequence[float] | None
+                :type axis: Vector | collections.abc.Sequence[float] | typing.Literal['X', 'Y', 'Z'] | None
                 :return: A new rotation matrix.
                 :rtype: typing_extensions.Self
         """
@@ -764,7 +773,7 @@ class Matrix:
     @classmethod
     def Shear(
         cls,
-        plane,
+        plane: typing.Literal["X", "Y", "XY", "XZ", "YZ"],
         size: int,
         factor: collections.abc.Sequence[float] | float,
         /,
@@ -773,6 +782,7 @@ class Matrix:
 
                 :param plane: An axis string,
         where a single axis is for a 2D matrix only.
+                :type plane: typing.Literal['X', 'Y', 'XY', 'XZ', 'YZ']
                 :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.
@@ -1399,13 +1409,14 @@ class Quaternion:
 
     def to_euler(
         self,
-        order="XYZ",
+        order: typing.Literal["XYZ", "XZY", "YXZ", "YZX", "ZXY", "ZYX"] = "XYZ",
         euler_compat: Euler | collections.abc.Sequence[float] | None = None,
         /,
     ) -> Euler:
         """Return Euler representation of the quaternion.
 
                 :param order: Rotation order.
+                :type order: typing.Literal['XYZ', 'XZY', 'YXZ', 'YZX', 'ZXY', 'ZYX']
                 :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.
@@ -1415,7 +1426,7 @@ class Quaternion:
         """
 
     def to_exponential_map(self) -> None:
-        """Return the exponential map representation of the quaternion.This representation consist of the rotation axis multiplied by the rotation angle.
+        """Return the exponential map representation of the quaternion.This representation consists of the rotation axis multiplied by the rotation angle.
         Such a representation is useful for interpolation between multiple orientations.To convert back to a quaternion, pass it to the `Quaternion` constructor.
 
                 :return: exponential map.
@@ -1430,13 +1441,14 @@ class Quaternion:
 
     def to_swing_twist(
         self,
-        axis,
+        axis: typing.Literal["X", "Y", "Z"],
         /,
     ) -> 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.
+                :type axis: typing.Literal['X', 'Y', 'Z']
                 :return: Swing, twist angle.
                 :rtype: tuple[Quaternion, float]
         """
@@ -3707,31 +3719,35 @@ class Vector:
         size: int,
         fill: float = 0.0,
         /,
-    ) -> None:
+    ) -> typing_extensions.Self:
         """Create a vector of length size with all values set to fill.
 
         :param size: The length of the vector to be created.
         :type size: int
         :param fill: The value used to fill the vector.
         :type fill: float
+        :return: A new vector.
+        :rtype: typing_extensions.Self
         """
 
     @classmethod
     def Linspace(
         cls,
-        start: int,
-        stop: int,
+        start: float,
+        stop: float,
         size: int,
         /,
-    ) -> None:
+    ) -> typing_extensions.Self:
         """Create a vector of the specified size which is filled with linearly spaced values between start and stop values.
 
         :param start: The start of the range used to fill the vector.
-        :type start: int
+        :type start: float
         :param stop: The end of the range used to fill the vector.
-        :type stop: int
+        :type stop: float
         :param size: The size of the vector to be created.
         :type size: int
+        :return: A new vector.
+        :rtype: typing_extensions.Self
         """
 
     @classmethod
@@ -3741,8 +3757,8 @@ class Vector:
         stop: int,
         step: int = 1,
         /,
-    ) -> None:
-        """Create a filled with a range of values.
+    ) -> typing_extensions.Self:
+        """Create a vector filled with a range of values.
 
         :param start: The start of the range used to fill the vector.
         :type start: int
@@ -3750,6 +3766,8 @@ class Vector:
         :type stop: int
         :param step: The step between successive values in the vector.
         :type step: int
+        :return: A new vector.
+        :rtype: typing_extensions.Self
         """
 
     @classmethod
@@ -3758,13 +3776,15 @@ class Vector:
         vector: collections.abc.Sequence[float] | typing_extensions.Self,
         size: int,
         /,
-    ) -> None:
+    ) -> typing_extensions.Self:
         """Create a vector by repeating the values in vector until the required size is reached.
 
         :param vector: The vector to draw values from.
         :type vector: collections.abc.Sequence[float] | typing_extensions.Self
         :param size: The size of the vector to be created.
         :type size: int
+        :return: A new vector.
+        :rtype: typing_extensions.Self
         """
 
     def angle(
@@ -3905,32 +3925,34 @@ class Vector:
 
     def resize(
         self,
-        size,
+        size: int,
         /,
     ) -> None:
         """Resize the vector to have size number of elements.
 
-        :param size:
+        :param size: The new size of the vector.
+        :type size: int
         """
 
     def resize_2d(self) -> None:
-        """Resize the vector to 2D  (x, y)."""
+        """Resize the vector to 2D (x, y)."""
 
     def resize_3d(self) -> None:
-        """Resize the vector to 3D  (x, y, z)."""
+        """Resize the vector to 3D (x, y, z)."""
 
     def resize_4d(self) -> None:
         """Resize the vector to 4D (x, y, z, w)."""
 
     def resized(
         self,
-        size,
+        size: int,
         /,
     ) -> typing_extensions.Self:
         """Return a resized copy of the vector with size number of elements.
 
-        :param size:
-        :return: a new vector
+        :param size: The new size of the vector.
+        :type size: int
+        :return: A new vector.
         :rtype: typing_extensions.Self
         """
 
@@ -4006,14 +4028,16 @@ class Vector:
 
     def to_track_quat(
         self,
-        track="Z",
-        up="Y",
+        track: typing.Literal["-", "X", "Y", "Z", "-X", "-Y", "-Z"] = "Z",
+        up: typing.Literal["X", "Y", "Z"] = "Y",
         /,
     ) -> Quaternion:
         """Return a quaternion rotation from the vector and the track and up axis.
 
         :param track: Track axis string.
+        :type track: typing.Literal['-', 'X', 'Y', 'Z', '-X', '-Y', '-Z']
         :param up: Up axis string.
+        :type up: typing.Literal['X', 'Y', 'Z']
         :return: rotation from the vector and the track and up axis.
         :rtype: Quaternion
         """

mathutils/bvhtree/__init__.pyi

@@ -72,7 +72,7 @@ class BVHTree:
 
     def find_nearest(
         self,
-        origin,
+        origin: collections.abc.Sequence[float] | mathutils.Vector,
         distance: float = 1.84467e19,
         /,
     ) -> tuple[
@@ -80,7 +80,8 @@ class BVHTree:
     ]:
         """Find the nearest element (typically face index) to a point.
 
-                :param origin:
+                :param origin: Find nearest element to this point.
+                :type origin: collections.abc.Sequence[float] | mathutils.Vector
                 :param distance: Maximum distance threshold.
                 :type distance: float
                 :return: Returns a tuple: (position, normal, index, distance),

mathutils/geometry/__init__.pyi

@@ -103,6 +103,7 @@ def closest_point_on_tri(
 
 def convex_hull_2d(
     points: collections.abc.Sequence[collections.abc.Sequence[float]],
+    /,
 ) -> list[int]:
     """Returns a list of indices into the list given
 
@@ -286,7 +287,7 @@ def intersect_line_sphere(
         :type sphere_co: collections.abc.Sequence[float] | mathutils.Vector
         :param sphere_radius: Radius of the sphere
         :type sphere_radius: float
-        :param clip: When False, dont restrict the intersection to the area of the sphere.
+        :param clip: When False, dont restrict the intersection to the line segment.
         :type clip: bool
         :return: The intersection points as a pair of vectors or None when there is no intersection
         :rtype: tuple[mathutils.Vector | None, mathutils.Vector | None]
@@ -311,7 +312,7 @@ def intersect_line_sphere_2d(
         :type sphere_co: collections.abc.Sequence[float] | mathutils.Vector
         :param sphere_radius: Radius of the sphere
         :type sphere_radius: float
-        :param clip: When False, dont restrict the intersection to the area of the sphere.
+        :param clip: When False, dont restrict the intersection to the line segment.
         :type clip: bool
         :return: The intersection points as a pair of vectors or None when there is no intersection
         :rtype: tuple[mathutils.Vector | None, mathutils.Vector | None]
@@ -472,7 +473,7 @@ def intersect_sphere_sphere_2d(
     radius_b: float,
     /,
 ) -> tuple[None, None] | tuple[mathutils.Vector, mathutils.Vector]:
-    """Returns 2 points on between intersecting circles.
+    """Returns 2 points between intersecting circles.
 
     :param p_a: Center of the first circle
     :type p_a: collections.abc.Sequence[float] | mathutils.Vector
@@ -482,21 +483,34 @@ def intersect_sphere_sphere_2d(
     :type p_b: collections.abc.Sequence[float] | mathutils.Vector
     :param radius_b: Radius of the second circle
     :type radius_b: float
-    :return: 2 points on between intersecting circles or None when there is no intersection.
+    :return: 2 points between intersecting circles or None when there is no intersection.
     :rtype: tuple[None, None] | tuple[mathutils.Vector, mathutils.Vector]
     """
 
 def intersect_tri_tri_2d(
-    tri_a1,
-    tri_a2,
-    tri_a3,
-    tri_b1,
-    tri_b2,
-    tri_b3,
+    tri_a1: collections.abc.Sequence[float] | mathutils.Vector,
+    tri_a2: collections.abc.Sequence[float] | mathutils.Vector,
+    tri_a3: collections.abc.Sequence[float] | mathutils.Vector,
+    tri_b1: collections.abc.Sequence[float] | mathutils.Vector,
+    tri_b2: collections.abc.Sequence[float] | mathutils.Vector,
+    tri_b3: collections.abc.Sequence[float] | mathutils.Vector,
     /,
 ) -> bool:
     """Check if two 2D triangles intersect.
 
+    :param tri_a1: First vertex of the first triangle.
+    :type tri_a1: collections.abc.Sequence[float] | mathutils.Vector
+    :param tri_a2: Second vertex of the first triangle.
+    :type tri_a2: collections.abc.Sequence[float] | mathutils.Vector
+    :param tri_a3: Third vertex of the first triangle.
+    :type tri_a3: collections.abc.Sequence[float] | mathutils.Vector
+    :param tri_b1: First vertex of the second triangle.
+    :type tri_b1: collections.abc.Sequence[float] | mathutils.Vector
+    :param tri_b2: Second vertex of the second triangle.
+    :type tri_b2: collections.abc.Sequence[float] | mathutils.Vector
+    :param tri_b3: Third vertex of the second triangle.
+    :type tri_b3: collections.abc.Sequence[float] | mathutils.Vector
+    :return: True if the triangles intersect.
     :rtype: bool
     """
 
@@ -520,21 +534,25 @@ def points_in_planes(
 
     :param planes: List of planes (4D vectors).
     :type planes: list[collections.abc.Sequence[float] | mathutils.Vector]
-    :param epsilon_coplanar: Epsilon value for interpreting plane pairs as co-plannar.
+    :param epsilon_coplanar: Epsilon value for interpreting plane pairs as co-planar.
     :type epsilon_coplanar: float
     :param epsilon_isect: Epsilon value for intersection.
     :type epsilon_isect: float
-    :return: Two lists, once containing the 3D coordinates inside the planes, another containing the plane indices used.
+    :return: Two lists, one containing the 3D coordinates inside the planes, another containing the plane indices used.
     :rtype: tuple[list[mathutils.Vector], list[int]]
     """
 
 def tessellate_polygon(
-    polylines,
+    polylines: collections.abc.Sequence[
+        collections.abc.Sequence[collections.abc.Sequence[float]]
+    ],
     /,
 ) -> list[tuple[int, int, int]]:
     """Takes a list of polylines (each point a pair or triplet of numbers) and returns the point indices for a polyline filled with triangles. Does not handle degenerate geometry (such as zero-length lines due to consecutive identical points).
 
     :param polylines: Polygons where each polygon is a sequence of 2D or 3D points.
+    :type polylines: collections.abc.Sequence[collections.abc.Sequence[collections.abc.Sequence[float]]]
+    :return: A list of triangles.
     :rtype: list[tuple[int, int, int]]
     """
 

mathutils/interpolate/__init__.pyi

@@ -10,13 +10,15 @@ import numpy.typing as npt
 
 def poly_3d_calc(
     veclist: collections.abc.Sequence[collections.abc.Sequence[float]],
-    pt,
+    pt: collections.abc.Sequence[float],
     /,
 ) -> list[float]:
     """Calculate barycentric weights for a point on a polygon.
 
     :param veclist: Sequence of 3D positions.
     :type veclist: collections.abc.Sequence[collections.abc.Sequence[float]]
-    :param pt: 2D or 3D position.   :type pt: Sequence[float]   :return: list of per-vector weights.
+    :param pt: 2D or 3D position.
+    :type pt: collections.abc.Sequence[float]
+    :return: list of per-vector weights.
     :rtype: list[float]
     """