fake-bpy-module 20241229__py3-none-any.whl → 20241230__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:
@@ -463,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:
@@ -622,23 +629,24 @@ class Matrix:
     @classmethod
     def LocRotScale(
         cls,
-        location: Vector | collections.abc.Sequence[float],
+        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: Vector | collections.abc.Sequence[float],
+        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: Vector | collections.abc.Sequence[float]
+                :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 | Quaternion | collections.abc.Sequence[collections.abc.Sequence[float]] | collections.abc.Sequence[float] | typing_extensions.Self
+                :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: Vector | collections.abc.Sequence[float]
+                :type scale: None | Vector | collections.abc.Sequence[float]
                 :return: Combined transformation as a 4x4 matrix.
                 :rtype: typing_extensions.Self
         """
@@ -699,7 +707,9 @@ class Matrix:
         """
 
     @classmethod
-    def Shear(cls, plane: str, size: int, factor: float) -> 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'],
@@ -708,7 +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: float
+                :type factor: collections.abc.Sequence[float] | float
                 :return: A new shear matrix.
                 :rtype: typing_extensions.Self
         """
@@ -926,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),
@@ -936,6 +946,7 @@ class Matrix:
         """
 
         :param rows:
+        :type rows: collections.abc.Sequence[collections.abc.Sequence[float]]
         """
 
     def __get__(self, instance, owner) -> typing_extensions.Self:
@@ -1348,10 +1359,17 @@ class Quaternion:
                 :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:
@@ -3884,10 +3902,11 @@ class Vector:
     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:

mathutils/bvhtree/__init__.pyi

@@ -48,12 +48,18 @@ 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.
@@ -62,7 +68,9 @@ class BVHTree:
 
     def find_nearest(
         self, origin, distance: float = 1.84467e19
-    ) -> tuple[mathutils.Vector, mathutils.Vector, int, float]:
+    ) -> tuple[
+        mathutils.Vector | None, mathutils.Vector | None, int | None, float | None
+    ]:
         """Find the nearest element (typically face index) to a point.
 
                 :param origin:
@@ -70,7 +78,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, mathutils.Vector, int, float]
+                :rtype: tuple[mathutils.Vector | None, mathutils.Vector | None, int | None, float | None]
         """
 
     def find_nearest_range(
@@ -99,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, mathutils.Vector, int, float]:
+    ) -> 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.
@@ -110,7 +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, mathutils.Vector, int, float]
+                :rtype: tuple[mathutils.Vector | None, mathutils.Vector | None, int | None, float | None]
         """
 
     def __init__(self, size):

mathutils/geometry/__init__.pyi

@@ -53,10 +53,13 @@ def barycentric_transform(
     :rtype: mathutils.Vector
     """
 
-def box_fit_2d(points) -> float:
+def box_fit_2d(
+    points: collections.abc.Sequence[collections.abc.Sequence[float]],
+) -> float:
     """Returns an angle that best fits the points to an axis aligned rectangle
 
     :param points: Sequence of 2D points.
+    :type points: collections.abc.Sequence[collections.abc.Sequence[float]]
     :return: angle
     :rtype: float
     """
@@ -92,16 +95,26 @@ def closest_point_on_tri(
     :rtype: mathutils.Vector
     """
 
-def convex_hull_2d(points) -> list[int]:
+def convex_hull_2d(
+    points: collections.abc.Sequence[collections.abc.Sequence[float]],
+) -> list[int]:
     """Returns a list of indices into the list given
 
     :param points: Sequence of 2D points.
+    :type points: collections.abc.Sequence[collections.abc.Sequence[float]]
     :return: a list of indices
     :rtype: list[int]
     """
 
 def delaunay_2d_cdt(
-    vert_coords, edges, faces, output_type: int, epsilon: float, need_ids=True
+    vert_coords: collections.abc.Sequence[
+        collections.abc.Sequence[float] | mathutils.Vector
+    ],
+    edges: collections.abc.Sequence[collections.abc.Sequence[int, int]],
+    faces: collections.abc.Sequence[collections.abc.Sequence[int]],
+    output_type: int,
+    epsilon: float,
+    need_ids=True,
 ) -> tuple[
     list[mathutils.Vector],
     list[tuple[int, int]],
@@ -124,8 +137,11 @@ def delaunay_2d_cdt(
     of the orig arrays, which may save some time.
 
         :param vert_coords: Vertex coordinates (2d)
+        :type vert_coords: collections.abc.Sequence[collections.abc.Sequence[float] | mathutils.Vector]
         :param edges: Edges, as pairs of indices in vert_coords
+        :type edges: collections.abc.Sequence[collections.abc.Sequence[int, int]]
         :param faces: Faces, each sublist is a face, as indices in vert_coords (CCW oriented)
+        :type faces: collections.abc.Sequence[collections.abc.Sequence[int]]
         :param output_type: What output looks like. 0 => triangles with convex hull. 1 => triangles inside constraints. 2 => the input constraints, intersected. 3 => like 2 but detect holes and omit them from output. 4 => like 2 but with extra edges to make valid BMesh faces. 5 => like 4 but detect holes and omit them from output.
         :type output_type: int
         :param epsilon: For nearness tests; should not be zero
@@ -179,7 +195,7 @@ def intersect_line_line(
     v2: collections.abc.Sequence[float] | mathutils.Vector,
     v3: collections.abc.Sequence[float] | mathutils.Vector,
     v4: collections.abc.Sequence[float] | mathutils.Vector,
-) -> tuple[mathutils.Vector, mathutils.Vector]:
+) -> None | tuple[mathutils.Vector, mathutils.Vector]:
     """Returns a tuple with the points on each line respectively closest to the other.
 
     :param v1: First point of the first line
@@ -191,7 +207,7 @@ def intersect_line_line(
     :param v4: Second point of the second line
     :type v4: collections.abc.Sequence[float] | mathutils.Vector
     :return: The intersection on each line or None when the lines are co-linear.
-    :rtype: tuple[mathutils.Vector, mathutils.Vector]
+    :rtype: None | tuple[mathutils.Vector, mathutils.Vector]
     """
 
 def intersect_line_line_2d(
@@ -199,7 +215,7 @@ def intersect_line_line_2d(
     lineA_p2: collections.abc.Sequence[float] | mathutils.Vector,
     lineB_p1: collections.abc.Sequence[float] | mathutils.Vector,
     lineB_p2: collections.abc.Sequence[float] | mathutils.Vector,
-) -> mathutils.Vector:
+) -> None | mathutils.Vector:
     """Takes 2 segments (defined by 4 vectors) and returns a vector for their point of intersection or None.
 
     :param lineA_p1: First point of the first line
@@ -211,7 +227,7 @@ def intersect_line_line_2d(
     :param lineB_p2: Second point of the second line
     :type lineB_p2: collections.abc.Sequence[float] | mathutils.Vector
     :return: The point of intersection or None when not found
-    :rtype: mathutils.Vector
+    :rtype: None | mathutils.Vector
     """
 
 def intersect_line_plane(
@@ -220,7 +236,7 @@ def intersect_line_plane(
     plane_co: collections.abc.Sequence[float] | mathutils.Vector,
     plane_no: collections.abc.Sequence[float] | mathutils.Vector,
     no_flip=False,
-) -> mathutils.Vector:
+) -> None | mathutils.Vector:
     """Calculate the intersection between a line (as 2 vectors) and a plane.
     Returns a vector for the intersection or None.
 
@@ -233,7 +249,7 @@ def intersect_line_plane(
         :param plane_no: The direction the plane is facing
         :type plane_no: collections.abc.Sequence[float] | mathutils.Vector
         :return: The point of intersection or None when not found
-        :rtype: mathutils.Vector
+        :rtype: None | mathutils.Vector
     """
 
 def intersect_line_sphere(
@@ -242,7 +258,7 @@ def intersect_line_sphere(
     sphere_co: collections.abc.Sequence[float] | mathutils.Vector,
     sphere_radius: float,
     clip=True,
-) -> tuple[mathutils.Vector, mathutils.Vector]:
+) -> tuple[mathutils.Vector | None, mathutils.Vector | None]:
     """Takes a line (as 2 points) and a sphere (as a point and a radius) and
     returns the intersection
 
@@ -255,7 +271,7 @@ def intersect_line_sphere(
         :param sphere_radius: Radius of the sphere
         :type sphere_radius: float
         :return: The intersection points as a pair of vectors or None when there is no intersection
-        :rtype: tuple[mathutils.Vector, mathutils.Vector]
+        :rtype: tuple[mathutils.Vector | None, mathutils.Vector | None]
     """
 
 def intersect_line_sphere_2d(
@@ -264,7 +280,7 @@ def intersect_line_sphere_2d(
     sphere_co: collections.abc.Sequence[float] | mathutils.Vector,
     sphere_radius: float,
     clip=True,
-) -> tuple[mathutils.Vector, mathutils.Vector]:
+) -> tuple[mathutils.Vector | None, mathutils.Vector | None]:
     """Takes a line (as 2 points) and a sphere (as a point and a radius) and
     returns the intersection
 
@@ -277,7 +293,7 @@ def intersect_line_sphere_2d(
         :param sphere_radius: Radius of the sphere
         :type sphere_radius: float
         :return: The intersection points as a pair of vectors or None when there is no intersection
-        :rtype: tuple[mathutils.Vector, mathutils.Vector]
+        :rtype: tuple[mathutils.Vector | None, mathutils.Vector | None]
     """
 
 def intersect_plane_plane(
@@ -285,7 +301,7 @@ def intersect_plane_plane(
     plane_a_no: collections.abc.Sequence[float] | mathutils.Vector,
     plane_b_co: collections.abc.Sequence[float] | mathutils.Vector,
     plane_b_no: collections.abc.Sequence[float] | mathutils.Vector,
-) -> tuple | tuple[mathutils.Vector, mathutils.Vector]:
+) -> tuple[None, None] | tuple[mathutils.Vector, mathutils.Vector]:
     """Return the intersection between two planes
 
     :param plane_a_co: Point on the first plane
@@ -297,7 +313,7 @@ def intersect_plane_plane(
     :param plane_b_no: Normal of the second plane
     :type plane_b_no: collections.abc.Sequence[float] | mathutils.Vector
     :return: The line of the intersection represented as a point and a vector or None if the intersection can't be calculated
-    :rtype: tuple | tuple[mathutils.Vector, mathutils.Vector]
+    :rtype: tuple[None, None] | tuple[mathutils.Vector, mathutils.Vector]
     """
 
 def intersect_point_line(
@@ -343,7 +359,7 @@ def intersect_point_tri(
     tri_p1: collections.abc.Sequence[float] | mathutils.Vector,
     tri_p2: collections.abc.Sequence[float] | mathutils.Vector,
     tri_p3: collections.abc.Sequence[float] | mathutils.Vector,
-) -> mathutils.Vector:
+) -> None | mathutils.Vector:
     """Takes 4 vectors: one is the point and the next 3 define the triangle. Projects the point onto the triangle plane and checks if it is within the triangle.
 
     :param pt: Point
@@ -355,7 +371,7 @@ def intersect_point_tri(
     :param tri_p3: Third point of the triangle
     :type tri_p3: collections.abc.Sequence[float] | mathutils.Vector
     :return: Point on the triangles plane or None if its outside the triangle
-    :rtype: mathutils.Vector
+    :rtype: None | mathutils.Vector
     """
 
 def intersect_point_tri_2d(
@@ -384,7 +400,7 @@ def intersect_ray_tri(
     ray: collections.abc.Sequence[float] | mathutils.Vector,
     orig: collections.abc.Sequence[float] | mathutils.Vector,
     clip: bool = True,
-) -> mathutils.Vector:
+) -> None | mathutils.Vector:
     """Returns the intersection between a ray and a triangle, if possible, returns None otherwise.
 
     :param v1: Point1
@@ -400,7 +416,7 @@ def intersect_ray_tri(
     :param clip: When False, don't restrict the intersection to the area of the triangle, use the infinite plane defined by the triangle.
     :type clip: bool
     :return: The point of intersection or None if no intersection is found
-    :rtype: mathutils.Vector
+    :rtype: None | mathutils.Vector
     """
 
 def intersect_sphere_sphere_2d(
@@ -408,7 +424,7 @@ def intersect_sphere_sphere_2d(
     radius_a: float,
     p_b: collections.abc.Sequence[float] | mathutils.Vector,
     radius_b: float,
-) -> tuple | tuple[mathutils.Vector, mathutils.Vector]:
+) -> tuple[None, None] | tuple[mathutils.Vector, mathutils.Vector]:
     """Returns 2 points on between intersecting circles.
 
     :param p_a: Center of the first circle
@@ -420,7 +436,7 @@ def intersect_sphere_sphere_2d(
     :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.
-    :rtype: tuple | tuple[mathutils.Vector, mathutils.Vector]
+    :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) -> bool:
@@ -429,10 +445,13 @@ def intersect_tri_tri_2d(tri_a1, tri_a2, tri_a3, tri_b1, tri_b2, tri_b3) -> bool
     :rtype: bool
     """
 
-def normal(vectors) -> mathutils.Vector:
+def normal(
+    vectors: collections.abc.Sequence[collections.abc.Sequence[float]],
+) -> mathutils.Vector:
     """Returns the normal of a 3D polygon.
 
     :param vectors: 3 or more vectors to calculate normals.
+    :type vectors: collections.abc.Sequence[collections.abc.Sequence[float]]
     :rtype: mathutils.Vector
     """
 

mathutils/interpolate/__init__.pyi

@@ -7,10 +7,13 @@ import typing
 import collections.abc
 import typing_extensions
 
-def poly_3d_calc(veclist, pt) -> list[float]:
+def poly_3d_calc(
+    veclist: collections.abc.Sequence[collections.abc.Sequence[float]], pt
+) -> 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.
     :rtype: list[float]
     """

mathutils/kdtree/__init__.pyi

@@ -17,21 +17,27 @@ class KDTree:
         """Balance the tree."""
 
     def find(
-        self, co, filter: collections.abc.Callable | None = None
+        self,
+        co: collections.abc.Sequence[float],
+        filter: collections.abc.Callable[int, bool] | None = None,
     ) -> tuple[mathutils.Vector, int, float]:
         """Find nearest point to co.
 
         :param co: 3D coordinates.
+        :type co: collections.abc.Sequence[float]
         :param filter: function which takes an index and returns True for indices to include in the search.
-        :type filter: collections.abc.Callable | None
+        :type filter: collections.abc.Callable[int, bool] | None
         :return: Returns (position, index, distance).
         :rtype: tuple[mathutils.Vector, int, float]
         """
 
-    def find_n(self, co, n: int) -> list[tuple[mathutils.Vector, int, float]]:
+    def find_n(
+        self, co: collections.abc.Sequence[float], n: int
+    ) -> list[tuple[mathutils.Vector, int, float]]:
         """Find nearest n points to co.
 
         :param co: 3D coordinates.
+        :type co: collections.abc.Sequence[float]
         :param n: Number of points to find.
         :type n: int
         :return: Returns a list of tuples (position, index, distance).
@@ -39,21 +45,23 @@ class KDTree:
         """
 
     def find_range(
-        self, co, radius: float
+        self, co: collections.abc.Sequence[float], radius: float
     ) -> list[tuple[mathutils.Vector, int, float]]:
         """Find all points within radius of co.
 
         :param co: 3D coordinates.
+        :type co: collections.abc.Sequence[float]
         :param radius: Distance to search for points.
         :type radius: float
         :return: Returns a list of tuples (position, index, distance).
         :rtype: list[tuple[mathutils.Vector, int, float]]
         """
 
-    def insert(self, co, index: int):
+    def insert(self, co: collections.abc.Sequence[float], index: int):
         """Insert a point into the KDTree.
 
         :param co: Point 3d position.
+        :type co: collections.abc.Sequence[float]
         :param index: The index of the point.
         :type index: int
         """

rna_info/__init__.pyi

@@ -66,7 +66,7 @@ class InfoPropertyRNA:
         class_fmt="{:s}",
         mathutils_fmt="{:s}",
         collection_id="Collection",
-        enum_descr_override: str | None = None,
+        enum_descr_override: None | str | None = None,
     ):
         """
 
@@ -77,7 +77,7 @@ class InfoPropertyRNA:
                 :param collection_id:
                 :param enum_descr_override: Optionally override items for enum.
         Otherwise expand the literal items.
-                :type enum_descr_override: str | None
+                :type enum_descr_override: None | str | None
         """
 
 class InfoStructRNA: