fake-bpy-module 20240524__py3-none-any.whl → 20240529__py3-none-any.whl

bmesh/types/__init__.pyi

@@ -253,11 +253,11 @@ class BMEdgeSeq:
         """Ensure internal data needed for int subscription is initialized with verts/edges/faces, eg bm.verts[index].This needs to be called again after adding/removing data in this sequence."""
         ...
 
-    def get(self, verts: BMVert, fallback=None) -> BMEdge:
+    def get(self, verts: collections.abc.Iterable[BMVert], fallback=None) -> BMEdge:
         """Return an edge which uses the verts passed.
 
         :param verts: Sequence of verts.
-        :type verts: BMVert
+        :type verts: collections.abc.Iterable[BMVert]
         :param fallback: Return this value if nothing is found.
         :return: The edge found or None
         :rtype: BMEdge
@@ -268,21 +268,22 @@ class BMEdgeSeq:
         """Initialize the index values of this sequence.This is the equivalent of looping over all elements and assigning the index values."""
         ...
 
-    def new(self, verts, example: BMEdge = None) -> BMEdge:
+    def new(self, verts, example: BMEdge | None = None) -> BMEdge:
         """Create a new edge from a given pair of verts.
 
         :param verts: Vertex pair.
         :param example: Existing edge to initialize settings (optional argument).
-        :type example: BMEdge
+        :type example: BMEdge | None
         :return: The newly created edge.
         :rtype: BMEdge
         """
         ...
 
-    def remove(self, edge):
+    def remove(self, edge: BMEdge):
         """Remove an edge.
 
         :param edge:
+        :type edge: BMEdge
         """
         ...
 
@@ -491,10 +492,10 @@ class BMFace:
     :type: int
     """
 
-    normal: typing.Sequence[float] | mathutils.Vector
+    normal: collections.abc.Sequence[float] | mathutils.Vector
     """ The normal for this face as a 3D, wrapped vector.
 
-    :type: typing.Sequence[float] | mathutils.Vector
+    :type: collections.abc.Sequence[float] | mathutils.Vector
     """
 
     select: bool
@@ -668,11 +669,11 @@ class BMFaceSeq:
         """Ensure internal data needed for int subscription is initialized with verts/edges/faces, eg bm.verts[index].This needs to be called again after adding/removing data in this sequence."""
         ...
 
-    def get(self, verts: BMVert, fallback=None) -> BMFace:
+    def get(self, verts: collections.abc.Iterable[BMVert], fallback=None) -> BMFace:
         """Return a face which uses the verts passed.
 
         :param verts: Sequence of verts.
-        :type verts: BMVert
+        :type verts: collections.abc.Iterable[BMVert]
         :param fallback: Return this value if nothing is found.
         :return: The face found or None
         :rtype: BMFace
@@ -683,22 +684,25 @@ class BMFaceSeq:
         """Initialize the index values of this sequence.This is the equivalent of looping over all elements and assigning the index values."""
         ...
 
-    def new(self, verts: typing.Iterable[BMVert], example: BMFace = None) -> BMFace:
+    def new(
+        self, verts: collections.abc.Iterable[BMVert], example: BMFace | None = None
+    ) -> BMFace:
         """Create a new face from a given set of verts.
 
         :param verts: Sequence of 3 or more verts.
-        :type verts: typing.Iterable[BMVert]
+        :type verts: collections.abc.Iterable[BMVert]
         :param example: Existing face to initialize settings (optional argument).
-        :type example: BMFace
+        :type example: BMFace | None
         :return: The newly created face.
         :rtype: BMFace
         """
         ...
 
-    def remove(self, face):
+    def remove(self, face: BMFace):
         """Remove a face.
 
         :param face:
+        :type face: BMFace
         """
         ...
 
@@ -1008,11 +1012,11 @@ class BMLayerCollection:
         """
         ...
 
-    def new(self, name: str) -> BMLayerItem:
+    def new(self, name: str | None) -> BMLayerItem:
         """Create a new layer
 
         :param name: Optional name argument (will be made unique).
-        :type name: str
+        :type name: str | None
         :return: The newly created layer.
         :rtype: BMLayerItem
         """
@@ -1052,10 +1056,11 @@ class BMLayerItem:
     :type: str
     """
 
-    def copy_from(self, other):
+    def copy_from(self, other: BMLayerItem):
         """Return a copy of the layer
 
-        :param other: Another layer to copy from.`BMLayerItem`
+        :param other: Another layer to copy from.
+        :type other: BMLayerItem
         """
         ...
 
@@ -1169,16 +1174,16 @@ class BMLoop:
         ...
 
     def copy_from_face_interp(
-        self, face: BMFace, vert: bool = True, multires: bool = True
+        self, face: BMFace, vert: bool | None = True, multires: bool | None = True
     ):
         """Interpolate the customdata from a face onto this loop (the loops vert should overlap the face).
 
         :param face: The face to interpolate data from.
         :type face: BMFace
         :param vert: When enabled, interpolate the loops vertex data (optional).
-        :type vert: bool
+        :type vert: bool | None
         :param multires: When enabled, interpolate the loops multires data (optional).
-        :type multires: bool
+        :type multires: bool | None
         """
         ...
 
@@ -1262,19 +1267,19 @@ class BMLoopUV:
     :type: bool
     """
 
-    uv: typing.Sequence[float] | mathutils.Vector
+    uv: collections.abc.Sequence[float] | mathutils.Vector
     """ Loops UV (as a 2D Vector).
 
-    :type: typing.Sequence[float] | mathutils.Vector
+    :type: collections.abc.Sequence[float] | mathutils.Vector
     """
 
 class BMVert:
     """The BMesh vertex type"""
 
-    co: typing.Sequence[float] | mathutils.Vector
+    co: collections.abc.Sequence[float] | mathutils.Vector
     """ The coordinates for this vertex as a 3D, wrapped vector.
 
-    :type: typing.Sequence[float] | mathutils.Vector
+    :type: collections.abc.Sequence[float] | mathutils.Vector
     """
 
     hide: bool
@@ -1331,10 +1336,10 @@ class BMVert:
     :type: list[BMLoop] | BMElemSeq
     """
 
-    normal: typing.Sequence[float] | mathutils.Vector
+    normal: collections.abc.Sequence[float] | mathutils.Vector
     """ The normal for this vertex as a 3D, wrapped vector.
 
-    :type: typing.Sequence[float] | mathutils.Vector
+    :type: collections.abc.Sequence[float] | mathutils.Vector
     """
 
     select: bool
@@ -1385,12 +1390,13 @@ class BMVert:
         """
         ...
 
-    def copy_from_vert_interp(self, vert_pair: BMVert, fac):
+    def copy_from_vert_interp(self, vert_pair: BMVert, fac: float):
         """Interpolate the customdata from a vert between 2 other verts.
 
         :param vert_pair: The vert to interpolate data from.
         :type vert_pair: BMVert
         :param fac:
+        :type fac: float
         """
         ...
 
@@ -1436,13 +1442,13 @@ class BMVertSeq:
 
     def new(
         self,
-        co: typing.Sequence[float] | mathutils.Vector = (0.0, 0.0, 0.0),
+        co: collections.abc.Sequence[float] | mathutils.Vector | None = (0.0, 0.0, 0.0),
         example: BMVert = None,
     ) -> BMVert:
         """Create a new vertex.
 
         :param co: The initial location of the vertex (optional argument).
-        :type co: typing.Sequence[float] | mathutils.Vector
+        :type co: collections.abc.Sequence[float] | mathutils.Vector | None
         :param example: Existing vert to initialize settings.
         :type example: BMVert
         :return: The newly created vertex.
@@ -1450,10 +1456,11 @@ class BMVertSeq:
         """
         ...
 
-    def remove(self, vert):
+    def remove(self, vert: BMVert):
         """Remove a vert.
 
         :param vert:
+        :type vert: BMVert
         """
         ...
 
@@ -1608,8 +1615,8 @@ class BMesh:
     def from_mesh(
         self,
         mesh: bpy.types.Mesh,
-        face_normals=True,
-        vertex_normals=True,
+        face_normals: bool = True,
+        vertex_normals: bool = True,
         use_shape_key: bool = False,
         shape_key_index: int = 0,
     ):
@@ -1618,7 +1625,9 @@ class BMesh:
         :param mesh: The mesh data to load.
         :type mesh: bpy.types.Mesh
         :param face_normals:
+        :type face_normals: bool
         :param vertex_normals:
+        :type vertex_normals: bool
         :param use_shape_key: Use the locations from a shape key.
         :type use_shape_key: bool
         :param shape_key_index: The shape key index to use.
@@ -1629,7 +1638,7 @@ class BMesh:
     def from_object(
         self,
         object: bpy.types.Object,
-        depsgraph,
+        depsgraph: bpy.types.Depsgraph,
         cage: bool = False,
         face_normals: bool = True,
         vertex_normals: bool = True,
@@ -1639,6 +1648,7 @@ class BMesh:
         :param object: The object data to load.
         :type object: bpy.types.Object
         :param depsgraph:
+        :type depsgraph: bpy.types.Depsgraph
         :param cage: Get the mesh as a deformed cage.
         :type cage: bool
         :param face_normals: Calculate face normals.

bmesh/utils/__init__.pyi

@@ -61,7 +61,7 @@ def face_split(
     face: bmesh.types.BMFace,
     vert_a: bmesh.types.BMVert,
     vert_b: bmesh.types.BMVert,
-    coords: list[float] = (),
+    coords: list[float] | None = (),
     use_exist: bool = True,
     example: bmesh.types.BMEdge = None,
 ) -> tuple[bmesh.types.BMFace, bmesh.types.BMLoop]:
@@ -74,7 +74,7 @@ def face_split(
     :param vert_b: Second vertex to cut in the face (face must contain the vert).
     :type vert_b: bmesh.types.BMVert
     :param coords: Optional argument to define points in between vert_a and vert_b.
-    :type coords: list[float]
+    :type coords: list[float] | None
     :param use_exist: .Use an existing edge if it exists (Only used when coords argument is empty or omitted)
     :type use_exist: bool
     :param example: Newly created edge will copy settings from this one.

bpy/app/__init__.pyi

@@ -208,6 +208,10 @@ online_access: typing.Any
 """ Boolean, true when internet access is allowed by Blender & 3rd party scripts (read-only)
 """
 
+online_access_override: typing.Any
+""" Boolean, true when internet access preference is overridden by the command line (read-only)
+"""
+
 opensubdiv: typing.Any
 """ Constant value bpy.app.opensubdiv(supported=True, version=(3, 6, 0), version_string=' 3,  6,  0')
 """
@@ -244,7 +248,7 @@ use_userpref_skip_save_on_exit: typing.Any
 """ Boolean, for application behavior (started with --enable-* matching this attribute name)
 """
 
-version: typing.Tuple[int, int, int]
+version: tuple[int, int, int]
 """ The Blender version as a tuple of 3 numbers. eg. (2, 83, 1)
 """
 

bpy/app/handlers/__init__.pyi

@@ -45,79 +45,79 @@ import bpy.types
 
 GenericType1 = typing.TypeVar("GenericType1")
 GenericType2 = typing.TypeVar("GenericType2")
-animation_playback_post: list[typing.Callable[[bpy.types.Scene, None]]]
+animation_playback_post: list[collections.abc.Callable[[bpy.types.Scene, None]]]
 """ on ending animation playback
 """
 
-animation_playback_pre: list[typing.Callable[[bpy.types.Scene, None]]]
+animation_playback_pre: list[collections.abc.Callable[[bpy.types.Scene, None]]]
 """ on starting animation playback
 """
 
-annotation_post: list[typing.Callable[[bpy.types.Scene, None]]]
+annotation_post: list[collections.abc.Callable[[bpy.types.Scene, None]]]
 """ on drawing an annotation (after)
 """
 
-annotation_pre: list[typing.Callable[[bpy.types.Scene, None]]]
+annotation_pre: list[collections.abc.Callable[[bpy.types.Scene, None]]]
 """ on drawing an annotation (before)
 """
 
-composite_cancel: list[typing.Callable[[bpy.types.Scene, None]]]
+composite_cancel: list[collections.abc.Callable[[bpy.types.Scene, None]]]
 """ on a compositing background job (cancel)
 """
 
-composite_post: list[typing.Callable[[bpy.types.Scene, None]]]
+composite_post: list[collections.abc.Callable[[bpy.types.Scene, None]]]
 """ on a compositing background job (after)
 """
 
-composite_pre: list[typing.Callable[[bpy.types.Scene, None]]]
+composite_pre: list[collections.abc.Callable[[bpy.types.Scene, None]]]
 """ on a compositing background job (before)
 """
 
-depsgraph_update_post: list[typing.Callable[[bpy.types.Scene, None]]]
+depsgraph_update_post: list[collections.abc.Callable[[bpy.types.Scene, None]]]
 """ on depsgraph update (post)
 """
 
-depsgraph_update_pre: list[typing.Callable[[bpy.types.Scene, None]]]
+depsgraph_update_pre: list[collections.abc.Callable[[bpy.types.Scene, None]]]
 """ on depsgraph update (pre)
 """
 
-frame_change_post: list[typing.Callable[[bpy.types.Scene, None]]]
+frame_change_post: list[collections.abc.Callable[[bpy.types.Scene, None]]]
 """ Called after frame change for playback and rendering, after the data has been evaluated for the new frame.
 """
 
-frame_change_pre: list[typing.Callable[[bpy.types.Scene, None]]]
+frame_change_pre: list[collections.abc.Callable[[bpy.types.Scene, None]]]
 """ Called after frame change for playback and rendering, before any data is evaluated for the new frame. This makes it possible to change data and relations (for example swap an object to another mesh) for the new frame. Note that this handler is not to be used as 'before the frame changes' event. The dependency graph is not available in this handler, as data and relations may have been altered and the dependency graph has not yet been updated for that.
 """
 
-load_factory_preferences_post: list[typing.Callable[[bpy.types.Scene, None]]]
+load_factory_preferences_post: list[collections.abc.Callable[[bpy.types.Scene, None]]]
 """ on loading factory preferences (after)
 """
 
-load_factory_startup_post: list[typing.Callable[[bpy.types.Scene, None]]]
+load_factory_startup_post: list[collections.abc.Callable[[bpy.types.Scene, None]]]
 """ on loading factory startup (after)
 """
 
-load_post: list[typing.Callable[[bpy.types.Scene, None]]]
+load_post: list[collections.abc.Callable[[bpy.types.Scene, None]]]
 """ on loading a new blend file (after). Accepts one argument: the file being loaded, an empty string for the startup-file.
 """
 
-load_post_fail: list[typing.Callable[[bpy.types.Scene, None]]]
+load_post_fail: list[collections.abc.Callable[[bpy.types.Scene, None]]]
 """ on failure to load a new blend file (after). Accepts one argument: the file being loaded, an empty string for the startup-file.
 """
 
-load_pre: list[typing.Callable[[bpy.types.Scene, None]]]
+load_pre: list[collections.abc.Callable[[bpy.types.Scene, None]]]
 """ on loading a new blend file (before).Accepts one argument: the file being loaded, an empty string for the startup-file.
 """
 
-object_bake_cancel: list[typing.Callable[[bpy.types.Scene, None]]]
+object_bake_cancel: list[collections.abc.Callable[[bpy.types.Scene, None]]]
 """ on canceling a bake job; will be called in the main thread
 """
 
-object_bake_complete: list[typing.Callable[[bpy.types.Scene, None]]]
+object_bake_complete: list[collections.abc.Callable[[bpy.types.Scene, None]]]
 """ on completing a bake job; will be called in the main thread
 """
 
-object_bake_pre: list[typing.Callable[[bpy.types.Scene, None]]]
+object_bake_pre: list[collections.abc.Callable[[bpy.types.Scene, None]]]
 """ before starting a bake job
 """
 
@@ -125,70 +125,70 @@ persistent: typing.Any
 """ Function decorator for callback functions not to be removed when loading new files
 """
 
-redo_post: list[typing.Callable[[bpy.types.Scene, None]]]
+redo_post: list[collections.abc.Callable[[bpy.types.Scene, None]]]
 """ on loading a redo step (after)
 """
 
-redo_pre: list[typing.Callable[[bpy.types.Scene, None]]]
+redo_pre: list[collections.abc.Callable[[bpy.types.Scene, None]]]
 """ on loading a redo step (before)
 """
 
-render_cancel: list[typing.Callable[[bpy.types.Scene, None]]]
+render_cancel: list[collections.abc.Callable[[bpy.types.Scene, None]]]
 """ on canceling a render job
 """
 
-render_complete: list[typing.Callable[[bpy.types.Scene, None]]]
+render_complete: list[collections.abc.Callable[[bpy.types.Scene, None]]]
 """ on completion of render job
 """
 
-render_init: list[typing.Callable[[bpy.types.Scene, None]]]
+render_init: list[collections.abc.Callable[[bpy.types.Scene, None]]]
 """ on initialization of a render job
 """
 
-render_post: list[typing.Callable[[bpy.types.Scene, None]]]
+render_post: list[collections.abc.Callable[[bpy.types.Scene, None]]]
 """ on render (after)
 """
 
-render_pre: list[typing.Callable[[bpy.types.Scene, None]]]
+render_pre: list[collections.abc.Callable[[bpy.types.Scene, None]]]
 """ on render (before)
 """
 
-render_stats: list[typing.Callable[[bpy.types.Scene, None]]]
-""" on printing render statistics
+render_stats: list[collections.abc.Callable[[bpy.types.Scene, None]]]
+""" on printing render statistics. Accepts one argument: the render stats (render/saving time plus in background mode frame/used [peak] memory).
 """
 
-render_write: list[typing.Callable[[bpy.types.Scene, None]]]
+render_write: list[collections.abc.Callable[[bpy.types.Scene, None]]]
 """ on writing a render frame (directly after the frame is written)
 """
 
-save_post: list[typing.Callable[[bpy.types.Scene, None]]]
+save_post: list[collections.abc.Callable[[bpy.types.Scene, None]]]
 """ on saving a blend file (after). Accepts one argument: the file being saved, an empty string for the startup-file.
 """
 
-save_post_fail: list[typing.Callable[[bpy.types.Scene, None]]]
+save_post_fail: list[collections.abc.Callable[[bpy.types.Scene, None]]]
 """ on failure to save a blend file (after). Accepts one argument: the file being saved, an empty string for the startup-file.
 """
 
-save_pre: list[typing.Callable[[bpy.types.Scene, None]]]
+save_pre: list[collections.abc.Callable[[bpy.types.Scene, None]]]
 """ on saving a blend file (before). Accepts one argument: the file being saved, an empty string for the startup-file.
 """
 
-translation_update_post: list[typing.Callable[[bpy.types.Scene, None]]]
+translation_update_post: list[collections.abc.Callable[[bpy.types.Scene, None]]]
 """ on translation settings update
 """
 
-undo_post: list[typing.Callable[[bpy.types.Scene, None]]]
+undo_post: list[collections.abc.Callable[[bpy.types.Scene, None]]]
 """ on loading an undo step (after)
 """
 
-undo_pre: list[typing.Callable[[bpy.types.Scene, None]]]
+undo_pre: list[collections.abc.Callable[[bpy.types.Scene, None]]]
 """ on loading an undo step (before)
 """
 
-version_update: list[typing.Callable[[bpy.types.Scene, None]]]
+version_update: list[collections.abc.Callable[[bpy.types.Scene, None]]]
 """ on ending the versioning code
 """
 
-xr_session_start_pre: list[typing.Callable[[bpy.types.Scene, None]]]
+xr_session_start_pre: list[collections.abc.Callable[[bpy.types.Scene, None]]]
 """ on starting an xr session (before)
 """

bpy/app/icons/__init__.pyi

@@ -6,17 +6,17 @@ GenericType2 = typing.TypeVar("GenericType2")
 
 def new_triangles(
     range: tuple | None,
-    coords: typing.Sequence[bytes] | None,
-    colors: typing.Sequence[bytes] | None,
+    coords: collections.abc.Sequence[bytes] | None,
+    colors: collections.abc.Sequence[bytes] | None,
 ) -> int:
     """Create a new icon from triangle geometry.
 
     :param range: Pair of ints.
     :type range: tuple | None
     :param coords: Sequence of bytes (6 floats for one triangle) for (X, Y) coordinates.
-    :type coords: typing.Sequence[bytes] | None
+    :type coords: collections.abc.Sequence[bytes] | None
     :param colors: Sequence of ints (12 for one triangles) for RGBA.
-    :type colors: typing.Sequence[bytes] | None
+    :type colors: collections.abc.Sequence[bytes] | None
     :return: Unique icon value (pass to interface icon_value argument).
     :rtype: int
     """

bpy/app/timers/__init__.pyi

@@ -36,18 +36,18 @@ import collections.abc
 GenericType1 = typing.TypeVar("GenericType1")
 GenericType2 = typing.TypeVar("GenericType2")
 
-def is_registered(function: typing.Callable[[], float]) -> bool:
+def is_registered(function: collections.abc.Callable[[], float]) -> bool:
     """Check if this function is registered as a timer.
 
     :param function: Function to check.
-    :type function: typing.Callable[[], float]
+    :type function: collections.abc.Callable[[], float]
     :return: True when this function is registered, otherwise False.
     :rtype: bool
     """
 
     ...
 
-def register(function: typing.Callable[[], float]):
+def register(function: collections.abc.Callable[[], float]):
     """Add a new function that will be called after the specified amount of seconds.
     The function gets no arguments and is expected to return either None or a float.
     If None is returned, the timer will be unregistered.
@@ -55,16 +55,16 @@ def register(function: typing.Callable[[], float]):
     functools.partial can be used to assign some parameters.
 
         :param function: The function that should called.
-        :type function: typing.Callable[[], float]
+        :type function: collections.abc.Callable[[], float]
     """
 
     ...
 
-def unregister(function: typing.Callable[[], float]):
+def unregister(function: collections.abc.Callable[[], float]):
     """Unregister timer.
 
     :param function: Function to unregister.
-    :type function: typing.Callable[[], float]
+    :type function: collections.abc.Callable[[], float]
     """
 
     ...