fake-bpy-module 20250612__py3-none-any.whl → 20260118__py3-none-any.whl

freestyle/utils/ContextFunctions/__init__.pyi

@@ -13,35 +13,30 @@ def get_border() -> tuple[int, int, int, int]:
     """Returns the border.
 
     :return: A tuple of 4 numbers (xmin, ymin, xmax, ymax).
-    :rtype: tuple[int, int, int, int]
     """
 
 def get_canvas_height() -> int:
     """Returns the canvas height.
 
     :return: The canvas height.
-    :rtype: int
     """
 
 def get_canvas_width() -> int:
     """Returns the canvas width.
 
     :return: The canvas width.
-    :rtype: int
     """
 
 def get_selected_fedge() -> freestyle.types.FEdge:
     """Returns the selected FEdge.
 
     :return: The selected FEdge.
-    :rtype: freestyle.types.FEdge
     """
 
 def get_time_stamp() -> int:
     """Returns the system time stamp.
 
     :return: The system time stamp.
-    :rtype: int
     """
 
 def load_map(
@@ -50,15 +45,11 @@ def load_map(
     """Loads an image map for further reading.
 
         :param file_name: The name of the image file.
-        :type file_name: str
         :param map_name: The name that will be used to access this image.
-        :type map_name: str
         :param num_levels: The number of levels in the map pyramid
     (default = 4). If num_levels == 0, the complete pyramid is
     built.
-        :type num_levels: int
         :param sigma: The sigma value of the gaussian function.
-        :type sigma: float
     """
 
 def read_complete_view_map_pixel(level: int, x: int, y: int) -> float:
@@ -66,15 +57,11 @@ def read_complete_view_map_pixel(level: int, x: int, y: int) -> float:
 
         :param level: The level of the pyramid in which we wish to read the
     pixel.
-        :type level: int
         :param x: The x coordinate of the pixel we wish to read. The origin
     is in the lower-left corner.
-        :type x: int
         :param y: The y coordinate of the pixel we wish to read. The origin
     is in the lower-left corner.
-        :type y: int
         :return: The floating-point value stored for that pixel.
-        :rtype: float
     """
 
 def read_directional_view_map_pixel(
@@ -84,34 +71,24 @@ def read_directional_view_map_pixel(
 
         :param orientation: The number telling which orientation we want to
     check.
-        :type orientation: int
         :param level: The level of the pyramid in which we wish to read the
     pixel.
-        :type level: int
         :param x: The x coordinate of the pixel we wish to read. The origin
     is in the lower-left corner.
-        :type x: int
         :param y: The y coordinate of the pixel we wish to read. The origin
     is in the lower-left corner.
-        :type y: int
         :return: The floating-point value stored for that pixel.
-        :rtype: float
     """
 
 def read_map_pixel(map_name: str, level: int, x: int, y: int) -> float:
     """Reads a pixel in a user-defined map.
 
         :param map_name: The name of the map.
-        :type map_name: str
         :param level: The level of the pyramid in which we wish to read the
     pixel.
-        :type level: int
         :param x: The x coordinate of the pixel we wish to read. The origin
     is in the lower-left corner.
-        :type x: int
         :param y: The y coordinate of the pixel we wish to read. The origin
     is in the lower-left corner.
-        :type y: int
         :return: The floating-point value stored for that pixel.
-        :rtype: float
     """

freestyle/utils/__init__.pyi

@@ -37,11 +37,11 @@ class StrokeCollector:
         """
 
 def angle_x_normal(it) -> None:
-    """unsigned angle between a Point's normal and the X axis, in radians"""
+    """unsigned angle between a Points normal and the X axis, in radians"""
 
 def bound(lower, x, higher) -> None: ...
 def bounding_box(stroke) -> None:
-    """Returns the maximum and minimum coordinates (the bounding box) of the stroke's vertices"""
+    """Returns the maximum and minimum coordinates (the bounding box) of the strokes vertices"""
 
 def curvature_from_stroke_vertex(svert) -> None: ...
 def find_matching_vertex(id, it) -> None:
@@ -51,7 +51,6 @@ def getCurrentScene() -> bpy.types.Scene:
     """Returns the current scene.
 
     :return: The current scene.
-    :rtype: bpy.types.Scene
     """
 
 def get_chain_length(ve, orientation) -> None:
@@ -77,22 +76,17 @@ def integrate(
 
         :param func: The UnaryFunction0D used to compute a value at each
     Interface0D.
-        :type func: freestyle.types.UnaryFunction0D
         :param it: The Interface0DIterator used to iterate over the 0D
     elements of this 1D element. The integration will occur over
     the 0D elements starting from the one pointed by it.
-        :type it: freestyle.types.Interface0DIterator
         :param it_end: The Interface0DIterator pointing the end of the 0D
     elements of the 1D element.
-        :type it_end: freestyle.types.Interface0DIterator
         :param integration_type: The integration method used to compute a
     single value from a set of values.
-        :type integration_type: freestyle.types.IntegrationType
         :return: The single value obtained for the 1D element. The return
     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) -> None:
@@ -116,7 +110,7 @@ def iter_distance_from_object(stroke, location, range_min, range_max, normfac) -
     """
 
 def iter_material_value(stroke, func, attribute) -> None:
-    """Yields a specific material attribute from the vertex' underlying material."""
+    """Yields a specific material attribute from the vertex underlying material."""
 
 def iter_t2d_along_stroke(stroke) -> None:
     """Yields the progress along the stroke."""
@@ -135,7 +129,7 @@ def simplify(points, tolerance) -> None:
     """Simplifies a set of points"""
 
 def stroke_curvature(it) -> None:
-    """Compute the 2D curvature at the stroke vertex pointed by the iterator 'it'.
+    """Compute the 2D curvature at the stroke vertex pointed by the iterator it.
     K = 1 / R
     where R is the radius of the circle going through the current vertex and its neighbors
 
@@ -143,7 +137,7 @@ def stroke_curvature(it) -> None:
 
 def stroke_normal(stroke) -> None:
     """Compute the 2D normal at the stroke vertex pointed by the iterator
-    'it'.  It is noted that Normal2DF0D computes normals based on
+    it.  It is noted that Normal2DF0D computes normals based on
     underlying FEdges instead, which is inappropriate for strokes when
     they have already been modified by stroke geometry modifiers.The returned normals are dynamic: they update when the
     vertex position (and therefore the vertex normal) changes.

gpu/capabilities/__init__.pyi

@@ -12,56 +12,48 @@ def compute_shader_support_get() -> bool:
     """Are compute shaders supported.
 
     :return: True when supported, False when not supported.
-    :rtype: bool
     """
 
 def extensions_get() -> tuple[str]:
     """Get supported extensions in the current context.
 
     :return: Extensions.
-    :rtype: tuple[str]
     """
 
 def hdr_support_get() -> bool:
     """Return whether GPU backend supports High Dynamic range for viewport.
 
     :return: HDR support available.
-    :rtype: bool
     """
 
 def max_batch_indices_get() -> int:
     """Get maximum number of vertex array indices.
 
     :return: Number of indices.
-    :rtype: int
     """
 
 def max_batch_vertices_get() -> int:
     """Get maximum number of vertex array vertices.
 
     :return: Number of vertices.
-    :rtype: int
     """
 
 def max_images_get() -> int:
     """Get maximum supported number of image units.
 
     :return: Number of image units.
-    :rtype: int
     """
 
 def max_texture_layers_get() -> int:
     """Get maximum number of layers in texture.
 
     :return: Number of layers.
-    :rtype: int
     """
 
 def max_texture_size_get() -> int:
     """Get estimated maximum texture size to be able to handle.
 
     :return: Texture size.
-    :rtype: int
     """
 
 def max_textures_frag_get() -> int:
@@ -69,7 +61,6 @@ def max_textures_frag_get() -> int:
     accessing texture maps from the fragment shader.
 
         :return: Texture image units.
-        :rtype: int
     """
 
 def max_textures_geom_get() -> int:
@@ -77,7 +68,6 @@ def max_textures_geom_get() -> int:
     accessing texture maps from the geometry shader.
 
         :return: Texture image units.
-        :rtype: int
     """
 
 def max_textures_get() -> int:
@@ -86,7 +76,6 @@ def max_textures_get() -> int:
     fragment processor.
 
         :return: Texture image units.
-        :rtype: int
     """
 
 def max_textures_vert_get() -> int:
@@ -94,7 +83,6 @@ def max_textures_vert_get() -> int:
     accessing texture maps from the vertex shader.
 
         :return: Texture image units.
-        :rtype: int
     """
 
 def max_uniforms_frag_get() -> int:
@@ -102,7 +90,6 @@ def max_uniforms_frag_get() -> int:
     storage for a fragment shader.
 
         :return: Number of values.
-        :rtype: int
     """
 
 def max_uniforms_vert_get() -> int:
@@ -110,7 +97,6 @@ def max_uniforms_vert_get() -> int:
     storage for a vertex shader.
 
         :return: Number of values.
-        :rtype: int
     """
 
 def max_varying_floats_get() -> int:
@@ -118,7 +104,6 @@ def max_varying_floats_get() -> int:
     vertex and fragment shaders.
 
         :return: Number of variables.
-        :rtype: int
     """
 
 def max_vertex_attribs_get() -> int:
@@ -126,30 +111,24 @@ def max_vertex_attribs_get() -> int:
     a vertex shader.
 
         :return: Number of attributes.
-        :rtype: int
     """
 
 def max_work_group_count_get(index: int) -> int:
     """Get maximum number of work groups that may be dispatched to a compute shader.
 
     :param index: Index of the dimension.
-    :type index: int
     :return: Maximum number of work groups for the queried dimension.
-    :rtype: int
     """
 
 def max_work_group_size_get(index: int) -> int:
     """Get maximum size of a work group that may be dispatched to a compute shader.
 
     :param index: Index of the dimension.
-    :type index: int
     :return: Maximum size of a work group for the queried dimension.
-    :rtype: int
     """
 
 def shader_image_load_store_support_get() -> bool:
     """Is image load/store supported.
 
     :return: True when supported, False when not supported.
-    :rtype: bool
     """

gpu/matrix/__init__.pyi

@@ -13,21 +13,18 @@ def get_model_view_matrix() -> mathutils.Matrix:
     """Return a copy of the model-view matrix.
 
     :return: A 4x4 view matrix.
-    :rtype: mathutils.Matrix
     """
 
 def get_normal_matrix() -> mathutils.Matrix:
     """Return a copy of the normal matrix.
 
     :return: A 3x3 normal matrix.
-    :rtype: mathutils.Matrix
     """
 
 def get_projection_matrix() -> mathutils.Matrix:
     """Return a copy of the projection matrix.
 
     :return: A 4x4 projection matrix.
-    :rtype: mathutils.Matrix
     """
 
 def load_identity() -> None:
@@ -40,7 +37,6 @@ def load_matrix(
     """Load a matrix into the stack.
 
     :param matrix: A 4x4 matrix.
-    :type matrix: collections.abc.Sequence[collections.abc.Sequence[float]] | mathutils.Matrix
     """
 
 def load_projection_matrix(
@@ -50,7 +46,6 @@ def load_projection_matrix(
     """Load a projection matrix into the stack.
 
     :param matrix: A 4x4 matrix.
-    :type matrix: collections.abc.Sequence[collections.abc.Sequence[float]] | mathutils.Matrix
     """
 
 def multiply_matrix(
@@ -60,7 +55,6 @@ def multiply_matrix(
     """Multiply the current stack matrix.
 
     :param matrix: A 4x4 matrix.
-    :type matrix: collections.abc.Sequence[collections.abc.Sequence[float]] | mathutils.Matrix
     """
 
 def pop() -> None:
@@ -88,19 +82,16 @@ def scale(scale: collections.abc.Sequence[float]) -> None:
     """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) -> None:
     """
 
     :param scale: Scale the current stack matrix.
-    :type scale: float
     """
 
 def translate(offset: collections.abc.Sequence[float]) -> None:
-    """Scale the current stack matrix.
+    """Translate the current stack matrix.
 
     :param offset: Translate the current stack matrix with 2 or 3 floats.
-    :type offset: collections.abc.Sequence[float]
     """

gpu/platform/__init__.pyi

@@ -11,34 +11,29 @@ import numpy.typing as npt
 def backend_type_get() -> str:
     """Get actuve GPU backend.
 
-    :return: Backend type ('OPENGL', 'VULKAN', 'METAL', 'NONE', 'UNKNOWN').
-    :rtype: str
+    :return: Backend type (OPENGL, VULKAN, METAL, NONE, UNKNOWN).
     """
 
 def device_type_get() -> str:
     """Get GPU device type.
 
-    :return: Device type ('APPLE', 'NVIDIA', 'AMD', 'INTEL', 'SOFTWARE', 'QUALCOMM', 'UNKNOWN').
-    :rtype: str
+    :return: Device type (APPLE, NVIDIA, AMD, INTEL, SOFTWARE, QUALCOMM, UNKNOWN).
     """
 
 def renderer_get() -> str:
     """Get GPU to be used for rendering.
 
     :return: GPU name.
-    :rtype: str
     """
 
 def vendor_get() -> str:
     """Get GPU vendor.
 
     :return: Vendor name.
-    :rtype: str
     """
 
 def version_get() -> str:
     """Get GPU driver version.
 
     :return: Driver version.
-    :rtype: str
     """

gpu/shader/__init__.pyi

@@ -9,6 +9,9 @@ All built-in shaders have the mat4 ModelViewProjectionMatrix
 
 Its value must be modified using the gpu.matrix module.
 
+[IMPORTANT]
+Shader uniforms must be explicitly initialized to avoid retaining values from previous executions.
+
 FLAT_COLOR
 
 
@@ -25,6 +28,15 @@ IMAGE
 
 
 
+IMAGE_SCENE_LINEAR_TO_REC709_SRGB
+
+
+    Attributes: vec3 pos, vec2 texCoord
+    Uniforms: sampler2D image
+    Note: Expect texture to be in scene linear color space
+
+
+
 IMAGE_COLOR
 
 
@@ -33,6 +45,15 @@ IMAGE_COLOR
 
 
 
+IMAGE_COLOR_SCENE_LINEAR_TO_REC709_SRGB
+
+
+    Attributes: vec3 pos, vec2 texCoord
+    Uniforms: sampler2D image, vec4 color
+    Note: Expect texture to be in scene linear color space
+
+
+
 SMOOTH_COLOR
 
 
@@ -69,7 +90,7 @@ POLYLINE_UNIFORM_COLOR
 
 
     Attributes: vec3 pos
-    Uniforms: vec2 viewportSize, float lineWidth
+    Uniforms: vec2 viewportSize, float lineWidth, vec4 color
 
 
 
@@ -81,7 +102,7 @@ POINT_FLAT_COLOR
 
 
 
-POLYLINE_UNIFORM_COLOR
+POINT_UNIFORM_COLOR
 
 
     Attributes: vec3 pos
@@ -97,29 +118,25 @@ import typing_extensions
 import numpy.typing as npt
 import gpu.types
 
-def create_from_info(shader_info) -> gpu.types.GPUShader:
+def create_from_info(shader_info: gpu.types.GPUShaderCreateInfo) -> gpu.types.GPUShader:
     """Create shader from a GPUShaderCreateInfo.
 
     :param shader_info: GPUShaderCreateInfo
-    :return: Shader object corresponding to the given name.
-    :rtype: gpu.types.GPUShader
+    :return: Shader object corresponding to the given shader info.
     """
 
-def from_builtin(shader_name: str, config: str = "DEFAULT") -> gpu.types.GPUShader:
+def from_builtin(shader_name: str, *, config: str = "DEFAULT") -> gpu.types.GPUShader:
     """Shaders that are embedded in the blender internal code (see `built-in-shaders`).
     They all read the uniform mat4 ModelViewProjectionMatrix,
     which can be edited by the `gpu.matrix` module.You can also choose a shader configuration that uses clip_planes by setting the CLIPPED value to the config parameter. Note that in this case you also need to manually set the value of mat4 ModelMatrix.
 
         :param shader_name: One of the builtin shader names.
-        :type shader_name: str
         :param config: One of these types of shader configuration:
 
     DEFAULT
 
     CLIPPED
-        :type config: str
         :return: Shader object corresponding to the given name.
-        :rtype: gpu.types.GPUShader
     """
 
 def unbind() -> None:

gpu/state/__init__.pyi

@@ -7,12 +7,19 @@ 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.
+    """
+
+def blend_get() -> str:
+    """Current blending equation.
+
+    :return: The current blend mode.
+    """
 
 def blend_set(mode: str) -> None:
     """Defines the fixed pipeline blending equation.
@@ -34,59 +41,73 @@ def blend_set(mode: str) -> None:
     SUBTRACT The original color channels are subtracted by the corresponding ones.
 
     INVERT The original color channels are replaced by its complementary color.
-        :type mode: str
     """
 
 def clip_distances_set(distances_enabled: int) -> None:
     """Sets the number of gl_ClipDistance planes used for clip geometry.
 
     :param distances_enabled: Number of clip distances enabled.
-    :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.
-    :type r: bool
+    :param r: Red component.
+    :param g: Green component.
+    :param b: Blue component.
+    :param a: Alpha component.
     """
 
-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.
+    """
+
+def depth_mask_set(value: bool) -> None:
     """Write to depth component.
 
     :param value: True for writing to the depth component.
     """
 
-def depth_test_get() -> None:
-    """Current depth_test equation."""
+def depth_test_get() -> str:
+    """Current depth_test equation.
+
+    :return: The current depth test mode.
+    """
 
 def depth_test_set(mode: str) -> None:
     """Defines the depth_test equation.
 
         :param mode: The depth test equation name.
     Possible values are NONE, ALWAYS, LESS, LESS_EQUAL, EQUAL, GREATER and GREATER_EQUAL.
-        :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.
+    """
+
+def front_facing_set(invert: bool) -> None:
     """Specifies the orientation of front-facing polygons.
 
     :param invert: True for clockwise polygons as front-facing.
     """
 
-def line_width_get() -> None:
-    """Current width of rasterized lines."""
+def line_width_get() -> float:
+    """Current width of rasterized lines.
+
+    :return: The current line width.
+    """
+
+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.
+    """
 
-def point_size_set(size) -> None:
+def point_size_set(size: float) -> None:
     """Specify the diameter of rasterized points.
 
     :param size: New diameter.
@@ -96,28 +117,26 @@ def program_point_size_set(enable: bool) -> None:
     """If enabled, the derived point size is taken from the (potentially clipped) shader builtin gl_PointSize.
 
     :param enable: True for shader builtin gl_PointSize.
-    :type enable: bool
     """
 
 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.
+    Note: Only valid between scissor_set and a framebuffer rebind.
 
         :return: The scissor of the active framebuffer as a tuple
     (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: 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.
-        :type x: int
-        :param xsize: width and height of the scissor rectangle.
-        :type xsize: int
+        :param x: Lower left corner x coordinate, in pixels.
+        :param y: Lower left corner y coordinate, in pixels.
+        :param xsize: Width of the scissor rectangle.
+        :param ysize: Height of the scissor rectangle.
     """
 
 def scissor_test_set(enable: bool) -> None:
@@ -125,18 +144,20 @@ def scissor_test_set(enable: bool) -> None:
 
         :param enable: True - enable scissor testing.
     False - disable scissor testing.
-        :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).
+    """
 
-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.
-        :type x: int
-        :param xsize: width and height of the viewport_set.
-        :type xsize: int
+        :param x: Lower left corner x coordinate, in pixels.
+        :param y: Lower left corner y coordinate, in pixels.
+        :param xsize: Width of the viewport.
+        :param ysize: Height of the viewport.
     """