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

bpy/utils/__init__.pyi

@@ -13,54 +13,46 @@ bpy.utils.units.rst
 import typing
 import collections.abc
 import typing_extensions
+import numpy.typing as npt
 import bpy.types
 
 from . import previews as previews
 from . import units as units
 
-def app_template_paths(*, path: str | None = None):
+def app_template_paths(*, path: str | None = None) -> None:
     """Returns valid application template paths.
 
     :param path: Optional subdir.
-    :type path: str | None
     :return: App template paths.
     """
 
 def blend_paths(
-    absolute: bool = False, packed: bool = False, local: bool = False
+    *, absolute: bool = False, packed: bool = False, local: bool = False
 ) -> list[str]:
     """Returns a list of paths to external files referenced by the loaded .blend file.
 
     :param absolute: When true the paths returned are made absolute.
-    :type absolute: bool
-    :param packed: When true skip file paths for packed data.
-    :type packed: bool
+    :param packed: When true include file paths for packed data.
     :param local: When true skip linked library paths.
-    :type local: bool
     :return: path list.
-    :rtype: list[str]
     """
 
 def escape_identifier(string: str) -> str:
     """Simple string escaping function used for animation paths.
 
     :param string: text
-    :type string: str
     :return: The escaped string.
-    :rtype: str
     """
 
-def execfile(filepath: str, *, mod: None | None = None):
+def execfile(filepath: str, *, mod: None | None = None) -> None:
     """Execute a file path as a Python script.
 
     :param filepath: Path of the script to execute.
-    :type filepath: str
     :param mod: Optional cached module, the result of a previous execution.
-    :type mod: None | None
     :return: The module which can be passed back in as mod.
     """
 
-def expose_bundled_modules():
+def expose_bundled_modules() -> None:
     """For Blender as a Python module, add bundled VFX library python bindings
     to sys.path. These may be used instead of dedicated packages, to ensure
     the libraries are compatible with Blender.
@@ -71,69 +63,54 @@ def extension_path_user(package: str, *, path: str = "", create: bool = False) -
     """Return a user writable directory associated with an extension.
 
     :param package: The __package__ of the extension.
-    :type package: str
     :param path: Optional subdirectory.
-    :type path: str
     :param create: Treat the path as a directory and create it if its not existing.
-    :type create: bool
     :return: a path.
-    :rtype: str
     """
 
-def flip_name(name: str, strip_digits: bool = False) -> str:
+def flip_name(name: str, *, strip_digits: bool = False) -> str:
     """Flip a name between left/right sides, useful for
     mirroring bone names.
 
         :param name: Bone name to flip.
-        :type name: str
         :param strip_digits: Whether to remove .### suffix.
-        :type strip_digits: bool
         :return: The flipped name.
-        :rtype: str
     """
 
 def is_path_builtin(path: str) -> bool:
     """Returns True if the path is one of the built-in paths used by Blender.
 
     :param path: Path you want to check if it is in the built-in settings directory
-    :type path: str
-    :rtype: bool
     """
 
 def is_path_extension(path: str) -> bool:
     """Returns True if the path is from an extensions repository.
 
     :param path: Path to check if it is within an extension repository.
-    :type path: str
-    :rtype: bool
     """
 
-def keyconfig_init(): ...
-def keyconfig_set(filepath, *, report=None): ...
+def keyconfig_init() -> None: ...
+def keyconfig_set(filepath, *, report=None) -> None: ...
 def load_scripts(
     *,
     reload_scripts: bool = False,
     refresh_scripts: bool = False,
     extensions: bool = True,
-):
+) -> None:
     """Load scripts and run each modules register function.
 
         :param reload_scripts: Causes all scripts to have their unregister method
     called before loading.
-        :type reload_scripts: bool
         :param refresh_scripts: only load scripts which are not already loaded
     as modules.
-        :type refresh_scripts: bool
         :param extensions: Loads additional scripts (add-ons & app-templates).
-        :type extensions: bool
     """
 
-def load_scripts_extensions(*, reload_scripts: bool = False):
+def load_scripts_extensions(*, reload_scripts: bool = False) -> None:
     """Load extensions scripts (add-ons and app-templates)
 
         :param reload_scripts: Causes all scripts to have their unregister method
     called before loading.
-        :type reload_scripts: bool
     """
 
 def make_rna_paths(
@@ -142,15 +119,11 @@ def make_rna_paths(
     """Create RNA "paths" from given names.
 
         :param struct_name: Name of a RNA struct (like e.g. "Scene").
-        :type struct_name: str
-        :param prop_name: Name of a RNA struct's property.
-        :type prop_name: str
+        :param prop_name: Name of a RNA structs property.
         :param enum_name: Name of a RNA enum identifier.
-        :type enum_name: str
         :return: A triple of three "RNA paths"
-    (most_complete_path, "struct.prop", "struct.prop:'enum'").
+    (most_complete_path, "struct.prop", "struct.prop:enum").
     If no enum_name is given, the third element will always be void.
-        :rtype: tuple[str, str, str]
     """
 
 def manual_language_code(default="en") -> str:
@@ -158,32 +131,27 @@ def manual_language_code(default="en") -> str:
 
         :return: The language code used for user manual URL component based on the current language user-preference,
     falling back to the default when unavailable.
-        :rtype: str
     """
 
-def manual_map(): ...
-def modules_from_path(path: str, loaded_modules) -> list:
+def manual_map() -> None: ...
+def modules_from_path(path: str, loaded_modules: set) -> list:
     """Load all modules in a path and return them as a list.
 
         :param path: this path is scanned for scripts and packages.
-        :type path: str
         :param loaded_modules: already loaded module names, files matching these
     names will be ignored.
         :return: all loaded modules.
-        :rtype: list
     """
 
-def preset_find(name, preset_path, *, display_name=False, ext=".py"): ...
+def preset_find(name, preset_path, *, display_name=False, ext=".py") -> None: ...
 def preset_paths(subdir: str) -> list[str]:
     """Returns a list of paths for a specific preset.
 
     :param subdir: preset subdirectory (must not be an absolute path).
-    :type subdir: str
     :return: Script paths.
-    :rtype: list[str]
     """
 
-def refresh_script_paths():
+def refresh_script_paths() -> None:
     """Run this after creating new script paths to update sys.path"""
 
 def register_class(
@@ -199,21 +167,27 @@ def register_class(
         | bpy.types.FileHandler
         | bpy.types.PropertyGroup
         | bpy.types.AddonPreferences
+        | bpy.types.NodeTree
+        | bpy.types.Node
+        | bpy.types.NodeSocket
     ],
-):
+) -> None:
     """Register a subclass of a Blender type class.
 
     :param cls: Registerable Blender class type.
-    :type cls: type[bpy.types.Panel | bpy.types.UIList | bpy.types.Menu | bpy.types.Header | bpy.types.Operator | bpy.types.KeyingSetInfo | bpy.types.RenderEngine | bpy.types.AssetShelf | bpy.types.FileHandler | bpy.types.PropertyGroup | bpy.types.AddonPreferences]
     """
 
-def register_classes_factory(classes):
+def register_classes_factory(
+    classes: collections.abc.Sequence[typing.Any],
+) -> tuple[collections.abc.Callable[None], collections.abc.Callable[None]]:
     """Utility function to create register and unregister functions
     which simply registers and unregisters a sequence of classes.
 
+        :param classes: Sequence of classes to register and unregister.
+        :return: register and unregister functions.
     """
 
-def register_cli_command(id: str, execute: collections.abc.Callable):
+def register_cli_command(id: str, execute: collections.abc.Callable) -> None:
     """Register a command, accessible via the (-c / --command) command-line argument.Custom CommandsRegistering commands makes it possible to conveniently expose command line
     functionality via commands passed to (-c / --command).Using Python Argument ParsingThis example shows how the Python argparse module can be used with a custom command.Using argparse is generally recommended as it has many useful utilities and
     generates a --help message for your command.
@@ -221,15 +195,15 @@ def register_cli_command(id: str, execute: collections.abc.Callable):
         :param id: The command identifier (must pass an str.isidentifier check).
 
     If the id is already registered, a warning is printed and the command is inaccessible to prevent accidents invoking the wrong command.
-        :type id: str
         :param execute: Callback, taking a single list of strings and returns an int.
     The arguments are built from all command-line arguments following the command id.
     The return value should be 0 for success, 1 on failure (specific error codes from the os module can also be used).
-        :type execute: collections.abc.Callable
         :return: The command handle which can be passed to `unregister_cli_command`.
+
+    This uses Pythons capsule type however the result should be considered an opaque handle only used for unregistering.
     """
 
-def register_manual_map(manual_hook): ...
+def register_manual_map(manual_hook) -> None: ...
 def register_preset_path(path: str) -> bool:
     """Register a preset search path.
 
@@ -241,9 +215,7 @@ def register_preset_path(path: str) -> bool:
     When the __init__.py is in the same location as a presets directory.
     For example an operators preset would be located under: presets/operator/{operator.id}/
     where operator.id is the bl_idname of the operator.
-        :type path: str
         :return: success
-        :rtype: bool
     """
 
 def register_submodule_factory(
@@ -254,48 +226,37 @@ def register_submodule_factory(
     calling their register & unregister functions.
 
         :param module_name: The module name, typically __name__.
-        :type module_name: str
         :param submodule_names: List of submodule names to load and unload.
-        :type submodule_names: list[str]
         :return: register and unregister functions.
-        :rtype: tuple[collections.abc.Callable[None], collections.abc.Callable[None]]
     """
 
 def register_tool(
     tool_cls: type[bpy.types.WorkSpaceTool],
     *,
-    after: None | collections.abc.Sequence[str] | None = None,
+    after: None | collections.abc.Sequence[str] | set[str] | None = None,
     separator: bool = False,
     group: bool = False,
-):
+) -> None:
     """Register a tool in the toolbar.
 
     :param tool_cls: A tool subclass.
-    :type tool_cls: type[bpy.types.WorkSpaceTool]
     :param after: Optional identifiers this tool will be added after.
-    :type after: None | collections.abc.Sequence[str] | None
     :param separator: When true, add a separator before this tool.
-    :type separator: bool
     :param group: When true, add a new nested group of tools.
-    :type group: bool
     """
 
 def resource_path(
-    type: str, major: int = bpy.app.version[0], minor: str = bpy.app.version[1]
+    type: str, *, major: int = bpy.app.version[0], minor: int = bpy.app.version[1]
 ) -> str:
     """Return the base path for storing system files.
 
-    :param type: string in ['USER', 'LOCAL', 'SYSTEM'].
-    :type type: str
+    :param type: string in [USER, LOCAL, SYSTEM].
     :param major: major version, defaults to current.
-    :type major: int
     :param minor: minor version, defaults to current.
-    :type minor: str
     :return: the resource path (not necessarily existing).
-    :rtype: str
     """
 
-def script_path_user():
+def script_path_user() -> None:
     """returns the env var and falls back to home dir or None"""
 
 def script_paths(
@@ -309,23 +270,17 @@ def script_paths(
     """Returns a list of valid script paths.
 
     :param subdir: Optional subdir.
-    :type subdir: str | None
     :param user_pref: Include the user preference script paths.
-    :type user_pref: bool
     :param check_all: Include local, user and system paths rather just the paths Blender uses.
-    :type check_all: bool
     :param use_user: Include user paths
-    :type use_user: bool
     :param use_system_environment: Include BLENDER_SYSTEM_SCRIPTS variable path
-    :type use_system_environment: bool
     :return: script paths.
-    :rtype: list[str]
     """
 
-def script_paths_pref():
+def script_paths_pref() -> None:
     """Returns a list of user preference script directories."""
 
-def script_paths_system_environment():
+def script_paths_system_environment() -> None:
     """Returns a list of system script directories from environment variables."""
 
 def smpte_from_frame(frame: float, *, fps=None, fps_base=None) -> str:
@@ -333,9 +288,7 @@ def smpte_from_frame(frame: float, *, fps=None, fps_base=None) -> str:
     HH:MM:SS:FF.If fps and fps_base are not given the current scene is used.
 
         :param frame: frame number.
-        :type frame: float
         :return: the frame string.
-        :rtype: str
     """
 
 def smpte_from_seconds(time: float, *, fps=None, fps_base=None) -> str:
@@ -343,16 +296,13 @@ def smpte_from_seconds(time: float, *, fps=None, fps_base=None) -> str:
     HH:MM:SS:FF.If fps and fps_base are not given the current scene is used.
 
         :param time: time in seconds.
-        :type time: float
         :return: the frame string.
-        :rtype: str
     """
 
-def time_from_frame(frame: float, *, fps=None, fps_base=None):
+def time_from_frame(frame: float, *, fps=None, fps_base=None) -> None:
     """Returns the time from a frame number .If fps and fps_base are not given the current scene is used.
 
     :param frame: number.
-    :type frame: float
     :return: the time in seconds.
     """
 
@@ -361,9 +311,7 @@ def time_to_frame(time: float, *, fps=None, fps_base=None) -> float:
     as a datetime.timedelta object.If fps and fps_base are not given the current scene is used.
 
         :param time: time in seconds.
-        :type time: float
         :return: The frame.
-        :rtype: float
     """
 
 def unescape_identifier(string: str) -> str:
@@ -371,9 +319,7 @@ def unescape_identifier(string: str) -> str:
     This performs the reverse of `escape_identifier`.
 
         :param string: text
-        :type string: str
         :return: The un-escaped string.
-        :rtype: str
     """
 
 def unregister_class(
@@ -389,44 +335,40 @@ def unregister_class(
         | bpy.types.FileHandler
         | bpy.types.PropertyGroup
         | bpy.types.AddonPreferences
+        | bpy.types.NodeTree
+        | bpy.types.Node
+        | bpy.types.NodeSocket
     ],
-):
+) -> None:
     """Unload the Python class from blender.
 
         :param cls: Blender type class,
     see `bpy.utils.register_class` for classes which can
     be registered.
-        :type cls: type[bpy.types.Panel | bpy.types.UIList | bpy.types.Menu | bpy.types.Header | bpy.types.Operator | bpy.types.KeyingSetInfo | bpy.types.RenderEngine | bpy.types.AssetShelf | bpy.types.FileHandler | bpy.types.PropertyGroup | bpy.types.AddonPreferences]
     """
 
-def unregister_cli_command(handle):
+def unregister_cli_command(handle) -> None:
     """Unregister a CLI command.
 
     :param handle: The return value of `register_cli_command`.
     """
 
-def unregister_manual_map(manual_hook): ...
+def unregister_manual_map(manual_hook) -> None: ...
 def unregister_preset_path(path: str) -> bool:
     """Unregister a preset search path.
 
         :param path: preset directory (must be an absolute path).
 
     This must match the registered path exactly.
-        :type path: str
         :return: success
-        :rtype: bool
     """
 
-def unregister_tool(tool_cls): ...
+def unregister_tool(tool_cls) -> None: ...
 def user_resource(resource_type: str, *, path: str = "", create: bool = False) -> str:
     """Return a user resource path (normally from the users home directory).
 
-    :param resource_type: Resource type in ['DATAFILES', 'CONFIG', 'SCRIPTS', 'EXTENSIONS'].
-    :type resource_type: str
+    :param resource_type: Resource type in [DATAFILES, CONFIG, SCRIPTS, EXTENSIONS].
     :param path: Optional subdirectory.
-    :type path: str
     :param create: Treat the path as a directory and create it if its not existing.
-    :type create: bool
     :return: a path.
-    :rtype: str
     """

bpy/utils/previews/__init__.pyi

@@ -16,17 +16,18 @@ This allows scripts to generate their own previews, and use them as icons in UI
 import typing
 import collections.abc
 import typing_extensions
+import numpy.typing as npt
 import bpy.types
 
-class ImagePreviewCollection:
-    """Dictionary-like class of previews.This is a subclass of Python's built-in dict type,
+class ImagePreviewCollection(dict[str, bpy.types.ImagePreview]):
+    """Dictionary-like class of previews.This is a subclass of Pythons built-in dict type,
     used to store multiple image previews.
     """
 
-    def clear(self):
+    def clear(self) -> None:
         """Clear all previews."""
 
-    def close(self):
+    def close(self) -> None:
         """Close the collection and clear all previews."""
 
     def load(
@@ -39,36 +40,27 @@ class ImagePreviewCollection:
         """Generate a new preview from given file path.
 
         :param name: The name (unique id) identifying the preview.
-        :type name: str | None
         :param filepath: The file path to generate the preview from.
-        :type filepath: bytes | str | None
-        :param filetype: The type of file, needed to generate the preview in ['IMAGE', 'MOVIE', 'BLEND', 'FONT'].
-        :type filetype: str | None
+        :param filetype: The type of file, needed to generate the preview in [IMAGE, MOVIE, BLEND, FONT, OBJECT_IO].
         :param force_reload: If True, force running thumbnail manager even if preview already exists in cache.
-        :type force_reload: bool | None
         :return: The Preview matching given name, or a new empty one.
-        :rtype: bpy.types.ImagePreview
         """
 
     def new(self, name: str | None) -> bpy.types.ImagePreview:
         """Generate a new empty preview.
 
         :param name: The name (unique id) identifying the preview.
-        :type name: str | None
         :return: The Preview matching given name, or a new empty one.
-        :rtype: bpy.types.ImagePreview
         """
 
 def new() -> ImagePreviewCollection:
     """
 
     :return: a new preview collection.
-    :rtype: ImagePreviewCollection
     """
 
-def remove(pcoll: ImagePreviewCollection | None):
+def remove(pcoll: ImagePreviewCollection | None) -> None:
     """Remove the specified previews collection.
 
     :param pcoll: Preview collection to close.
-    :type pcoll: ImagePreviewCollection | None
     """

bpy/utils/units/__init__.pyi

@@ -6,11 +6,13 @@ This module contains some data/methods regarding units handling.
 import typing
 import collections.abc
 import typing_extensions
+import numpy.typing as npt
 
 def to_string(
     unit_system: str | None,
     unit_category: str | None,
     value: float | None,
+    *,
     precision: int | None = 3,
     split_unit: bool | None = False,
     compatible_unit: bool | None = False,
@@ -18,47 +20,36 @@ def to_string(
     """Convert a given input float value into a string with units.
 
         :param unit_system: The unit system, from `bpy.utils.units.systems`.
-        :type unit_system: str | None
         :param unit_category: The category of data we are converting (length, area, rotation, etc.),
     from `bpy.utils.units.categories`.
-        :type unit_category: str | None
         :param value: The value to convert to a string.
-        :type value: float | None
         :param precision: Number of digits after the comma.
-        :type precision: int | None
         :param split_unit: Whether to use several units if needed (1m1cm), or always only one (1.01m).
-        :type split_unit: bool | None
-        :param compatible_unit: Whether to use keyboard-friendly units (1m2) or nicer utf-8 ones (1m²).
-        :type compatible_unit: bool | None
+        :param compatible_unit: Whether to use keyboard-friendly units (1m2) or nicer UTF8 ones (1m).
         :return: The converted string.
-        :rtype: str
     """
 
 def to_value(
     unit_system: str | None,
     unit_category: str | None,
     str_input: str | None,
+    *,
     str_ref_unit: None | str | None = None,
 ) -> float:
     """Convert a given input string into a float value.
 
         :param unit_system: The unit system, from `bpy.utils.units.systems`.
-        :type unit_system: str | None
         :param unit_category: The category of data we are converting (length, area, rotation, etc.),
     from `bpy.utils.units.categories`.
-        :type unit_category: str | None
         :param str_input: The string to convert to a float value.
-        :type str_input: str | None
         :param str_ref_unit: A reference string from which to extract a default unit, if none is found in str_input.
-        :type str_ref_unit: None | str | None
         :return: The converted/interpreted value.
-        :rtype: float
     """
 
 categories: typing.Any
-""" Constant value bpy.utils.units.categories(NONE='NONE', LENGTH='LENGTH', AREA='AREA', VOLUME='VOLUME', MASS='MASS', ROTATION='ROTATION', TIME='TIME', TIME_ABSOLUTE='TIME_ABSOLUTE', VELOCITY='VELOCITY', ACCELERATION='ACCELERATION', CAMERA='CAMERA', POWER='POWER', TEMPERATURE='TEMPERATURE', WAVELENGTH='WAVELENGTH', COLOR_TEMPERATURE='COLOR_TEMPERATURE', FREQUENCY='FREQUENCY')
+""" Constant value bpy.utils.units.categories(NONE=NONE, LENGTH=LENGTH, AREA=AREA, VOLUME=VOLUME, MASS=MASS, ROTATION=ROTATION, TIME=TIME, TIME_ABSOLUTE=TIME_ABSOLUTE, VELOCITY=VELOCITY, ACCELERATION=ACCELERATION, CAMERA=CAMERA, POWER=POWER, TEMPERATURE=TEMPERATURE, WAVELENGTH=WAVELENGTH, COLOR_TEMPERATURE=COLOR_TEMPERATURE, FREQUENCY=FREQUENCY)
 """
 
 systems: typing.Any
-""" Constant value bpy.utils.units.systems(NONE='NONE', METRIC='METRIC', IMPERIAL='IMPERIAL')
+""" Constant value bpy.utils.units.systems(NONE=NONE, METRIC=METRIC, IMPERIAL=IMPERIAL)
 """

bpy_extras/__init__.pyi

@@ -20,6 +20,7 @@ bpy_extras.id_map_utils.rst
 import typing
 import collections.abc
 import typing_extensions
+import numpy.typing as npt
 from . import anim_utils as anim_utils
 from . import asset_utils as asset_utils
 from . import bmesh_utils as bmesh_utils