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

bpy_extras/asset_utils/__init__.pyi

@@ -0,0 +1,39 @@
+import sys
+import typing
+
+GenericType = typing.TypeVar("GenericType")
+
+
+class AssetBrowserPanel:
+    bl_space_type: typing.Any
+    ''' '''
+
+    def asset_browser_panel_poll(self, context):
+        ''' 
+
+        '''
+        ...
+
+    def poll(self, context):
+        ''' 
+
+        '''
+        ...
+
+
+class AssetMetaDataPanel:
+    bl_region_type: typing.Any
+    ''' '''
+
+    bl_space_type: typing.Any
+    ''' '''
+
+    def poll(self, context):
+        ''' 
+
+        '''
+        ...
+
+
+class SpaceAssetInfo:
+    ...

bpy_extras/bmesh_utils/__init__.pyi

@@ -0,0 +1,20 @@
+import sys
+import typing
+
+GenericType = typing.TypeVar("GenericType")
+
+
+def bmesh_linked_uv_islands(bm, uv_layer):
+    ''' 
+
+    '''
+
+    ...
+
+
+def match_uv(face, vert, uv, uv_layer):
+    ''' 
+
+    '''
+
+    ...

bpy_extras/extensions/junction_module/__init__.pyi

@@ -0,0 +1,48 @@
+import sys
+import typing
+
+GenericType = typing.TypeVar("GenericType")
+
+
+class JunctionModuleHandle:
+    def register_module(self):
+        ''' 
+
+        '''
+        ...
+
+    def register_submodule(self, submodule_name, dirpath):
+        ''' 
+
+        '''
+        ...
+
+    def rename_directory(self, submodule_name, dirpath):
+        ''' 
+
+        '''
+        ...
+
+    def rename_submodule(self, submodule_name_src, submodule_name_dst):
+        ''' 
+
+        '''
+        ...
+
+    def submodule_items(self):
+        ''' 
+
+        '''
+        ...
+
+    def unregister_module(self):
+        ''' 
+
+        '''
+        ...
+
+    def unregister_submodule(self, submodule_name):
+        ''' 
+
+        '''
+        ...

bpy_extras/id_map_utils/__init__.pyi

@@ -0,0 +1,28 @@
+import sys
+import typing
+
+GenericType = typing.TypeVar("GenericType")
+
+
+def get_all_referenced_ids(i, ref_m):
+    ''' Return a set of IDs directly or indirectly referenced by id.
+
+    '''
+
+    ...
+
+
+def get_id_reference_map():
+    ''' Return a dictionary of direct datablock references for every datablock in the blend file.
+
+    '''
+
+    ...
+
+
+def recursive_get_referenced_ids(ref_map, id, referenced_ids, visited):
+    ''' 
+
+    '''
+
+    ...

bpy_extras/image_utils/__init__.pyi

@@ -0,0 +1,42 @@
+import sys
+import typing
+import bpy.types
+
+GenericType = typing.TypeVar("GenericType")
+
+
+def load_image(imagepath,
+               dirname: str = '',
+               place_holder: bool = False,
+               recursive: bool = False,
+               ncase_cmp: bool = True,
+               convert_callback: typing.Any = None,
+               verbose=False,
+               relpath: str = None,
+               check_existing: bool = False,
+               force_reload: bool = False) -> 'bpy.types.Image':
+    ''' Return an image from the file path with options to search multiple paths and return a placeholder if its not found.
+
+    :param filepath: The image filename If a path precedes it, this will be searched as well.
+    :type filepath: str
+    :param dirname: is the directory where the image may be located - any file at the end will be ignored.
+    :type dirname: str
+    :param place_holder: if True a new place holder image will be created. this is useful so later you can relink the image to its original data.
+    :type place_holder: bool
+    :param recursive: If True, directories will be recursively searched. Be careful with this if you have files in your root directory because it may take a long time.
+    :type recursive: bool
+    :param ncase_cmp: on non windows systems, find the correct case for the file.
+    :type ncase_cmp: bool
+    :param convert_callback: a function that takes an existing path and returns a new one. Use this when loading image formats blender may not support, the CONVERT_CALLBACK can take the path for a GIF (for example), convert it to a PNG and return the PNG's path. For formats blender can read, simply return the path that is given.
+    :type convert_callback: typing.Any
+    :param relpath: If not None, make the file relative to this path.
+    :type relpath: str
+    :param check_existing: If true, returns already loaded image datablock if possible (based on file path).
+    :type check_existing: bool
+    :param force_reload: If true, force reloading of image (only useful when `check_existing` is also enabled).
+    :type force_reload: bool
+    :rtype: 'bpy.types.Image'
+    :return: an image or None
+    '''
+
+    ...

bpy_extras/io_utils/__init__.pyi

@@ -0,0 +1,165 @@
+import sys
+import typing
+import bpy.types
+
+GenericType = typing.TypeVar("GenericType")
+
+
+class ExportHelper:
+    def check(self, _context):
+        ''' 
+
+        '''
+        ...
+
+    def invoke(self, context, _event):
+        ''' 
+
+        '''
+        ...
+
+
+class ImportHelper:
+    def check(self, _context):
+        ''' 
+
+        '''
+        ...
+
+    def invoke(self, context, _event):
+        ''' 
+
+        '''
+        ...
+
+
+def axis_conversion(from_forward='Y', from_up='Z', to_forward='Y', to_up='Z'):
+    ''' Each argument us an axis in ['X', 'Y', 'Z', '-X', '-Y', '-Z'] where the first 2 are a source and the second 2 are the target.
+
+    '''
+
+    ...
+
+
+def axis_conversion_ensure(operator: 'bpy.types.Operator', forward_attr: str,
+                           up_attr: str) -> bool:
+    ''' Function to ensure an operator has valid axis conversion settings, intended to be used from `bpy.types.Operator.check`.
+
+    :param operator: the operator to access axis attributes from.
+    :type operator: 'bpy.types.Operator'
+    :param forward_attr: attribute storing the forward axis
+    :type forward_attr: str
+    :param up_attr: attribute storing the up axis
+    :type up_attr: str
+    :rtype: bool
+    :return: True if the value was modified.
+    '''
+
+    ...
+
+
+def create_derived_objects(
+        depsgraph: 'bpy.types.Depsgraph',
+        objects: typing.Iterable['bpy.types.Object']) -> typing.Dict:
+    ''' This function takes a sequence of objects, returning their instances.
+
+    :param depsgraph: The evaluated depsgraph.
+    :type depsgraph: 'bpy.types.Depsgraph'
+    :param objects: A sequencer of objects.
+    :type objects: typing.Iterable['bpy.types.Object']
+    :rtype: typing.Dict
+    :return: A dictionary where each key is an object from `objects`, values are lists of (`bpy.types.Object`, `mathutils.Matrix`) tuples representing instances.
+    '''
+
+    ...
+
+
+def orientation_helper(axis_forward='Y', axis_up='Z'):
+    ''' A decorator for import/export classes, generating properties needed by the axis conversion system and IO helpers, with specified default values (axes).
+
+    '''
+
+    ...
+
+
+def path_reference(
+        filepath: str,
+        base_src: str,
+        base_dst: str,
+        mode: str = 'AUTO',
+        copy_subdir: str = '',
+        copy_set: typing.Set = None,
+        library: typing.Optional['bpy.types.Library'] = None) -> str:
+    ''' Return a filepath relative to a destination directory, for use with exporters.
+
+    :param filepath: the file path to return, supporting blenders relative '//' prefix.
+    :type filepath: str
+    :param base_src: the directory the *filepath* is relative too (normally the blend file).
+    :type base_src: str
+    :param base_dst: the directory the *filepath* will be referenced from (normally the export path).
+    :type base_dst: str
+    :param mode: the method used get the path in ['AUTO', 'ABSOLUTE', 'RELATIVE', 'MATCH', 'STRIP', 'COPY']
+    :type mode: str
+    :param copy_subdir: the subdirectory of *base_dst* to use when mode='COPY'.
+    :type copy_subdir: str
+    :param copy_set: collect from/to pairs when mode='COPY', pass to *path_reference_copy* when exporting is done.
+    :type copy_set: typing.Set
+    :param library: The library this path is relative to.
+    :type library: typing.Optional['bpy.types.Library']
+    :rtype: str
+    :return: the new filepath.
+    '''
+
+    ...
+
+
+def path_reference_copy(copy_set: typing.Set,
+                        report: typing.Any = '<built-in function print>'):
+    ''' Execute copying files of path_reference
+
+    :param copy_set: set of (from, to) pairs to copy.
+    :type copy_set: typing.Set
+    :param report: function used for reporting warnings, takes a string argument.
+    :type report: typing.Any
+    '''
+
+    ...
+
+
+def unique_name(key: typing.Any,
+                name: str,
+                name_dict: typing.Dict,
+                name_max=-1,
+                clean_func: typing.Any = None,
+                sep: str = '.'):
+    ''' Helper function for storing unique names which may have special characters stripped and restricted to a maximum length.
+
+    :param key: unique item this name belongs to, name_dict[key] will be reused when available. This can be the object, mesh, material, etc instance itself.
+    :type key: typing.Any
+    :param name: The name used to create a unique value in *name_dict*.
+    :type name: str
+    :param name_dict: This is used to cache namespace to ensure no collisions occur, this should be an empty dict initially and only modified by this function.
+    :type name_dict: typing.Dict
+    :param clean_func: Function to call on *name* before creating a unique value.
+    :type clean_func: typing.Any
+    :param sep: Separator to use when between the name and a number when a duplicate name is found.
+    :type sep: str
+    '''
+
+    ...
+
+
+def unpack_face_list(list_of_tuples):
+    ''' 
+
+    '''
+
+    ...
+
+
+def unpack_list(list_of_tuples):
+    ''' 
+
+    '''
+
+    ...

bpy_extras/keyconfig_utils/__init__.pyi

@@ -0,0 +1,28 @@
+import sys
+import typing
+
+GenericType = typing.TypeVar("GenericType")
+
+
+def addon_keymap_register(keymap_data):
+    ''' Register a set of keymaps for addons using a list of keymaps. See 'blender_defaults.py' for examples of the format this takes.
+
+    '''
+
+    ...
+
+
+def addon_keymap_unregister(keymap_data):
+    ''' Unregister a set of keymaps for addons.
+
+    '''
+
+    ...
+
+
+def keyconfig_test(kc):
+    ''' 
+
+    '''
+
+    ...

bpy_extras/mesh_utils/__init__.pyi

@@ -0,0 +1,91 @@
+import sys
+import typing
+import bpy.types
+
+GenericType = typing.TypeVar("GenericType")
+
+
+def edge_face_count(mesh) -> typing.List:
+    ''' 
+
+    :rtype: typing.List
+    :return: list face users for each item in mesh.edges.
+    '''
+
+    ...
+
+
+def edge_face_count_dict(mesh) -> typing.Dict:
+    ''' 
+
+    :rtype: typing.Dict
+    :return: dict of edge keys with their value set to the number of faces using each edge.
+    '''
+
+    ...
+
+
+def edge_loops_from_edges(mesh, edges=None):
+    ''' Edge loops defined by edges Takes me.edges or a list of edges and returns the edge loops return a list of vertex indices. [ [1, 6, 7, 2], ...] closed loops have matching start and end values.
+
+    '''
+
+    ...
+
+
+def mesh_linked_triangles(mesh: 'bpy.types.Mesh') -> typing.List:
+    ''' Splits the mesh into connected triangles, use this for separating cubes from other mesh elements within 1 mesh datablock.
+
+    :param mesh: the mesh used to group with.
+    :type mesh: 'bpy.types.Mesh'
+    :rtype: typing.List
+    :return: lists of lists containing triangles.
+    '''
+
+    ...
+
+
+def mesh_linked_uv_islands(mesh: 'bpy.types.Mesh') -> typing.List:
+    ''' Returns lists of polygon indices connected by UV islands.
+
+    :param mesh: the mesh used to group with.
+    :type mesh: 'bpy.types.Mesh'
+    :rtype: typing.List
+    :return: list of lists containing polygon indices
+    '''
+
+    ...
+
+
+def ngon_tessellate(from_data: typing.Union[typing.List, 'bpy.types.Mesh'],
+                    indices: typing.List,
+                    fix_loops: bool = True,
+                    debug_print=True):
+    ''' Takes a poly-line of indices (ngon) and returns a list of face index lists. Designed to be used for importers that need indices for an ngon to create from existing verts.
+
+    :param from_data: either a mesh, or a list/tuple of vectors.
+    :type from_data: typing.Union[typing.List, 'bpy.types.Mesh']
+    :param indices: a list of indices to use this list is the ordered closed poly-line to fill, and can be a subset of the data given.
+    :type indices: typing.List
+    :param fix_loops: If this is enabled poly-lines that use loops to make multiple poly-lines are dealt with correctly.
+    :type fix_loops: bool
+    '''
+
+    ...
+
+
+def triangle_random_points(
+        num_points: typing.Any, loop_triangles: typing.
+        Union['bpy.types.MeshLoopTriangle', typing.Sequence]) -> typing.List:
+    ''' Generates a list of random points over mesh loop triangles.
+
+    :type int: typing.Any
+    :param loop_triangles: list of the triangles to generate points on.
+    :type loop_triangles: typing.Union['bpy.types.MeshLoopTriangle', typing.Sequence]
+    :param num_points:  the number of random points to generate on each triangle.
+    :type num_points: typing.Any
+    :rtype: typing.List
+    :return: list of random points over all triangles.
+    '''
+
+    ...