fake-bpy-module 20241102__py3-none-any.whl → 20241111__py3-none-any.whl

mathutils/bvhtree/__init__.pyi

@@ -53,43 +53,41 @@ class BVHTree:
         """BVH tree constructed geometry passed in as arguments.
 
         :param vertices: float triplets each representing (x, y, z)
-        :param polygons: Sequence of polyugons, each containing indices to the vertices argument.
+        :param polygons: Sequence of polygons, each containing indices to the vertices argument.
         :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) -> tuple:
+    def find_nearest(self, origin, distance: float = 1.84467e19):
         """Find the nearest element (typically face index) to a point.
 
                 :param origin:
                 :param distance: Maximum distance threshold.
                 :type distance: float
-                :return: Returns a tuple
-        (`Vector` location, `Vector` normal, int index, float distance),
+                :return: Returns a tuple: (position, normal, index, distance),
         Values will all be None if no hit is found.
-                :rtype: tuple
         """
 
-    def find_nearest_range(self, origin, distance: float = 1.84467e19) -> list:
+    def find_nearest_range(
+        self, origin, distance: float = 1.84467e19
+    ) -> int | mathutils.Vector:
         """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
-        (`Vector` location, `Vector` normal, int index, float distance),
-                :rtype: list
+        :param origin:
+        :param distance: Maximum distance threshold.
+        :type distance: float
+        :return: Returns a list of tuples (position, normal, index, distance)
+        :rtype: int | mathutils.Vector
         """
 
-    def overlap(self, other_tree: typing_extensions.Self) -> list:
+    def overlap(self, other_tree: typing_extensions.Self):
         """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
         """
 
     def ray_cast(
@@ -97,7 +95,7 @@ class BVHTree:
         origin: collections.abc.Sequence[float] | mathutils.Vector,
         direction: collections.abc.Sequence[float] | mathutils.Vector,
         distance: float = sys.float_info.max,
-    ) -> tuple:
+    ):
         """Cast a ray onto the mesh.
 
                 :param origin: Start location of the ray in object space.
@@ -106,10 +104,8 @@ class BVHTree:
                 :type direction: collections.abc.Sequence[float] | mathutils.Vector
                 :param distance: Maximum distance threshold.
                 :type distance: float
-                :return: Returns a tuple
-        (`Vector` location, `Vector` normal, int index, float distance),
+                :return: Returns a tuple: (position, normal, index, distance),
         Values will all be None if no hit is found.
-                :rtype: tuple
         """
 
     def __init__(self, size):

mathutils/geometry/__init__.pyi

@@ -32,7 +32,7 @@ def barycentric_transform(
     tri_b1: collections.abc.Sequence[float] | mathutils.Vector,
     tri_b2: collections.abc.Sequence[float] | mathutils.Vector,
     tri_b3: collections.abc.Sequence[float] | mathutils.Vector,
-):
+) -> mathutils.Vector:
     """Return a transformed point, the transformation is defined by 2 triangles.
 
     :param point: The point to transform.
@@ -50,24 +50,23 @@ def barycentric_transform(
     :param tri_b3: target triangle vertex.
     :type tri_b3: collections.abc.Sequence[float] | mathutils.Vector
     :return: The transformed point
+    :rtype: mathutils.Vector
     """
 
-def box_fit_2d(points: list) -> float:
+def box_fit_2d(points) -> float:
     """Returns an angle that best fits the points to an axis aligned rectangle
 
-    :param points: list of 2d points.
-    :type points: list
+    :param points: Sequence of 2D points.
     :return: angle
     :rtype: float
     """
 
-def box_pack_2d(boxes: list) -> tuple:
+def box_pack_2d(boxes: float):
     """Returns a tuple with the width and height of the packed bounding box.
 
-    :param boxes: list of boxes, each box is a list where the first 4 items are [x, y, width, height, ...] other items are ignored.
-    :type boxes: list
-    :return: the width and height of the packed bounding box
-    :rtype: tuple
+    :param boxes: list of boxes, each box is a list where the first 4 items are [X, Y, width, height, ...] other items are ignored. The X & Y values in this list are modified to set the packed positions.
+    :type boxes: float
+    :return: The width and height of the packed bounding box.
     """
 
 def closest_point_on_tri(
@@ -90,16 +89,16 @@ def closest_point_on_tri(
     :rtype: mathutils.Vector
     """
 
-def convex_hull_2d(points: list) -> list[int]:
+def convex_hull_2d(points):
     """Returns a list of indices into the list given
 
-    :param points: list of 2d points.
-    :type points: list
+    :param points: Sequence of 2D points.
     :return: a list of indices
-    :rtype: list[int]
     """
 
-def delaunay_2d_cdt(vert_coords, edges, faces, output_type, epsilon, need_ids=True):
+def delaunay_2d_cdt(
+    vert_coords, edges, faces, output_type: int, epsilon: float, need_ids=True
+):
     """Computes the Constrained Delaunay Triangulation of a set of vertices,
     with edges and faces that must appear in the triangulation.
     Some triangles may be eaten away, or combined with other triangles,
@@ -112,20 +111,16 @@ def delaunay_2d_cdt(vert_coords, edges, faces, output_type, epsilon, need_ids=Tr
     with the edges implied by each of the faces (n of them for an n-gon).
     If the need_ids argument is supplied, and False, then the code skips the preparation
     of the orig arrays, which may save some time.
-    :arg vert_coords: Vertex coordinates (2d)
-    :type vert_coords: list of `mathutils.Vector`
-    :arg edges: Edges, as pairs of indices in vert_coords
-    :type edges: list of (int, int)
-    :arg faces: Faces, each sublist is a face, as indices in vert_coords (CCW oriented)
-    :type faces: list of list of int
-    :arg 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: intn   :arg epsilon: For nearness tests; should not be zero
-    :type epsilon: float
-    :arg need_ids: are the orig output arrays needed?
-    :type need_args: bool
-    :return: Output tuple, (vert_coords, edges, faces, orig_verts, orig_edges, orig_faces)
-    :rtype: (list of mathutils.Vector, list of (int, int), list of list of int, list of list of int, list of list of int, list of list of int)
 
+        :param vert_coords: Vertex coordinates (2d)
+        :param edges: Edges, as pairs of indices in vert_coords
+        :param faces: Faces, each sublist is a face, as indices in vert_coords (CCW oriented)
+        :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
+        :type epsilon: float
+        :param need_ids: are the orig output arrays needed?
+        :return: Output tuple, (vert_coords, edges, faces, orig_verts, orig_edges, orig_faces)
     """
 
 def distance_point_to_plane(
@@ -163,7 +158,7 @@ def interpolate_bezier(
     :type knot2: collections.abc.Sequence[float] | mathutils.Vector
     :param resolution: Number of points to return.
     :type resolution: int
-    :return: The interpolated points
+    :return: The interpolated points.
     """
 
 def intersect_line_line(
@@ -171,7 +166,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, ...]:
+):
     """Returns a tuple with the points on each line respectively closest to the other.
 
     :param v1: First point of the first line
@@ -182,7 +177,7 @@ def intersect_line_line(
     :type v3: collections.abc.Sequence[float] | mathutils.Vector
     :param v4: Second point of the second line
     :type v4: collections.abc.Sequence[float] | mathutils.Vector
-    :rtype: tuple[mathutils.Vector, ...]
+    :return: The intersection on each line or None when the lines are co-linear.
     """
 
 def intersect_line_line_2d(
@@ -190,7 +185,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:
+):
     """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
@@ -202,7 +197,6 @@ 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
     """
 
 def intersect_line_plane(
@@ -211,7 +205,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:
+):
     """Calculate the intersection between a line (as 2 vectors) and a plane.
     Returns a vector for the intersection or None.
 
@@ -224,7 +218,6 @@ 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
     """
 
 def intersect_line_sphere(
@@ -285,21 +278,20 @@ def intersect_plane_plane(
     :type plane_b_co: collections.abc.Sequence[float] | mathutils.Vector
     :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
+    :return: The line of the intersection represented as a point and a vector or None if the intersection can't be calculated
     """
 
 def intersect_point_line(
     pt: collections.abc.Sequence[float] | mathutils.Vector,
     line_p1: collections.abc.Sequence[float] | mathutils.Vector,
     line_p2,
-) -> tuple[mathutils.Vector]:
+):
     """Takes a point and a line and returns a tuple with the closest point on the line and its distance from the first point of the line as a percentage of the length of the line.
 
     :param pt: Point
     :type pt: collections.abc.Sequence[float] | mathutils.Vector
     :param line_p1: First point of the lineSecond point of the line
     :type line_p1: collections.abc.Sequence[float] | mathutils.Vector
-    :rtype: tuple[mathutils.Vector]
     """
 
 def intersect_point_quad_2d(
@@ -331,7 +323,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:
+):
     """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
@@ -343,7 +335,6 @@ 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
     """
 
 def intersect_point_tri_2d(
@@ -372,7 +363,7 @@ def intersect_ray_tri(
     ray: collections.abc.Sequence[float] | mathutils.Vector,
     orig: collections.abc.Sequence[float] | mathutils.Vector,
     clip: bool = True,
-) -> mathutils.Vector:
+):
     """Returns the intersection between a ray and a triangle, if possible, returns None otherwise.
 
     :param v1: Point1
@@ -388,7 +379,6 @@ 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
     """
 
 def intersect_sphere_sphere_2d(
@@ -396,7 +386,7 @@ def intersect_sphere_sphere_2d(
     radius_a: float,
     p_b: collections.abc.Sequence[float] | mathutils.Vector,
     radius_b: float,
-) -> tuple[mathutils.Vector, ...]:
+):
     """Returns 2 points on between intersecting circles.
 
     :param p_a: Center of the first circle
@@ -407,7 +397,7 @@ 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
-    :rtype: tuple[mathutils.Vector, ...]
+    :return: 2 points on between intersecting circles or None when there is no intersection.
     """
 
 def intersect_tri_tri_2d(tri_a1, tri_a2, tri_a3, tri_b1, tri_b2, tri_b3) -> bool:
@@ -419,31 +409,28 @@ def intersect_tri_tri_2d(tri_a1, tri_a2, tri_a3, tri_b1, tri_b2, tri_b3) -> bool
 def normal(vectors) -> mathutils.Vector:
     """Returns the normal of a 3D polygon.
 
-    :param vectors: Vectors to calculate normals with
+    :param vectors: 3 or more vectors to calculate normals.
     :rtype: mathutils.Vector
     """
 
 def points_in_planes(
-    planes: list[mathutils.Vector],
-    epsilon_coplanar: float = 0.0001,
-    epsilon_isect: float = 1e-06,
+    planes, epsilon_coplanar: float = 0.0001, epsilon_isect: float = 1e-06
 ):
     """Returns a list of points inside all planes given and a list of index values for the planes used.
 
     :param planes: List of planes (4D vectors).
-    :type planes: list[mathutils.Vector]
     :param epsilon_coplanar: Epsilon value for interpreting plane pairs as co-plannar.
     :type epsilon_coplanar: float
     :param epsilon_isect: Epsilon value for intersection.
     :type epsilon_isect: float
-    :return: two lists, once containing the vertices inside the planes, another containing the plane indices used
+    :return: Two lists, once containing the 3D coordinates inside the planes, another containing the plane indices used.
     """
 
-def tessellate_polygon(veclist_list) -> list:
+def tessellate_polygon(polylines) -> 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 veclist_list: list of polylines
-    :rtype: list
+    :param polylines: Polygons where each polygon is a sequence of 2D or 3D points.
+    :rtype: int
     """
 
 def volume_tetrahedron(

mathutils/interpolate/__init__.pyi

@@ -10,6 +10,6 @@ import typing_extensions
 def poly_3d_calc(veclist, pt):
     """Calculate barycentric weights for a point on a polygon.
 
-    :param veclist: list of vectors
-    :param pt: point   :rtype: list of per-vector weights
+    :param veclist: Sequence of 3D positions.
+    :param pt: 2D or 3D position.   :type pt: Sequence[float]   :return: list of per-vector weights.
     """

mathutils/kdtree/__init__.pyi

@@ -8,7 +8,6 @@ Generic 3-dimensional kd-tree to perform spatial searches.
 import typing
 import collections.abc
 import typing_extensions
-import mathutils
 
 class KDTree:
     """KdTree(size) -> new kd-tree initialized to hold size items."""
@@ -16,54 +15,40 @@ class KDTree:
     def balance(self):
         """Balance the tree."""
 
-    def find(
-        self,
-        co: collections.abc.Sequence[float] | mathutils.Vector,
-        filter: collections.abc.Callable | None = None,
-    ) -> tuple:
+    def find(self, co, filter: collections.abc.Callable | None = None) -> int:
         """Find nearest point to co.
 
-        :param co: 3d coordinates.
-        :type co: collections.abc.Sequence[float] | mathutils.Vector
+        :param co: 3D coordinates.
         :param filter: function which takes an index and returns True for indices to include in the search.
         :type filter: collections.abc.Callable | None
-        :return: Returns (`Vector`, index, distance).
-        :rtype: tuple
+        :return: Returns (position, index, distance).
+        :rtype: int
         """
 
-    def find_n(
-        self, co: collections.abc.Sequence[float] | mathutils.Vector, n: int
-    ) -> list:
+    def find_n(self, co, n: int) -> int:
         """Find nearest n points to co.
 
-        :param co: 3d coordinates.
-        :type co: collections.abc.Sequence[float] | mathutils.Vector
+        :param co: 3D coordinates.
         :param n: Number of points to find.
         :type n: int
-        :return: Returns a list of tuples (`Vector`, index, distance).
-        :rtype: list
+        :return: Returns a list of tuples (position, index, distance).
+        :rtype: int
         """
 
-    def find_range(
-        self, co: collections.abc.Sequence[float] | mathutils.Vector, radius: float
-    ) -> list:
+    def find_range(self, co, radius: float) -> int:
         """Find all points within radius of co.
 
-        :param co: 3d coordinates.
-        :type co: collections.abc.Sequence[float] | mathutils.Vector
+        :param co: 3D coordinates.
         :param radius: Distance to search for points.
         :type radius: float
-        :return: Returns a list of tuples (`Vector`, index, distance).
-        :rtype: list
+        :return: Returns a list of tuples (position, index, distance).
+        :rtype: int
         """
 
-    def insert(
-        self, co: collections.abc.Sequence[float] | mathutils.Vector, index: int
-    ):
+    def insert(self, co, index: int):
         """Insert a point into the KDTree.
 
         :param co: Point 3d position.
-        :type co: collections.abc.Sequence[float] | mathutils.Vector
         :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,
     ):
         """
 
@@ -77,7 +77,6 @@ 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
         """
 
 class InfoStructRNA: