fake-bpy-module 20240224__py3-none-any.whl → 20240326__py3-none-any.whl

bmesh/utils/__init__.pyi

@@ -3,33 +3,33 @@ import bmesh.types
 
 GenericType = typing.TypeVar("GenericType")
 
-def edge_rotate(edge: "bmesh.types.BMEdge", ccw: bool = False) -> "bmesh.types.BMEdge":
+def edge_rotate(edge: bmesh.types.BMEdge, ccw: bool = False) -> bmesh.types.BMEdge:
     """Rotate the edge and return the newly created edge.
     If rotating the edge fails, None will be returned.
 
         :param edge: The edge to rotate.
-        :type edge: 'bmesh.types.BMEdge'
+        :type edge: bmesh.types.BMEdge
         :param ccw: When True the edge will be rotated counter clockwise.
         :type ccw: bool
-        :rtype: 'bmesh.types.BMEdge'
         :return: The newly rotated edge.
+        :rtype: bmesh.types.BMEdge
     """
 
     ...
 
 def edge_split(
-    edge: "bmesh.types.BMEdge", vert: "bmesh.types.BMVert", fac: float
+    edge: bmesh.types.BMEdge, vert: bmesh.types.BMVert, fac: float
 ) -> typing.Tuple:
     """Split an edge, return the newly created data.
 
     :param edge: The edge to split.
-    :type edge: 'bmesh.types.BMEdge'
+    :type edge: bmesh.types.BMEdge
     :param vert: One of the verts on the edge, defines the split direction.
-    :type vert: 'bmesh.types.BMVert'
+    :type vert: bmesh.types.BMVert
     :param fac: The point on the edge where the new vert will be created [0 - 1].
     :type fac: float
-    :rtype: typing.Tuple
     :return: The newly created (edge, vert) pair.
+    :rtype: typing.Tuple
     """
 
     ...
@@ -39,155 +39,155 @@ def face_flip(faces):
 
     ...
 
-def face_join(faces: "bmesh.types.BMFace", remove: bool = True) -> "bmesh.types.BMFace":
+def face_join(faces: bmesh.types.BMFace, remove: bool = True) -> bmesh.types.BMFace:
     """Joins a sequence of faces.
 
     :param faces: Sequence of faces.
-    :type faces: 'bmesh.types.BMFace'
+    :type faces: bmesh.types.BMFace
     :param remove: Remove the edges and vertices between the faces.
     :type remove: bool
-    :rtype: 'bmesh.types.BMFace'
     :return: The newly created face or None on failure.
+    :rtype: bmesh.types.BMFace
     """
 
     ...
 
 def face_split(
-    face: "bmesh.types.BMFace",
-    vert_a: "bmesh.types.BMVert",
-    vert_b: "bmesh.types.BMVert",
+    face: bmesh.types.BMFace,
+    vert_a: bmesh.types.BMVert,
+    vert_b: bmesh.types.BMVert,
     coords: typing.List[float] = (),
     use_exist: bool = True,
-    example: "bmesh.types.BMEdge" = None,
-) -> typing.Tuple["bmesh.types.BMFace", "bmesh.types.BMLoop"]:
+    example: bmesh.types.BMEdge = None,
+) -> typing.Tuple[bmesh.types.BMFace, bmesh.types.BMLoop]:
     """Face split with optional intermediate points.
 
     :param face: The face to cut.
-    :type face: 'bmesh.types.BMFace'
+    :type face: bmesh.types.BMFace
     :param vert_a: First vertex to cut in the face (face must contain the vert).
-    :type vert_a: 'bmesh.types.BMVert'
+    :type vert_a: bmesh.types.BMVert
     :param vert_b: Second vertex to cut in the face (face must contain the vert).
-    :type vert_b: 'bmesh.types.BMVert'
+    :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]
     :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'
-    :rtype: typing.Tuple['bmesh.types.BMFace', 'bmesh.types.BMLoop']
+    :type example: bmesh.types.BMEdge
     :return: The newly created face or None on failure.
+    :rtype: typing.Tuple[bmesh.types.BMFace, bmesh.types.BMLoop]
     """
 
     ...
 
 def face_split_edgenet(
-    face: "bmesh.types.BMFace", edgenet: "bmesh.types.BMEdge"
-) -> typing.Tuple:
+    face: typing.Union[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.
-    :type face: 'bmesh.types.BMFace'
+    :param face: The face to split.The face to split.
+    :type face: typing.Union[bmesh.types.BMFace, bmesh.types.BMFace]
     :param edgenet: Sequence of edges.
-    :type edgenet: 'bmesh.types.BMEdge'
-    :rtype: typing.Tuple
+    :type edgenet: bmesh.types.BMEdge
     :return: The newly created faces.
     """
 
     ...
 
 def face_vert_separate(
-    face: "bmesh.types.BMFace", vert: "bmesh.types.BMVert"
-) -> "bmesh.types.BMVert":
+    face: bmesh.types.BMFace, vert: bmesh.types.BMVert
+) -> bmesh.types.BMVert:
     """Rip a vertex in a face away and add a new vertex.
 
     :param face: The face to separate.
-    :type face: 'bmesh.types.BMFace'
+    :type face: bmesh.types.BMFace
     :param vert: A vertex in the face to separate.
-    :type vert: 'bmesh.types.BMVert'
-    :rtype: 'bmesh.types.BMVert'
+    :type vert: bmesh.types.BMVert
     :return: The newly created vertex or None on failure.
+    :rtype: bmesh.types.BMVert
     """
 
     ...
 
-def loop_separate(loop: "bmesh.types.BMLoop") -> "bmesh.types.BMVert":
+def loop_separate(loop: bmesh.types.BMLoop) -> bmesh.types.BMVert:
     """Rip a vertex in a face away and add a new vertex.
 
     :param loop: The loop to separate.
-    :type loop: 'bmesh.types.BMLoop'
-    :rtype: 'bmesh.types.BMVert'
+    :type loop: bmesh.types.BMLoop
     :return: The newly created vertex or None on failure.
+    :rtype: bmesh.types.BMVert
     """
 
     ...
 
 def vert_collapse_edge(
-    vert: "bmesh.types.BMVert", edge: "bmesh.types.BMEdge"
-) -> "bmesh.types.BMEdge":
+    vert: bmesh.types.BMVert, edge: bmesh.types.BMEdge
+) -> bmesh.types.BMEdge:
     """Collapse a vertex into an edge.
 
     :param vert: The vert that will be collapsed.
-    :type vert: 'bmesh.types.BMVert'
+    :type vert: bmesh.types.BMVert
     :param edge: The edge to collapse into.
-    :type edge: 'bmesh.types.BMEdge'
-    :rtype: 'bmesh.types.BMEdge'
+    :type edge: bmesh.types.BMEdge
     :return: The resulting edge from the collapse operation.
+    :rtype: bmesh.types.BMEdge
     """
 
     ...
 
 def vert_collapse_faces(
-    vert: "bmesh.types.BMVert", edge: "bmesh.types.BMEdge", fac: float, join_faces: bool
-) -> "bmesh.types.BMEdge":
+    vert: bmesh.types.BMVert, edge: bmesh.types.BMEdge, fac: float, join_faces: bool
+) -> bmesh.types.BMEdge:
     """Collapses a vertex that has only two manifold edges onto a vertex it shares an edge with.
 
     :param vert: The vert that will be collapsed.
-    :type vert: 'bmesh.types.BMVert'
+    :type vert: bmesh.types.BMVert
     :param edge: The edge to collapse into.
-    :type edge: 'bmesh.types.BMEdge'
+    :type edge: bmesh.types.BMEdge
     :param fac: The factor to use when merging customdata [0 - 1].
     :type fac: float
     :param join_faces: When true the faces around the vertex will be joined otherwise collapse the vertex by merging the 2 edges this vertex connects to into one.
     :type join_faces: bool
-    :rtype: 'bmesh.types.BMEdge'
     :return: The resulting edge from the collapse operation.
+    :rtype: bmesh.types.BMEdge
     """
 
     ...
 
-def vert_dissolve(vert: "bmesh.types.BMVert") -> bool:
+def vert_dissolve(vert: bmesh.types.BMVert) -> bool:
     """Dissolve this vertex (will be removed).
 
     :param vert: The vert to be dissolved.
-    :type vert: 'bmesh.types.BMVert'
-    :rtype: bool
+    :type vert: bmesh.types.BMVert
     :return: True when the vertex dissolve is successful.
+    :rtype: bool
     """
 
     ...
 
 def vert_separate(
-    vert: "bmesh.types.BMVert", edges: "bmesh.types.BMEdge"
-) -> typing.Tuple["bmesh.types.BMVert"]:
+    vert: bmesh.types.BMVert, edges: bmesh.types.BMEdge
+) -> typing.Tuple[bmesh.types.BMVert]:
     """Separate this vertex at every edge.
 
     :param vert: The vert to be separated.
-    :type vert: 'bmesh.types.BMVert'
+    :type vert: bmesh.types.BMVert
     :param edges: The edges to separated.
-    :type edges: 'bmesh.types.BMEdge'
-    :rtype: typing.Tuple['bmesh.types.BMVert']
+    :type edges: bmesh.types.BMEdge
     :return: The newly separated verts (including the vertex passed).
+    :rtype: typing.Tuple[bmesh.types.BMVert]
     """
 
     ...
 
-def vert_splice(vert: "bmesh.types.BMVert", vert_target: "bmesh.types.BMVert"):
+def vert_splice(vert: bmesh.types.BMVert, vert_target: bmesh.types.BMVert):
     """Splice vert into vert_target.
 
     :param vert: The vertex to be removed.
-    :type vert: 'bmesh.types.BMVert'
+    :type vert: bmesh.types.BMVert
     :param vert_target: The vertex to use.
-    :type vert_target: 'bmesh.types.BMVert'
+    :type vert_target: bmesh.types.BMVert
     """
 
     ...

bpy/__init__.pyi

@@ -10,8 +10,8 @@ from . import types
 from . import utils
 
 GenericType = typing.TypeVar("GenericType")
-context: "bpy.types.Context"
+context: bpy.types.Context
 
-data: "bpy.types.BlendData"
+data: bpy.types.BlendData
 """ Access to Blender's internal data
 """

bpy/app/__init__.pyi

@@ -6,21 +6,20 @@ from . import translations
 
 GenericType = typing.TypeVar("GenericType")
 
-def help_text(all: typing.Optional[bool] = False):
+def help_text(all: bool = 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
     """
 
     ...
 
-def is_job_running(job_type: typing.Optional[str]) -> typing.Any:
+def is_job_running(job_type: str):
     """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]
-    :rtype: typing.Any
+    :type job_type: str
     :return: Whether a job of the given type is currently running.
     """
 

bpy/app/handlers/__init__.pyi

@@ -2,79 +2,79 @@ import typing
 import bpy.types
 
 GenericType = typing.TypeVar("GenericType")
-animation_playback_post: typing.List[typing.Callable[["bpy.types.Scene"], None]]
+animation_playback_post: typing.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: typing.List[typing.Callable[[bpy.types.Scene, None]]]
 """ on starting animation playback
 """
 
-annotation_post: typing.List[typing.Callable[["bpy.types.Scene"], None]]
+annotation_post: typing.List[typing.Callable[[bpy.types.Scene, None]]]
 """ on drawing an annotation (after)
 """
 
-annotation_pre: typing.List[typing.Callable[["bpy.types.Scene"], None]]
+annotation_pre: typing.List[typing.Callable[[bpy.types.Scene, None]]]
 """ on drawing an annotation (before)
 """
 
-composite_cancel: typing.List[typing.Callable[["bpy.types.Scene"], None]]
+composite_cancel: typing.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: typing.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: typing.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: typing.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: typing.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: typing.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: typing.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: typing.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: typing.List[typing.Callable[[bpy.types.Scene, None]]]
 """ on loading factory startup (after)
 """
 
-load_post: typing.List[typing.Callable[["bpy.types.Scene"], None]]
+load_post: typing.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: typing.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: typing.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: typing.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: typing.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: typing.List[typing.Callable[[bpy.types.Scene, None]]]
 """ before starting a bake job
 """
 
@@ -82,70 +82,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: typing.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: typing.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: typing.List[typing.Callable[[bpy.types.Scene, None]]]
 """ on canceling a render job
 """
 
-render_complete: typing.List[typing.Callable[["bpy.types.Scene"], None]]
+render_complete: typing.List[typing.Callable[[bpy.types.Scene, None]]]
 """ on completion of render job
 """
 
-render_init: typing.List[typing.Callable[["bpy.types.Scene"], None]]
+render_init: typing.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: typing.List[typing.Callable[[bpy.types.Scene, None]]]
 """ on render (after)
 """
 
-render_pre: typing.List[typing.Callable[["bpy.types.Scene"], None]]
+render_pre: typing.List[typing.Callable[[bpy.types.Scene, None]]]
 """ on render (before)
 """
 
-render_stats: typing.List[typing.Callable[["bpy.types.Scene"], None]]
+render_stats: typing.List[typing.Callable[[bpy.types.Scene, None]]]
 """ on printing render statistics
 """
 
-render_write: typing.List[typing.Callable[["bpy.types.Scene"], None]]
+render_write: typing.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: typing.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: typing.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: typing.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: typing.List[typing.Callable[[bpy.types.Scene, None]]]
 """ on translation settings update
 """
 
-undo_post: typing.List[typing.Callable[["bpy.types.Scene"], None]]
+undo_post: typing.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: typing.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: typing.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: typing.List[typing.Callable[[bpy.types.Scene, None]]]
 """ on starting an xr session (before)
 """

bpy/app/icons/__init__.pyi

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

bpy/app/timers/__init__.pyi

@@ -2,21 +2,19 @@ import typing
 
 GenericType = typing.TypeVar("GenericType")
 
-def is_registered(function: typing.Optional[int]) -> bool:
+def is_registered(function: int) -> bool:
     """Check if this function is registered as a timer.
 
     :param function: Function to check.
-    :type function: typing.Optional[int]
-    :rtype: bool
+    :type function: int
     :return: True when this function is registered, otherwise False.
+    :rtype: bool
     """
 
     ...
 
 def register(
-    function: typing.Optional[typing.Callable],
-    first_interval: typing.Optional[float] = 0,
-    persistent: typing.Optional[bool] = False,
+    function: typing.Callable, first_interval: float = 0, persistent: bool = 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.
@@ -25,20 +23,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
         :param first_interval: Seconds until the callback should be called the first time.
-        :type first_interval: typing.Optional[float]
+        :type first_interval: float
         :param persistent: Don't remove timer when a new file is loaded.
-        :type persistent: typing.Optional[bool]
+        :type persistent: bool
     """
 
     ...
 
-def unregister(function: typing.Optional[typing.Any]):
+def unregister(function: typing.Any):
     """Unregister timer.
 
     :param function: Function to unregister.
-    :type function: typing.Optional[typing.Any]
+    :type function: typing.Any
     """
 
     ...