fake-bpy-module-latest 20251002__py3-none-any.whl → 20260113__py3-none-any.whl

gpu/state/__init__.pyi

@@ -7,12 +7,21 @@ import typing
 import collections.abc
 import typing_extensions
 import numpy.typing as npt
+import gpu.types
 
-def active_framebuffer_get(enable) -> None:
-    """Return the active frame-buffer in context."""
+def active_framebuffer_get() -> gpu.types.GPUFrameBuffer:
+    """Return the active frame-buffer in context.
 
-def blend_get() -> None:
-    """Current blending equation."""
+    :return: The active framebuffer.
+    :rtype: gpu.types.GPUFrameBuffer
+    """
+
+def blend_get() -> str:
+    """Current blending equation.
+
+    :return: The current blend mode.
+    :rtype: str
+    """
 
 def blend_set(mode: str) -> None:
     """Defines the fixed pipeline blending equation.
@@ -44,24 +53,39 @@ def clip_distances_set(distances_enabled: int) -> None:
     :type distances_enabled: int
     """
 
-def color_mask_set(r: bool, g, b, a) -> None:
+def color_mask_set(r: bool, g: bool, b: bool, a: bool) -> None:
     """Enable or disable writing of frame buffer color components.
 
-    :param r: components red, green, blue, and alpha.
+    :param r: Red component.
     :type r: bool
+    :param g: Green component.
+    :type g: bool
+    :param b: Blue component.
+    :type b: bool
+    :param a: Alpha component.
+    :type a: bool
     """
 
-def depth_mask_get() -> None:
-    """Writing status in the depth component."""
+def depth_mask_get() -> bool:
+    """Writing status in the depth component.
 
-def depth_mask_set(value) -> None:
+    :return: True if writing to the depth component is enabled.
+    :rtype: bool
+    """
+
+def depth_mask_set(value: bool) -> None:
     """Write to depth component.
 
     :param value: True for writing to the depth component.
+    :type value: bool
     """
 
-def depth_test_get() -> None:
-    """Current depth_test equation."""
+def depth_test_get() -> str:
+    """Current depth_test equation.
+
+    :return: The current depth test mode.
+    :rtype: str
+    """
 
 def depth_test_set(mode: str) -> None:
     """Defines the depth_test equation.
@@ -71,25 +95,39 @@ def depth_test_set(mode: str) -> None:
         :type mode: str
     """
 
-def face_culling_set(culling) -> None:
-    """Specify whether none, front-facing or back-facing facets can be culled."""
+def face_culling_set(culling: str) -> None:
+    """Specify whether none, front-facing or back-facing facets can be culled.
 
-def front_facing_set(invert) -> None:
+    :param culling: NONE, FRONT or BACK.
+    :type culling: str
+    """
+
+def front_facing_set(invert: bool) -> None:
     """Specifies the orientation of front-facing polygons.
 
     :param invert: True for clockwise polygons as front-facing.
+    :type invert: bool
+    """
+
+def line_width_get() -> float:
+    """Current width of rasterized lines.
+
+    :return: The current line width.
+    :rtype: float
     """
 
-def line_width_get() -> None:
-    """Current width of rasterized lines."""
+def line_width_set(width: float) -> None:
+    """Specify the width of rasterized lines.
 
-def line_width_set(width) -> None:
-    """Specify the width of rasterized lines."""
+    :param width: New width.
+    :type width: float
+    """
 
-def point_size_set(size) -> None:
+def point_size_set(size: float) -> None:
     """Specify the diameter of rasterized points.
 
     :param size: New diameter.
+    :type size: float
     """
 
 def program_point_size_set(enable: bool) -> None:
@@ -110,14 +148,18 @@ def scissor_get() -> tuple[int, int, int, int]:
         :rtype: tuple[int, int, int, int]
     """
 
-def scissor_set(x: int, y, xsize: int, ysize) -> None:
+def scissor_set(x: int, y: int, xsize: int, ysize: int) -> None:
     """Specifies the scissor area of the active framebuffer.
     Note: The scissor state is not saved upon framebuffer rebind.
 
-        :param x: lower left corner of the scissor rectangle, in pixels.
+        :param x: Lower left corner x coordinate, in pixels.
         :type x: int
-        :param xsize: width and height of the scissor rectangle.
+        :param y: Lower left corner y coordinate, in pixels.
+        :type y: int
+        :param xsize: Width of the scissor rectangle.
         :type xsize: int
+        :param ysize: Height of the scissor rectangle.
+        :type ysize: int
     """
 
 def scissor_test_set(enable: bool) -> None:
@@ -128,15 +170,23 @@ def scissor_test_set(enable: bool) -> None:
         :type enable: bool
     """
 
-def viewport_get() -> None:
-    """Viewport of the active framebuffer."""
+def viewport_get() -> tuple[int, int, int, int]:
+    """Viewport of the active framebuffer.
+
+    :return: The viewport as a tuple (x, y, xsize, ysize).
+    :rtype: tuple[int, int, int, int]
+    """
 
-def viewport_set(x: int, y, xsize: int, ysize) -> None:
+def viewport_set(x: int, y: int, xsize: int, ysize: int) -> None:
     """Specifies the viewport of the active framebuffer.
     Note: The viewport state is not saved upon framebuffer rebind.
 
-        :param x: lower left corner of the viewport_set rectangle, in pixels.
+        :param x: Lower left corner x coordinate, in pixels.
         :type x: int
-        :param xsize: width and height of the viewport_set.
+        :param y: Lower left corner y coordinate, in pixels.
+        :type y: int
+        :param xsize: Width of the viewport.
         :type xsize: int
+        :param ysize: Height of the viewport.
+        :type ysize: int
     """

gpu/types/__init__.pyi

@@ -14,11 +14,12 @@ class Buffer:
 class GPUBatch:
     """Reusable container for drawable geometry."""
 
-    def draw(self, shader=None) -> None:
+    def draw(self, shader: GPUShader | None = None) -> None:
         """Run the drawing shader with the parameters assigned to the batch.
 
                 :param shader: Shader that performs the drawing operations.
         If None is passed, the last shader set to this batch will run.
+                :type shader: GPUShader | None
         """
 
     def draw_instanced(
@@ -116,7 +117,7 @@ class GPUFrameBuffer:
         slot: int,
         format: str,
         *,
-        data: Buffer = data,
+        data: Buffer | None = None,
     ) -> Buffer:
         """Read a block of pixels from the frame buffer.
 
@@ -134,13 +135,13 @@ class GPUFrameBuffer:
         UINT_24_8 is deprecated, use FLOAT instead.
                 :type format: str
                 :param data: Optional Buffer object to fill with the pixels values.
-                :type data: Buffer
+                :type data: Buffer | None
                 :return: The Buffer with the read pixels.
                 :rtype: Buffer
         """
 
     def read_depth(
-        self, x: int, y, xsize: int, ysize, *, data: Buffer = data
+        self, x: int, y, xsize: int, ysize, *, data: Buffer | None = None
     ) -> Buffer:
         """Read a pixel depth block from the frame buffer.
 
@@ -151,7 +152,7 @@ class GPUFrameBuffer:
         :type xsize: int
         :param ysize:
         :param data: Optional Buffer object to fill with the pixels values.
-        :type data: Buffer
+        :type data: Buffer | None
         :return: The Buffer with the read pixels.
         :rtype: Buffer
         """
@@ -294,12 +295,13 @@ This is deprecated and will always return -1.
         :type texture: GPUTexture
         """
 
-    def uniform_block(self, name: str, ubo) -> None:
-        """Specify the value of an uniform buffer object variable for the current GPUShader.
+    def uniform_block(self, name: str, ubo: GPUUniformBuf) -> None:
+        """Specify the value of a uniform buffer object variable for the current GPUShader.
 
-        :param name: name of the uniform variable whose UBO is to be specified.
+        :param name: Name of the uniform variable whose UBO is to be specified.
         :type name: str
         :param ubo: Uniform Buffer to attach.
+        :type ubo: GPUUniformBuf
         """
 
     def uniform_block_from_name(self, name: str) -> int:
@@ -342,19 +344,19 @@ This is deprecated and will always return -1.
         :rtype: int
         """
 
-    def uniform_int(self, name: str, seq: collections.abc.Sequence[int]) -> None:
+    def uniform_int(self, name: str, seq: collections.abc.Sequence[int] | int) -> None:
         """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.
+        :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]
+        :type seq: collections.abc.Sequence[int] | int
         """
 
     def uniform_sampler(self, name: str, texture: GPUTexture) -> None:
         """Specify the value of a texture uniform variable for the current GPUShader.
 
-        :param name: name of the uniform variable whose texture is to be specified.
+        :param name: Name of the uniform variable whose texture is to be specified.
         :type name: str
         :param texture: Texture to attach.
         :type texture: GPUTexture
@@ -391,13 +393,18 @@ This is deprecated and will always return -1.
                 :type count: int
         """
 
-    def uniform_vector_int(self, location, buffer, length, count) -> None:
-        """See GPUShader.uniform_vector_float(...) description.
+    def uniform_vector_int(
+        self, location: int, buffer, length: int, count: int
+    ) -> None:
+        """Set the buffer to fill the uniform.
 
-        :param location:
-        :param buffer:
-        :param length:
-        :param count:
+        :param location: Location of the uniform variable to be modified.
+        :type location: int
+        :param buffer: Buffer object with format matching the uniform.
+        :param length: Size of the uniform data type.
+        :type length: int
+        :param count: Specifies the number of elements that are to be modified.
+        :type count: int
         """
 
 class GPUShaderCreateInfo:
@@ -419,7 +426,7 @@ class GPUShaderCreateInfo:
         :type value: str
         """
 
-    def depth_write(self, value) -> None:
+    def depth_write(self, value: str) -> None:
         """Specify a depth write behavior when modifying gl_FragDepth.There is a common optimization for GPUs that relies on an early depth
         test to be run before the fragment shader so that the shader evaluation
         can be skipped if the fragment ends up being discarded because it is occluded.This optimization does not affect the final rendering, and is typically
@@ -433,6 +440,7 @@ class GPUShaderCreateInfo:
         :ANY: enables depth write in a fragment shader for any fragments
         :GREATER: enables depth write in a fragment shader for depth values thatare greater than the depth value in the output buffer.
         :LESS: enables depth write in a fragment shader for depth values thatare less than the depth value in the output buffer.
+                :type value: str
         """
 
     def fragment_out(
@@ -991,7 +999,7 @@ class GPUStageInterfaceInfo:
         """
 
 class GPUTexture:
-    """This object gives access to off GPU textures."""
+    """This object gives access to GPU textures."""
 
     format: str
     """ Format of the texture.
@@ -1011,6 +1019,13 @@ class GPUTexture:
     :type: int
     """
 
+    def anisotropic_filter(self, use_anisotropic: bool) -> None:
+        """Set anisotropic filter usage. This only has effect if mipmapping is enabled.
+
+        :param use_anisotropic: If set to true, the texture will use anisotropic filtering.
+        :type use_anisotropic: bool
+        """
+
     def clear(
         self,
         format: str = "FLOAT",
@@ -1026,6 +1041,62 @@ class GPUTexture:
                 :type value: collections.abc.Sequence[float]
         """
 
+    def extend_mode(
+        self,
+        extend_mode: typing.Literal[
+            "EXTEND", "REPEAT", "MIRRORED_REPEAT", "CLAMP_TO_BORDER"
+        ] = "EXTEND",
+        /,
+    ) -> None:
+        """Set texture sampling method for coordinates outside of the [0..1] uv range along
+        both the x and y axis.
+
+                :param extend_mode: the specified extent mode.
+                :type extend_mode: typing.Literal['EXTEND', 'REPEAT', 'MIRRORED_REPEAT', 'CLAMP_TO_BORDER']
+        """
+
+    def extend_mode_x(
+        self,
+        extend_mode: typing.Literal[
+            "EXTEND", "REPEAT", "MIRRORED_REPEAT", "CLAMP_TO_BORDER"
+        ] = "EXTEND",
+        /,
+    ) -> None:
+        """Set texture sampling method for coordinates outside of the [0..1] uv range along the x axis.
+
+        :param extend_mode: the specified extent mode.
+        :type extend_mode: typing.Literal['EXTEND', 'REPEAT', 'MIRRORED_REPEAT', 'CLAMP_TO_BORDER']
+        """
+
+    def extend_mode_y(
+        self,
+        extend_mode: typing.Literal[
+            "EXTEND", "REPEAT", "MIRRORED_REPEAT", "CLAMP_TO_BORDER"
+        ] = "EXTEND",
+        /,
+    ) -> None:
+        """Set texture sampling method for coordinates outside of the [0..1] uv range along the y axis.
+
+        :param extend_mode: the specified extent mode.
+        :type extend_mode: typing.Literal['EXTEND', 'REPEAT', 'MIRRORED_REPEAT', 'CLAMP_TO_BORDER']
+        """
+
+    def filter_mode(self, use_filter: bool) -> None:
+        """Set texture filter usage.
+
+        :param use_filter: If set to true, the texture will use linear interpolation between neighboring texels.
+        :type use_filter: bool
+        """
+
+    def mipmap_mode(self, use_mipmap: bool = True, use_filter: bool = True) -> None:
+        """Set texture filter and mip-map usage.
+
+        :param use_mipmap: If set to true, the texture will use mip-mapping as anti-aliasing method.
+        :type use_mipmap: bool
+        :param use_filter: If set to true, the texture will use linear interpolation between neighboring texels.
+        :type use_filter: bool
+        """
+
     def read(self) -> None:
         """Creates a buffer with the value of all pixels."""
 

gpu_extras/presets/__init__.pyi

@@ -32,6 +32,7 @@ def draw_texture_2d(
     position: collections.abc.Sequence[float] | mathutils.Vector,
     width: float,
     height: float,
+    is_scene_linear_with_rec709_srgb_target: bool = False,
 ) -> None:
     """Draw a 2d texture.
 
@@ -44,4 +45,10 @@ def draw_texture_2d(
         :type width: float
         :param height: Height of the image when drawn.
         :type height: float
+        :param is_scene_linear_with_rec709_srgb_target: True if the texture is stored in scene linear color space and
+    the destination frame-buffer uses the Rec.709 sRGB color space
+    (which is true when drawing textures acquired from `bpy.types.Image` inside a
+    PRE_VIEW, POST_VIEW or POST_PIXEL draw handler).
+    Otherwise the color space is assumed to match the one of the frame-buffer. (default=False)
+        :type is_scene_linear_with_rec709_srgb_target: bool
     """

idprop/types/__init__.pyi

@@ -27,8 +27,12 @@ class IDPropertyGroup:
     def items(self) -> None:
         """Iterate through the items in the dict; behaves like dictionary method items."""
 
-    def keys(self) -> None:
-        """Return the keys associated with this group as a list of strings."""
+    def keys(self) -> IDPropertyGroupViewKeys:
+        """Return the keys associated with this group.
+
+        :return: The keys.
+        :rtype: IDPropertyGroupViewKeys
+        """
 
     def pop(self, key: str, default: typing.Any) -> None:
         """Remove an item from the group, returning a Python representation.

imbuf/__init__.pyi

@@ -37,11 +37,11 @@ def load_from_buffer(buffer) -> imbuf.types.ImBuf:
     """
 
 def new(size: tuple[int, int]) -> imbuf.types.ImBuf:
-    """Load a new image.
+    """Create a new image.
 
     :param size: The size of the image in pixels.
     :type size: tuple[int, int]
-    :return: the newly loaded image.
+    :return: the newly created image.
     :rtype: imbuf.types.ImBuf
     """
 

imbuf/types/__init__.pyi

@@ -14,7 +14,7 @@ import numpy.typing as npt
 
 class ImBuf:
     channels: int
-    """ Number of bit-planes.
+    """ Number of color channels.
 
     :type: int
     """
@@ -26,7 +26,7 @@ class ImBuf:
     """
 
     planes: int
-    """ Number of bits associated with this image.
+    """ Number of bits per pixel.
 
     :type: int
     """

keyingsets_builtins/__init__.pyi

@@ -34,7 +34,7 @@ class BUILTIN_KSI_Available(_bpy_types.KeyingSetInfo):
         """
 
 class BUILTIN_KSI_BendyBones(_bpy_types.KeyingSetInfo):
-    """Insert a keyframe for each of the BBone shape properties"""
+    """Insert a keyframe for each of the B-Bone shape properties"""
 
     bl_label: typing.Any
     bl_rna: typing.Any