fake-bpy-module 20240516__py3-none-any.whl → 20240517__py3-none-any.whl

bmesh/types/__init__.pyi

@@ -51,21 +51,21 @@ class BMDeformVert:
         """
         ...
 
-    def keys(self) -> typing.List[int]:
+    def keys(self) -> list[int]:
         """Return the group indices used by this vertex
         (matching Python's dict.keys() functionality).
 
                 :return: the deform group this vertex uses
-                :rtype: typing.List[int]
+                :rtype: list[int]
         """
         ...
 
-    def values(self) -> typing.List[float]:
+    def values(self) -> list[float]:
         """Return the weights of the deform vertex
         (matching Python's dict.values() functionality).
 
                 :return: The weights that influence this vertex
-                :rtype: typing.List[float]
+                :rtype: list[float]
         """
         ...
 
@@ -120,16 +120,16 @@ class BMEdge:
     :type: bool
     """
 
-    link_faces: typing.Union[typing.List[BMFace], BMElemSeq]
+    link_faces: list[BMFace] | BMElemSeq
     """ Faces connected to this edge, (read-only).
 
-    :type: typing.Union[typing.List[BMFace], BMElemSeq]
+    :type: list[BMFace] | BMElemSeq
     """
 
-    link_loops: typing.Union[typing.List[BMLoop], BMElemSeq]
+    link_loops: list[BMLoop] | BMElemSeq
     """ Loops connected to this edge, (read-only).
 
-    :type: typing.Union[typing.List[BMLoop], BMElemSeq]
+    :type: list[BMLoop] | BMElemSeq
     """
 
     seam: bool
@@ -156,10 +156,10 @@ class BMEdge:
     :type: bool
     """
 
-    verts: typing.Union[typing.List[BMVert], BMElemSeq]
+    verts: list[BMVert] | BMElemSeq
     """ Verts this edge uses (always 2), (read-only).
 
-    :type: typing.Union[typing.List[BMVert], BMElemSeq]
+    :type: list[BMVert] | BMElemSeq
     """
 
     def calc_face_angle(self, fallback: typing.Any = None) -> float:
@@ -360,10 +360,10 @@ class BMEditSelIter:
 class BMEditSelSeq:
     """ """
 
-    active: typing.Union[BMVert, BMEdge, BMFace]
+    active: BMVert | BMEdge | BMFace
     """ The last selected element or None (read-only).
 
-    :type: typing.Union[BMVert, BMEdge, BMFace]
+    :type: BMVert | BMEdge | BMFace
     """
 
     def add(self, element):
@@ -462,10 +462,10 @@ class BMElemSeq:
 class BMFace:
     """The BMesh face with 3 or more sides"""
 
-    edges: typing.Union[typing.List[BMEdge], BMElemSeq]
+    edges: list[BMEdge] | BMElemSeq
     """ Edges of this face, (read-only).
 
-    :type: typing.Union[typing.List[BMEdge], BMElemSeq]
+    :type: list[BMEdge] | BMElemSeq
     """
 
     hide: bool
@@ -486,10 +486,10 @@ class BMFace:
     :type: bool
     """
 
-    loops: typing.Union[typing.List[BMLoop], BMElemSeq]
+    loops: list[BMLoop] | BMElemSeq
     """ Loops of this face, (read-only).
 
-    :type: typing.Union[typing.List[BMLoop], BMElemSeq]
+    :type: list[BMLoop] | BMElemSeq
     """
 
     material_index: int
@@ -498,10 +498,10 @@ class BMFace:
     :type: int
     """
 
-    normal: typing.Union[typing.Sequence[float], mathutils.Vector]
+    normal: typing.Sequence[float] | mathutils.Vector
     """ The normal for this face as a 3D, wrapped vector.
 
-    :type: typing.Union[typing.Sequence[float], mathutils.Vector]
+    :type: typing.Sequence[float] | mathutils.Vector
     """
 
     select: bool
@@ -522,10 +522,10 @@ class BMFace:
     :type: bool
     """
 
-    verts: typing.Union[typing.List[BMVert], BMElemSeq]
+    verts: list[BMVert] | BMElemSeq
     """ Verts of this face, (read-only).
 
-    :type: typing.Union[typing.List[BMVert], BMElemSeq]
+    :type: list[BMVert] | BMElemSeq
     """
 
     def calc_area(self) -> float:
@@ -921,12 +921,12 @@ class BMLayerCollection:
         """
         ...
 
-    def keys(self) -> typing.List[str]:
+    def keys(self) -> list[str]:
         """Return the identifiers of collection members
         (matching Python's dict.keys() functionality).
 
                 :return: the identifiers for each member of this collection.
-                :rtype: typing.List[str]
+                :rtype: list[str]
         """
         ...
 
@@ -1038,10 +1038,10 @@ class BMLoop:
     :type: BMLoop
     """
 
-    link_loops: typing.Union[typing.List[BMLoop], BMElemSeq]
+    link_loops: list[BMLoop] | BMElemSeq
     """ Loops connected to this loop, (read-only).
 
-    :type: typing.Union[typing.List[BMLoop], BMElemSeq]
+    :type: list[BMLoop] | BMElemSeq
     """
 
     tag: bool
@@ -1188,19 +1188,19 @@ class BMLoopUV:
     :type: bool
     """
 
-    uv: typing.Union[typing.Sequence[float], mathutils.Vector]
+    uv: typing.Sequence[float] | mathutils.Vector
     """ Loops UV (as a 2D Vector).
 
-    :type: typing.Union[typing.Sequence[float], mathutils.Vector]
+    :type: typing.Sequence[float] | mathutils.Vector
     """
 
 class BMVert:
     """The BMesh vertex type"""
 
-    co: typing.Union[typing.Sequence[float], mathutils.Vector]
+    co: typing.Sequence[float] | mathutils.Vector
     """ The coordinates for this vertex as a 3D, wrapped vector.
 
-    :type: typing.Union[typing.Sequence[float], mathutils.Vector]
+    :type: typing.Sequence[float] | mathutils.Vector
     """
 
     hide: bool
@@ -1239,28 +1239,28 @@ class BMVert:
     :type: bool
     """
 
-    link_edges: typing.Union[typing.List[BMEdge], BMElemSeq]
+    link_edges: list[BMEdge] | BMElemSeq
     """ Edges connected to this vertex (read-only).
 
-    :type: typing.Union[typing.List[BMEdge], BMElemSeq]
+    :type: list[BMEdge] | BMElemSeq
     """
 
-    link_faces: typing.Union[typing.List[BMFace], BMElemSeq]
+    link_faces: list[BMFace] | BMElemSeq
     """ Faces connected to this vertex (read-only).
 
-    :type: typing.Union[typing.List[BMFace], BMElemSeq]
+    :type: list[BMFace] | BMElemSeq
     """
 
-    link_loops: typing.Union[typing.List[BMLoop], BMElemSeq]
+    link_loops: list[BMLoop] | BMElemSeq
     """ Loops that use this vertex (read-only).
 
-    :type: typing.Union[typing.List[BMLoop], BMElemSeq]
+    :type: list[BMLoop] | BMElemSeq
     """
 
-    normal: typing.Union[typing.Sequence[float], mathutils.Vector]
+    normal: typing.Sequence[float] | mathutils.Vector
     """ The normal for this vertex as a 3D, wrapped vector.
 
-    :type: typing.Union[typing.Sequence[float], mathutils.Vector]
+    :type: typing.Sequence[float] | mathutils.Vector
     """
 
     select: bool
@@ -1364,13 +1364,13 @@ class BMVertSeq:
 
     def new(
         self,
-        co: typing.Union[typing.Sequence[float], mathutils.Vector] = (0.0, 0.0, 0.0),
+        co: typing.Sequence[float] | mathutils.Vector = (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.Union[typing.Sequence[float], mathutils.Vector]
+        :type co: typing.Sequence[float] | mathutils.Vector
         :param example: Existing vert to initialize settings.
         :type example: BMVert
         :return: The newly created vertex.

bmesh/utils/__init__.pyi

@@ -22,9 +22,7 @@ def edge_rotate(edge: bmesh.types.BMEdge, ccw: bool = False) -> bmesh.types.BMEd
 
     ...
 
-def edge_split(
-    edge: bmesh.types.BMEdge, vert: bmesh.types.BMVert, fac: float
-) -> typing.Tuple:
+def edge_split(edge: bmesh.types.BMEdge, vert: bmesh.types.BMVert, fac: float) -> tuple:
     """Split an edge, return the newly created data.
 
     :param edge: The edge to split.
@@ -34,7 +32,7 @@ def edge_split(
     :param fac: The point on the edge where the new vert will be created [0 - 1].
     :type fac: float
     :return: The newly created (edge, vert) pair.
-    :rtype: typing.Tuple
+    :rtype: tuple
     """
 
     ...
@@ -61,10 +59,10 @@ def face_split(
     face: bmesh.types.BMFace,
     vert_a: bmesh.types.BMVert,
     vert_b: bmesh.types.BMVert,
-    coords: typing.List[float] = (),
+    coords: list[float] = (),
     use_exist: bool = True,
     example: bmesh.types.BMEdge = None,
-) -> typing.Tuple[bmesh.types.BMFace, bmesh.types.BMLoop]:
+) -> tuple[bmesh.types.BMFace, bmesh.types.BMLoop]:
     """Face split with optional intermediate points.
 
     :param face: The face to cut.
@@ -74,25 +72,24 @@ 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: typing.List[float]
+    :type coords: list[float]
     :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.
     :type example: bmesh.types.BMEdge
     :return: The newly created face or None on failure.
-    :rtype: typing.Tuple[bmesh.types.BMFace, bmesh.types.BMLoop]
+    :rtype: tuple[bmesh.types.BMFace, bmesh.types.BMLoop]
     """
 
     ...
 
 def face_split_edgenet(
-    face: typing.Union[bmesh.types.BMFace, bmesh.types.BMFace],
-    edgenet: bmesh.types.BMEdge,
+    face: bmesh.types.BMFace | bmesh.types.BMFace, edgenet: bmesh.types.BMEdge
 ):
     """Splits a face into any number of regions defined by an edgenet.
 
     :param face: The face to split.The face to split.
-    :type face: typing.Union[bmesh.types.BMFace, bmesh.types.BMFace]
+    :type face: bmesh.types.BMFace | bmesh.types.BMFace
     :param edgenet: Sequence of edges.
     :type edgenet: bmesh.types.BMEdge
     :return: The newly created faces.
@@ -173,7 +170,7 @@ def vert_dissolve(vert: bmesh.types.BMVert) -> bool:
 
 def vert_separate(
     vert: bmesh.types.BMVert, edges: bmesh.types.BMEdge
-) -> typing.Tuple[bmesh.types.BMVert, ...]:
+) -> tuple[bmesh.types.BMVert, ...]:
     """Separate this vertex at every edge.
 
     :param vert: The vert to be separated.
@@ -181,7 +178,7 @@ def vert_separate(
     :param edges: The edges to separated.
     :type edges: bmesh.types.BMEdge
     :return: The newly separated verts (including the vertex passed).
-    :rtype: typing.Tuple[bmesh.types.BMVert, ...]
+    :rtype: tuple[bmesh.types.BMVert, ...]
     """
 
     ...

bpy/app/__init__.pyi

@@ -19,20 +19,20 @@ from . import translations
 
 GenericType = typing.TypeVar("GenericType")
 
-def help_text(all: typing.Optional[bool] = False):
+def help_text(all: bool | None = False):
     """Return the help text as a string.
 
     :param all: Return all arguments, even those which aren't available for the current platform.
-    :type all: typing.Optional[bool]
+    :type all: bool | None
     """
 
     ...
 
-def is_job_running(job_type: typing.Optional[str]):
+def is_job_running(job_type: str | None):
     """Check whether a job of the given type is running.
 
     :param job_type: job type in `rna_enum_wm_job_type_items`.
-    :type job_type: typing.Optional[str]
+    :type job_type: str | None
     :return: Whether a job of the given type is currently running.
     """
 

bpy/app/handlers/__init__.pyi

@@ -43,79 +43,79 @@ import typing
 import bpy.types
 
 GenericType = typing.TypeVar("GenericType")
-animation_playback_post: typing.List[typing.Callable[[bpy.types.Scene, None]]]
+animation_playback_post: list[typing.Callable[[bpy.types.Scene, None]]]
 """ on ending animation playback
 """
 
-animation_playback_pre: typing.List[typing.Callable[[bpy.types.Scene, None]]]
+animation_playback_pre: list[typing.Callable[[bpy.types.Scene, None]]]
 """ on starting animation playback
 """
 
-annotation_post: typing.List[typing.Callable[[bpy.types.Scene, None]]]
+annotation_post: list[typing.Callable[[bpy.types.Scene, None]]]
 """ on drawing an annotation (after)
 """
 
-annotation_pre: typing.List[typing.Callable[[bpy.types.Scene, None]]]
+annotation_pre: list[typing.Callable[[bpy.types.Scene, None]]]
 """ on drawing an annotation (before)
 """
 
-composite_cancel: typing.List[typing.Callable[[bpy.types.Scene, None]]]
+composite_cancel: list[typing.Callable[[bpy.types.Scene, None]]]
 """ on a compositing background job (cancel)
 """
 
-composite_post: typing.List[typing.Callable[[bpy.types.Scene, None]]]
+composite_post: list[typing.Callable[[bpy.types.Scene, None]]]
 """ on a compositing background job (after)
 """
 
-composite_pre: typing.List[typing.Callable[[bpy.types.Scene, None]]]
+composite_pre: list[typing.Callable[[bpy.types.Scene, None]]]
 """ on a compositing background job (before)
 """
 
-depsgraph_update_post: typing.List[typing.Callable[[bpy.types.Scene, None]]]
+depsgraph_update_post: list[typing.Callable[[bpy.types.Scene, None]]]
 """ on depsgraph update (post)
 """
 
-depsgraph_update_pre: typing.List[typing.Callable[[bpy.types.Scene, None]]]
+depsgraph_update_pre: list[typing.Callable[[bpy.types.Scene, None]]]
 """ on depsgraph update (pre)
 """
 
-frame_change_post: typing.List[typing.Callable[[bpy.types.Scene, None]]]
+frame_change_post: list[typing.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: typing.List[typing.Callable[[bpy.types.Scene, None]]]
+frame_change_pre: list[typing.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: typing.List[typing.Callable[[bpy.types.Scene, None]]]
+load_factory_preferences_post: list[typing.Callable[[bpy.types.Scene, None]]]
 """ on loading factory preferences (after)
 """
 
-load_factory_startup_post: typing.List[typing.Callable[[bpy.types.Scene, None]]]
+load_factory_startup_post: list[typing.Callable[[bpy.types.Scene, None]]]
 """ on loading factory startup (after)
 """
 
-load_post: typing.List[typing.Callable[[bpy.types.Scene, None]]]
+load_post: list[typing.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: typing.List[typing.Callable[[bpy.types.Scene, None]]]
+load_post_fail: list[typing.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: typing.List[typing.Callable[[bpy.types.Scene, None]]]
+load_pre: list[typing.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: typing.List[typing.Callable[[bpy.types.Scene, None]]]
+object_bake_cancel: list[typing.Callable[[bpy.types.Scene, None]]]
 """ on canceling a bake job; will be called in the main thread
 """
 
-object_bake_complete: typing.List[typing.Callable[[bpy.types.Scene, None]]]
+object_bake_complete: list[typing.Callable[[bpy.types.Scene, None]]]
 """ on completing a bake job; will be called in the main thread
 """
 
-object_bake_pre: typing.List[typing.Callable[[bpy.types.Scene, None]]]
+object_bake_pre: list[typing.Callable[[bpy.types.Scene, None]]]
 """ before starting a bake job
 """
 
@@ -123,70 +123,70 @@ persistent: typing.Any
 """ Function decorator for callback functions not to be removed when loading new files
 """
 
-redo_post: typing.List[typing.Callable[[bpy.types.Scene, None]]]
+redo_post: list[typing.Callable[[bpy.types.Scene, None]]]
 """ on loading a redo step (after)
 """
 
-redo_pre: typing.List[typing.Callable[[bpy.types.Scene, None]]]
+redo_pre: list[typing.Callable[[bpy.types.Scene, None]]]
 """ on loading a redo step (before)
 """
 
-render_cancel: typing.List[typing.Callable[[bpy.types.Scene, None]]]
+render_cancel: list[typing.Callable[[bpy.types.Scene, None]]]
 """ on canceling a render job
 """
 
-render_complete: typing.List[typing.Callable[[bpy.types.Scene, None]]]
+render_complete: list[typing.Callable[[bpy.types.Scene, None]]]
 """ on completion of render job
 """
 
-render_init: typing.List[typing.Callable[[bpy.types.Scene, None]]]
+render_init: list[typing.Callable[[bpy.types.Scene, None]]]
 """ on initialization of a render job
 """
 
-render_post: typing.List[typing.Callable[[bpy.types.Scene, None]]]
+render_post: list[typing.Callable[[bpy.types.Scene, None]]]
 """ on render (after)
 """
 
-render_pre: typing.List[typing.Callable[[bpy.types.Scene, None]]]
+render_pre: list[typing.Callable[[bpy.types.Scene, None]]]
 """ on render (before)
 """
 
-render_stats: typing.List[typing.Callable[[bpy.types.Scene, None]]]
+render_stats: list[typing.Callable[[bpy.types.Scene, None]]]
 """ on printing render statistics
 """
 
-render_write: typing.List[typing.Callable[[bpy.types.Scene, None]]]
+render_write: list[typing.Callable[[bpy.types.Scene, None]]]
 """ on writing a render frame (directly after the frame is written)
 """
 
-save_post: typing.List[typing.Callable[[bpy.types.Scene, None]]]
+save_post: list[typing.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: typing.List[typing.Callable[[bpy.types.Scene, None]]]
+save_post_fail: list[typing.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: typing.List[typing.Callable[[bpy.types.Scene, None]]]
+save_pre: list[typing.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: typing.List[typing.Callable[[bpy.types.Scene, None]]]
+translation_update_post: list[typing.Callable[[bpy.types.Scene, None]]]
 """ on translation settings update
 """
 
-undo_post: typing.List[typing.Callable[[bpy.types.Scene, None]]]
+undo_post: list[typing.Callable[[bpy.types.Scene, None]]]
 """ on loading an undo step (after)
 """
 
-undo_pre: typing.List[typing.Callable[[bpy.types.Scene, None]]]
+undo_pre: list[typing.Callable[[bpy.types.Scene, None]]]
 """ on loading an undo step (before)
 """
 
-version_update: typing.List[typing.Callable[[bpy.types.Scene, None]]]
+version_update: list[typing.Callable[[bpy.types.Scene, None]]]
 """ on ending the versioning code
 """
 
-xr_session_start_pre: typing.List[typing.Callable[[bpy.types.Scene, None]]]
+xr_session_start_pre: list[typing.Callable[[bpy.types.Scene, None]]]
 """ on starting an xr session (before)
 """

bpy/app/icons/__init__.pyi

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

bpy/app/timers/__init__.pyi

@@ -34,11 +34,11 @@ import typing
 
 GenericType = typing.TypeVar("GenericType")
 
-def is_registered(function: typing.Optional[int]) -> bool:
+def is_registered(function: int | None) -> bool:
     """Check if this function is registered as a timer.
 
     :param function: Function to check.
-    :type function: typing.Optional[int]
+    :type function: int | None
     :return: True when this function is registered, otherwise False.
     :rtype: bool
     """
@@ -46,9 +46,9 @@ def is_registered(function: typing.Optional[int]) -> bool:
     ...
 
 def register(
-    function: typing.Optional[typing.Callable],
-    first_interval: typing.Optional[float] = 0,
-    persistent: typing.Optional[bool] = False,
+    function: typing.Callable | None,
+    first_interval: float | None = 0,
+    persistent: bool | None = False,
 ):
     """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.
@@ -57,20 +57,20 @@ def register(
     functools.partial can be used to assign some parameters.
 
         :param function: The function that should called.
-        :type function: typing.Optional[typing.Callable]
+        :type function: typing.Callable | None
         :param first_interval: Seconds until the callback should be called the first time.
-        :type first_interval: typing.Optional[float]
+        :type first_interval: float | None
         :param persistent: Don't remove timer when a new file is loaded.
-        :type persistent: typing.Optional[bool]
+        :type persistent: bool | None
     """
 
     ...
 
-def unregister(function: typing.Optional[typing.Any]):
+def unregister(function: typing.Any | None):
     """Unregister timer.
 
     :param function: Function to unregister.
-    :type function: typing.Optional[typing.Any]
+    :type function: typing.Any | None
     """
 
     ...