fake-bge-module 20250312__py3-none-any.whl → 20260203__py3-none-any.whl

mathutils/geometry/__init__.pyi

@@ -1,27 +1,25 @@
 """
-The Blender geometry module
+The Blender geometry module.
 
 """
 
 import typing
 import collections.abc
 import typing_extensions
+import numpy.typing as npt
 import mathutils
 
 def area_tri(
     v1: collections.abc.Sequence[float] | mathutils.Vector,
     v2: collections.abc.Sequence[float] | mathutils.Vector,
     v3: collections.abc.Sequence[float] | mathutils.Vector,
+    /,
 ) -> float:
     """Returns the area size of the 2D or 3D triangle defined.
 
     :param v1: Point1
-    :type v1: collections.abc.Sequence[float] | mathutils.Vector
     :param v2: Point2
-    :type v2: collections.abc.Sequence[float] | mathutils.Vector
     :param v3: Point3
-    :type v3: collections.abc.Sequence[float] | mathutils.Vector
-    :rtype: float
     """
 
 def barycentric_transform(
@@ -32,45 +30,38 @@ 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.
-    :type point: collections.abc.Sequence[float] | mathutils.Vector
     :param tri_a1: source triangle vertex.
-    :type tri_a1: collections.abc.Sequence[float] | mathutils.Vector
     :param tri_a2: source triangle vertex.
-    :type tri_a2: collections.abc.Sequence[float] | mathutils.Vector
     :param tri_a3: source triangle vertex.
-    :type tri_a3: collections.abc.Sequence[float] | mathutils.Vector
     :param tri_b1: target triangle vertex.
-    :type tri_b1: collections.abc.Sequence[float] | mathutils.Vector
     :param tri_b2: target triangle vertex.
-    :type tri_b2: collections.abc.Sequence[float] | mathutils.Vector
     :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: 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
     """
 
-def box_pack_2d(boxes: list[list[float]]) -> tuple[float, float]:
+def box_pack_2d(
+    boxes: list[list[float]],
+    /,
+) -> tuple[float, 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. The X & Y values in this list are modified to set the packed positions.
-    :type boxes: list[list[float]]
     :return: The width and height of the packed bounding box.
-    :rtype: tuple[float, float]
     """
 
 def closest_point_on_tri(
@@ -78,30 +69,25 @@ def closest_point_on_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.
 
     :param pt: Point
-    :type pt: collections.abc.Sequence[float] | mathutils.Vector
     :param tri_p1: First point of the triangle
-    :type tri_p1: collections.abc.Sequence[float] | mathutils.Vector
     :param tri_p2: Second point of the triangle
-    :type tri_p2: collections.abc.Sequence[float] | mathutils.Vector
     :param tri_p3: Third point of the triangle
-    :type tri_p3: collections.abc.Sequence[float] | mathutils.Vector
     :return: The closest point of the triangle.
-    :rtype: mathutils.Vector
     """
 
 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(
@@ -112,7 +98,8 @@ def delaunay_2d_cdt(
     faces: collections.abc.Sequence[collections.abc.Sequence[int]],
     output_type: int,
     epsilon: float,
-    need_ids=True,
+    need_ids: bool = True,
+    /,
 ) -> tuple[
     list[mathutils.Vector],
     list[tuple[int, int]],
@@ -135,34 +122,25 @@ 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 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)
-        :rtype: tuple[list[mathutils.Vector], list[tuple[int, int]], list[list[int]], list[list[int]], list[list[int]], list[list[int]]]
     """
 
 def distance_point_to_plane(
     pt: collections.abc.Sequence[float] | mathutils.Vector,
     plane_co: collections.abc.Sequence[float] | mathutils.Vector,
     plane_no: collections.abc.Sequence[float] | mathutils.Vector,
+    /,
 ) -> float:
     """Returns the signed distance between a point and a plane    (negative when below the normal).
 
     :param pt: Point
-    :type pt: collections.abc.Sequence[float] | mathutils.Vector
     :param plane_co: A point on the plane
-    :type plane_co: collections.abc.Sequence[float] | mathutils.Vector
     :param plane_no: The direction the plane is facing
-    :type plane_no: collections.abc.Sequence[float] | mathutils.Vector
-    :rtype: float
     """
 
 def interpolate_bezier(
@@ -171,21 +149,16 @@ def interpolate_bezier(
     handle2: collections.abc.Sequence[float] | mathutils.Vector,
     knot2: collections.abc.Sequence[float] | mathutils.Vector,
     resolution: int,
+    /,
 ) -> list[mathutils.Vector]:
     """Interpolate a bezier spline segment.
 
     :param knot1: First bezier spline point.
-    :type knot1: collections.abc.Sequence[float] | mathutils.Vector
     :param handle1: First bezier spline handle.
-    :type handle1: collections.abc.Sequence[float] | mathutils.Vector
     :param handle2: Second bezier spline handle.
-    :type handle2: collections.abc.Sequence[float] | mathutils.Vector
     :param knot2: Second bezier spline point.
-    :type knot2: collections.abc.Sequence[float] | mathutils.Vector
     :param resolution: Number of points to return.
-    :type resolution: int
     :return: The interpolated points.
-    :rtype: list[mathutils.Vector]
     """
 
 def intersect_line_line(
@@ -193,19 +166,15 @@ 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,
+    /,
 ) -> 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
-    :type v1: collections.abc.Sequence[float] | mathutils.Vector
     :param v2: Second point of the first line
-    :type v2: collections.abc.Sequence[float] | mathutils.Vector
     :param v3: First point of the second 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
     :return: The intersection on each line or None when the lines are co-linear.
-    :rtype: None | tuple[mathutils.Vector, mathutils.Vector]
     """
 
 def intersect_line_line_2d(
@@ -213,19 +182,15 @@ 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,
+    /,
 ) -> 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
-    :type lineA_p1: collections.abc.Sequence[float] | mathutils.Vector
     :param lineA_p2: Second point of the first line
-    :type lineA_p2: collections.abc.Sequence[float] | mathutils.Vector
     :param lineB_p1: First point of the second line
-    :type lineB_p1: collections.abc.Sequence[float] | mathutils.Vector
     :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: None | mathutils.Vector
     """
 
 def intersect_line_plane(
@@ -233,21 +198,18 @@ def intersect_line_plane(
     line_b: collections.abc.Sequence[float] | mathutils.Vector,
     plane_co: collections.abc.Sequence[float] | mathutils.Vector,
     plane_no: collections.abc.Sequence[float] | mathutils.Vector,
-    no_flip=False,
+    no_flip: bool = False,
+    /,
 ) -> None | mathutils.Vector:
     """Calculate the intersection between a line (as 2 vectors) and a plane.
     Returns a vector for the intersection or None.
 
         :param line_a: First point of the first line
-        :type line_a: collections.abc.Sequence[float] | mathutils.Vector
         :param line_b: Second point of the first line
-        :type line_b: collections.abc.Sequence[float] | mathutils.Vector
         :param plane_co: A point on the plane
-        :type plane_co: collections.abc.Sequence[float] | mathutils.Vector
         :param plane_no: The direction the plane is facing
-        :type plane_no: collections.abc.Sequence[float] | mathutils.Vector
+        :param no_flip: Not implemented
         :return: The point of intersection or None when not found
-        :rtype: None | mathutils.Vector
     """
 
 def intersect_line_sphere(
@@ -255,21 +217,18 @@ def intersect_line_sphere(
     line_b: collections.abc.Sequence[float] | mathutils.Vector,
     sphere_co: collections.abc.Sequence[float] | mathutils.Vector,
     sphere_radius: float,
-    clip=True,
+    clip: bool = True,
+    /,
 ) -> 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
 
         :param line_a: First point of the line
-        :type line_a: collections.abc.Sequence[float] | mathutils.Vector
         :param line_b: Second point of the line
-        :type line_b: collections.abc.Sequence[float] | mathutils.Vector
         :param sphere_co: The center of the 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 line segment.
         :return: The intersection points as a pair of vectors or None when there is no intersection
-        :rtype: tuple[mathutils.Vector | None, mathutils.Vector | None]
     """
 
 def intersect_line_sphere_2d(
@@ -277,21 +236,18 @@ def intersect_line_sphere_2d(
     line_b: collections.abc.Sequence[float] | mathutils.Vector,
     sphere_co: collections.abc.Sequence[float] | mathutils.Vector,
     sphere_radius: float,
-    clip=True,
+    clip: bool = True,
+    /,
 ) -> 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
 
         :param line_a: First point of the line
-        :type line_a: collections.abc.Sequence[float] | mathutils.Vector
         :param line_b: Second point of the line
-        :type line_b: collections.abc.Sequence[float] | mathutils.Vector
         :param sphere_co: The center of the 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 line segment.
         :return: The intersection points as a pair of vectors or None when there is no intersection
-        :rtype: tuple[mathutils.Vector | None, mathutils.Vector | None]
     """
 
 def intersect_plane_plane(
@@ -299,33 +255,41 @@ 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[None, None] | tuple[mathutils.Vector, mathutils.Vector]:
     """Return the intersection between two planes
 
     :param plane_a_co: Point on the first plane
-    :type plane_a_co: collections.abc.Sequence[float] | mathutils.Vector
     :param plane_a_no: Normal of the first plane
-    :type plane_a_no: collections.abc.Sequence[float] | mathutils.Vector
     :param plane_b_co: Point on the second 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 or None if the intersection can't be calculated
-    :rtype: tuple[None, None] | tuple[mathutils.Vector, mathutils.Vector]
+    :return: The line of the intersection represented as a point and a vector or None if the intersection cant be calculated
     """
 
 def intersect_point_line(
     pt: collections.abc.Sequence[float] | mathutils.Vector,
     line_p1: collections.abc.Sequence[float] | mathutils.Vector,
-    line_p2,
+    line_p2: collections.abc.Sequence[float] | mathutils.Vector,
+    /,
+) -> tuple[mathutils.Vector, float]:
+    """Takes a point and a line and returns 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
+    :param line_p1: First point of the line
+    :param line_p2: Second point of the line
+    """
+
+def intersect_point_line_segment(
+    pt: collections.abc.Sequence[float] | mathutils.Vector,
+    seg_p1: collections.abc.Sequence[float] | mathutils.Vector,
+    seg_p2: collections.abc.Sequence[float] | mathutils.Vector,
+    /,
 ) -> tuple[mathutils.Vector, float]:
-    """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.
+    """Takes a point and a segment and returns the closest point on the segment and the distance to the segment.
 
     :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, float]
+    :param seg_p1: First point of the segment
+    :param seg_p2: Second point of the segment
     """
 
 def intersect_point_quad_2d(
@@ -334,22 +298,17 @@ def intersect_point_quad_2d(
     quad_p2: collections.abc.Sequence[float] | mathutils.Vector,
     quad_p3: collections.abc.Sequence[float] | mathutils.Vector,
     quad_p4: collections.abc.Sequence[float] | mathutils.Vector,
+    /,
 ) -> int:
     """Takes 5 vectors (using only the x and y coordinates): one is the point and the next 4 define the quad,
     only the x and y are used from the vectors. Returns 1 if the point is within the quad, otherwise 0.
     Works only with convex quads without singular edges.
 
         :param pt: Point
-        :type pt: collections.abc.Sequence[float] | mathutils.Vector
         :param quad_p1: First point of the quad
-        :type quad_p1: collections.abc.Sequence[float] | mathutils.Vector
         :param quad_p2: Second point of the quad
-        :type quad_p2: collections.abc.Sequence[float] | mathutils.Vector
         :param quad_p3: Third point of the quad
-        :type quad_p3: collections.abc.Sequence[float] | mathutils.Vector
         :param quad_p4: Fourth point of the quad
-        :type quad_p4: collections.abc.Sequence[float] | mathutils.Vector
-        :rtype: int
     """
 
 def intersect_point_tri(
@@ -357,19 +316,15 @@ 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,
+    /,
 ) -> 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
-    :type pt: collections.abc.Sequence[float] | mathutils.Vector
     :param tri_p1: First point of the triangle
-    :type tri_p1: collections.abc.Sequence[float] | mathutils.Vector
     :param tri_p2: Second point of the triangle
-    :type tri_p2: collections.abc.Sequence[float] | mathutils.Vector
     :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: None | mathutils.Vector
     """
 
 def intersect_point_tri_2d(
@@ -377,18 +332,14 @@ def intersect_point_tri_2d(
     tri_p1: collections.abc.Sequence[float] | mathutils.Vector,
     tri_p2: collections.abc.Sequence[float] | mathutils.Vector,
     tri_p3: collections.abc.Sequence[float] | mathutils.Vector,
+    /,
 ) -> int:
     """Takes 4 vectors (using only the x and y coordinates): one is the point and the next 3 define the triangle. Returns 1 if the point is within the triangle, otherwise 0.
 
     :param pt: Point
-    :type pt: collections.abc.Sequence[float] | mathutils.Vector
     :param tri_p1: First point of the triangle
-    :type tri_p1: collections.abc.Sequence[float] | mathutils.Vector
     :param tri_p2: Second point of the triangle
-    :type tri_p2: collections.abc.Sequence[float] | mathutils.Vector
     :param tri_p3: Third point of the triangle
-    :type tri_p3: collections.abc.Sequence[float] | mathutils.Vector
-    :rtype: int
     """
 
 def intersect_ray_tri(
@@ -398,23 +349,17 @@ def intersect_ray_tri(
     ray: collections.abc.Sequence[float] | mathutils.Vector,
     orig: collections.abc.Sequence[float] | mathutils.Vector,
     clip: bool = True,
+    /,
 ) -> None | mathutils.Vector:
     """Returns the intersection between a ray and a triangle, if possible, returns None otherwise.
 
     :param v1: Point1
-    :type v1: collections.abc.Sequence[float] | mathutils.Vector
     :param v2: Point2
-    :type v2: collections.abc.Sequence[float] | mathutils.Vector
     :param v3: Point3
-    :type v3: collections.abc.Sequence[float] | mathutils.Vector
     :param ray: Direction of the projection
-    :type ray: collections.abc.Sequence[float] | mathutils.Vector
     :param orig: Origin
-    :type orig: collections.abc.Sequence[float] | mathutils.Vector
-    :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
+    :param clip: When False, dont restrict the intersection to the area of the triangle, use the infinite plane defined by the triangle.
     :return: The point of intersection or None if no intersection is found
-    :rtype: None | mathutils.Vector
     """
 
 def intersect_sphere_sphere_2d(
@@ -422,59 +367,69 @@ def intersect_sphere_sphere_2d(
     radius_a: float,
     p_b: collections.abc.Sequence[float] | mathutils.Vector,
     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
     :param radius_a: Radius of the first circle
-    :type radius_a: float
     :param p_b: Center of the second circle
-    :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.
-    :rtype: tuple[None, None] | tuple[mathutils.Vector, mathutils.Vector]
+    :return: 2 points 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:
+def intersect_tri_tri_2d(
+    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.
 
-    :rtype: bool
+    :param tri_a1: First vertex of the first triangle.
+    :param tri_a2: Second vertex of the first triangle.
+    :param tri_a3: Third vertex of the first triangle.
+    :param tri_b1: First vertex of the second triangle.
+    :param tri_b2: Second vertex of the second triangle.
+    :param tri_b3: Third vertex of the second triangle.
+    :return: True if the triangles intersect.
     """
 
 def normal(
-    vectors: collections.abc.Sequence[collections.abc.Sequence[float]],
+    *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
     """
 
 def points_in_planes(
     planes: list[collections.abc.Sequence[float] | mathutils.Vector],
     epsilon_coplanar: float = 0.0001,
     epsilon_isect: float = 1e-06,
+    /,
 ) -> tuple[list[mathutils.Vector], list[int]]:
     """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[collections.abc.Sequence[float] | mathutils.Vector]
-    :param epsilon_coplanar: Epsilon value for interpreting plane pairs as co-plannar.
-    :type epsilon_coplanar: float
+    :param epsilon_coplanar: Epsilon value for interpreting plane pairs as co-planar.
     :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.
-    :rtype: tuple[list[mathutils.Vector], list[int]]
+    :return: Two lists, one containing the 3D coordinates inside the planes, another containing the plane indices used.
     """
 
-def tessellate_polygon(polylines) -> list[tuple[int, int, int]]:
+def tessellate_polygon(
+    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.
-    :rtype: list[tuple[int, int, int]]
+    :return: A list of triangles.
     """
 
 def volume_tetrahedron(
@@ -482,16 +437,12 @@ def volume_tetrahedron(
     v2: collections.abc.Sequence[float] | mathutils.Vector,
     v3: collections.abc.Sequence[float] | mathutils.Vector,
     v4: collections.abc.Sequence[float] | mathutils.Vector,
+    /,
 ) -> float:
     """Return the volume formed by a tetrahedron (points can be in any order).
 
     :param v1: Point1
-    :type v1: collections.abc.Sequence[float] | mathutils.Vector
     :param v2: Point2
-    :type v2: collections.abc.Sequence[float] | mathutils.Vector
     :param v3: Point3
-    :type v3: collections.abc.Sequence[float] | mathutils.Vector
     :param v4: Point4
-    :type v4: collections.abc.Sequence[float] | mathutils.Vector
-    :rtype: float
     """

mathutils/interpolate/__init__.pyi

@@ -1,19 +1,21 @@
 """
-The Blender interpolate module
+The Blender interpolate module.
 
 """
 
 import typing
 import collections.abc
 import typing_extensions
+import numpy.typing as npt
 
 def poly_3d_calc(
-    veclist: collections.abc.Sequence[collections.abc.Sequence[float]], pt
+    veclist: collections.abc.Sequence[collections.abc.Sequence[float]],
+    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.
-    :rtype: list[float]
+    :param pt: 2D or 3D position.
+    :return: list of per-vector weights.
     """

mathutils/kdtree/__init__.pyi

@@ -8,27 +8,26 @@ Generic 3-dimensional kd-tree to perform spatial searches.
 import typing
 import collections.abc
 import typing_extensions
+import numpy.typing as npt
 import mathutils
 
 class KDTree:
     """KdTree(size) -> new kd-tree initialized to hold size items."""
 
-    def balance(self):
+    def balance(self) -> None:
         """Balance the tree."""
 
     def find(
         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[int, bool] | None
         :return: Returns (position, index, distance).
-        :rtype: tuple[mathutils.Vector, int, float]
         """
 
     def find_n(
@@ -37,11 +36,8 @@ class KDTree:
         """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).
-        :rtype: list[tuple[mathutils.Vector, int, float]]
         """
 
     def find_range(
@@ -50,23 +46,18 @@ class KDTree:
         """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: collections.abc.Sequence[float], index: int):
+    def insert(self, co: collections.abc.Sequence[float], index: int) -> None:
         """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
         """
 
-    def __init__(self, size):
+    def __init__(self, size) -> None:
         """
 
         :param size: