fake-bpy-module 20231205__py3-none-any.whl → 20231207__py3-none-any.whl

bpy/utils/__init__.pyi

@@ -0,0 +1,429 @@
+import sys
+import typing
+import bpy.types
+
+from . import units
+from . import previews
+
+GenericType = typing.TypeVar("GenericType")
+
+
+def app_template_paths(*, path: typing.Optional[str] = None) -> typing.Any:
+    ''' Returns valid application template paths.
+
+    :param path: Optional subdir.
+    :type path: typing.Optional[str]
+    :rtype: typing.Any
+    :return: app template paths.
+    '''
+
+    ...
+
+
+def blend_paths(absolute: typing.Optional[bool] = False,
+                packed: typing.Optional[bool] = False,
+                local: typing.Optional[bool] = False) -> typing.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: typing.Optional[bool]
+    :param packed: When true skip file paths for packed data.
+    :type packed: typing.Optional[bool]
+    :param local: When true skip linked library paths.
+    :type local: typing.Optional[bool]
+    :rtype: typing.List[str]
+    :return: path list.
+    '''
+
+    ...
+
+
+def escape_identifier(string: typing.Optional[str]) -> str:
+    ''' Simple string escaping function used for animation paths.
+
+    :param string: text
+    :type string: typing.Optional[str]
+    :rtype: str
+    :return: The escaped string.
+    '''
+
+    ...
+
+
+def execfile(filepath: typing.Optional[str],
+             *,
+             mod: typing.Optional[typing.Any] = None) -> typing.Any:
+    ''' Execute a file path as a Python script.
+
+    :param filepath: Path of the script to execute.
+    :type filepath: typing.Optional[str]
+    :param mod: Optional cached module, the result of a previous execution.
+    :type mod: typing.Optional[typing.Any]
+    :rtype: typing.Any
+    :return: The module which can be passed back in as ``mod``.
+    '''
+
+    ...
+
+
+def flip_name(name: typing.Optional[str],
+              strip_digits: typing.Optional[bool] = False) -> str:
+    ''' Flip a name between left/right sides, useful for mirroring bone names.
+
+    :param name: Bone name to flip.
+    :type name: typing.Optional[str]
+    :param strip_digits: Whether to remove ``.###`` suffix.
+    :type strip_digits: typing.Optional[bool]
+    :rtype: str
+    :return: The flipped name.
+    '''
+
+    ...
+
+
+def is_path_builtin(path):
+    ''' 
+
+    '''
+
+    ...
+
+
+def keyconfig_init():
+    ''' 
+
+    '''
+
+    ...
+
+
+def keyconfig_set(filepath, *, report=None):
+    ''' 
+
+    '''
+
+    ...
+
+
+def load_scripts(*,
+                 reload_scripts: typing.Optional[bool] = False,
+                 refresh_scripts: typing.Optional[bool] = False,
+                 extensions: typing.Optional[bool] = True):
+    ''' 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: typing.Optional[bool]
+    :param refresh_scripts: only load scripts which are not already loaded as modules.
+    :type refresh_scripts: typing.Optional[bool]
+    :param extensions: Loads additional scripts (add-ons & app-templates).
+    :type extensions: typing.Optional[bool]
+    '''
+
+    ...
+
+
+def load_scripts_extensions(reload_scripts):
+    ''' 
+
+    '''
+
+    ...
+
+
+def make_rna_paths(struct_name: typing.Optional[str],
+                   prop_name: typing.Optional[str],
+                   enum_name: typing.Optional[str]) -> typing.Tuple:
+    ''' Create RNA "paths" from given names.
+
+    :param struct_name: Name of a RNA struct (like e.g. "Scene").
+    :type struct_name: typing.Optional[str]
+    :param prop_name: Name of a RNA struct's property.
+    :type prop_name: typing.Optional[str]
+    :param enum_name: Name of a RNA enum identifier.
+    :type enum_name: typing.Optional[str]
+    :rtype: typing.Tuple
+    :return: A triple of three "RNA paths" (most_complete_path, "struct.prop", "struct.prop:'enum'"). If no enum_name is given, the third element will always be void.
+    '''
+
+    ...
+
+
+def manual_language_code(default='en') -> str:
+    ''' 
+
+    :rtype: 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.
+    '''
+
+    ...
+
+
+def manual_map():
+    ''' 
+
+    '''
+
+    ...
+
+
+def modules_from_path(
+        path: typing.Optional[str],
+        loaded_modules: typing.Optional[typing.Set]) -> typing.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: typing.Optional[str]
+    :param loaded_modules: already loaded module names, files matching these names will be ignored.
+    :type loaded_modules: typing.Optional[typing.Set]
+    :rtype: typing.List
+    :return: all loaded modules.
+    '''
+
+    ...
+
+
+def preset_find(name, preset_path, *, display_name=False, ext='.py'):
+    ''' 
+
+    '''
+
+    ...
+
+
+def preset_paths(subdir: typing.Optional[str]) -> typing.List:
+    ''' Returns a list of paths for a specific preset.
+
+    :param subdir: preset subdirectory (must not be an absolute path).
+    :type subdir: typing.Optional[str]
+    :rtype: typing.List
+    :return: script paths.
+    '''
+
+    ...
+
+
+def refresh_script_paths():
+    ''' Run this after creating new script paths to update sys.path
+
+    '''
+
+    ...
+
+
+def register_class(cls: typing.Optional[typing.Any]):
+    ''' Register a subclass of a Blender type class. :raises ValueError: if the class is not a subclass of a registerable blender class.
+
+    :param cls: `bpy.types.Panel`, `bpy.types.UIList`, `bpy.types.Menu`, `bpy.types.Header`, `bpy.types.Operator`, `bpy.types.KeyingSetInfo`, `bpy.types.RenderEngine`, `bpy.types.AssetShelf`
+    :type cls: typing.Optional[typing.Any]
+    '''
+
+    ...
+
+
+def register_classes_factory(classes):
+    ''' Utility function to create register and unregister functions which simply registers and unregisters a sequence of classes.
+
+    '''
+
+    ...
+
+
+def register_manual_map(manual_hook):
+    ''' 
+
+    '''
+
+    ...
+
+
+def register_submodule_factory(
+        module_name: typing.Optional[str],
+        submodule_names: typing.Optional[typing.List[str]]) -> typing.Tuple:
+    ''' Utility function to create register and unregister functions which simply load submodules, calling their register & unregister functions.
+
+    :param module_name: The module name, typically ``__name__``.
+    :type module_name: typing.Optional[str]
+    :param submodule_names: List of submodule names to load and unload.
+    :type submodule_names: typing.Optional[typing.List[str]]
+    :rtype: typing.Tuple
+    :return: register and unregister functions.
+    '''
+
+    ...
+
+
+def register_tool(tool_cls,
+                  *,
+                  after: typing.Optional[typing.Any] = None,
+                  separator: typing.Optional[bool] = False,
+                  group: typing.Optional[bool] = False):
+    ''' Register a tool in the toolbar.
+
+    :param tool: A tool subclass.
+    :type tool: typing.Optional['bpy.types.WorkSpaceTool']
+    :param space_type: Space type identifier.
+    :type space_type: typing.Optional[str]
+    :param after: Optional identifiers this tool will be added after.
+    :type after: typing.Optional[typing.Any]
+    :param separator: When true, add a separator before this tool.
+    :type separator: typing.Optional[bool]
+    :param group: When true, add a new nested group of tools.
+    :type group: typing.Optional[bool]
+    '''
+
+    ...
+
+
+def resource_path(type: typing.Optional[str],
+                  major: typing.Optional[int] = 'bpy.app.version[0]',
+                  minor: typing.Optional[str] = 'bpy.app.version[1]') -> str:
+    ''' Return the base path for storing system files.
+
+    :param type: string in ['USER', 'LOCAL', 'SYSTEM'].
+    :type type: typing.Optional[str]
+    :param major: major version, defaults to current.
+    :type major: typing.Optional[int]
+    :param minor: minor version, defaults to current.
+    :type minor: typing.Optional[str]
+    :rtype: str
+    :return: the resource path (not necessarily existing).
+    '''
+
+    ...
+
+
+def script_path_user():
+    ''' returns the env var and falls back to home dir or None
+
+    '''
+
+    ...
+
+
+def script_paths(*,
+                 subdir: typing.Optional[str] = None,
+                 user_pref: typing.Optional[bool] = True,
+                 check_all: typing.Optional[bool] = False,
+                 use_user=True) -> typing.List:
+    ''' Returns a list of valid script paths.
+
+    :param subdir: Optional subdir.
+    :type subdir: typing.Optional[str]
+    :param user_pref: Include the user preference script paths.
+    :type user_pref: typing.Optional[bool]
+    :param check_all: Include local, user and system paths rather just the paths Blender uses.
+    :type check_all: typing.Optional[bool]
+    :rtype: typing.List
+    :return: script paths.
+    '''
+
+    ...
+
+
+def script_paths_pref():
+    ''' 
+
+    '''
+
+    ...
+
+
+def smpte_from_frame(frame: typing.Optional[int], *, fps=None,
+                     fps_base=None) -> str:
+    ''' Returns an SMPTE formatted string from the *frame*: ``HH:MM:SS:FF``. If *fps* and *fps_base* are not given the current scene is used.
+
+    :param frame: frame number.
+    :type frame: typing.Optional[int]
+    :rtype: str
+    :return: the frame string.
+    '''
+
+    ...
+
+
+def smpte_from_seconds(time: typing.Optional[typing.Union[int, float]],
+                       *,
+                       fps=None,
+                       fps_base=None) -> str:
+    ''' Returns an SMPTE formatted string from the *time*: ``HH:MM:SS:FF``. If *fps* and *fps_base* are not given the current scene is used.
+
+    :param time: time in seconds.
+    :type time: typing.Optional[typing.Union[int, float]]
+    :rtype: str
+    :return: the frame string.
+    '''
+
+    ...
+
+
+def time_from_frame(frame, fps, fps_base):
+    ''' 
+
+    '''
+
+    ...
+
+
+def time_to_frame(time, fps, fps_base):
+    ''' 
+
+    '''
+
+    ...
+
+
+def unescape_identifier(string: typing.Optional[str]) -> str:
+    ''' Simple string un-escape function used for animation paths. This performs the reverse of `escape_identifier`.
+
+    :param string: text
+    :type string: typing.Optional[str]
+    :rtype: str
+    :return: The un-escaped string.
+    '''
+
+    ...
+
+
+def unregister_class(cls: typing.Optional[typing.Any]):
+    ''' Unload the Python class from blender.
+
+    :param cls: Blender type class, see :mod:`bpy.utils.register_class` for classes which can be registered.
+    :type cls: typing.Optional[typing.Any]
+    '''
+
+    ...
+
+
+def unregister_manual_map(manual_hook):
+    ''' 
+
+    '''
+
+    ...
+
+
+def unregister_tool(tool_cls):
+    ''' 
+
+    '''
+
+    ...
+
+
+def user_resource(resource_type,
+                  *,
+                  path: typing.Optional[str] = '',
+                  create: typing.Optional[bool] = False) -> str:
+    ''' Return a user resource path (normally from the users home directory).
+
+    :param type: Resource type in ['DATAFILES', 'CONFIG', 'SCRIPTS', 'AUTOSAVE'].
+    :type type: typing.Optional[str]
+    :param path: Optional subdirectory.
+    :type path: typing.Optional[str]
+    :param create: Treat the path as a directory and create it if its not existing.
+    :type create: typing.Optional[bool]
+    :rtype: str
+    :return: a path.
+    '''
+
+    ...

bpy/utils/previews/__init__.pyi

@@ -0,0 +1,73 @@
+import sys
+import typing
+import bpy.types
+
+GenericType = typing.TypeVar("GenericType")
+
+
+class ImagePreviewCollection:
+    ''' Dictionary-like class of previews. This is a subclass of Python's built-in dict type, used to store multiple image previews.
+    '''
+
+    def clear(self):
+        ''' Clear all previews.
+
+        '''
+        ...
+
+    def close(self):
+        ''' Close the collection and clear all previews.
+
+        '''
+        ...
+
+    def load(self,
+             name: typing.Optional[str],
+             filepath: typing.Optional[typing.Union[str, bytes]],
+             filetype: typing.Optional[str],
+             force_reload: typing.Optional[bool] = False
+             ) -> 'bpy.types.ImagePreview':
+        ''' Generate a new preview from given file path. :raises KeyError: if ``name`` already exists.
+
+        :param name: The name (unique id) identifying the preview.
+        :type name: typing.Optional[str]
+        :param filepath: The file path to generate the preview from.
+        :type filepath: typing.Optional[typing.Union[str, bytes]]
+        :param filetype: The type of file, needed to generate the preview in ['IMAGE', 'MOVIE', 'BLEND', 'FONT'].
+        :type filetype: typing.Optional[str]
+        :param force_reload: If True, force running thumbnail manager even if preview already exists in cache.
+        :type force_reload: typing.Optional[bool]
+        :rtype: 'bpy.types.ImagePreview'
+        :return: The Preview matching given name, or a new empty one.
+        '''
+        ...
+
+    def new(self, name: typing.Optional[str]) -> 'bpy.types.ImagePreview':
+        ''' Generate a new empty preview. :raises KeyError: if ``name`` already exists.
+
+        :param name: The name (unique id) identifying the preview.
+        :type name: typing.Optional[str]
+        :rtype: 'bpy.types.ImagePreview'
+        :return: The Preview matching given name, or a new empty one.
+        '''
+        ...
+
+
+def new() -> 'ImagePreviewCollection':
+    ''' 
+
+    :rtype: 'ImagePreviewCollection'
+    :return: a new preview collection.
+    '''
+
+    ...
+
+
+def remove(pcoll: typing.Optional['ImagePreviewCollection']):
+    ''' Remove the specified previews collection.
+
+    :param pcoll: Preview collection to close.
+    :type pcoll: typing.Optional['ImagePreviewCollection']
+    '''
+
+    ...

bpy/utils/units/__init__.pyi

@@ -0,0 +1,61 @@
+import sys
+import typing
+
+GenericType = typing.TypeVar("GenericType")
+
+
+def to_string(unit_system: typing.Optional[str],
+              unit_category: typing.Optional[str],
+              value: typing.Optional[float],
+              precision: typing.Optional[int] = 3,
+              split_unit: typing.Optional[bool] = False,
+              compatible_unit: typing.Optional[bool] = False) -> str:
+    ''' Convert a given input float value into a string with units. :raises ValueError: if conversion fails to generate a valid Python string.
+
+    :param unit_system: `bpy.utils.units.systems`.
+    :type unit_system: typing.Optional[str]
+    :param unit_category: The category of data we are converting (length, area, rotation, etc.), from :attr:`bpy.utils.units.categories`.
+    :type unit_category: typing.Optional[str]
+    :param value: The value to convert to a string.
+    :type value: typing.Optional[float]
+    :param precision: Number of digits after the comma.
+    :type precision: typing.Optional[int]
+    :param split_unit: Whether to use several units if needed (1m1cm), or always only one (1.01m).
+    :type split_unit: typing.Optional[bool]
+    :param compatible_unit: Whether to use keyboard-friendly units (1m2) or nicer utf-8 ones (1m²).
+    :type compatible_unit: typing.Optional[bool]
+    :rtype: str
+    :return: The converted string.
+    '''
+
+    ...
+
+
+def to_value(unit_system: typing.Optional[str],
+             unit_category: typing.Optional[str],
+             str_input: typing.Optional[str],
+             str_ref_unit: typing.Optional[str] = None) -> float:
+    ''' Convert a given input string into a float value. :raises ValueError: if conversion fails to generate a valid Python float value.
+
+    :param unit_system: `bpy.utils.units.systems`.
+    :type unit_system: typing.Optional[str]
+    :param unit_category: The category of data we are converting (length, area, rotation, etc.), from :attr:`bpy.utils.units.categories`.
+    :type unit_category: typing.Optional[str]
+    :param str_input: The string to convert to a float value.
+    :type str_input: typing.Optional[str]
+    :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: typing.Optional[str]
+    :rtype: float
+    :return: The converted/interpreted value.
+    '''
+
+    ...
+
+
+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')
+'''
+
+systems: typing.Any
+''' Constant value bpy.utils.units.systems(NONE='NONE', METRIC='METRIC', IMPERIAL='IMPERIAL')
+'''

bpy_extras/__init__.pyi

@@ -0,0 +1,18 @@
+import sys
+import typing
+from . import view3d_utils
+from . import object_utils
+from . import node_utils
+from . import keyconfig_utils
+from . import id_map_utils
+from . import image_utils
+from . import asset_utils
+from . import mesh_utils
+from . import io_utils
+from . import anim_utils
+from . import node_shader_utils
+from . import wm_utils
+from . import bmesh_utils
+from . import extensions
+
+GenericType = typing.TypeVar("GenericType")

bpy_extras/anim_utils/__init__.pyi

@@ -0,0 +1,108 @@
+import sys
+import typing
+import bpy.types
+
+GenericType = typing.TypeVar("GenericType")
+
+
+class BakeOptions:
+    ...
+
+
+class KeyframesCo:
+    keyframes_from_fcurve: typing.Any
+    ''' '''
+
+    def add_paths(self, rna_path, total_indices):
+        ''' 
+
+        '''
+        ...
+
+    def extend_co_value(self, rna_path, frame, value):
+        ''' 
+
+        '''
+        ...
+
+    def extend_co_values(self, rna_path, total_indices, frame, values):
+        ''' 
+
+        '''
+        ...
+
+    def insert_keyframes_into_existing_action(
+            self, lookup_fcurves, total_new_keys, action, action_group_name):
+        ''' 
+
+        '''
+        ...
+
+    def insert_keyframes_into_new_action(self, total_new_keys, action,
+                                         action_group_name):
+        ''' 
+
+        '''
+        ...
+
+
+def bake_action(obj: 'bpy.types.Object', *,
+                action: typing.Optional['bpy.types.Action'], frames: int,
+                bake_o) -> 'bpy.types.Action':
+    ''' 
+
+    :param obj: Object to bake.
+    :type obj: 'bpy.types.Object'
+    :param action: An action to bake the data into, or None for a new action to be created.
+    :type action: typing.Optional['bpy.types.Action']
+    :param frames: Frames to bake.
+    :type frames: int
+    :rtype: 'bpy.types.Action'
+    :return: an action or None
+    '''
+
+    ...
+
+
+def bake_action_iter(obj: 'bpy.types.Object', *,
+                     action: typing.Optional['bpy.types.Action'],
+                     bake_o) -> 'bpy.types.Action':
+    ''' An coroutine that bakes action for a single object.
+
+    :param obj: Object to bake.
+    :type obj: 'bpy.types.Object'
+    :param action: An action to bake the data into, or None for a new action to be created.
+    :type action: typing.Optional['bpy.types.Action']
+    :param bake_options: Boolean options of what to include into the action bake.
+    :type bake_options: typing.Any
+    :rtype: 'bpy.types.Action'
+    :return: an action or None
+    '''
+
+    ...
+
+
+def bake_action_objects(object_action_pairs, *, frames: int,
+                        bake_o) -> typing.Iterable['bpy.types.Action']:
+    ''' A version of :func:`bake_action_objects_iter` that takes frames and returns the output.
+
+    :param frames: Frames to bake.
+    :type frames: int
+    :rtype: typing.Iterable['bpy.types.Action']
+    :return: A sequence of Action or None types (aligned with `object_action_pairs`)
+    '''
+
+    ...
+
+
+def bake_action_objects_iter(
+        object_action_pairs: typing.
+        Union['bpy.types.Action', 'bpy.types.Sequence', 'bpy.types.Object'],
+        bake_o):
+    ''' An coroutine that bakes actions for multiple objects.
+
+    :param object_action_pairs: Sequence of object action tuples, action is the destination for the baked data. When None a new action will be created.
+    :type object_action_pairs: typing.Union['bpy.types.Action', 'bpy.types.Sequence', 'bpy.types.Object']
+    '''
+
+    ...