fake-bpy-module 20241103__py3-none-any.whl → 20241112__py3-none-any.whl

mathutils/__init__.pyi

@@ -422,18 +422,10 @@ class Euler:
                 :param other:
         """
 
-    def rotate(
-        self,
-        other: Matrix
-        | Quaternion
-        | collections.abc.Sequence[collections.abc.Sequence[float]]
-        | collections.abc.Sequence[float]
-        | typing_extensions.Self,
-    ):
+    def rotate(self, other):
         """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):
@@ -620,35 +612,24 @@ class Matrix:
         """
 
     @classmethod
-    def LocRotScale(
-        cls,
-        location: Vector | collections.abc.Sequence[float] | None,
-        rotation: Euler | Quaternion | collections.abc.Sequence[float] | None,
-        scale: Vector | collections.abc.Sequence[float] | None,
-    ) -> typing_extensions.Self:
+    def LocRotScale(cls, location, rotation, scale) -> 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] | None
-                :param rotation: The rotation component.
-                :type rotation: Euler | Quaternion | collections.abc.Sequence[float] | None
+                :param rotation: The rotation component as a 3x3 matrix, quaternion, euler or None for no rotation.
                 :param scale: The scale component.
-                :type scale: Vector | collections.abc.Sequence[float] | None
-                :return: Combined transformation matrix.
+                :return: Combined transformation as a 4x4 matrix.
                 :rtype: typing_extensions.Self
         """
 
     @classmethod
-    def OrthoProjection(
-        cls, axis: Vector | collections.abc.Sequence[float] | str, size: int
-    ) -> typing_extensions.Self:
+    def OrthoProjection(cls, axis, 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.
@@ -656,12 +637,7 @@ class Matrix:
         """
 
     @classmethod
-    def Rotation(
-        cls,
-        angle: float,
-        size: int,
-        axis: Vector | collections.abc.Sequence[float] | str | None = "",
-    ) -> typing_extensions.Self:
+    def Rotation(cls, angle: float, size: int, axis) -> typing_extensions.Self:
         """Create a matrix representing a rotation.
 
                 :param angle: The angle of rotation desired, in radians.
@@ -670,7 +646,6 @@ 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
         """
@@ -695,7 +670,7 @@ class Matrix:
         """
 
     @classmethod
-    def Shear(cls, plane: str, size: int, factor: float) -> typing_extensions.Self:
+    def Shear(cls, plane: str, size: int, factor) -> typing_extensions.Self:
         """Create a matrix to represent an shear transformation.
 
                 :param plane: Can be any of the following: ['X', 'Y', 'XY', 'XZ', 'YZ'],
@@ -703,9 +678,7 @@ class Matrix:
                 :type plane: str
                 :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 3 or 4 size matrix
-        pass a pair of floats corresponding with the plane axis.
-                :type factor: float
+                :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.
                 :return: A new shear matrix.
                 :rtype: typing_extensions.Self
         """
@@ -739,11 +712,11 @@ class Matrix:
         :rtype: typing_extensions.Self
         """
 
-    def decompose(self) -> tuple[Vector, Quaternion, Vector]:
+    def decompose(self) -> Quaternion:
         """Return the translation, rotation, and scale components of this matrix.
 
-        :return: tuple of translation, rotation, and scale
-        :rtype: tuple[Vector, Quaternion, Vector]
+        :return: Tuple of translation, rotation, and scale.
+        :rtype: Quaternion
         """
 
     def determinant(self) -> float:
@@ -783,14 +756,12 @@ class Matrix:
 
         """
 
-    def inverted(self, fallback: typing.Any | None = None) -> typing_extensions.Self:
+    def inverted(self, fallback=None):
         """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_extensions.Self
+                :return: The inverted matrix or fallback when given.
         """
 
     def inverted_safe(self) -> typing_extensions.Self:
@@ -831,18 +802,10 @@ class Matrix:
     def resize_4x4(self):
         """Resize the matrix to 4x4."""
 
-    def rotate(
-        self,
-        other: Euler
-        | Quaternion
-        | collections.abc.Sequence[collections.abc.Sequence[float]]
-        | collections.abc.Sequence[float]
-        | typing_extensions.Self,
-    ):
+    def rotate(self, other):
         """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:
@@ -1254,18 +1217,10 @@ class Quaternion:
         :rtype: typing_extensions.Self
         """
 
-    def rotate(
-        self,
-        other: Euler
-        | Matrix
-        | collections.abc.Sequence[collections.abc.Sequence[float]]
-        | collections.abc.Sequence[float]
-        | typing_extensions.Self,
-    ):
+    def rotate(self, other):
         """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(
@@ -1294,11 +1249,10 @@ class Quaternion:
         :rtype: typing_extensions.Self
         """
 
-    def to_axis_angle(self) -> tuple[Vector, float]:
+    def to_axis_angle(self):
         """Return the axis, angle representation of the quaternion.
 
-        :return: axis, angle.
-        :rtype: tuple[Vector, float]
+        :return: Axis, angle.
         """
 
     def to_euler(
@@ -1333,13 +1287,13 @@ class Quaternion:
         :rtype: Matrix
         """
 
-    def to_swing_twist(self, axis) -> tuple[Quaternion, float]:
+    def to_swing_twist(self, axis: str):
         """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']
-                :return: swing, twist angle.
-                :rtype: tuple[Quaternion, float]
+                :param axis: Twist axis as a string in ['X', 'Y', 'Z'].
+                :type axis: str
+                :return: Swing, twist angle.
         """
 
     def __init__(self, seq=(1.0, 0.0, 0.0, 0.0)):
@@ -3644,33 +3598,27 @@ class Vector:
     def angle(
         self,
         other: collections.abc.Sequence[float] | typing_extensions.Self,
-        fallback: typing.Any | None = None,
-    ) -> float:
+        fallback=None,
+    ):
         """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
         """
 
     def angle_signed(
-        self,
-        other: collections.abc.Sequence[float] | typing_extensions.Self,
-        fallback: typing.Any,
-    ) -> float:
+        self, other: collections.abc.Sequence[float] | typing_extensions.Self, fallback
+    ):
         """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
                 :return: angle in radians or fallback when given
-                :rtype: float
         """
 
     def copy(self) -> typing_extensions.Self:
@@ -3680,15 +3628,12 @@ class Vector:
         :rtype: typing_extensions.Self
         """
 
-    def cross(
-        self, other: collections.abc.Sequence[float] | typing_extensions.Self
-    ) -> typing_extensions.Self:
+    def cross(self, other: collections.abc.Sequence[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.
-        :rtype: typing_extensions.Self
+        :return: The cross product as a vector or a float when 2D vectors are used.
         """
 
     def dot(
@@ -3789,18 +3734,10 @@ class Vector:
         :rtype: typing_extensions.Self
         """
 
-    def rotate(
-        self,
-        other: Euler
-        | Matrix
-        | Quaternion
-        | collections.abc.Sequence[collections.abc.Sequence[float]]
-        | collections.abc.Sequence[float],
-    ):
+    def rotate(self, other):
         """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(
@@ -3819,7 +3756,7 @@ class Vector:
         self,
         other: collections.abc.Sequence[float] | typing_extensions.Self,
         factor: float,
-        fallback: typing.Any | None = None,
+        fallback=None,
     ) -> typing_extensions.Self:
         """Returns the interpolation of two non-zero vectors (spherical coordinates).
 
@@ -3829,7 +3766,6 @@ 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
         """
@@ -3866,13 +3802,12 @@ class Vector:
         :rtype: Quaternion
         """
 
-    def to_tuple(self, precision: int = -1) -> tuple:
+    def to_tuple(self, precision: int = -1):
         """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
         """
 
     def zero(self):

mathutils/bvhtree/__init__.pyi

@@ -60,36 +60,34 @@ class BVHTree:
         :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,22 +89,15 @@ 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: list[mathutils.Vector],
-    edges,
-    faces,
-    output_type: int,
-    epsilon: float,
-    need_ids=True,
+    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.
@@ -121,7 +113,6 @@ def delaunay_2d_cdt(
     of the orig arrays, which may save some time.
 
         :param vert_coords: Vertex coordinates (2d)
-        :type vert_coords: list[mathutils.Vector]
         :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.
@@ -167,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(
@@ -175,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
@@ -187,7 +178,6 @@ 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, ...]
     """
 
 def intersect_line_line_2d(
@@ -195,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
@@ -207,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(
@@ -216,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.
 
@@ -229,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(
@@ -290,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(
@@ -336,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
@@ -348,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(
@@ -377,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
@@ -393,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(
@@ -401,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
@@ -413,7 +398,6 @@ 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[mathutils.Vector, ...]
     """
 
 def intersect_tri_tri_2d(tri_a1, tri_a2, tri_a3, tri_b1, tri_b2, tri_b3) -> bool:
@@ -425,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.
     """