fake-bpy-module 20250603__py3-none-any.whl → 20250606__py3-none-any.whl

freestyle/utils/ContextFunctions/__init__.pyi

@@ -44,7 +44,9 @@ def get_time_stamp() -> int:
     :rtype: int
     """
 
-def load_map(file_name: str, map_name: str, num_levels: int = 4, sigma: float = 1.0):
+def load_map(
+    file_name: str, map_name: str, num_levels: int = 4, sigma: float = 1.0
+) -> None:
     """Loads an image map for further reading.
 
         :param file_name: The name of the image file.

freestyle/utils/__init__.pyi

@@ -21,7 +21,7 @@ from . import ContextFunctions as ContextFunctions
 class BoundingBox:
     """Object representing a bounding box consisting out of 2 2D vectors"""
 
-    def inside(self, other):
+    def inside(self, other) -> None:
         """True if self inside other, False otherwise
 
         :param other:
@@ -30,21 +30,21 @@ class BoundingBox:
 class StrokeCollector:
     """Collects and Stores stroke objects"""
 
-    def shade(self, stroke):
+    def shade(self, stroke) -> None:
         """
 
         :param stroke:
         """
 
-def angle_x_normal(it):
+def angle_x_normal(it) -> None:
     """unsigned angle between a Point's normal and the X axis, in radians"""
 
-def bound(lower, x, higher): ...
-def bounding_box(stroke):
+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"""
 
-def curvature_from_stroke_vertex(svert): ...
-def find_matching_vertex(id, it):
+def curvature_from_stroke_vertex(svert) -> None: ...
+def find_matching_vertex(id, it) -> None:
     """Finds the matching vertex, or returns None."""
 
 def getCurrentScene() -> bpy.types.Scene:
@@ -54,16 +54,16 @@ def getCurrentScene() -> bpy.types.Scene:
     :rtype: bpy.types.Scene
     """
 
-def get_chain_length(ve, orientation):
+def get_chain_length(ve, orientation) -> None:
     """Returns the 2d length of a given ViewEdge."""
 
-def get_object_name(stroke):
+def get_object_name(stroke) -> None:
     """Returns the name of the object that this stroke is drawn on."""
 
-def get_strokes():
+def get_strokes() -> None:
     """Get all strokes that are currently available"""
 
-def get_test_stroke():
+def get_test_stroke() -> None:
     """Returns a static stroke object for testing"""
 
 def integrate(
@@ -95,53 +95,53 @@ def integrate(
         :rtype: float
     """
 
-def is_poly_clockwise(stroke):
+def is_poly_clockwise(stroke) -> None:
     """True if the stroke is orientated in a clockwise way, False otherwise"""
 
-def iter_distance_along_stroke(stroke):
+def iter_distance_along_stroke(stroke) -> None:
     """Yields the absolute distance along the stroke up to the current vertex."""
 
-def iter_distance_from_camera(stroke, range_min, range_max, normfac):
+def iter_distance_from_camera(stroke, range_min, range_max, normfac) -> None:
     """Yields the distance to the camera relative to the maximum
     possible distance for every stroke vertex, constrained by
     given minimum and maximum values.
 
     """
 
-def iter_distance_from_object(stroke, location, range_min, range_max, normfac):
+def iter_distance_from_object(stroke, location, range_min, range_max, normfac) -> None:
     """yields the distance to the given object relative to the maximum
     possible distance for every stroke vertex, constrained by
     given minimum and maximum values.
 
     """
 
-def iter_material_value(stroke, func, attribute):
+def iter_material_value(stroke, func, attribute) -> None:
     """Yields a specific material attribute from the vertex' underlying material."""
 
-def iter_t2d_along_stroke(stroke):
+def iter_t2d_along_stroke(stroke) -> None:
     """Yields the progress along the stroke."""
 
-def material_from_fedge(fe):
+def material_from_fedge(fe) -> None:
     """get the diffuse RGBA color from an FEdge"""
 
-def normal_at_I0D(it): ...
-def pairwise(iterable, types={Stroke, StrokeVertexIterator}):
+def normal_at_I0D(it) -> None: ...
+def pairwise(iterable, types={StrokeVertexIterator, Stroke}) -> None:
     """Yields a tuple containing the previous and current object"""
 
-def rgb_to_bw(r, g, b):
+def rgb_to_bw(r, g, b) -> None:
     """Method to convert rgb to a bw intensity value."""
 
-def simplify(points, tolerance):
+def simplify(points, tolerance) -> None:
     """Simplifies a set of points"""
 
-def stroke_curvature(it):
+def stroke_curvature(it) -> None:
     """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
 
     """
 
-def stroke_normal(stroke):
+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
     underlying FEdges instead, which is inappropriate for strokes when
@@ -152,5 +152,5 @@ def stroke_normal(stroke):
 
     """
 
-def tripplewise(iterable):
+def tripplewise(iterable) -> None:
     """Yields a tuple containing the current object and its immediate neighbors"""

gpu/matrix/__init__.pyi

@@ -30,13 +30,13 @@ def get_projection_matrix() -> mathutils.Matrix:
     :rtype: mathutils.Matrix
     """
 
-def load_identity():
+def load_identity() -> None:
     """Load an identity matrix into the stack."""
 
 def load_matrix(
     matrix: collections.abc.Sequence[collections.abc.Sequence[float]]
     | mathutils.Matrix,
-):
+) -> None:
     """Load a matrix into the stack.
 
     :param matrix: A 4x4 matrix.
@@ -46,7 +46,7 @@ def load_matrix(
 def load_projection_matrix(
     matrix: collections.abc.Sequence[collections.abc.Sequence[float]]
     | mathutils.Matrix,
-):
+) -> None:
     """Load a projection matrix into the stack.
 
     :param matrix: A 4x4 matrix.
@@ -56,49 +56,49 @@ def load_projection_matrix(
 def multiply_matrix(
     matrix: collections.abc.Sequence[collections.abc.Sequence[float]]
     | mathutils.Matrix,
-):
+) -> None:
     """Multiply the current stack matrix.
 
     :param matrix: A 4x4 matrix.
     :type matrix: collections.abc.Sequence[collections.abc.Sequence[float]] | mathutils.Matrix
     """
 
-def pop():
+def pop() -> None:
     """Remove the last model-view matrix from the stack."""
 
-def pop_projection():
+def pop_projection() -> None:
     """Remove the last projection matrix from the stack."""
 
-def push():
+def push() -> None:
     """Add to the model-view matrix stack."""
 
-def push_pop():
+def push_pop() -> None:
     """Context manager to ensure balanced push/pop calls, even in the case of an error."""
 
-def push_pop_projection():
+def push_pop_projection() -> None:
     """Context manager to ensure balanced push/pop calls, even in the case of an error."""
 
-def push_projection():
+def push_projection() -> None:
     """Add to the projection matrix stack."""
 
-def reset():
+def reset() -> None:
     """Empty stack and set to identity."""
 
-def scale(scale: collections.abc.Sequence[float]):
+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):
+def scale_uniform(scale: float) -> None:
     """
 
     :param scale: Scale the current stack matrix.
     :type scale: float
     """
 
-def translate(offset: collections.abc.Sequence[float]):
+def translate(offset: collections.abc.Sequence[float]) -> None:
     """Scale the current stack matrix.
 
     :param offset: Translate the current stack matrix with 2 or 3 floats.

gpu/select/__init__.pyi

@@ -8,7 +8,7 @@ import collections.abc
 import typing_extensions
 import numpy.typing as npt
 
-def load_id(id):
+def load_id(id) -> None:
     """Set the selection ID.
 
     :param id: Number (32-bit uint).

gpu/shader/__init__.pyi

@@ -122,5 +122,5 @@ def from_builtin(shader_name: str, config: str = "DEFAULT") -> gpu.types.GPUShad
         :rtype: gpu.types.GPUShader
     """
 
-def unbind():
+def unbind() -> None:
     """Unbind the bound shader object."""

gpu/state/__init__.pyi

@@ -8,13 +8,13 @@ import collections.abc
 import typing_extensions
 import numpy.typing as npt
 
-def active_framebuffer_get(enable):
+def active_framebuffer_get(enable) -> None:
     """Return the active frame-buffer in context."""
 
-def blend_get():
+def blend_get() -> None:
     """Current blending equation."""
 
-def blend_set(mode: str):
+def blend_set(mode: str) -> None:
     """Defines the fixed pipeline blending equation.
 
         :param mode: The type of blend mode.
@@ -37,33 +37,33 @@ def blend_set(mode: str):
         :type mode: str
     """
 
-def clip_distances_set(distances_enabled: int):
+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):
+def color_mask_set(r: bool, g, b, a) -> None:
     """Enable or disable writing of frame buffer color components.
 
     :param r: components red, green, blue, and alpha.
     :type r: bool
     """
 
-def depth_mask_get():
+def depth_mask_get() -> None:
     """Writing status in the depth component."""
 
-def depth_mask_set(value):
+def depth_mask_set(value) -> None:
     """Write to depth component.
 
     :param value: True for writing to the depth component.
     """
 
-def depth_test_get():
+def depth_test_get() -> None:
     """Current depth_test equation."""
 
-def depth_test_set(mode: str):
+def depth_test_set(mode: str) -> None:
     """Defines the depth_test equation.
 
         :param mode: The depth test equation name.
@@ -71,28 +71,28 @@ def depth_test_set(mode: str):
         :type mode: str
     """
 
-def face_culling_set(culling):
+def face_culling_set(culling) -> None:
     """Specify whether none, front-facing or back-facing facets can be culled."""
 
-def front_facing_set(invert):
+def front_facing_set(invert) -> None:
     """Specifies the orientation of front-facing polygons.
 
     :param invert: True for clockwise polygons as front-facing.
     """
 
-def line_width_get():
+def line_width_get() -> None:
     """Current width of rasterized lines."""
 
-def line_width_set(width):
+def line_width_set(width) -> None:
     """Specify the width of rasterized lines."""
 
-def point_size_set(size):
+def point_size_set(size) -> None:
     """Specify the diameter of rasterized points.
 
     :param size: New diameter.
     """
 
-def program_point_size_set(enable: bool):
+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.
@@ -110,7 +110,7 @@ def scissor_get() -> tuple[int, int, int, int]:
         :rtype: tuple[int, int, int, int]
     """
 
-def scissor_set(x: int, y, xsize: int, ysize):
+def scissor_set(x: int, y, xsize: int, ysize) -> None:
     """Specifies the scissor area of the active framebuffer.
     Note: The scissor state is not saved upon framebuffer rebind.
 
@@ -120,7 +120,7 @@ def scissor_set(x: int, y, xsize: int, ysize):
         :type xsize: int
     """
 
-def scissor_test_set(enable: bool):
+def scissor_test_set(enable: bool) -> None:
     """Enable/disable scissor testing on the active framebuffer.
 
         :param enable: True - enable scissor testing.
@@ -128,10 +128,10 @@ def scissor_test_set(enable: bool):
         :type enable: bool
     """
 
-def viewport_get():
+def viewport_get() -> None:
     """Viewport of the active framebuffer."""
 
-def viewport_set(x: int, y, xsize: int, ysize):
+def viewport_set(x: int, y, xsize: int, ysize) -> None:
     """Specifies the viewport of the active framebuffer.
     Note: The viewport state is not saved upon framebuffer rebind.