fake-bge-module 20250104__py3-none-any.whl → 20250201__py3-none-any.whl

freestyle/types/__init__.pyi

@@ -273,7 +273,7 @@ class ChainingIterator:
         self,
         restrict_to_selection: bool = True,
         restrict_to_unvisited: bool = True,
-        begin=None,
+        begin: None | ViewEdge | None = None,
         orientation: bool = True,
     ):
         """Builds a Chaining Iterator from the first ViewEdge used for
@@ -286,6 +286,7 @@ class ChainingIterator:
         already been chained must be ignored ot not.
                 :type restrict_to_unvisited: bool
                 :param begin: The ViewEdge from which to start the chain.
+                :type begin: None | ViewEdge | None
                 :param orientation: The direction to follow to explore the graph. If
         true, the direction indicated by the first ViewEdge is used.
                 :type orientation: bool
@@ -306,7 +307,7 @@ class ChainingIterator:
 
         """
 
-    def traverse(self, it: AdjacencyIterator):
+    def traverse(self, it: AdjacencyIterator) -> None | ViewEdge:
         """This method iterates over the potential next ViewEdges and returns
         the one that will be followed next. Returns the next ViewEdge to
         follow or None when the end of the chain is reached.
@@ -316,6 +317,7 @@ class ChainingIterator:
         restriction rules by only iterating over the valid ViewEdges.
                 :type it: AdjacencyIterator
                 :return: Returns the next ViewEdge to follow, or None if chaining ends.
+                :rtype: None | ViewEdge
         """
 
 class Curve:
@@ -358,16 +360,18 @@ class Curve:
                 :type id: Id
         """
 
-    def push_vertex_back(self, vertex):
+    def push_vertex_back(self, vertex: CurvePoint | SVertex):
         """Adds a single vertex at the end of the Curve.
 
         :param vertex: A vertex object.
+        :type vertex: CurvePoint | SVertex
         """
 
-    def push_vertex_front(self, vertex):
+    def push_vertex_front(self, vertex: CurvePoint | SVertex):
         """Adds a single vertex at the front of the Curve.
 
         :param vertex: A vertex object.
+        :type vertex: CurvePoint | SVertex
         """
 
 class CurvePoint:
@@ -865,12 +869,15 @@ class, the .object property refers to a `StrokeVertex` object.
                 :type brother: typing_extensions.Self
         """
 
-    def __init__(self, it: CurvePointIterator | SVertexIterator):
+    def __init__(
+        self,
+        it: CurvePointIterator | SVertexIterator | StrokeVertexIterator | typing.Any,
+    ):
         """Construct a nested Interface0DIterator using either the copy constructor
         or the constructor that takes an he argument of a Function0D.
 
                 :param it: An iterator object to be nested.
-                :type it: CurvePointIterator | SVertexIterator
+                :type it: CurvePointIterator | SVertexIterator | StrokeVertexIterator | typing.Any
         """
 
 class Interface1D:
@@ -1042,11 +1049,23 @@ class Material:
 
     def __init__(
         self,
-        line: float,
+        line: collections.abc.Sequence[float]
+        | list[float]
+        | mathutils.Vector
+        | tuple[float, float, float, float],
         diffuse: typing.Any,
-        ambient: float,
-        specular: float,
-        emission: float,
+        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,
     ):
@@ -1054,15 +1073,15 @@ class Material:
         copy constructor, or an overloaded constructor
 
                 :param line: The line color.
-                :type line: float
+                :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: float
+                :type ambient: collections.abc.Sequence[float] | list[float] | mathutils.Vector | tuple[float, float, float, float]
                 :param specular: The specular color.
-                :type specular: float
+                :type specular: collections.abc.Sequence[float] | list[float] | mathutils.Vector | tuple[float, float, float, float]
                 :param emission: The emissive color.
-                :type emission: float
+                :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.
@@ -1098,19 +1117,32 @@ class Noise:
         :rtype: float
         """
 
-    def smoothNoise2(self, v) -> float:
+    def smoothNoise2(
+        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] | list[float] | mathutils.Vector | tuple[float, float]
         :return: A smooth noise value.
         :rtype: float
         """
 
-    def smoothNoise3(self, v: float) -> float:
+    def smoothNoise3(
+        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: float
+        :type v: collections.abc.Sequence[float] | list[float] | mathutils.Vector | tuple[float, float, float]
         :return: A smooth noise value.
         :rtype: float
         """
@@ -1130,10 +1162,20 @@ class Noise:
         :rtype: float
         """
 
-    def turbulence2(self, v, freq: float, amp: float, oct: int = 4) -> float:
+    def turbulence2(
+        self,
+        v: collections.abc.Sequence[float]
+        | list[float]
+        | mathutils.Vector
+        | tuple[float, float],
+        freq: float,
+        amp: float,
+        oct: int = 4,
+    ) -> float:
         """Returns a noise value for a 2D element.
 
         :param v: Two-dimensional sample point.
+        :type v: collections.abc.Sequence[float] | list[float] | mathutils.Vector | tuple[float, float]
         :param freq: Noise frequency.
         :type freq: float
         :param amp: Amplitude.
@@ -1144,11 +1186,20 @@ class Noise:
         :rtype: float
         """
 
-    def turbulence3(self, v: float, freq: float, amp: float, oct: int = 4) -> float:
+    def turbulence3(
+        self,
+        v: collections.abc.Sequence[float]
+        | list[float]
+        | mathutils.Vector
+        | tuple[float, float, float],
+        freq: float,
+        amp: float,
+        oct: int = 4,
+    ) -> float:
         """Returns a noise value for a 3D element.
 
         :param v: Three-dimensional sample point.
-        :type v: float
+        :type v: collections.abc.Sequence[float] | list[float] | mathutils.Vector | tuple[float, float, float]
         :param freq: Noise frequency.
         :type freq: float
         :param amp: Amplitude.
@@ -1269,7 +1320,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.
 
@@ -1277,6 +1328,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
@@ -1621,12 +1673,18 @@ ViewVertex, and None otherwise.
         :type fedge: FEdge
         """
 
-    def add_normal(self, normal: float):
+    def add_normal(
+        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: float
+                :type normal: collections.abc.Sequence[float] | list[float] | mathutils.Vector | tuple[float, float, float]
         """
 
 class SVertexIterator:
@@ -1978,7 +2036,14 @@ when following the stroke.
                 :type value: float
         """
 
-    def set_attribute_vec2(self, name: str, value: float):
+    def set_attribute_vec2(
+        self,
+        name: str,
+        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,
         the new value replaces the old one.
@@ -1986,10 +2051,17 @@ when following the stroke.
                 :param name: The name of the attribute.
                 :type name: str
                 :param value: The attribute value.
-                :type value: float
+                :type value: collections.abc.Sequence[float] | list[float] | mathutils.Vector | tuple[float, float, float]
         """
 
-    def set_attribute_vec3(self, name: str, value: float):
+    def set_attribute_vec3(
+        self,
+        name: str,
+        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.
         Otherwise, the new value replaces the old one.
@@ -1997,7 +2069,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: float
+                :type value: collections.abc.Sequence[float] | list[float] | mathutils.Vector | tuple[float, float, float]
         """
 
 class StrokeShader:
@@ -2737,11 +2809,12 @@ of the "begin" ViewEdge.
     :type: bool
     """
 
-    def __init__(self, begin=None, orientation: bool = True):
+    def __init__(self, begin: None | ViewEdge | None = None, orientation: bool = True):
         """Builds a ViewEdgeIterator from a starting ViewEdge and its
         orientation or the copy constructor.
 
                 :param begin: The ViewEdge from where to start the iteration.
+                :type begin: None | ViewEdge | None
                 :param orientation: If true, we'll look for the next ViewEdge among
         the ViewEdges that surround the ending ViewVertex of begin. If
         false, we'll search over the ViewEdges surrounding the ending
@@ -2925,12 +2998,12 @@ class orientedViewEdgeIterator:
     obtained from a ViewVertex by calling edges_begin() or edges_end().
     """
 
-    object: tuple[ViewEdge]
+    object: tuple[ViewEdge, bool]
     """ The oriented ViewEdge (i.e., a tuple of the pointed ViewEdge and a boolean
 value) currently pointed to by this iterator. If the boolean value is true,
 the ViewEdge is incoming.
 
-    :type: tuple[ViewEdge]
+    :type: tuple[ViewEdge, bool]
     """
 
     def __init__(self):

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:

freestyle/utils/__init__.pyi

@@ -70,7 +70,7 @@ def integrate(
     it: freestyle.types.Interface0DIterator,
     it_end: freestyle.types.Interface0DIterator,
     integration_type: freestyle.types.IntegrationType,
-):
+) -> float:
     """Returns a single value from a set of values evaluated at each 0D
     element of this 1D element.
 
@@ -91,6 +91,7 @@ def integrate(
     value type is float if func is of the `UnaryFunction0DDouble`
     or `UnaryFunction0DFloat` type, and int if func is of the
     `UnaryFunction0DUnsigned` type.
+        :rtype: float
     """
 
 def is_poly_clockwise(stroke):

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/matrix/__init__.pyi

@@ -83,10 +83,11 @@ def push_projection():
 def reset():
     """Empty stack and set to identity."""
 
-def scale(scale):
+def scale(scale: collections.abc.Sequence[float]):
     """Scale the current stack matrix.
 
     :param scale: Scale the current stack matrix with 2 or 3 floats.
+    :type scale: collections.abc.Sequence[float]
     """
 
 def scale_uniform(scale: float):
@@ -96,8 +97,9 @@ def scale_uniform(scale: float):
     :type scale: float
     """
 
-def translate(offset):
+def translate(offset: collections.abc.Sequence[float]):
     """Scale the current stack matrix.
 
     :param offset: Translate the current stack matrix with 2 or 3 floats.
+    :type offset: collections.abc.Sequence[float]
     """

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

@@ -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,10 +276,11 @@ class GPUShader:
         :rtype: int
         """
 
-    def attrs_info_get(self):
+    def attrs_info_get(self) -> tuple[tuple[str, str | None], ...]:
         """Information about the attributes used in the Shader.
 
         :return: tuples containing information about the attributes in order (name, type)
+        :rtype: tuple[tuple[str, str | None], ...]
         """
 
     def bind(self):
@@ -312,20 +319,22 @@ class GPUShader:
         :rtype: int
         """
 
-    def uniform_bool(self, name: str, value):
+    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 | collections.abc.Sequence[bool]
         """
 
-    def uniform_float(self, name: str, value):
+    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: collections.abc.Sequence[float] | float
         """
 
     def uniform_from_name(self, name: str) -> int:
@@ -337,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):
@@ -354,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
@@ -971,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):
@@ -995,11 +1017,21 @@ class GPUUniformBuf:
 class GPUVertBuf:
     """Contains a VBO."""
 
-    def attr_fill(self, id, data):
+    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 | 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

@@ -4,7 +4,18 @@ import typing_extensions
 import gpu.types
 
 def batch_for_shader(
-    shader: gpu.types.GPUShader, type: str, content, *, indices=None
+    shader: gpu.types.GPUShader,
+    type: str,
+    content: dict[
+        str,
+        gpu.types.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:
     """Return a batch already configured and compatible with the shader.
 
@@ -14,6 +25,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, gpu.types.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,17 +4,26 @@ import typing_extensions
 import gpu.types
 import mathutils
 
-def draw_circle_2d(position, color, radius: float, *, segments=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: None | int | None
     """
 
 def draw_texture_2d(

idprop/types/__init__.pyi

@@ -29,21 +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):
+    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: dict[str, typing.Any] | typing_extensions.Self
         """
 
     def values(self):

imbuf/__init__.pyi

@@ -18,26 +18,29 @@ import imbuf.types
 
 from . import types as types
 
-def load(filepath) -> imbuf.types.ImBuf:
+def load(filepath: bytes | str) -> imbuf.types.ImBuf:
     """Load an image from a file.
 
     :param filepath: the filepath of the image.
+    :type filepath: bytes | str
     :return: the newly loaded image.
     :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
     """
 
-def write(image: imbuf.types.ImBuf, filepath=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: None | bytes | str
     """

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