fake-bge-module 20250317__py3-none-any.whl → 20260201__py3-none-any.whl

gpu_extras/__init__.pyi

@@ -10,5 +10,6 @@ gpu_extras.presets.rst
 import typing
 import collections.abc
 import typing_extensions
+import numpy.typing as npt
 from . import batch as batch
 from . import presets as presets

gpu_extras/batch/__init__.pyi

@@ -1,6 +1,7 @@
 import typing
 import collections.abc
 import typing_extensions
+import numpy.typing as npt
 import gpu.types
 
 def batch_for_shader(
@@ -20,12 +21,8 @@ def batch_for_shader(
     """Return a batch already configured and compatible with the shader.
 
         :param shader: shader for which a compatible format will be computed.
-        :type shader: gpu.types.GPUShader
-        :param type: "'POINTS', 'LINES', 'TRIS' or 'LINES_ADJ'".
-        :type type: str
+        :param type: "POINTS, LINES, TRIS or LINES_ADJ".
         :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

@@ -1,6 +1,7 @@
 import typing
 import collections.abc
 import typing_extensions
+import numpy.typing as npt
 import gpu.types
 import mathutils
 
@@ -10,20 +11,16 @@ def draw_circle_2d(
     radius: float,
     *,
     segments: None | int | None = 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(
@@ -31,16 +28,18 @@ 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.
 
         :param texture: GPUTexture to draw (e.g. gpu.texture.from_image(image) for `bpy.types.Image`).
-        :type texture: gpu.types.GPUTexture
         :param position: Position of the lower left corner.
-        :type position: collections.abc.Sequence[float] | mathutils.Vector
         :param width: Width of the image when drawn (not necessarily
     the original width of the texture).
-        :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)
     """

idprop/__init__.pyi

@@ -1,4 +1,21 @@
+"""
+This module provides access to ID property types, used for
+custom properties on data-blocks, accessed via ["key"]
+
+ syntax.
+
+* See info_quickstart-custom_properties for example usage.
+* See bpy_types-custom_properties for types that support custom properties.
+
+idprop.types.rst
+
+:maxdepth: 1
+:caption: Submodules
+
+"""
+
 import typing
 import collections.abc
 import typing_extensions
+import numpy.typing as npt
 from . import types as types

idprop/types/__init__.pyi

@@ -1,59 +1,60 @@
 import typing
 import collections.abc
 import typing_extensions
+import numpy.typing as npt
 
 class IDPropertyArray:
     typecode: typing.Any
     """ The type of the data in the array {'f': float, 'd': double, 'i': int, 'b': bool}."""
 
-    def to_list(self):
+    def to_list(self) -> None:
         """Return the array as a list."""
 
 class IDPropertyGroup:
     name: typing.Any
     """ The name of this Group."""
 
-    def clear(self):
+    def clear(self) -> None:
         """Clear all members from this group."""
 
-    def get(self, key, default=None):
+    def get(self, key, default=None) -> None:
         """Return the value for key, if it exists, else default.
 
         :param key:
         :param default:
         """
 
-    def items(self):
+    def items(self) -> None:
         """Iterate through the items in the dict; behaves like dictionary method items."""
 
-    def keys(self):
-        """Return the keys associated with this group as a list of strings."""
+    def keys(self) -> IDPropertyGroupViewKeys:
+        """Return the keys associated with this group.
 
-    def pop(self, key: str, default: typing.Any):
+        :return: The keys.
+        """
+
+    def pop(self, key: str, default: typing.Any) -> None:
         """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
+        :param default: Value to return when key isnt found, otherwise raise an exception.
         """
 
-    def to_dict(self):
+    def to_dict(self) -> None:
         """Return a purely Python version of the group."""
 
-    def update(self, other: dict[str, typing.Any] | typing_extensions.Self):
+    def update(self, other: dict[str, typing.Any] | typing_extensions.Self) -> None:
         """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):
+    def values(self) -> None:
         """Return the values associated with this group."""
 
 class IDPropertyGroupIterItems: ...
 class IDPropertyGroupIterKeys: ...
 class IDPropertyGroupIterValues: ...
-class IDPropertyGroupViewItems: ...
-class IDPropertyGroupViewKeys: ...
-class IDPropertyGroupViewValues: ...
+class IDPropertyGroupViewItems(collections.abc.Iterable[tuple[str, typing.Any]]): ...
+class IDPropertyGroupViewKeys(collections.abc.Iterable[str]): ...
+class IDPropertyGroupViewValues(collections.abc.Iterable[typing.Any]): ...

imbuf/__init__.pyi

@@ -14,6 +14,7 @@ imbuf.types.rst
 import typing
 import collections.abc
 import typing_extensions
+import numpy.typing as npt
 import imbuf.types
 
 from . import types as types
@@ -22,25 +23,28 @@ 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 load_from_buffer(buffer) -> imbuf.types.ImBuf:
+    """Load an image from a buffer.
+
+    :param buffer: A buffer containing the image data.
+    :return: the newly loaded image.
     """
 
 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.
-    :rtype: imbuf.types.ImBuf
+    :return: the newly created image.
     """
 
-def write(image: imbuf.types.ImBuf, filepath: None | bytes | str = image.filepath):
+def write(
+    image: imbuf.types.ImBuf, *, filepath: None | bytes | str = image.filepath
+) -> None:
     """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

@@ -10,56 +10,43 @@ ID type to store and manipulate image data at runtime.
 import typing
 import collections.abc
 import typing_extensions
+import numpy.typing as npt
 
 class ImBuf:
     channels: int
-    """ Number of bit-planes.
-
-    :type: int
-    """
+    """ Number of color channels."""
 
     filepath: str
-    """ filepath associated with this image.
-
-    :type: str
-    """
+    """ filepath associated with this image."""
 
     planes: int
-    """ Number of bits associated with this image.
-
-    :type: int
-    """
+    """ Number of bits per pixel."""
 
-    ppm: typing.Any
+    ppm: tuple[float, float]
     """ pixels per meter."""
 
-    size: typing.Any
+    size: tuple[int, int]
     """ size of the image in pixels."""
 
     def copy(self) -> typing_extensions.Self:
         """
 
         :return: A copy of the image.
-        :rtype: typing_extensions.Self
         """
 
-    def crop(self, min: tuple[int, int], max: tuple[int, int]):
+    def crop(self, min: tuple[int, int], max: tuple[int, int]) -> None:
         """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):
+    def free(self) -> None:
         """Clear image data immediately (causing an error on re-use)."""
 
-    def resize(self, size: tuple[int, int], method: str = "FAST"):
+    def resize(self, size: tuple[int, int], *, method: str = "FAST") -> None:
         """Resize the image.
 
         :param size: New size.
-        :type size: tuple[int, int]
-        :param method: Method of resizing ('FAST', 'BILINEAR')
-        :type method: str
+        :param method: Method of resizing (FAST, BILINEAR)
         """