fake-bpy-module 20241102__py3-none-any.whl → 20241111__py3-none-any.whl

bmesh/types/__init__.pyi

@@ -46,20 +46,18 @@ class BMDeformVert:
                 :return: (key, value) pairs for each deform weight of this vertex.
         """
 
-    def keys(self) -> list[int]:
+    def keys(self):
         """Return the group indices used by this vertex
         (matching Python's dict.keys() functionality).
 
                 :return: the deform group this vertex uses
-                :rtype: list[int]
         """
 
-    def values(self) -> list[float]:
+    def values(self):
         """Return the weights of the deform vertex
         (matching Python's dict.values() functionality).
 
                 :return: The weights that influence this vertex
-                :rtype: list[float]
         """
 
 class BMEdge:
@@ -155,22 +153,20 @@ class BMEdge:
     :type: BMElemSeq[BMVert]
     """
 
-    def calc_face_angle(self, fallback: typing.Any | None = None) -> float:
+    def calc_face_angle(self, fallback=None) -> float:
         """
 
                 :param fallback: return this when the edge doesn't have 2 faces
         (instead of raising a `ValueError`).
-                :type fallback: typing.Any | None
                 :return: The angle between 2 connected faces in radians.
                 :rtype: float
         """
 
-    def calc_face_angle_signed(self, fallback: typing.Any | None = None) -> float:
+    def calc_face_angle_signed(self, fallback=None) -> float:
         """
 
                 :param fallback: return this when the edge doesn't have 2 faces
         (instead of raising a `ValueError`).
-                :type fallback: typing.Any | None
                 :return: The angle between 2 connected faces in radians (negative for concave join).
                 :rtype: float
         """
@@ -210,13 +206,12 @@ class BMEdge:
     def normal_update(self):
         """Update normals of all connected faces and the edge verts."""
 
-    def other_vert(self, vert: BMVert) -> BMVert:
+    def other_vert(self, vert: BMVert):
         """Return the other vertex on this edge or None if the vertex is not used by this edge.
 
         :param vert: a vert in this edge.
         :type vert: BMVert
         :return: The edges other vert.
-        :rtype: BMVert
         """
 
     def select_set(self, select: bool):
@@ -266,11 +261,10 @@ class BMEdgeSeq:
     def ensure_lookup_table(self):
         """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: list[BMVert], fallback=None) -> BMEdge:
+    def get(self, verts, fallback=None) -> BMEdge:
         """Return an edge which uses the verts passed.
 
         :param verts: Sequence of verts.
-        :type verts: list[BMVert]
         :param fallback: Return this value if nothing is found.
         :return: The edge found or None
         :rtype: BMEdge
@@ -279,13 +273,10 @@ class BMEdgeSeq:
     def index_update(self):
         """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: tuple[BMVert, BMVert], example: BMEdge | None = 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.
-        :type verts: tuple[BMVert, BMVert]
         :param example: Existing edge to initialize settings (optional argument).
         :type example: BMEdge | None
         :return: The newly created edge.
@@ -299,11 +290,12 @@ class BMEdgeSeq:
         :type edge: BMEdge
         """
 
-    def sort(self, key=None, reverse: bool = False):
+    def sort(self, key: collections.abc.Callable | None = None, reverse: bool = False):
         """Sort the elements of this sequence, using an optional custom sort key.
         Indices of elements are not changed, `BMElemSeq.index_update` can be used for that.
 
                 :param key: The key that sets the ordering of the elements.
+                :type key: collections.abc.Callable | None
                 :param reverse: Reverse the order of the elements
                 :type reverse: bool
         """
@@ -647,11 +639,10 @@ class BMFaceSeq:
     def ensure_lookup_table(self):
         """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: list[BMVert], fallback=None) -> BMFace:
+    def get(self, verts, fallback=None) -> BMFace:
         """Return a face which uses the verts passed.
 
         :param verts: Sequence of verts.
-        :type verts: list[BMVert]
         :param fallback: Return this value if nothing is found.
         :return: The face found or None
         :rtype: BMFace
@@ -660,11 +651,10 @@ class BMFaceSeq:
     def index_update(self):
         """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: list[BMVert], example: BMFace | None = None) -> BMFace:
+    def new(self, verts, 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: list[BMVert]
         :param example: Existing face to initialize settings (optional argument).
         :type example: BMFace | None
         :return: The newly created face.
@@ -678,11 +668,12 @@ class BMFaceSeq:
         :type face: BMFace
         """
 
-    def sort(self, key=None, reverse: bool = False):
+    def sort(self, key: collections.abc.Callable | None = None, reverse: bool = False):
         """Sort the elements of this sequence, using an optional custom sort key.
         Indices of elements are not changed, `BMElemSeq.index_update` can be used for that.
 
                 :param key: The key that sets the ordering of the elements.
+                :type key: collections.abc.Callable | None
                 :param reverse: Reverse the order of the elements
                 :type reverse: bool
         """
@@ -967,12 +958,11 @@ class BMLayerCollection[_GenericType1]:
                 :rtype: list[str, BMLayerItem[_GenericType1]]
         """
 
-    def keys(self) -> list[str]:
+    def keys(self):
         """Return the identifiers of collection members
         (matching Python's dict.keys() functionality).
 
                 :return: the identifiers for each member of this collection.
-                :rtype: list[str]
         """
 
     def new(self, name: str | None = "") -> BMLayerItem[_GenericType1]:
@@ -1317,12 +1307,11 @@ class BMVert:
     :type: bool
     """
 
-    def calc_edge_angle(self, fallback: typing.Any | None = None) -> float:
+    def calc_edge_angle(self, fallback=None) -> float:
         """Return the angle between this vert's two connected edges.
 
                 :param fallback: return this when the vert doesn't have 2 edges
         (instead of raising a `ValueError`).
-                :type fallback: typing.Any | None
                 :return: Angle between edges in radians.
                 :rtype: float
         """
@@ -1350,11 +1339,10 @@ class BMVert:
         :type face: BMFace
         """
 
-    def copy_from_vert_interp(self, vert_pair: tuple[BMVert, BMVert], fac: float):
+    def copy_from_vert_interp(self, vert_pair, fac: float):
         """Interpolate the customdata from a vert between 2 other verts.
 
         :param vert_pair: The verts between which to interpolate data from.
-        :type vert_pair: tuple[BMVert, BMVert]
         :param fac:
         :type fac: float
         """
@@ -1445,11 +1433,12 @@ class BMVertSeq:
         :type vert: BMVert
         """
 
-    def sort(self, key=None, reverse: bool = False):
+    def sort(self, key: collections.abc.Callable | None = None, reverse: bool = False):
         """Sort the elements of this sequence, using an optional custom sort key.
         Indices of elements are not changed, `BMElemSeq.index_update` can be used for that.
 
                 :param key: The key that sets the ordering of the elements.
+                :type key: collections.abc.Callable | None
                 :param reverse: Reverse the order of the elements
                 :type reverse: bool
         """
@@ -1539,10 +1528,11 @@ class BMesh:
     :type: BMVertSeq
     """
 
-    def calc_loop_triangles(self):
+    def calc_loop_triangles(self) -> BMLoop:
         """Calculate triangle tessellation from quads/ngons.
 
         :return: The triangulated faces.
+        :rtype: BMLoop
         """
 
     def calc_volume(self, signed: bool = False) -> float:
@@ -1635,12 +1625,11 @@ class BMesh:
         self,
         matrix: collections.abc.Sequence[collections.abc.Sequence[float]]
         | mathutils.Matrix,
-        filter: set | None = None,
+        filter=None,
     ):
         """Transform the mesh (optionally filtering flagged data only).
 
-        :param matrix: transform matrix.
+        :param matrix: 4x4x transform matrix.
         :type matrix: collections.abc.Sequence[collections.abc.Sequence[float]] | mathutils.Matrix
         :param filter: set of values in ('SELECT', 'HIDE', 'SEAM', 'SMOOTH', 'TAG').
-        :type filter: set | None
         """

bmesh/utils/__init__.pyi

@@ -20,7 +20,7 @@ def edge_rotate(edge: bmesh.types.BMEdge, ccw: bool = False) -> bmesh.types.BMEd
         :rtype: bmesh.types.BMEdge
     """
 
-def edge_split(edge: bmesh.types.BMEdge, vert: bmesh.types.BMVert, fac: float) -> tuple:
+def edge_split(edge: bmesh.types.BMEdge, vert: bmesh.types.BMVert, fac: float):
     """Split an edge, return the newly created data.
 
     :param edge: The edge to split.
@@ -30,7 +30,6 @@ def edge_split(edge: bmesh.types.BMEdge, vert: bmesh.types.BMVert, fac: float) -
     :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: tuple
     """
 
 def face_flip(faces):
@@ -51,10 +50,10 @@ def face_split(
     face: bmesh.types.BMFace,
     vert_a: bmesh.types.BMVert,
     vert_b: bmesh.types.BMVert,
-    coords: list[float] = (),
+    coords=(),
     use_exist: bool = True,
     example: bmesh.types.BMEdge | None = None,
-) -> tuple[bmesh.types.BMFace, bmesh.types.BMLoop]:
+):
     """Face split with optional intermediate points.
 
     :param face: The face to cut.
@@ -63,27 +62,21 @@ def face_split(
     :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
-    :param coords: Optional argument to define points in between vert_a and vert_b.
-    :type coords: list[float]
+    :param coords: Optional sequence of 3D points in between vert_a and vert_b.
     :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 | None
     :return: The newly created face or None on failure.
-    :rtype: tuple[bmesh.types.BMFace, bmesh.types.BMLoop]
     """
 
-def face_split_edgenet(
-    face: bmesh.types.BMFace, edgenet: bmesh.types.BMEdge
-) -> tuple[bmesh.types.BMFace, ...]:
+def face_split_edgenet(face: bmesh.types.BMFace, edgenet):
     """Splits a face into any number of regions defined by an edgenet.
 
     :param face: The face to split.The face to split.
     :type face: bmesh.types.BMFace
     :param edgenet: Sequence of edges.
-    :type edgenet: bmesh.types.BMEdge
     :return: The newly created faces.
-    :rtype: tuple[bmesh.types.BMFace, ...]
     """
 
 def face_vert_separate(
@@ -147,9 +140,7 @@ def vert_dissolve(vert: bmesh.types.BMVert) -> bool:
     :rtype: bool
     """
 
-def vert_separate(
-    vert: bmesh.types.BMVert, edges: bmesh.types.BMEdge
-) -> tuple[bmesh.types.BMVert, ...]:
+def vert_separate(vert: bmesh.types.BMVert, edges: bmesh.types.BMEdge):
     """Separate this vertex at every edge.
 
     :param vert: The vert to be separated.
@@ -157,7 +148,6 @@ def vert_separate(
     :param edges: The edges to separated.
     :type edges: bmesh.types.BMEdge
     :return: The newly separated verts (including the vertex passed).
-    :rtype: tuple[bmesh.types.BMVert, ...]
     """
 
 def vert_splice(vert: bmesh.types.BMVert, vert_target: bmesh.types.BMVert):

bpy/app/icons/__init__.pyi

@@ -2,28 +2,22 @@ import typing
 import collections.abc
 import typing_extensions
 
-def new_triangles(
-    range: tuple | None,
-    coords: collections.abc.Sequence[bytes] | None,
-    colors: collections.abc.Sequence[bytes] | None,
-) -> int:
+def new_triangles(range, coords: bytes | None, colors: 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: collections.abc.Sequence[bytes] | None
-    :param colors: Sequence of ints (12 for one triangles) for RGBA.
-    :type colors: collections.abc.Sequence[bytes] | None
+    :type coords: bytes | None
+    :param colors: Sequence of bytes (12 for one triangles) for RGBA.
+    :type colors: bytes | None
     :return: Unique icon value (pass to interface icon_value argument).
     :rtype: int
     """
 
-def new_triangles_from_file(filepath: str | None) -> int:
+def new_triangles_from_file(filepath) -> int:
     """Create a new icon from triangle geometry.
 
     :param filepath: File path.
-    :type filepath: str | None
     :return: Unique icon value (pass to interface icon_value argument).
     :rtype: int
     """

bpy/app/translations/__init__.pyi

@@ -67,74 +67,67 @@ def locale_explode(locale):
     :return: A tuple (language, country, variant, language_country, language@variant).
     """
 
-def pgettext(msgid: str | None, msgctxt: str | None = None):
+def pgettext(msgid: str | None, msgctxt=None):
     """Try to translate the given msgid (with optional msgctxt).
 
     :param msgid: The string to translate.
     :type msgid: str | None
     :param msgctxt: The translation context (defaults to BLT_I18NCONTEXT_DEFAULT).
-    :type msgctxt: str | None
     :return: The translated string (or msgid if no translation was found).
     """
 
-def pgettext_data(msgid: str | None, msgctxt: str | None = None):
+def pgettext_data(msgid: str | None, msgctxt=None):
     """Try to translate the given msgid (with optional msgctxt), if new data name's translation is enabled.
 
     :param msgid: The string to translate.
     :type msgid: str | None
     :param msgctxt: The translation context (defaults to BLT_I18NCONTEXT_DEFAULT).
-    :type msgctxt: str | None
     :return: The translated string (or msgid if no translation was found).
     """
 
-def pgettext_iface(msgid: str | None, msgctxt: str | None = None):
+def pgettext_iface(msgid: str | None, msgctxt=None):
     """Try to translate the given msgid (with optional msgctxt), if labels' translation is enabled.
 
     :param msgid: The string to translate.
     :type msgid: str | None
     :param msgctxt: The translation context (defaults to BLT_I18NCONTEXT_DEFAULT).
-    :type msgctxt: str | None
     :return: The translated string (or msgid if no translation was found).
     """
 
-def pgettext_n(msgid: str | None, msgctxt: str | None = None):
+def pgettext_n(msgid: str | None, msgctxt=None):
     """Extract the given msgid to translation files. This is a no-op function that will only mark the string to extract, but not perform the actual translation.
 
     :param msgid: The string to extract.
     :type msgid: str | None
     :param msgctxt: The translation context (defaults to BLT_I18NCONTEXT_DEFAULT).
-    :type msgctxt: str | None
     :return: The original string.
     """
 
-def pgettext_rpt(msgid: str | None, msgctxt: str | None = None):
+def pgettext_rpt(msgid: str | None, msgctxt=None):
     """Try to translate the given msgid (with optional msgctxt), if reports' translation is enabled.
 
     :param msgid: The string to translate.
     :type msgid: str | None
     :param msgctxt: The translation context (defaults to BLT_I18NCONTEXT_DEFAULT).
-    :type msgctxt: str | None
     :return: The translated string (or msgid if no translation was found).
     """
 
-def pgettext_tip(msgid: str | None, msgctxt: str | None = None):
+def pgettext_tip(msgid: str | None, msgctxt=None):
     """Try to translate the given msgid (with optional msgctxt), if tooltips' translation is enabled.
 
     :param msgid: The string to translate.
     :type msgid: str | None
     :param msgctxt: The translation context (defaults to BLT_I18NCONTEXT_DEFAULT).
-    :type msgctxt: str | None
     :return: The translated string (or msgid if no translation was found).
     """
 
-def register(module_name: str | None, translations_dict: dict | None):
+def register(module_name: str | None, translations_dict):
     """Registers an addon's UI translations.
 
         :param module_name: The name identifying the addon.
         :type module_name: str | None
         :param translations_dict: A dictionary built like that:
     {locale: {msg_key: msg_translation, ...}, ...}
-        :type translations_dict: dict | None
     """
 
 def unregister(module_name: str | None):

bpy/msgbus/__init__.pyi

@@ -59,23 +59,22 @@ def publish_rna(key):
         :param key: Represents the type of data being subscribed to
 
     Arguments include
-    - `bpy.types.Property` instance.
-    - `bpy.types.Struct` type.
-    - (`bpy.types.Struct`, str) type and property name.
+    - A property instance.
+    - A struct type.
+    - A tuple representing a (struct, property name) pair.
     """
 
-def subscribe_rna(key, owner: typing.Any | None, args, notify, options=set()):
+def subscribe_rna(key, owner, args, notify, options=set()):
     """Register a message bus subscription. It will be cleared when another blend file is
     loaded, or can be cleared explicitly via `bpy.msgbus.clear_by_owner`.
 
         :param key: Represents the type of data being subscribed to
 
     Arguments include
-    - `bpy.types.Property` instance.
-    - `bpy.types.Struct` type.
-    - (`bpy.types.Struct`, str) type and property name.
+    - A property instance.
+    - A struct type.
+    - A tuple representing a (struct, property name) pair.
         :param owner: Handle for this subscription (compared by identity).
-        :type owner: typing.Any | None
         :param options: Change the behavior of the subscriber.
 
     PERSISTENT when set, the subscriber will be kept when remapping ID data.

bpy/ops/curves/__init__.pyi

@@ -402,6 +402,22 @@ def select_linked(
     :type undo: bool | None
     """
 
+def select_linked_pick(
+    override_context: bpy.types.Context | dict[str, typing.Any] | None = None,
+    execution_context: int | str | None = None,
+    undo: bool | None = None,
+    *,
+    deselect: bool | None = False,
+):
+    """Select all points in the curve under the cursor
+
+    :type override_context: bpy.types.Context | dict[str, typing.Any] | None
+    :type execution_context: int | str | None
+    :type undo: bool | None
+    :param deselect: Deselect, Deselect linked control points rather than selecting them
+    :type deselect: bool | None
+    """
+
 def select_more(
     override_context: bpy.types.Context | dict[str, typing.Any] | None = None,
     execution_context: int | str | None = None,

bpy/ops/nla/__init__.pyi

@@ -116,7 +116,7 @@ def bake(
         :type only_selected: bool | None
         :param visual_keying: Visual Keying, Keyframe from the final transformations (with constraints applied)
         :type visual_keying: bool | None
-        :param clear_constraints: Clear Constraints, Remove all constraints from keyed object/bones, and do 'visual' keying
+        :param clear_constraints: Clear Constraints, Remove all constraints from keyed object/bones. To get a correct bake with this setting Visual Keying should be enabled
         :type clear_constraints: bool | None
         :param clear_parents: Clear Parents, Bake animation onto the object then clear parents (objects only)
         :type clear_parents: bool | None

bpy/ops/sequencer/__init__.pyi

@@ -1606,6 +1606,7 @@ def select_box(
     ymax: int | None = 0,
     wait_for_input: bool | None = True,
     mode: typing.Literal["SET", "ADD", "SUB"] | None = "SET",
+    tweak: bool | None = False,
     include_handles: bool | None = False,
     ignore_connections: bool | None = False,
 ):
@@ -1635,6 +1636,8 @@ def select_box(
     SUB
     Subtract -- Subtract existing selection.
         :type mode: typing.Literal['SET','ADD','SUB'] | None
+        :param tweak: Tweak, Make box select pass through to sequence slide when the cursor is hovering on a strip
+        :type tweak: bool | None
         :param include_handles: Select Handles, Select the strips and their handles
         :type include_handles: bool | None
         :param ignore_connections: Ignore Connections, Select strips individually whether or not they are connected

bpy/path/__init__.pyi

@@ -9,15 +9,12 @@ import collections.abc
 import typing_extensions
 import bpy.types
 
-def abspath(
-    path, *, start: bytes | str | None = None, library: bpy.types.Library | None = None
-) -> str:
+def abspath(path, *, start=None, library: bpy.types.Library | None = None) -> str:
     """Returns the absolute path relative to the current blend file
     using the "//" prefix.
 
         :param start: Relative to this path,
     when not set the current filename is used.
-        :type start: bytes | str | None
         :param library: The library this path is from. This is only included for
     convenience, when the library is not None its path replaces start.
         :type library: bpy.types.Library | None
@@ -32,14 +29,13 @@ def basename(path) -> str:
     :rtype: str
     """
 
-def clean_name(name: bytes | str, *, replace: str = "_") -> str:
+def clean_name(name, *, replace: str = "_") -> str:
     """Returns a name with characters replaced that
     may cause problems under various circumstances,
     such as writing to a file.All characters besides A-Z/a-z, 0-9 are replaced with "_"
     or the replace argument if defined.
 
         :param name: The path name.
-        :type name: bytes | str
         :param replace: The replacement for non-valid characters.
         :type replace: str
         :return: The cleaned name.
@@ -94,17 +90,16 @@ def ensure_ext(filepath: str, ext: str, *, case_sensitive: bool = False) -> str:
         :rtype: str
     """
 
-def is_subdir(path: bytes | str, directory) -> bool:
+def is_subdir(path, directory) -> bool:
     """Returns true if path in a subdirectory of directory.
     Both paths must be absolute.
 
         :param path: An absolute path.
-        :type path: bytes | str
         :return: Whether or not the path is a subdirectory.
         :rtype: bool
     """
 
-def module_names(path: str, *, recursive: bool = False, package: str = "") -> list[str]:
+def module_names(path: str, *, recursive: bool = False, package: str = ""):
     """Return a list of modules which can be imported from path.
 
     :param path: a directory to scan.
@@ -114,7 +109,6 @@ def module_names(path: str, *, recursive: bool = False, package: str = "") -> li
     :param package: Optional string, used as the prefix for module names (without the trailing ".").
     :type package: str
     :return: a list of string pairs (module_name, module_file).
-    :rtype: list[str]
     """
 
 def native_pathsep(path: str) -> str:
@@ -126,25 +120,21 @@ def native_pathsep(path: str) -> str:
     :rtype: str
     """
 
-def reduce_dirs(dirs: list[str]) -> list[str]:
+def reduce_dirs(dirs):
     """Given a sequence of directories, remove duplicates and
     any directories nested in one of the other paths.
     (Useful for recursive path searching).
 
         :param dirs: Sequence of directory paths.
-        :type dirs: list[str]
         :return: A unique list of paths.
-        :rtype: list[str]
     """
 
-def relpath(path: bytes | str, *, start: bytes | str | None = None) -> str:
+def relpath(path, *, start=None) -> str:
     """Returns the path relative to the current blend file using the "//" prefix.
 
         :param path: An absolute path.
-        :type path: bytes | str
         :param start: Relative to this path,
     when not set the current filename is used.
-        :type start: bytes | str | None
         :return: The relative path.
         :rtype: str
     """