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

freestyle/functions/__init__.pyi

@@ -329,12 +329,15 @@ class GetOccludeeF1D:
     def __init__(self):
         """Builds a GetOccludeeF1D object."""
 
-    def __call__(self, inter: freestyle.types.Interface1D):
+    def __call__(
+        self, inter: freestyle.types.Interface1D
+    ) -> list[freestyle.types.ViewShape]:
         """Returns a list of occluded shapes covered by this Interface1D.
 
         :param inter: An Interface1D object.
         :type inter: freestyle.types.Interface1D
         :return: A list of occluded shapes covered by the Interface1D.
+        :rtype: list[freestyle.types.ViewShape]
         """
 
 class GetOccludersF0D:
@@ -343,7 +346,9 @@ class GetOccludersF0D:
     def __init__(self):
         """Builds a GetOccludersF0D object."""
 
-    def __call__(self, it: freestyle.types.Interface0DIterator):
+    def __call__(
+        self, it: freestyle.types.Interface0DIterator
+    ) -> list[freestyle.types.ViewShape]:
         """Returns a list of `freestyle.types.ViewShape` occluding the
         `freestyle.types.Interface0D` pointed by the Interface0DIterator.
 
@@ -351,6 +356,7 @@ class GetOccludersF0D:
                 :type it: freestyle.types.Interface0DIterator
                 :return: A list of ViewShape objects occluding the pointed
         Interface0D.
+                :rtype: list[freestyle.types.ViewShape]
         """
 
 class GetOccludersF1D:
@@ -359,12 +365,15 @@ class GetOccludersF1D:
     def __init__(self):
         """Builds a GetOccludersF1D object."""
 
-    def __call__(self, inter: freestyle.types.Interface1D):
+    def __call__(
+        self, inter: freestyle.types.Interface1D
+    ) -> list[freestyle.types.ViewShape]:
         """Returns a list of occluding shapes that cover this Interface1D.
 
         :param inter: An Interface1D object.
         :type inter: freestyle.types.Interface1D
         :return: A list of occluding shapes that cover the Interface1D.
+        :rtype: list[freestyle.types.ViewShape]
         """
 
 class GetParameterF0D:
@@ -521,12 +530,15 @@ class GetShapeF1D:
     def __init__(self):
         """Builds a GetShapeF1D object."""
 
-    def __call__(self, inter: freestyle.types.Interface1D):
+    def __call__(
+        self, inter: freestyle.types.Interface1D
+    ) -> list[freestyle.types.ViewShape]:
         """Returns a list of shapes covered by this Interface1D.
 
         :param inter: An Interface1D object.
         :type inter: freestyle.types.Interface1D
         :return: A list of shapes covered by the Interface1D.
+        :rtype: list[freestyle.types.ViewShape]
         """
 
 class GetSteerableViewMapDensityF1D:

freestyle/types/__init__.pyi

@@ -1046,11 +1046,23 @@ class Material:
 
     def __init__(
         self,
-        line: collections.abc.Sequence[float] | float | mathutils.Vector,
+        line: collections.abc.Sequence[float]
+        | list[float]
+        | mathutils.Vector
+        | tuple[float, float, float, float],
         diffuse: typing.Any,
-        ambient: collections.abc.Sequence[float] | float | mathutils.Vector,
-        specular: collections.abc.Sequence[float] | float | mathutils.Vector,
-        emission: collections.abc.Sequence[float] | float | mathutils.Vector,
+        ambient: collections.abc.Sequence[float]
+        | list[float]
+        | mathutils.Vector
+        | tuple[float, float, float, float],
+        specular: collections.abc.Sequence[float]
+        | list[float]
+        | mathutils.Vector
+        | tuple[float, float, float, float],
+        emission: collections.abc.Sequence[float]
+        | list[float]
+        | mathutils.Vector
+        | tuple[float, float, float, float],
         shininess: float,
         priority: int,
     ):
@@ -1058,15 +1070,15 @@ class Material:
         copy constructor, or an overloaded constructor
 
                 :param line: The line color.
-                :type line: collections.abc.Sequence[float] | float | mathutils.Vector
+                :type line: collections.abc.Sequence[float] | list[float] | mathutils.Vector | tuple[float, float, float, float]
                 :param diffuse: The diffuse color.
                 :type diffuse: typing.Any
                 :param ambient: The ambient color.
-                :type ambient: collections.abc.Sequence[float] | float | mathutils.Vector
+                :type ambient: collections.abc.Sequence[float] | list[float] | mathutils.Vector | tuple[float, float, float, float]
                 :param specular: The specular color.
-                :type specular: collections.abc.Sequence[float] | float | mathutils.Vector
+                :type specular: collections.abc.Sequence[float] | list[float] | mathutils.Vector | tuple[float, float, float, float]
                 :param emission: The emissive color.
-                :type emission: collections.abc.Sequence[float] | float | mathutils.Vector
+                :type emission: collections.abc.Sequence[float] | list[float] | mathutils.Vector | tuple[float, float, float, float]
                 :param shininess: The shininess coefficient.
                 :type shininess: float
                 :param priority: The line color priority.
@@ -1103,23 +1115,31 @@ class Noise:
         """
 
     def smoothNoise2(
-        self, v: collections.abc.Sequence[float] | mathutils.Vector
+        self,
+        v: collections.abc.Sequence[float]
+        | list[float]
+        | mathutils.Vector
+        | tuple[float, float],
     ) -> float:
         """Returns a smooth noise value for a 2D element.
 
         :param v: Two-dimensional sample point.
-        :type v: collections.abc.Sequence[float] | mathutils.Vector
+        :type v: collections.abc.Sequence[float] | list[float] | mathutils.Vector | tuple[float, float]
         :return: A smooth noise value.
         :rtype: float
         """
 
     def smoothNoise3(
-        self, v: collections.abc.Sequence[float] | float | mathutils.Vector
+        self,
+        v: collections.abc.Sequence[float]
+        | list[float]
+        | mathutils.Vector
+        | tuple[float, float, float],
     ) -> float:
         """Returns a smooth noise value for a 3D element.
 
         :param v: Three-dimensional sample point.
-        :type v: collections.abc.Sequence[float] | float | mathutils.Vector
+        :type v: collections.abc.Sequence[float] | list[float] | mathutils.Vector | tuple[float, float, float]
         :return: A smooth noise value.
         :rtype: float
         """
@@ -1141,7 +1161,10 @@ class Noise:
 
     def turbulence2(
         self,
-        v: collections.abc.Sequence[float] | mathutils.Vector,
+        v: collections.abc.Sequence[float]
+        | list[float]
+        | mathutils.Vector
+        | tuple[float, float],
         freq: float,
         amp: float,
         oct: int = 4,
@@ -1149,7 +1172,7 @@ class Noise:
         """Returns a noise value for a 2D element.
 
         :param v: Two-dimensional sample point.
-        :type v: collections.abc.Sequence[float] | mathutils.Vector
+        :type v: collections.abc.Sequence[float] | list[float] | mathutils.Vector | tuple[float, float]
         :param freq: Noise frequency.
         :type freq: float
         :param amp: Amplitude.
@@ -1162,7 +1185,10 @@ class Noise:
 
     def turbulence3(
         self,
-        v: collections.abc.Sequence[float] | float | mathutils.Vector,
+        v: collections.abc.Sequence[float]
+        | list[float]
+        | mathutils.Vector
+        | tuple[float, float, float],
         freq: float,
         amp: float,
         oct: int = 4,
@@ -1170,7 +1196,7 @@ class Noise:
         """Returns a noise value for a 3D element.
 
         :param v: Three-dimensional sample point.
-        :type v: collections.abc.Sequence[float] | float | mathutils.Vector
+        :type v: collections.abc.Sequence[float] | list[float] | mathutils.Vector | tuple[float, float, float]
         :param freq: Noise frequency.
         :type freq: float
         :param amp: Amplitude.
@@ -1291,7 +1317,7 @@ class Operators:
         """
 
     @staticmethod
-    def create(pred: UnaryPredicate1D, shaders):
+    def create(pred: UnaryPredicate1D, shaders: list[StrokeShader]):
         """Creates and shades the strokes from the current set of chains. A
         predicate can be specified to make a selection pass on the chains.
 
@@ -1299,6 +1325,7 @@ class Operators:
         transform as a stroke.
                 :type pred: UnaryPredicate1D
                 :param shaders: The list of shaders used to shade the strokes.
+                :type shaders: list[StrokeShader]
         """
 
     @staticmethod
@@ -1644,13 +1671,17 @@ ViewVertex, and None otherwise.
         """
 
     def add_normal(
-        self, normal: collections.abc.Sequence[float] | float | mathutils.Vector
+        self,
+        normal: collections.abc.Sequence[float]
+        | list[float]
+        | mathutils.Vector
+        | tuple[float, float, float],
     ):
         """Adds a normal to the SVertex's set of normals. If the same normal
         is already in the set, nothing changes.
 
                 :param normal: A three-dimensional vector.
-                :type normal: collections.abc.Sequence[float] | float | mathutils.Vector
+                :type normal: collections.abc.Sequence[float] | list[float] | mathutils.Vector | tuple[float, float, float]
         """
 
 class SVertexIterator:
@@ -2005,7 +2036,10 @@ when following the stroke.
     def set_attribute_vec2(
         self,
         name: str,
-        value: collections.abc.Sequence[float] | float | mathutils.Vector,
+        value: collections.abc.Sequence[float]
+        | list[float]
+        | mathutils.Vector
+        | tuple[float, float, float],
     ):
         """Adds a user-defined attribute of two-dimensional vector type. If
         there is no attribute of the given name, it is added. Otherwise,
@@ -2014,13 +2048,16 @@ when following the stroke.
                 :param name: The name of the attribute.
                 :type name: str
                 :param value: The attribute value.
-                :type value: collections.abc.Sequence[float] | float | mathutils.Vector
+                :type value: collections.abc.Sequence[float] | list[float] | mathutils.Vector | tuple[float, float, float]
         """
 
     def set_attribute_vec3(
         self,
         name: str,
-        value: collections.abc.Sequence[float] | float | mathutils.Vector,
+        value: collections.abc.Sequence[float]
+        | list[float]
+        | mathutils.Vector
+        | tuple[float, float, float],
     ):
         """Adds a user-defined attribute of three-dimensional vector type.
         If there is no attribute of the given name, it is added.
@@ -2029,7 +2066,7 @@ when following the stroke.
                 :param name: The name of the attribute.
                 :type name: str
                 :param value: The attribute value as a 3D vector.
-                :type value: collections.abc.Sequence[float] | float | mathutils.Vector
+                :type value: collections.abc.Sequence[float] | list[float] | mathutils.Vector | tuple[float, float, float]
         """
 
 class StrokeShader:

freestyle/utils/ContextFunctions/__init__.pyi

@@ -8,11 +8,11 @@ import collections.abc
 import typing_extensions
 import freestyle.types
 
-def get_border() -> int:
+def get_border() -> tuple[int, int, int, int]:
     """Returns the border.
 
     :return: A tuple of 4 numbers (xmin, ymin, xmax, ymax).
-    :rtype: int
+    :rtype: tuple[int, int, int, int]
     """
 
 def get_canvas_height() -> int:

gpu/capabilities/__init__.pyi

@@ -14,10 +14,11 @@ def compute_shader_support_get() -> bool:
     :rtype: bool
     """
 
-def extensions_get():
+def extensions_get() -> tuple[str]:
     """Get supported extensions in the current context.
 
     :return: Extensions.
+    :rtype: tuple[str]
     """
 
 def hdr_support_get() -> bool:

gpu/state/__init__.pyi

@@ -98,7 +98,7 @@ def program_point_size_set(enable: bool):
     :type enable: bool
     """
 
-def scissor_get() -> int:
+def scissor_get() -> tuple[int, int, int, int]:
     """Retrieve the scissors of the active framebuffer.
     Note: Only valid between 'scissor_set' and a framebuffer rebind.
 
@@ -106,7 +106,7 @@ def scissor_get() -> int:
     (x, y, xsize, ysize).
     x, y: lower left corner of the scissor rectangle, in pixels.
     xsize, ysize: width and height of the scissor rectangle.
-        :rtype: int
+        :rtype: tuple[int, int, int, int]
     """
 
 def scissor_set(x: int, y, xsize: int, ysize):

gpu/types/__init__.pyi

@@ -271,11 +271,11 @@ class GPUShader:
         :rtype: int
         """
 
-    def attrs_info_get(self) -> str:
+    def attrs_info_get(self) -> tuple[tuple[str, str], int]:
         """Information about the attributes used in the Shader.
 
         :return: tuples containing information about the attributes in order (name, type)
-        :rtype: str
+        :rtype: tuple[tuple[str, str], int]
         """
 
     def bind(self):

gpu_extras/batch/__init__.pyi

@@ -1,11 +1,14 @@
 import typing
 import collections.abc
 import typing_extensions
-import bgl
 import gpu.types
 
 def batch_for_shader(
-    shader: gpu.types.GPUShader, type: str, content: bgl.Buffer, *, indices=None
+    shader: gpu.types.GPUShader,
+    type: str,
+    content: dict[str, gpu.types.Buffer],
+    *,
+    indices=None,
 ) -> gpu.types.GPUBatch:
     """Return a batch already configured and compatible with the shader.
 
@@ -15,7 +18,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: bgl.Buffer
+        :type content: dict[str, gpu.types.Buffer]
         :return: compatible batch
         :rtype: gpu.types.GPUBatch
     """

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):