fake-bpy-module 20241228__py3-none-any.whl → 20241230__py3-none-any.whl

gpu/types/__init__.pyi

@@ -87,11 +87,17 @@ class GPUFrameBuffer:
     def bind(self):
         """Context manager to ensure balanced bind calls, even in the case of an error."""
 
-    def clear(self, color=None, depth: float | None = None, stencil: int | None = None):
+    def clear(
+        self,
+        color: collections.abc.Sequence[float] | None = None,
+        depth: float | None = None,
+        stencil: int | None = None,
+    ):
         """Fill color, depth and stencil textures with specific value.
         Common values: color=(0.0, 0.0, 0.0, 1.0), depth=1.0, stencil=0.
 
                 :param color: Sequence of 3 or 4 floats representing (r, g, b, a).
+                :type color: collections.abc.Sequence[float] | None
                 :param depth: depth value.
                 :type depth: float | None
                 :param stencil: stencil value.
@@ -270,11 +276,11 @@ class GPUShader:
         :rtype: int
         """
 
-    def attrs_info_get(self) -> tuple[tuple[str, str], int]:
+    def attrs_info_get(self) -> tuple[tuple[str, str | None], int]:
         """Information about the attributes used in the Shader.
 
         :return: tuples containing information about the attributes in order (name, type)
-        :rtype: tuple[tuple[str, str], int]
+        :rtype: tuple[tuple[str, str | None], int]
         """
 
     def bind(self):
@@ -313,22 +319,22 @@ class GPUShader:
         :rtype: int
         """
 
-    def uniform_bool(self, name: str, value: bool):
+    def uniform_bool(self, name: str, value: bool | collections.abc.Sequence[bool]):
         """Specify the value of a uniform variable for the current program object.
 
         :param name: Name of the uniform variable whose value is to be changed.
         :type name: str
         :param value: Value that will be used to update the specified uniform variable.
-        :type value: bool
+        :type value: bool | collections.abc.Sequence[bool]
         """
 
-    def uniform_float(self, name: str, value: float):
+    def uniform_float(self, name: str, value: collections.abc.Sequence[float] | float):
         """Specify the value of a uniform variable for the current program object.
 
         :param name: Name of the uniform variable whose value is to be changed.
         :type name: str
         :param value: Value that will be used to update the specified uniform variable.
-        :type value: float
+        :type value: collections.abc.Sequence[float] | float
         """
 
     def uniform_from_name(self, name: str) -> int:
@@ -340,12 +346,13 @@ class GPUShader:
         :rtype: int
         """
 
-    def uniform_int(self, name: str, seq):
+    def uniform_int(self, name: str, seq: collections.abc.Sequence[int]):
         """Specify the value of a uniform variable for the current program object.
 
         :param name: name of the uniform variable whose value is to be changed.
         :type name: str
         :param seq: Value that will be used to update the specified uniform variable.
+        :type seq: collections.abc.Sequence[int]
         """
 
     def uniform_sampler(self, name: str, texture: GPUTexture):
@@ -357,12 +364,19 @@ class GPUShader:
         :type texture: GPUTexture
         """
 
-    def uniform_vector_float(self, location: int, buffer, length: int, count: int):
+    def uniform_vector_float(
+        self,
+        location: int,
+        buffer: collections.abc.Sequence[float],
+        length: int,
+        count: int,
+    ):
         """Set the buffer to fill the uniform.
 
                 :param location: Location of the uniform variable to be modified.
                 :type location: int
                 :param buffer: The data that should be set. Can support the buffer protocol.
+                :type buffer: collections.abc.Sequence[float]
                 :param length: Size of the uniform data type:
 
         1: float
@@ -974,13 +988,18 @@ class GPUTexture:
     :type: int
     """
 
-    def clear(self, format: str = "FLOAT", value=(0.0, 0.0, 0.0, 1.0)):
+    def clear(
+        self,
+        format: str = "FLOAT",
+        value: collections.abc.Sequence[float] = (0.0, 0.0, 0.0, 1.0),
+    ):
         """Fill texture with specific value.
 
                 :param format: The format that describes the content of a single item.
         Possible values are FLOAT, INT, UINT, UBYTE, UINT_24_8 and 10_11_11_REV.
                 :type format: str
                 :param value: Sequence each representing the value to fill. Sizes 1..4 are supported.
+                :type value: collections.abc.Sequence[float]
         """
 
     def read(self):
@@ -998,13 +1017,21 @@ class GPUUniformBuf:
 class GPUVertBuf:
     """Contains a VBO."""
 
-    def attr_fill(self, id: int | str, data: Buffer):
+    def attr_fill(
+        self,
+        id: int | str,
+        data: Buffer
+        | collections.abc.Sequence[collections.abc.Sequence[float]]
+        | collections.abc.Sequence[collections.abc.Sequence[int]]
+        | collections.abc.Sequence[float]
+        | collections.abc.Sequence[int],
+    ):
         """Insert data into the buffer for a single attribute.
 
         :param id: Either the name or the id of the attribute.
         :type id: int | str
         :param data: Buffer or sequence of data that should be stored in the buffer
-        :type data: Buffer
+        :type data: Buffer | collections.abc.Sequence[collections.abc.Sequence[float]] | collections.abc.Sequence[collections.abc.Sequence[int]] | collections.abc.Sequence[float] | collections.abc.Sequence[int]
         """
 
 class GPUVertFormat:

gpu_extras/batch/__init__.pyi

@@ -7,7 +7,14 @@ import gpu.types
 def batch_for_shader(
     shader: gpu.types.GPUShader,
     type: str,
-    content: dict[str, bgl.Buffer],
+    content: dict[
+        str,
+        bgl.Buffer
+        | collections.abc.Sequence[float]
+        | collections.abc.Sequence[int]
+        | collections.abc.Sequence[collections.abc.Sequence[float]]
+        | collections.abc.Sequence[collections.abc.Sequence[int]],
+    ],
     *,
     indices=None,
 ) -> gpu.types.GPUBatch:
@@ -19,7 +26,7 @@ def batch_for_shader(
         :type type: str
         :param content: Maps the name of the shader attribute with the data to fill the vertex buffer.
     For the dictionary values see documentation for `gpu.types.GPUVertBuf.attr_fill` data argument.
-        :type content: dict[str, bgl.Buffer]
+        :type content: dict[str, bgl.Buffer | collections.abc.Sequence[float] | collections.abc.Sequence[int] | collections.abc.Sequence[collections.abc.Sequence[float]] | collections.abc.Sequence[collections.abc.Sequence[int]]]
         :return: compatible batch
         :rtype: gpu.types.GPUBatch
     """

gpu_extras/presets/__init__.pyi

@@ -4,18 +4,26 @@ import typing_extensions
 import gpu.types
 import mathutils
 
-def draw_circle_2d(position, color, radius: float, *, segments: int | None = None):
+def draw_circle_2d(
+    position: collections.abc.Sequence[float],
+    color: collections.abc.Sequence[float],
+    radius: float,
+    *,
+    segments: None | int | None = None,
+):
     """Draw a circle.
 
         :param position: 2D position where the circle will be drawn.
+        :type position: collections.abc.Sequence[float]
         :param color: Color of the circle (RGBA).
     To use transparency blend must be set to ALPHA, see: `gpu.state.blend_set`.
+        :type color: collections.abc.Sequence[float]
         :param radius: Radius of the circle.
         :type radius: float
         :param segments: How many segments will be used to draw the circle.
     Higher values give better results but the drawing will take longer.
     If None or not specified, an automatic value will be calculated.
-        :type segments: int | None
+        :type segments: None | int | None
     """
 
 def draw_texture_2d(

imbuf/__init__.pyi

@@ -36,11 +36,11 @@ def new(size: tuple[int, int]) -> imbuf.types.ImBuf:
     :rtype: imbuf.types.ImBuf
     """
 
-def write(image: imbuf.types.ImBuf, filepath: bytes | str = image.filepath):
+def write(image: imbuf.types.ImBuf, filepath: None | bytes | str = image.filepath):
     """Write an image.
 
     :param image: the image to write.
     :type image: imbuf.types.ImBuf
     :param filepath: Optional filepath of the image (fallback to the images file path).
-    :type filepath: bytes | str
+    :type filepath: None | bytes | str
     """

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]
     """