fake-bpy-module 20241207__py3-none-any.whl → 20241208__py3-none-any.whl

idprop/types/__init__.pyi

@@ -29,22 +29,23 @@ class IDPropertyGroup:
     def keys(self):
         """Return the keys associated with this group as a list of strings."""
 
-    def pop(self, key: str, default):
+    def pop(self, key: str, default: typing.Any):
         """Remove an item from the group, returning a Python representation.
 
         :param key: Name of item to remove.
         :type key: str
         :param default: Value to return when key isn't found, otherwise raise an exception.
+        :type default: typing.Any
         """
 
     def to_dict(self):
         """Return a purely Python version of the group."""
 
-    def update(self, other: typing_extensions.Self):
+    def update(self, other: dict[str, typing.Any] | typing_extensions.Self):
         """Update key, values.
 
         :param other: Updates the values in the group with this.
-        :type other: typing_extensions.Self
+        :type other: dict[str, typing.Any] | typing_extensions.Self
         """
 
     def values(self):

imbuf/__init__.pyi

@@ -27,10 +27,11 @@ def load(filepath: bytes | str) -> imbuf.types.ImBuf:
     :rtype: imbuf.types.ImBuf
     """
 
-def new(size) -> imbuf.types.ImBuf:
+def new(size: tuple[int, int]) -> imbuf.types.ImBuf:
     """Load a new image.
 
     :param size: The size of the image in pixels.
+    :type size: tuple[int, int]
     :return: the newly loaded image.
     :rtype: imbuf.types.ImBuf
     """

imbuf/types/__init__.pyi

@@ -43,20 +43,23 @@ class ImBuf:
         :rtype: typing_extensions.Self
         """
 
-    def crop(self, min, max):
+    def crop(self, min: tuple[int, int], max: tuple[int, int]):
         """Crop the image.
 
         :param min: X, Y minimum.
+        :type min: tuple[int, int]
         :param max: X, Y maximum.
+        :type max: tuple[int, int]
         """
 
     def free(self):
         """Clear image data immediately (causing an error on re-use)."""
 
-    def resize(self, size, method: str = "FAST"):
+    def resize(self, size: tuple[int, int], method: str = "FAST"):
         """Resize the image.
 
         :param size: New size.
+        :type size: tuple[int, int]
         :param method: Method of resizing ('FAST', 'BILINEAR')
         :type method: str
         """

mathutils/__init__.pyi

@@ -742,11 +742,11 @@ class Matrix:
         :rtype: typing_extensions.Self
         """
 
-    def decompose(self) -> Quaternion:
+    def decompose(self) -> tuple[Vector, Quaternion, Vector]:
         """Return the translation, rotation, and scale components of this matrix.
 
         :return: Tuple of translation, rotation, and scale.
-        :rtype: Quaternion
+        :rtype: tuple[Vector, Quaternion, Vector]
         """
 
     def determinant(self) -> float:
@@ -786,13 +786,16 @@ class Matrix:
 
         """
 
-    def inverted(self, fallback=None) -> typing_extensions.Self:
+    def inverted(
+        self, fallback: typing.Any | None = None
+    ) -> typing.Any | typing_extensions.Self:
         """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
+                :rtype: typing.Any | typing_extensions.Self
         """
 
     def inverted_safe(self) -> typing_extensions.Self:
@@ -1296,10 +1299,11 @@ class Quaternion:
         :rtype: typing_extensions.Self
         """
 
-    def to_axis_angle(self):
+    def to_axis_angle(self) -> tuple[Vector, float]:
         """Return the axis, angle representation of the quaternion.
 
         :return: Axis, angle.
+        :rtype: tuple[Vector, float]
         """
 
     def to_euler(
@@ -1334,13 +1338,14 @@ class Quaternion:
         :rtype: Matrix
         """
 
-    def to_swing_twist(self, axis: str):
+    def to_swing_twist(self, axis: str) -> tuple[Quaternion, float]:
         """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'].
                 :type axis: str
                 :return: Swing, twist angle.
+                :rtype: tuple[Quaternion, float]
         """
 
     def __init__(self, seq=(1.0, 0.0, 0.0, 0.0)):
@@ -3645,29 +3650,33 @@ class Vector:
     def angle(
         self,
         other: collections.abc.Sequence[float] | typing_extensions.Self,
-        fallback=None,
-    ) -> float:
+        fallback: typing.Any | None = None,
+    ) -> float | typing.Any:
         """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
+                :rtype: float | typing.Any
         """
 
     def angle_signed(
-        self, other: collections.abc.Sequence[float] | typing_extensions.Self, fallback
-    ) -> float:
+        self,
+        other: collections.abc.Sequence[float] | typing_extensions.Self,
+        fallback: typing.Any,
+    ) -> float | typing.Any:
         """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
+                :rtype: float | typing.Any
         """
 
     def copy(self) -> typing_extensions.Self:
@@ -3816,7 +3825,7 @@ class Vector:
         self,
         other: collections.abc.Sequence[float] | typing_extensions.Self,
         factor: float,
-        fallback=None,
+        fallback: typing.Any | None = None,
     ) -> typing_extensions.Self:
         """Returns the interpolation of two non-zero vectors (spherical coordinates).
 
@@ -3826,6 +3835,7 @@ 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
         """
@@ -3862,12 +3872,13 @@ class Vector:
         :rtype: Quaternion
         """
 
-    def to_tuple(self, precision: int = -1):
+    def to_tuple(self, precision: int = -1) -> tuple[float]:
         """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[float]
         """
 
     def zero(self):

mathutils/bvhtree/__init__.pyi

@@ -62,7 +62,7 @@ class BVHTree:
 
     def find_nearest(
         self, origin, distance: float = 1.84467e19
-    ) -> float | mathutils.Vector:
+    ) -> tuple[mathutils.Vector, mathutils.Vector, int, float]:
         """Find the nearest element (typically face index) to a point.
 
                 :param origin:
@@ -70,27 +70,28 @@ class BVHTree:
                 :type distance: float
                 :return: Returns a tuple: (position, normal, index, distance),
         Values will all be None if no hit is found.
-                :rtype: float | mathutils.Vector
+                :rtype: tuple[mathutils.Vector, mathutils.Vector, int, float]
         """
 
     def find_nearest_range(
         self, origin, distance: float = 1.84467e19
-    ) -> int | mathutils.Vector:
+    ) -> list[tuple[mathutils.Vector, mathutils.Vector, int, float]]:
         """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 (position, normal, index, distance)
-        :rtype: int | mathutils.Vector
+        :rtype: list[tuple[mathutils.Vector, mathutils.Vector, int, float]]
         """
 
-    def overlap(self, other_tree: typing_extensions.Self):
+    def overlap(self, other_tree: typing_extensions.Self) -> list[tuple[int, int]]:
         """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[tuple[int, int]]
         """
 
     def ray_cast(
@@ -98,7 +99,7 @@ class BVHTree:
         origin: collections.abc.Sequence[float] | mathutils.Vector,
         direction: collections.abc.Sequence[float] | mathutils.Vector,
         distance: float = sys.float_info.max,
-    ) -> float | mathutils.Vector:
+    ) -> tuple[mathutils.Vector, mathutils.Vector, int, float]:
         """Cast a ray onto the mesh.
 
                 :param origin: Start location of the ray in object space.
@@ -109,7 +110,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: float | mathutils.Vector
+                :rtype: tuple[mathutils.Vector, mathutils.Vector, int, float]
         """
 
     def __init__(self, size):

mathutils/geometry/__init__.pyi

@@ -61,12 +61,15 @@ def box_fit_2d(points) -> float:
     :rtype: float
     """
 
-def box_pack_2d(boxes: float):
+def box_pack_2d(
+    boxes: list[list[float, float, float, float, int]],
+) -> 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: float
+    :type boxes: list[list[float, float, float, float, int]]
     :return: The width and height of the packed bounding box.
+    :rtype: tuple[float, float]
     """
 
 def closest_point_on_tri(
@@ -89,16 +92,24 @@ def closest_point_on_tri(
     :rtype: mathutils.Vector
     """
 
-def convex_hull_2d(points):
+def convex_hull_2d(points) -> list[int]:
     """Returns a list of indices into the list given
 
     :param points: Sequence of 2D points.
     :return: a list of indices
+    :rtype: list[int]
     """
 
 def delaunay_2d_cdt(
     vert_coords, edges, faces, output_type: int, epsilon: float, need_ids=True
-):
+) -> tuple[
+    list[mathutils.Vector],
+    list[tuple[int, int]],
+    list[list[int]],
+    list[list[int]],
+    list[list[int]],
+    list[list[int]],
+]:
     """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,
@@ -121,6 +132,7 @@ def delaunay_2d_cdt(
         :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(
@@ -145,7 +157,7 @@ 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.
@@ -159,6 +171,7 @@ def interpolate_bezier(
     :param resolution: Number of points to return.
     :type resolution: int
     :return: The interpolated points.
+    :rtype: list[mathutils.Vector]
     """
 
 def intersect_line_line(
@@ -166,7 +179,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]:
     """Returns a tuple with the points on each line respectively closest to the other.
 
     :param v1: First point of the first line
@@ -178,6 +191,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]
     """
 
 def intersect_line_line_2d(
@@ -228,7 +242,7 @@ def intersect_line_sphere(
     sphere_co: collections.abc.Sequence[float] | mathutils.Vector,
     sphere_radius: float,
     clip=True,
-) -> mathutils.Vector:
+) -> tuple[mathutils.Vector, mathutils.Vector]:
     """Takes a line (as 2 points) and a sphere (as a point and a radius) and
     returns the intersection
 
@@ -241,7 +255,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: mathutils.Vector
+        :rtype: tuple[mathutils.Vector, mathutils.Vector]
     """
 
 def intersect_line_sphere_2d(
@@ -250,7 +264,7 @@ def intersect_line_sphere_2d(
     sphere_co: collections.abc.Sequence[float] | mathutils.Vector,
     sphere_radius: float,
     clip=True,
-) -> mathutils.Vector:
+) -> tuple[mathutils.Vector, mathutils.Vector]:
     """Takes a line (as 2 points) and a sphere (as a point and a radius) and
     returns the intersection
 
@@ -263,7 +277,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: mathutils.Vector
+        :rtype: tuple[mathutils.Vector, mathutils.Vector]
     """
 
 def intersect_plane_plane(
@@ -271,7 +285,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]:
     """Return the intersection between two planes
 
     :param plane_a_co: Point on the first plane
@@ -283,19 +297,21 @@ 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]
     """
 
 def intersect_point_line(
     pt: collections.abc.Sequence[float] | mathutils.Vector,
     line_p1: collections.abc.Sequence[float] | mathutils.Vector,
     line_p2,
-):
+) -> 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.
 
     :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]
     """
 
 def intersect_point_quad_2d(
@@ -392,7 +408,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]:
     """Returns 2 points on between intersecting circles.
 
     :param p_a: Center of the first circle
@@ -404,6 +420,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]
     """
 
 def intersect_tri_tri_2d(tri_a1, tri_a2, tri_a3, tri_b1, tri_b2, tri_b3) -> bool:
@@ -420,23 +437,27 @@ def normal(vectors) -> mathutils.Vector:
     """
 
 def points_in_planes(
-    planes, epsilon_coplanar: float = 0.0001, epsilon_isect: float = 1e-06
-):
+    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_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]]
     """
 
-def tessellate_polygon(polylines) -> int:
+def tessellate_polygon(polylines) -> 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: int
+    :rtype: list[tuple[int, int, int]]
     """
 
 def volume_tetrahedron(

mathutils/interpolate/__init__.pyi

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

mathutils/kdtree/__init__.pyi

@@ -8,6 +8,7 @@ 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."""
@@ -15,34 +16,38 @@ class KDTree:
     def balance(self):
         """Balance the tree."""
 
-    def find(self, co, filter: collections.abc.Callable | None = None) -> int:
+    def find(
+        self, co, filter: collections.abc.Callable | None = None
+    ) -> tuple[mathutils.Vector, int, float]:
         """Find nearest point to co.
 
         :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 (position, index, distance).
-        :rtype: int
+        :rtype: tuple[mathutils.Vector, int, float]
         """
 
-    def find_n(self, co, n: int) -> int:
+    def find_n(self, co, n: int) -> list[tuple[mathutils.Vector, int, float]]:
         """Find nearest n points to co.
 
         :param co: 3D coordinates.
         :param n: Number of points to find.
         :type n: int
         :return: Returns a list of tuples (position, index, distance).
-        :rtype: int
+        :rtype: list[tuple[mathutils.Vector, int, float]]
         """
 
-    def find_range(self, co, radius: float) -> int:
+    def find_range(
+        self, co, radius: float
+    ) -> list[tuple[mathutils.Vector, int, float]]:
         """Find all points within radius of co.
 
         :param co: 3D coordinates.
         :param radius: Distance to search for points.
         :type radius: float
         :return: Returns a list of tuples (position, index, distance).
-        :rtype: int
+        :rtype: list[tuple[mathutils.Vector, int, float]]
         """
 
     def insert(self, co, index: int):

mathutils/noise/__init__.pyi

@@ -295,7 +295,7 @@ def voronoi(
     position: collections.abc.Sequence[float] | mathutils.Vector,
     distance_metric: str = "DISTANCE",
     exponent: float = 2.5,
-):
+) -> list[list[float], list[mathutils.Vector]]:
     """Returns a list of distances to the four closest features and their locations.
 
     :param position: The position to evaluate the selected noise function.
@@ -305,4 +305,5 @@ def voronoi(
     :param exponent: The exponent for Minkowski distance metric.
     :type exponent: float
     :return: A list of distances to the four closest features and their locations.
+    :rtype: list[list[float], list[mathutils.Vector]]
     """