fake-bpy-module 20250102__py3-none-any.whl → 20250104__py3-none-any.whl

bmesh/ops/__init__.pyi

@@ -1061,7 +1061,7 @@ def grid_fill(
 def holes_fill(
     bm: bmesh.types.BMesh, edges: list[bmesh.types.BMEdge] = [], sides: int = 0
 ) -> dict[str, typing.Any]:
-    """Fill Holes.Fill boundary edges with faces, copying surrounding customdata.
+    """Fill Holes.Fill boundary edges with faces, copying surrounding custom-data.
 
         :param bm: The bmesh to operate on.
         :type bm: bmesh.types.BMesh

bmesh/utils/__init__.pyi

@@ -77,7 +77,7 @@ def face_split(
 
 def face_split_edgenet(
     face: bmesh.types.BMFace, edgenet: collections.abc.Sequence[bmesh.types.BMEdge]
-) -> tuple[bmesh.types.BMFace, int]:
+) -> tuple[bmesh.types.BMFace, ...]:
     """Splits a face into any number of regions defined by an edgenet.
 
     :param face: The face to split.The face to split.
@@ -85,7 +85,7 @@ def face_split_edgenet(
     :param edgenet: Sequence of edges.
     :type edgenet: collections.abc.Sequence[bmesh.types.BMEdge]
     :return: The newly created faces.
-    :rtype: tuple[bmesh.types.BMFace, int]
+    :rtype: tuple[bmesh.types.BMFace, ...]
     """
 
 def face_vert_separate(
@@ -151,7 +151,7 @@ def vert_dissolve(vert: bmesh.types.BMVert) -> bool:
 
 def vert_separate(
     vert: bmesh.types.BMVert, edges: bmesh.types.BMEdge
-) -> tuple[bmesh.types.BMVert, int]:
+) -> tuple[bmesh.types.BMVert, ...]:
     """Separate this vertex at every edge.
 
     :param vert: The vert to be separated.
@@ -159,7 +159,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: tuple[bmesh.types.BMVert, int]
+    :rtype: tuple[bmesh.types.BMVert, ...]
     """
 
 def vert_splice(vert: bmesh.types.BMVert, vert_target: bmesh.types.BMVert):

bpy/ops/wm/__init__.pyi

@@ -4950,6 +4950,18 @@ def usd_export(
     | None = "KEEP",
     usdz_downscale_custom_size: int | None = 128,
     merge_parent_xform: bool | None = False,
+    convert_scene_units: typing.Literal[
+        "METERS",
+        "KILOMETERS",
+        "CENTIMETERS",
+        "MILLIMETERS",
+        "INCHES",
+        "FEET",
+        "YARDS",
+        "CUSTOM",
+    ]
+    | None = "METERS",
+    meters_per_unit: float | None = 1.0,
 ):
     """Export current scene in a USD archive
 
@@ -5191,6 +5203,34 @@ def usd_export(
         :type usdz_downscale_custom_size: int | None
         :param merge_parent_xform: Merge parent Xform, Merge USD primitives with their Xform parent if possible. USD does not allow nested UsdGeomGprims, intermediary Xform prims will be defined to keep the USD file valid when encountering object hierarchies.
         :type merge_parent_xform: bool | None
+        :param convert_scene_units: Units, Set the USD Stage meters per unit to the chosen measurement, or a custom value
+
+    METERS
+    Meters -- Scene meters per unit to 1.0.
+
+    KILOMETERS
+    Kilometers -- Scene meters per unit to 1000.0.
+
+    CENTIMETERS
+    Centimeters -- Scene meters per unit to 0.01.
+
+    MILLIMETERS
+    Millimeters -- Scene meters per unit to 0.001.
+
+    INCHES
+    Inches -- Scene meters per unit to 0.0254.
+
+    FEET
+    Feet -- Scene meters per unit to 0.3048.
+
+    YARDS
+    Yards -- Scene meters per unit to 0.9144.
+
+    CUSTOM
+    Custom -- Specify a custom scene meters per unit value.
+        :type convert_scene_units: typing.Literal['METERS','KILOMETERS','CENTIMETERS','MILLIMETERS','INCHES','FEET','YARDS','CUSTOM'] | None
+        :param meters_per_unit: Meters Per Unit, Custom value for meters per unit in the USD Stage
+        :type meters_per_unit: float | None
     """
 
 def usd_import(
@@ -5266,6 +5306,7 @@ def usd_import(
     create_world_material: bool | None = True,
     import_defined_only: bool | None = True,
     merge_parent_xform: bool | None = True,
+    apply_unit_conversion_scale: bool | None = True,
 ):
     """Import USD stage into current scene
 
@@ -5443,6 +5484,8 @@ def usd_import(
         :type import_defined_only: bool | None
         :param merge_parent_xform: Merge parent Xform, Allow USD primitives to merge with their Xform parent if they are the only child in the hierarchy
         :type merge_parent_xform: bool | None
+        :param apply_unit_conversion_scale: Apply Unit Conversion Scale, Scale the scene objects by the USD stage's meters per unit value. This scaling is applied in addition to the value specified in the Scale option
+        :type apply_unit_conversion_scale: bool | None
     """
 
 def window_close(execution_context: int | str | None = None, undo: bool | None = None):

bpy/props/__init__.pyi

@@ -107,8 +107,8 @@ def BoolProperty(
     description: str | None = "",
     translation_context: str | None = "*",
     default=False,
-    options: bpy.typing.PropertyFlagItems = {"ANIMATABLE"},
-    override: bpy.typing.PropertyOverrideFlagItems = set(),
+    options: set[bpy.typing.PropertyFlagItems] = {"ANIMATABLE"},
+    override: set[bpy.typing.PropertyOverrideFlagItems] = set(),
     tags=set(),
     subtype: bpy.typing.PropertySubtypeNumberItems = "NONE",
     update: collections.abc.Callable[[bpy.types.bpy_struct, bpy.types.Context], None]
@@ -125,9 +125,9 @@ def BoolProperty(
         :param translation_context: Text used as context to disambiguate translations.
         :type translation_context: str | None
         :param options: Enumerator in `rna_enum_property_flag_items`.
-        :type options: bpy.typing.PropertyFlagItems
+        :type options: set[bpy.typing.PropertyFlagItems]
         :param override: Enumerator in `rna_enum_property_override_flag_items`.
-        :type override: bpy.typing.PropertyOverrideFlagItems
+        :type override: set[bpy.typing.PropertyOverrideFlagItems]
         :param tags: Enumerator of tags that are defined by parent class.
         :param subtype: Enumerator in `rna_enum_property_subtype_number_items`.
         :type subtype: bpy.typing.PropertySubtypeNumberItems
@@ -149,8 +149,8 @@ def BoolVectorProperty(
     description: str | None = "",
     translation_context: str | None = "*",
     default: collections.abc.Sequence[bool] | None = (False, False, False),
-    options: bpy.typing.PropertyFlagItems = {"ANIMATABLE"},
-    override: bpy.typing.PropertyOverrideFlagItems = set(),
+    options: set[bpy.typing.PropertyFlagItems] = {"ANIMATABLE"},
+    override: set[bpy.typing.PropertyOverrideFlagItems] = set(),
     tags=set(),
     subtype: bpy.typing.PropertySubtypeNumberArrayItems = "NONE",
     size: collections.abc.Sequence[int] | int | None = 3,
@@ -160,7 +160,7 @@ def BoolVectorProperty(
         [bpy.types.bpy_struct], collections.abc.Sequence[bool]
     ]
     | None = None,
-    set: collections.abc.Callable[[bpy.types.bpy_struct, tuple[bool, int]], None]
+    set: collections.abc.Callable[[bpy.types.bpy_struct, tuple[bool, ...]], None]
     | None = None,
 ):
     """Returns a new vector boolean property definition.
@@ -174,9 +174,9 @@ def BoolVectorProperty(
         :param default: sequence of booleans the length of size.
         :type default: collections.abc.Sequence[bool] | None
         :param options: Enumerator in `rna_enum_property_flag_items`.
-        :type options: bpy.typing.PropertyFlagItems
+        :type options: set[bpy.typing.PropertyFlagItems]
         :param override: Enumerator in `rna_enum_property_override_flag_items`.
-        :type override: bpy.typing.PropertyOverrideFlagItems
+        :type override: set[bpy.typing.PropertyOverrideFlagItems]
         :param tags: Enumerator of tags that are defined by parent class.
         :param subtype: Enumerator in `rna_enum_property_subtype_number_array_items`.
         :type subtype: bpy.typing.PropertySubtypeNumberArrayItems
@@ -191,7 +191,7 @@ def BoolVectorProperty(
         :type get: collections.abc.Callable[[bpy.types.bpy_struct], collections.abc.Sequence[bool]] | None
         :param set: Function to be called when this value is 'written',
     This function must take 2 values (self, value) and return None.
-        :type set: collections.abc.Callable[[bpy.types.bpy_struct, tuple[bool, int]], None] | None
+        :type set: collections.abc.Callable[[bpy.types.bpy_struct, tuple[bool, ...]], None] | None
     """
 
 def CollectionProperty(
@@ -200,8 +200,8 @@ def CollectionProperty(
     name: str | None = "",
     description: str | None = "",
     translation_context: str | None = "*",
-    options: bpy.typing.PropertyFlagItems = {"ANIMATABLE"},
-    override: bpy.typing.PropertyOverrideFlagCollectionItems = set(),
+    options: set[bpy.typing.PropertyFlagItems] = {"ANIMATABLE"},
+    override: set[bpy.typing.PropertyOverrideFlagCollectionItems] = set(),
     tags=set(),
 ):
     """Returns a new collection property definition.
@@ -215,9 +215,9 @@ def CollectionProperty(
     :param translation_context: Text used as context to disambiguate translations.
     :type translation_context: str | None
     :param options: Enumerator in `rna_enum_property_flag_items`.
-    :type options: bpy.typing.PropertyFlagItems
+    :type options: set[bpy.typing.PropertyFlagItems]
     :param override: Enumerator in `rna_enum_property_override_flag_collection_items`.
-    :type override: bpy.typing.PropertyOverrideFlagCollectionItems
+    :type override: set[bpy.typing.PropertyOverrideFlagCollectionItems]
     :param tags: Enumerator of tags that are defined by parent class.
     """
 
@@ -242,8 +242,8 @@ def EnumProperty(
     description: str | None = "",
     translation_context: str | None = "*",
     default: int | str | None = None,
-    options: bpy.typing.PropertyFlagEnumItems = {"ANIMATABLE"},
-    override: bpy.typing.PropertyOverrideFlagItems = set(),
+    options: set[bpy.typing.PropertyFlagEnumItems] = {"ANIMATABLE"},
+    override: set[bpy.typing.PropertyOverrideFlagItems] = set(),
     tags=set(),
     update: collections.abc.Callable[[bpy.types.bpy_struct, bpy.types.Context], None]
     | None = None,
@@ -306,9 +306,9 @@ def EnumProperty(
     (i.e. if a callback function is given as items parameter).
         :type default: int | str | None
         :param options: Enumerator in `rna_enum_property_flag_enum_items`.
-        :type options: bpy.typing.PropertyFlagEnumItems
+        :type options: set[bpy.typing.PropertyFlagEnumItems]
         :param override: Enumerator in `rna_enum_property_override_flag_items`.
-        :type override: bpy.typing.PropertyOverrideFlagItems
+        :type override: set[bpy.typing.PropertyOverrideFlagItems]
         :param tags: Enumerator of tags that are defined by parent class.
         :param update: Function to be called when this value is modified,
     This function must take 2 values (self, context) and return None.
@@ -334,8 +334,8 @@ def FloatProperty(
     soft_max: float | None = 3.402823e38,
     step: int | None = 3,
     precision: int | None = 2,
-    options: bpy.typing.PropertyFlagItems = {"ANIMATABLE"},
-    override: bpy.typing.PropertyOverrideFlagItems = set(),
+    options: set[bpy.typing.PropertyFlagItems] = {"ANIMATABLE"},
+    override: set[bpy.typing.PropertyOverrideFlagItems] = set(),
     tags=set(),
     subtype: bpy.typing.PropertySubtypeNumberItems = "NONE",
     unit: bpy.typing.PropertyUnitItems = "NONE",
@@ -365,9 +365,9 @@ def FloatProperty(
         :param precision: Maximum number of decimal digits to display, in [0, 6]. Fraction is automatically hidden for exact integer values of fields with unit 'NONE' or 'TIME' (frame count) and step divisible by 100.
         :type precision: int | None
         :param options: Enumerator in `rna_enum_property_flag_items`.
-        :type options: bpy.typing.PropertyFlagItems
+        :type options: set[bpy.typing.PropertyFlagItems]
         :param override: Enumerator in `rna_enum_property_override_flag_items`.
-        :type override: bpy.typing.PropertyOverrideFlagItems
+        :type override: set[bpy.typing.PropertyOverrideFlagItems]
         :param tags: Enumerator of tags that are defined by parent class.
         :param subtype: Enumerator in `rna_enum_property_subtype_number_items`.
         :type subtype: bpy.typing.PropertySubtypeNumberItems
@@ -397,8 +397,8 @@ def FloatVectorProperty(
     soft_max: float | None = sys.float_info.max,
     step: int | None = 3,
     precision: int | None = 2,
-    options: bpy.typing.PropertyFlagItems = {"ANIMATABLE"},
-    override: bpy.typing.PropertyOverrideFlagItems = set(),
+    options: set[bpy.typing.PropertyFlagItems] = {"ANIMATABLE"},
+    override: set[bpy.typing.PropertyOverrideFlagItems] = set(),
     tags=set(),
     subtype: bpy.typing.PropertySubtypeNumberArrayItems = "NONE",
     unit: bpy.typing.PropertyUnitItems = "NONE",
@@ -409,7 +409,7 @@ def FloatVectorProperty(
         [bpy.types.bpy_struct], collections.abc.Sequence[float]
     ]
     | None = None,
-    set: collections.abc.Callable[[bpy.types.bpy_struct, tuple[float, int]], None]
+    set: collections.abc.Callable[[bpy.types.bpy_struct, tuple[float, ...]], None]
     | None = None,
 ):
     """Returns a new vector float property definition.
@@ -435,9 +435,9 @@ def FloatVectorProperty(
         :param precision: Maximum number of decimal digits to display, in [0, 6]. Fraction is automatically hidden for exact integer values of fields with unit 'NONE' or 'TIME' (frame count) and step divisible by 100.
         :type precision: int | None
         :param options: Enumerator in `rna_enum_property_flag_items`.
-        :type options: bpy.typing.PropertyFlagItems
+        :type options: set[bpy.typing.PropertyFlagItems]
         :param override: Enumerator in `rna_enum_property_override_flag_items`.
-        :type override: bpy.typing.PropertyOverrideFlagItems
+        :type override: set[bpy.typing.PropertyOverrideFlagItems]
         :param tags: Enumerator of tags that are defined by parent class.
         :param subtype: Enumerator in `rna_enum_property_subtype_number_array_items`.
         :type subtype: bpy.typing.PropertySubtypeNumberArrayItems
@@ -454,7 +454,7 @@ def FloatVectorProperty(
         :type get: collections.abc.Callable[[bpy.types.bpy_struct], collections.abc.Sequence[float]] | None
         :param set: Function to be called when this value is 'written',
     This function must take 2 values (self, value) and return None.
-        :type set: collections.abc.Callable[[bpy.types.bpy_struct, tuple[float, int]], None] | None
+        :type set: collections.abc.Callable[[bpy.types.bpy_struct, tuple[float, ...]], None] | None
     """
 
 def IntProperty(
@@ -468,8 +468,8 @@ def IntProperty(
     soft_min: int | None = None,
     soft_max: int | None = None,
     step: int | None = 1,
-    options: bpy.typing.PropertyFlagItems = {"ANIMATABLE"},
-    override: bpy.typing.PropertyOverrideFlagItems = set(),
+    options: set[bpy.typing.PropertyFlagItems] = {"ANIMATABLE"},
+    override: set[bpy.typing.PropertyOverrideFlagItems] = set(),
     tags=set(),
     subtype: bpy.typing.PropertySubtypeNumberItems = "NONE",
     update: collections.abc.Callable[[bpy.types.bpy_struct, bpy.types.Context], None]
@@ -496,9 +496,9 @@ def IntProperty(
         :param step: Step of increment/decrement in UI, in [1, 100], defaults to 1 (WARNING: unused currently!).
         :type step: int | None
         :param options: Enumerator in `rna_enum_property_flag_items`.
-        :type options: bpy.typing.PropertyFlagItems
+        :type options: set[bpy.typing.PropertyFlagItems]
         :param override: Enumerator in `rna_enum_property_override_flag_items`.
-        :type override: bpy.typing.PropertyOverrideFlagItems
+        :type override: set[bpy.typing.PropertyOverrideFlagItems]
         :param tags: Enumerator of tags that are defined by parent class.
         :param subtype: Enumerator in `rna_enum_property_subtype_number_items`.
         :type subtype: bpy.typing.PropertySubtypeNumberItems
@@ -525,8 +525,8 @@ def IntVectorProperty(
     soft_min: int | None = None,
     soft_max: int | None = None,
     step: int | None = 1,
-    options: bpy.typing.PropertyFlagItems = {"ANIMATABLE"},
-    override: bpy.typing.PropertyOverrideFlagItems = set(),
+    options: set[bpy.typing.PropertyFlagItems] = {"ANIMATABLE"},
+    override: set[bpy.typing.PropertyOverrideFlagItems] = set(),
     tags=set(),
     subtype: bpy.typing.PropertySubtypeNumberArrayItems = "NONE",
     size: collections.abc.Sequence[int] | int | None = 3,
@@ -534,7 +534,7 @@ def IntVectorProperty(
     | None = None,
     get: collections.abc.Callable[[bpy.types.bpy_struct], collections.abc.Sequence[int]]
     | None = None,
-    set: collections.abc.Callable[[bpy.types.bpy_struct, tuple[int, int]], None]
+    set: collections.abc.Callable[[bpy.types.bpy_struct, tuple[int, ...]], None]
     | None = None,
 ):
     """Returns a new vector int property definition.
@@ -558,9 +558,9 @@ def IntVectorProperty(
         :param step: Step of increment/decrement in UI, in [1, 100], defaults to 1 (WARNING: unused currently!).
         :type step: int | None
         :param options: Enumerator in `rna_enum_property_flag_items`.
-        :type options: bpy.typing.PropertyFlagItems
+        :type options: set[bpy.typing.PropertyFlagItems]
         :param override: Enumerator in `rna_enum_property_override_flag_items`.
-        :type override: bpy.typing.PropertyOverrideFlagItems
+        :type override: set[bpy.typing.PropertyOverrideFlagItems]
         :param tags: Enumerator of tags that are defined by parent class.
         :param subtype: Enumerator in `rna_enum_property_subtype_number_array_items`.
         :type subtype: bpy.typing.PropertySubtypeNumberArrayItems
@@ -575,7 +575,7 @@ def IntVectorProperty(
         :type get: collections.abc.Callable[[bpy.types.bpy_struct], collections.abc.Sequence[int]] | None
         :param set: Function to be called when this value is 'written',
     This function must take 2 values (self, value) and return None.
-        :type set: collections.abc.Callable[[bpy.types.bpy_struct, tuple[int, int]], None] | None
+        :type set: collections.abc.Callable[[bpy.types.bpy_struct, tuple[int, ...]], None] | None
     """
 
 def PointerProperty(
@@ -584,8 +584,8 @@ def PointerProperty(
     name: str | None = "",
     description: str | None = "",
     translation_context: str | None = "*",
-    options: bpy.typing.PropertyFlagItems = {"ANIMATABLE"},
-    override: bpy.typing.PropertyOverrideFlagItems = set(),
+    options: set[bpy.typing.PropertyFlagItems] = {"ANIMATABLE"},
+    override: set[bpy.typing.PropertyOverrideFlagItems] = set(),
     tags=set(),
     poll: collections.abc.Callable[[bpy.types.bpy_struct, bpy.types.ID], bool]
     | None = None,
@@ -603,9 +603,9 @@ def PointerProperty(
         :param translation_context: Text used as context to disambiguate translations.
         :type translation_context: str | None
         :param options: Enumerator in `rna_enum_property_flag_items`.
-        :type options: bpy.typing.PropertyFlagItems
+        :type options: set[bpy.typing.PropertyFlagItems]
         :param override: Enumerator in `rna_enum_property_override_flag_items`.
-        :type override: bpy.typing.PropertyOverrideFlagItems
+        :type override: set[bpy.typing.PropertyOverrideFlagItems]
         :param tags: Enumerator of tags that are defined by parent class.
         :param poll: function to be called to determine whether an item is valid for this property.
     The function must take 2 values (self, object) and return Bool.
@@ -633,8 +633,8 @@ def StringProperty(
     translation_context: str | None = "*",
     default: str | None = "",
     maxlen: int | None = 0,
-    options: bpy.typing.PropertyFlagItems = {"ANIMATABLE"},
-    override: bpy.typing.PropertyOverrideFlagItems = set(),
+    options: set[bpy.typing.PropertyFlagItems] = {"ANIMATABLE"},
+    override: set[bpy.typing.PropertyOverrideFlagItems] = set(),
     tags=set(),
     subtype: bpy.typing.PropertySubtypeStringItems = "NONE",
     update: collections.abc.Callable[[bpy.types.bpy_struct, bpy.types.Context], None]
@@ -658,9 +658,9 @@ def StringProperty(
         :param maxlen: maximum length of the string.
         :type maxlen: int | None
         :param options: Enumerator in `rna_enum_property_flag_items`.
-        :type options: bpy.typing.PropertyFlagItems
+        :type options: set[bpy.typing.PropertyFlagItems]
         :param override: Enumerator in `rna_enum_property_override_flag_items`.
-        :type override: bpy.typing.PropertyOverrideFlagItems
+        :type override: set[bpy.typing.PropertyOverrideFlagItems]
         :param tags: Enumerator of tags that are defined by parent class.
         :param subtype: Enumerator in `rna_enum_property_subtype_string_items`.
         :type subtype: bpy.typing.PropertySubtypeStringItems

bpy/types/__init__.pyi

@@ -158117,20 +158117,20 @@ class Gizmo(bpy_struct):
         :rtype: tuple[float, float]
         """
 
-    def target_get_value(self, target: str | None) -> float | tuple[float, int]:
+    def target_get_value(self, target: str | None) -> float | tuple[float, ...]:
         """Get the value of this target property.
 
         :param target: Target property name.
         :type target: str | None
         :return: The value of the target property as a value or array based on the target type.
-        :rtype: float | tuple[float, int]
+        :rtype: float | tuple[float, ...]
         """
 
     def target_set_handler(
         self,
         target: str | None,
         get: collections.abc.Callable[float | collections.abc.Sequence[float]] | None,
-        set: collections.abc.Callable[[tuple[float, int]], typing.Any] | None,
+        set: collections.abc.Callable[[tuple[float, ...]], typing.Any] | None,
         range: collections.abc.Callable | None = None,
     ):
         """Assigns callbacks to a gizmos property.
@@ -158140,7 +158140,7 @@ class Gizmo(bpy_struct):
         :param get: Function that returns the value for this property (single value or sequence).
         :type get: collections.abc.Callable[float | collections.abc.Sequence[float]] | None
         :param set: Function that takes a single value argument and applies it.
-        :type set: collections.abc.Callable[[tuple[float, int]], typing.Any] | None
+        :type set: collections.abc.Callable[[tuple[float, ...]], typing.Any] | None
         :param range: Function that returns a (min, max) tuple for gizmos that use a range. The returned value is not used.
         :type range: collections.abc.Callable | None
         """
@@ -186905,13 +186905,13 @@ expanding an operator into a menu.
     @classmethod
     def poll_message_set(
         cls,
-        message: collections.abc.Callable[[typing.Any, int], str | None] | str | None,
+        message: collections.abc.Callable[[typing.Any, ...], str | None] | str | None,
         *args,
     ):
         """Set the message to show in the tool-tip when poll fails.When message is callable, additional user defined positional arguments are passed to the message function.
 
         :param message: The message or a function that returns the message.
-        :type message: collections.abc.Callable[[typing.Any, int], str | None] | str | None
+        :type message: collections.abc.Callable[[typing.Any, ...], str | None] | str | None
         :param args:
         """
 
@@ -208895,8 +208895,8 @@ class Space(bpy_struct):
     @classmethod
     def draw_handler_add(
         cls,
-        callback: collections.abc.Callable[[typing.Any, int], typing.Any] | None,
-        args: tuple[typing.Any, int] | None,
+        callback: collections.abc.Callable[[typing.Any, ...], typing.Any] | None,
+        args: tuple[typing.Any, ...] | None,
         region_type: str | None,
         draw_type: str | None,
     ) -> typing.Any:
@@ -208906,9 +208906,9 @@ class Space(bpy_struct):
 
                 :param callback: A function that will be called when the region is drawn.
         It gets the specified arguments as input, it's return value is ignored.
-                :type callback: collections.abc.Callable[[typing.Any, int], typing.Any] | None
+                :type callback: collections.abc.Callable[[typing.Any, ...], typing.Any] | None
                 :param args: Arguments that will be passed to the callback.
-                :type args: tuple[typing.Any, int] | None
+                :type args: tuple[typing.Any, ...] | None
                 :param region_type: The region type the callback draws in; usually WINDOW. (`bpy.types.Region.type`)
                 :type region_type: str | None
                 :param draw_type: Usually POST_PIXEL for 2D drawing and POST_VIEW for 3D drawing. In some cases PRE_VIEW can be used. BACKDROP can be used for backdrops in the node editor.
@@ -209239,8 +209239,8 @@ class SpaceClipEditor(Space, bpy_struct):
     @classmethod
     def draw_handler_add(
         cls,
-        callback: collections.abc.Callable[[typing.Any, int], typing.Any] | None,
-        args: tuple[typing.Any, int] | None,
+        callback: collections.abc.Callable[[typing.Any, ...], typing.Any] | None,
+        args: tuple[typing.Any, ...] | None,
         region_type: str | None,
         draw_type: str | None,
     ) -> typing.Any:
@@ -209250,9 +209250,9 @@ class SpaceClipEditor(Space, bpy_struct):
 
                 :param callback: A function that will be called when the region is drawn.
         It gets the specified arguments as input, it's return value is ignored.
-                :type callback: collections.abc.Callable[[typing.Any, int], typing.Any] | None
+                :type callback: collections.abc.Callable[[typing.Any, ...], typing.Any] | None
                 :param args: Arguments that will be passed to the callback.
-                :type args: tuple[typing.Any, int] | None
+                :type args: tuple[typing.Any, ...] | None
                 :param region_type: The region type the callback draws in; usually WINDOW. (`bpy.types.Region.type`)
                 :type region_type: str | None
                 :param draw_type: Usually POST_PIXEL for 2D drawing and POST_VIEW for 3D drawing. In some cases PRE_VIEW can be used. BACKDROP can be used for backdrops in the node editor.
@@ -209341,8 +209341,8 @@ class SpaceConsole(Space, bpy_struct):
     @classmethod
     def draw_handler_add(
         cls,
-        callback: collections.abc.Callable[[typing.Any, int], typing.Any] | None,
-        args: tuple[typing.Any, int] | None,
+        callback: collections.abc.Callable[[typing.Any, ...], typing.Any] | None,
+        args: tuple[typing.Any, ...] | None,
         region_type: str | None,
         draw_type: str | None,
     ) -> typing.Any:
@@ -209352,9 +209352,9 @@ class SpaceConsole(Space, bpy_struct):
 
                 :param callback: A function that will be called when the region is drawn.
         It gets the specified arguments as input, it's return value is ignored.
-                :type callback: collections.abc.Callable[[typing.Any, int], typing.Any] | None
+                :type callback: collections.abc.Callable[[typing.Any, ...], typing.Any] | None
                 :param args: Arguments that will be passed to the callback.
-                :type args: tuple[typing.Any, int] | None
+                :type args: tuple[typing.Any, ...] | None
                 :param region_type: The region type the callback draws in; usually WINDOW. (`bpy.types.Region.type`)
                 :type region_type: str | None
                 :param draw_type: Usually POST_PIXEL for 2D drawing and POST_VIEW for 3D drawing. In some cases PRE_VIEW can be used. BACKDROP can be used for backdrops in the node editor.
@@ -209549,8 +209549,8 @@ class SpaceDopeSheetEditor(Space, bpy_struct):
     @classmethod
     def draw_handler_add(
         cls,
-        callback: collections.abc.Callable[[typing.Any, int], typing.Any] | None,
-        args: tuple[typing.Any, int] | None,
+        callback: collections.abc.Callable[[typing.Any, ...], typing.Any] | None,
+        args: tuple[typing.Any, ...] | None,
         region_type: str | None,
         draw_type: str | None,
     ) -> typing.Any:
@@ -209560,9 +209560,9 @@ class SpaceDopeSheetEditor(Space, bpy_struct):
 
                 :param callback: A function that will be called when the region is drawn.
         It gets the specified arguments as input, it's return value is ignored.
-                :type callback: collections.abc.Callable[[typing.Any, int], typing.Any] | None
+                :type callback: collections.abc.Callable[[typing.Any, ...], typing.Any] | None
                 :param args: Arguments that will be passed to the callback.
-                :type args: tuple[typing.Any, int] | None
+                :type args: tuple[typing.Any, ...] | None
                 :param region_type: The region type the callback draws in; usually WINDOW. (`bpy.types.Region.type`)
                 :type region_type: str | None
                 :param draw_type: Usually POST_PIXEL for 2D drawing and POST_VIEW for 3D drawing. In some cases PRE_VIEW can be used. BACKDROP can be used for backdrops in the node editor.
@@ -209720,8 +209720,8 @@ class SpaceFileBrowser(Space, bpy_struct):
     @classmethod
     def draw_handler_add(
         cls,
-        callback: collections.abc.Callable[[typing.Any, int], typing.Any] | None,
-        args: tuple[typing.Any, int] | None,
+        callback: collections.abc.Callable[[typing.Any, ...], typing.Any] | None,
+        args: tuple[typing.Any, ...] | None,
         region_type: str | None,
         draw_type: str | None,
     ) -> typing.Any:
@@ -209731,9 +209731,9 @@ class SpaceFileBrowser(Space, bpy_struct):
 
                 :param callback: A function that will be called when the region is drawn.
         It gets the specified arguments as input, it's return value is ignored.
-                :type callback: collections.abc.Callable[[typing.Any, int], typing.Any] | None
+                :type callback: collections.abc.Callable[[typing.Any, ...], typing.Any] | None
                 :param args: Arguments that will be passed to the callback.
-                :type args: tuple[typing.Any, int] | None
+                :type args: tuple[typing.Any, ...] | None
                 :param region_type: The region type the callback draws in; usually WINDOW. (`bpy.types.Region.type`)
                 :type region_type: str | None
                 :param draw_type: Usually POST_PIXEL for 2D drawing and POST_VIEW for 3D drawing. In some cases PRE_VIEW can be used. BACKDROP can be used for backdrops in the node editor.
@@ -209906,8 +209906,8 @@ class SpaceGraphEditor(Space, bpy_struct):
     @classmethod
     def draw_handler_add(
         cls,
-        callback: collections.abc.Callable[[typing.Any, int], typing.Any] | None,
-        args: tuple[typing.Any, int] | None,
+        callback: collections.abc.Callable[[typing.Any, ...], typing.Any] | None,
+        args: tuple[typing.Any, ...] | None,
         region_type: str | None,
         draw_type: str | None,
     ) -> typing.Any:
@@ -209917,9 +209917,9 @@ class SpaceGraphEditor(Space, bpy_struct):
 
                 :param callback: A function that will be called when the region is drawn.
         It gets the specified arguments as input, it's return value is ignored.
-                :type callback: collections.abc.Callable[[typing.Any, int], typing.Any] | None
+                :type callback: collections.abc.Callable[[typing.Any, ...], typing.Any] | None
                 :param args: Arguments that will be passed to the callback.
-                :type args: tuple[typing.Any, int] | None
+                :type args: tuple[typing.Any, ...] | None
                 :param region_type: The region type the callback draws in; usually WINDOW. (`bpy.types.Region.type`)
                 :type region_type: str | None
                 :param draw_type: Usually POST_PIXEL for 2D drawing and POST_VIEW for 3D drawing. In some cases PRE_VIEW can be used. BACKDROP can be used for backdrops in the node editor.
@@ -210190,8 +210190,8 @@ class SpaceImageEditor(Space, bpy_struct):
     @classmethod
     def draw_handler_add(
         cls,
-        callback: collections.abc.Callable[[typing.Any, int], typing.Any] | None,
-        args: tuple[typing.Any, int] | None,
+        callback: collections.abc.Callable[[typing.Any, ...], typing.Any] | None,
+        args: tuple[typing.Any, ...] | None,
         region_type: str | None,
         draw_type: str | None,
     ) -> typing.Any:
@@ -210201,9 +210201,9 @@ class SpaceImageEditor(Space, bpy_struct):
 
                 :param callback: A function that will be called when the region is drawn.
         It gets the specified arguments as input, it's return value is ignored.
-                :type callback: collections.abc.Callable[[typing.Any, int], typing.Any] | None
+                :type callback: collections.abc.Callable[[typing.Any, ...], typing.Any] | None
                 :param args: Arguments that will be passed to the callback.
-                :type args: tuple[typing.Any, int] | None
+                :type args: tuple[typing.Any, ...] | None
                 :param region_type: The region type the callback draws in; usually WINDOW. (`bpy.types.Region.type`)
                 :type region_type: str | None
                 :param draw_type: Usually POST_PIXEL for 2D drawing and POST_VIEW for 3D drawing. In some cases PRE_VIEW can be used. BACKDROP can be used for backdrops in the node editor.
@@ -210317,8 +210317,8 @@ class SpaceInfo(Space, bpy_struct):
     @classmethod
     def draw_handler_add(
         cls,
-        callback: collections.abc.Callable[[typing.Any, int], typing.Any] | None,
-        args: tuple[typing.Any, int] | None,
+        callback: collections.abc.Callable[[typing.Any, ...], typing.Any] | None,
+        args: tuple[typing.Any, ...] | None,
         region_type: str | None,
         draw_type: str | None,
     ) -> typing.Any:
@@ -210328,9 +210328,9 @@ class SpaceInfo(Space, bpy_struct):
 
                 :param callback: A function that will be called when the region is drawn.
         It gets the specified arguments as input, it's return value is ignored.
-                :type callback: collections.abc.Callable[[typing.Any, int], typing.Any] | None
+                :type callback: collections.abc.Callable[[typing.Any, ...], typing.Any] | None
                 :param args: Arguments that will be passed to the callback.
-                :type args: tuple[typing.Any, int] | None
+                :type args: tuple[typing.Any, ...] | None
                 :param region_type: The region type the callback draws in; usually WINDOW. (`bpy.types.Region.type`)
                 :type region_type: str | None
                 :param draw_type: Usually POST_PIXEL for 2D drawing and POST_VIEW for 3D drawing. In some cases PRE_VIEW can be used. BACKDROP can be used for backdrops in the node editor.
@@ -210431,8 +210431,8 @@ class SpaceNLA(Space, bpy_struct):
     @classmethod
     def draw_handler_add(
         cls,
-        callback: collections.abc.Callable[[typing.Any, int], typing.Any] | None,
-        args: tuple[typing.Any, int] | None,
+        callback: collections.abc.Callable[[typing.Any, ...], typing.Any] | None,
+        args: tuple[typing.Any, ...] | None,
         region_type: str | None,
         draw_type: str | None,
     ) -> typing.Any:
@@ -210442,9 +210442,9 @@ class SpaceNLA(Space, bpy_struct):
 
                 :param callback: A function that will be called when the region is drawn.
         It gets the specified arguments as input, it's return value is ignored.
-                :type callback: collections.abc.Callable[[typing.Any, int], typing.Any] | None
+                :type callback: collections.abc.Callable[[typing.Any, ...], typing.Any] | None
                 :param args: Arguments that will be passed to the callback.
-                :type args: tuple[typing.Any, int] | None
+                :type args: tuple[typing.Any, ...] | None
                 :param region_type: The region type the callback draws in; usually WINDOW. (`bpy.types.Region.type`)
                 :type region_type: str | None
                 :param draw_type: Usually POST_PIXEL for 2D drawing and POST_VIEW for 3D drawing. In some cases PRE_VIEW can be used. BACKDROP can be used for backdrops in the node editor.
@@ -210634,8 +210634,8 @@ class SpaceNodeEditor(Space, bpy_struct):
     @classmethod
     def draw_handler_add(
         cls,
-        callback: collections.abc.Callable[[typing.Any, int], typing.Any] | None,
-        args: tuple[typing.Any, int] | None,
+        callback: collections.abc.Callable[[typing.Any, ...], typing.Any] | None,
+        args: tuple[typing.Any, ...] | None,
         region_type: str | None,
         draw_type: str | None,
     ) -> typing.Any:
@@ -210645,9 +210645,9 @@ class SpaceNodeEditor(Space, bpy_struct):
 
                 :param callback: A function that will be called when the region is drawn.
         It gets the specified arguments as input, it's return value is ignored.
-                :type callback: collections.abc.Callable[[typing.Any, int], typing.Any] | None
+                :type callback: collections.abc.Callable[[typing.Any, ...], typing.Any] | None
                 :param args: Arguments that will be passed to the callback.
-                :type args: tuple[typing.Any, int] | None
+                :type args: tuple[typing.Any, ...] | None
                 :param region_type: The region type the callback draws in; usually WINDOW. (`bpy.types.Region.type`)
                 :type region_type: str | None
                 :param draw_type: Usually POST_PIXEL for 2D drawing and POST_VIEW for 3D drawing. In some cases PRE_VIEW can be used. BACKDROP can be used for backdrops in the node editor.
@@ -210967,8 +210967,8 @@ class SpaceOutliner(Space, bpy_struct):
     @classmethod
     def draw_handler_add(
         cls,
-        callback: collections.abc.Callable[[typing.Any, int], typing.Any] | None,
-        args: tuple[typing.Any, int] | None,
+        callback: collections.abc.Callable[[typing.Any, ...], typing.Any] | None,
+        args: tuple[typing.Any, ...] | None,
         region_type: str | None,
         draw_type: str | None,
     ) -> typing.Any:
@@ -210978,9 +210978,9 @@ class SpaceOutliner(Space, bpy_struct):
 
                 :param callback: A function that will be called when the region is drawn.
         It gets the specified arguments as input, it's return value is ignored.
-                :type callback: collections.abc.Callable[[typing.Any, int], typing.Any] | None
+                :type callback: collections.abc.Callable[[typing.Any, ...], typing.Any] | None
                 :param args: Arguments that will be passed to the callback.
-                :type args: tuple[typing.Any, int] | None
+                :type args: tuple[typing.Any, ...] | None
                 :param region_type: The region type the callback draws in; usually WINDOW. (`bpy.types.Region.type`)
                 :type region_type: str | None
                 :param draw_type: Usually POST_PIXEL for 2D drawing and POST_VIEW for 3D drawing. In some cases PRE_VIEW can be used. BACKDROP can be used for backdrops in the node editor.
@@ -211039,8 +211039,8 @@ class SpacePreferences(Space, bpy_struct):
     @classmethod
     def draw_handler_add(
         cls,
-        callback: collections.abc.Callable[[typing.Any, int], typing.Any] | None,
-        args: tuple[typing.Any, int] | None,
+        callback: collections.abc.Callable[[typing.Any, ...], typing.Any] | None,
+        args: tuple[typing.Any, ...] | None,
         region_type: str | None,
         draw_type: str | None,
     ) -> typing.Any:
@@ -211050,9 +211050,9 @@ class SpacePreferences(Space, bpy_struct):
 
                 :param callback: A function that will be called when the region is drawn.
         It gets the specified arguments as input, it's return value is ignored.
-                :type callback: collections.abc.Callable[[typing.Any, int], typing.Any] | None
+                :type callback: collections.abc.Callable[[typing.Any, ...], typing.Any] | None
                 :param args: Arguments that will be passed to the callback.
-                :type args: tuple[typing.Any, int] | None
+                :type args: tuple[typing.Any, ...] | None
                 :param region_type: The region type the callback draws in; usually WINDOW. (`bpy.types.Region.type`)
                 :type region_type: str | None
                 :param draw_type: Usually POST_PIXEL for 2D drawing and POST_VIEW for 3D drawing. In some cases PRE_VIEW can be used. BACKDROP can be used for backdrops in the node editor.
@@ -211154,8 +211154,8 @@ class SpaceProperties(Space, bpy_struct):
     @classmethod
     def draw_handler_add(
         cls,
-        callback: collections.abc.Callable[[typing.Any, int], typing.Any] | None,
-        args: tuple[typing.Any, int] | None,
+        callback: collections.abc.Callable[[typing.Any, ...], typing.Any] | None,
+        args: tuple[typing.Any, ...] | None,
         region_type: str | None,
         draw_type: str | None,
     ) -> typing.Any:
@@ -211165,9 +211165,9 @@ class SpaceProperties(Space, bpy_struct):
 
                 :param callback: A function that will be called when the region is drawn.
         It gets the specified arguments as input, it's return value is ignored.
-                :type callback: collections.abc.Callable[[typing.Any, int], typing.Any] | None
+                :type callback: collections.abc.Callable[[typing.Any, ...], typing.Any] | None
                 :param args: Arguments that will be passed to the callback.
-                :type args: tuple[typing.Any, int] | None
+                :type args: tuple[typing.Any, ...] | None
                 :param region_type: The region type the callback draws in; usually WINDOW. (`bpy.types.Region.type`)
                 :type region_type: str | None
                 :param draw_type: Usually POST_PIXEL for 2D drawing and POST_VIEW for 3D drawing. In some cases PRE_VIEW can be used. BACKDROP can be used for backdrops in the node editor.
@@ -211410,8 +211410,8 @@ class SpaceSequenceEditor(Space, bpy_struct):
     @classmethod
     def draw_handler_add(
         cls,
-        callback: collections.abc.Callable[[typing.Any, int], typing.Any] | None,
-        args: tuple[typing.Any, int] | None,
+        callback: collections.abc.Callable[[typing.Any, ...], typing.Any] | None,
+        args: tuple[typing.Any, ...] | None,
         region_type: str | None,
         draw_type: str | None,
     ) -> typing.Any:
@@ -211421,9 +211421,9 @@ class SpaceSequenceEditor(Space, bpy_struct):
 
                 :param callback: A function that will be called when the region is drawn.
         It gets the specified arguments as input, it's return value is ignored.
-                :type callback: collections.abc.Callable[[typing.Any, int], typing.Any] | None
+                :type callback: collections.abc.Callable[[typing.Any, ...], typing.Any] | None
                 :param args: Arguments that will be passed to the callback.
-                :type args: tuple[typing.Any, int] | None
+                :type args: tuple[typing.Any, ...] | None
                 :param region_type: The region type the callback draws in; usually WINDOW. (`bpy.types.Region.type`)
                 :type region_type: str | None
                 :param draw_type: Usually POST_PIXEL for 2D drawing and POST_VIEW for 3D drawing. In some cases PRE_VIEW can be used. BACKDROP can be used for backdrops in the node editor.
@@ -211554,8 +211554,8 @@ class SpaceSpreadsheet(Space, bpy_struct):
     @classmethod
     def draw_handler_add(
         cls,
-        callback: collections.abc.Callable[[typing.Any, int], typing.Any] | None,
-        args: tuple[typing.Any, int] | None,
+        callback: collections.abc.Callable[[typing.Any, ...], typing.Any] | None,
+        args: tuple[typing.Any, ...] | None,
         region_type: str | None,
         draw_type: str | None,
     ) -> typing.Any:
@@ -211565,9 +211565,9 @@ class SpaceSpreadsheet(Space, bpy_struct):
 
                 :param callback: A function that will be called when the region is drawn.
         It gets the specified arguments as input, it's return value is ignored.
-                :type callback: collections.abc.Callable[[typing.Any, int], typing.Any] | None
+                :type callback: collections.abc.Callable[[typing.Any, ...], typing.Any] | None
                 :param args: Arguments that will be passed to the callback.
-                :type args: tuple[typing.Any, int] | None
+                :type args: tuple[typing.Any, ...] | None
                 :param region_type: The region type the callback draws in; usually WINDOW. (`bpy.types.Region.type`)
                 :type region_type: str | None
                 :param draw_type: Usually POST_PIXEL for 2D drawing and POST_VIEW for 3D drawing. In some cases PRE_VIEW can be used. BACKDROP can be used for backdrops in the node editor.
@@ -211754,8 +211754,8 @@ class SpaceTextEditor(Space, bpy_struct):
     @classmethod
     def draw_handler_add(
         cls,
-        callback: collections.abc.Callable[[typing.Any, int], typing.Any] | None,
-        args: tuple[typing.Any, int] | None,
+        callback: collections.abc.Callable[[typing.Any, ...], typing.Any] | None,
+        args: tuple[typing.Any, ...] | None,
         region_type: str | None,
         draw_type: str | None,
     ) -> typing.Any:
@@ -211765,9 +211765,9 @@ class SpaceTextEditor(Space, bpy_struct):
 
                 :param callback: A function that will be called when the region is drawn.
         It gets the specified arguments as input, it's return value is ignored.
-                :type callback: collections.abc.Callable[[typing.Any, int], typing.Any] | None
+                :type callback: collections.abc.Callable[[typing.Any, ...], typing.Any] | None
                 :param args: Arguments that will be passed to the callback.
-                :type args: tuple[typing.Any, int] | None
+                :type args: tuple[typing.Any, ...] | None
                 :param region_type: The region type the callback draws in; usually WINDOW. (`bpy.types.Region.type`)
                 :type region_type: str | None
                 :param draw_type: Usually POST_PIXEL for 2D drawing and POST_VIEW for 3D drawing. In some cases PRE_VIEW can be used. BACKDROP can be used for backdrops in the node editor.
@@ -212459,8 +212459,8 @@ class SpaceView3D(Space, bpy_struct):
     @classmethod
     def draw_handler_add(
         cls,
-        callback: collections.abc.Callable[[typing.Any, int], typing.Any] | None,
-        args: tuple[typing.Any, int] | None,
+        callback: collections.abc.Callable[[typing.Any, ...], typing.Any] | None,
+        args: tuple[typing.Any, ...] | None,
         region_type: str | None,
         draw_type: str | None,
     ) -> typing.Any:
@@ -212470,9 +212470,9 @@ class SpaceView3D(Space, bpy_struct):
 
                 :param callback: A function that will be called when the region is drawn.
         It gets the specified arguments as input, it's return value is ignored.
-                :type callback: collections.abc.Callable[[typing.Any, int], typing.Any] | None
+                :type callback: collections.abc.Callable[[typing.Any, ...], typing.Any] | None
                 :param args: Arguments that will be passed to the callback.
-                :type args: tuple[typing.Any, int] | None
+                :type args: tuple[typing.Any, ...] | None
                 :param region_type: The region type the callback draws in; usually WINDOW. (`bpy.types.Region.type`)
                 :type region_type: str | None
                 :param draw_type: Usually POST_PIXEL for 2D drawing and POST_VIEW for 3D drawing. In some cases PRE_VIEW can be used. BACKDROP can be used for backdrops in the node editor.
@@ -230598,10 +230598,10 @@ class WindowManager(ID, bpy_struct):
     def draw_cursor_add(
         cls,
         callback: collections.abc.Callable[
-            [typing.Any, int, tuple[int, int]], typing.Any
+            [typing.Any, ..., tuple[int, int]], typing.Any
         ]
         | None,
-        args: tuple[typing.Any, int] | None,
+        args: tuple[typing.Any, ...] | None,
         space_type: str | None,
         region_type: str | None,
     ) -> typing.Any:
@@ -230611,9 +230611,9 @@ class WindowManager(ID, bpy_struct):
 
                 :param callback: A function that will be called when the cursor is drawn.
         It gets the specified arguments as input with the mouse position (tuple) as last argument.
-                :type callback: collections.abc.Callable[[typing.Any, int, tuple[int, int]], typing.Any] | None
+                :type callback: collections.abc.Callable[[typing.Any, ..., tuple[int, int]], typing.Any] | None
                 :param args: Arguments that will be passed to the callback.
-                :type args: tuple[typing.Any, int] | None
+                :type args: tuple[typing.Any, ...] | None
                 :param space_type: The space type the callback draws in; for example VIEW_3D. (`bpy.types.Space.type`)
                 :type space_type: str | None
                 :param region_type: The region type the callback draws in; usually WINDOW. (`bpy.types.Region.type`)

{fake_bpy_module-20250102.dist-info → fake_bpy_module-20250104.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: fake-bpy-module
-Version: 20250102
+Version: 20250104
 Summary: Collection of the fake Blender Python API module for the code completion.
 Author: nutti
 Author-email: nutti.metro@gmail.com

{fake_bpy_module-20250102.dist-info → fake_bpy_module-20250104.dist-info}/RECORD

@@ -185,9 +185,9 @@ blf/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 bmesh/__init__.pyi,sha256=6QP0wBMiFIY5MtM1Yuw4Qj2ZPtEZHFUdAf1ay4z-SQE,1500
 bmesh/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 bmesh/geometry/__init__.pyi,sha256=fgGEevkhB2IEtja2X5rm6OQU5EoDfkPaqiKeNGfWZ6c,656
-bmesh/ops/__init__.pyi,sha256=7W-Tv_SgkgEMa90SsRfRzBzNG2Wt1EU622YpkDYJthc,74701
+bmesh/ops/__init__.pyi,sha256=DMiZji_B_pnY7y_hrTysJAkYhSrfEz9jnAqIuO16mBc,74702
 bmesh/types/__init__.pyi,sha256=1KUSIGZDOD-fC_iPMVljAL2QYyYHpsCzWbgnsJJyT8A,43472
-bmesh/utils/__init__.pyi,sha256=dxZKrKK89WTo7uvlIZd2JUtAUJWqDXRtHMaLLojlY9A,6235
+bmesh/utils/__init__.pyi,sha256=XNhFTqYQPL7ZUvljUTQkN0X_3YCS_RyrOgEzqrQZiDg,6235
 bpy/__init__.pyi,sha256=aaYss17B3fH0ejnN9bMctoFfT8ptLuJWq4Kjgm2Gm9Y,495
 bpy/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 bpy/app/__init__.pyi,sha256=gQJdiazscopU-G66fjv1pOLRZykYpJ-6L0aIAYBvzKA,8205
@@ -270,12 +270,12 @@ bpy/ops/uilist/__init__.pyi,sha256=1Vu7qHRYL-MOM5kdcHJLmJwucvveh10t1wbmL_98GEM,1
 bpy/ops/uv/__init__.pyi,sha256=e6ilriSD-iJymqq1PjEw-DWy218-OeCTTeAiJm4NfGc,45187
 bpy/ops/view2d/__init__.pyi,sha256=bw6xoLUDUWQGk36g4T8THDWpNSH_VX8Pyg_mlGB9Dik,6986
 bpy/ops/view3d/__init__.pyi,sha256=MGiNsaGKtQPLFiSQgEdKlULq2a0Rp6W3vGTub0Hb3p4,30689
-bpy/ops/wm/__init__.pyi,sha256=hKfEGg5ZP1ydNAkhidsg-KN0yT_p28pgR_g2Vns_bq4,214261
+bpy/ops/wm/__init__.pyi,sha256=7u4gDHRotDpsFjWyimS-8PEZmebPepjI0Mj4qiDk-W4,215760
 bpy/ops/workspace/__init__.pyi,sha256=BHvDV5CcVBnuKaL8akhm-Es7VcGUjf3jGFTbfx5YHCU,1983
 bpy/ops/world/__init__.pyi,sha256=pBV8EDA8HoWovDSul6mxkF7Mt6N3PQWuukRhkw3dBr8,601
 bpy/path/__init__.pyi,sha256=emlV7ocbsOuOSMzxJXr6ldKRk2-_K0DWlKc3Ylt5dsU,5484
-bpy/props/__init__.pyi,sha256=XCW9PAdsJ0eCqKV9IMd7KY-WJBXNuN902exwwL7nNtE,34382
-bpy/types/__init__.pyi,sha256=VT2ULajsB_5Y69Xn-g7FlPNoT8-6enwISqxFl1gN620,5409745
+bpy/props/__init__.pyi,sha256=hHBLsZzldT2B5zmWZroZzoT5cyHruSaTaBR1oAyIfZc,34582
+bpy/types/__init__.pyi,sha256=N-SPQnADVELgaoIXnXayKrkqg4W0qIWe3Uupln27Pww,5409745
 bpy/typing/__init__.pyi,sha256=u2XKjd6ZB1Wjt7JwabxexZdswEZLYR2jQpxzzp6AThg,138679
 bpy/utils/__init__.pyi,sha256=Shl-q0XiWluRIHc6l_YMuVwFrz3vOJ0hnlgjVp1OirY,13711
 bpy/utils/previews/__init__.pyi,sha256=AsbDN4vRLbSTZ7_S_4LqmI1sJmV_8NnqDt1QfBdH94Y,2280
@@ -311,7 +311,7 @@ freestyle/functions/__init__.pyi,sha256=sEPnGHwZm8XBlfE7CKLros3CKJlAh1h1FI74nBTE
 freestyle/predicates/__init__.pyi,sha256=TI-9arpIRbq7ePsxHS-d-4iIj54uHMp-ZyGhPVODMPg,13461
 freestyle/shaders/__init__.pyi,sha256=1Ov48B4P7LV3dwjBqHqqqbPFRBZWjENqIDaFb97Qdj0,23835
 freestyle/types/__init__.pyi,sha256=BsZjLTN4AobRDBHcT_yh-VC7lo7mDvJPclsVl-fK5FM,100093
-freestyle/utils/__init__.pyi,sha256=lW5JWrilkFTvRmtYoS3hbmWfj2abo2hHsvp4eyGLbcQ,5108
+freestyle/utils/__init__.pyi,sha256=DdX3Qj2yTIu8jXdOAnf_9yKhJ5AQFnS_zVvSAdTfBpU,5108
 freestyle/utils/ContextFunctions/__init__.pyi,sha256=fPDfiBEjpoqXQhBhmHJ6WxG9oLMItwQ32MxKQz_c9_I,3445
 gpu/__init__.pyi,sha256=Q-AbyJO85pPYcwXNWtvgAhFGGJ6OnnHrlsXQxur9jhs,7999
 gpu/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -322,7 +322,7 @@ gpu/select/__init__.pyi,sha256=piRQyAtE8YnDjLSqF8S_SSttxzZTickDlbHRONYYdV8,207
 gpu/shader/__init__.pyi,sha256=JsSm0Zagw7GAVxeaLK4cUAa1oyjSckfNwpweWfepUQg,2138
 gpu/state/__init__.pyi,sha256=AimAU8NQNaZqYSgKtg7aMS76dzxNuK7m1vTA2ZwMnCQ,4310
 gpu/texture/__init__.pyi,sha256=NWixhD9M2vFrAIWlQDM0Co-CNRiU7BbL7imkSOloHHI,641
-gpu/types/__init__.pyi,sha256=YP9_rEYD3QKsEAm23qlbvFrZzypTn86XT8Qf65N9pbw,27923
+gpu/types/__init__.pyi,sha256=Q8Gym2MsHoDFLW7snVIfPMUGCQns-XA2URYfeOV3nnk,27923
 gpu_extras/__init__.pyi,sha256=oNgtMNheClZ_iCmKSH63hBJ4U0huayOWKil-qPvYHds,213
 gpu_extras/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 gpu_extras/batch/__init__.pyi,sha256=t-kFLEyZ0OABqt8VbtSwvo60S7vw15Tq5HRea-G3odE,1278
@@ -339,10 +339,10 @@ keyingsets_builtins/__init__.pyi,sha256=FmSnRj8eAiQ_O-X_-kAHM_a8rCv_HZBrjXLXDRss
 keyingsets_builtins/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 keyingsets_utils/__init__.pyi,sha256=UpGuAqOVl6bmy3rffJhqFS8ZKhUtAV-MfVyuuHtqXQI,770
 keyingsets_utils/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-mathutils/__init__.pyi,sha256=ISsSCElrC_d8RQyErtGB00lCpUWV0EdXP5DCpELTjn0,89139
+mathutils/__init__.pyi,sha256=2wLZ7iMLvXeB3Jk1cWKqU0WeJwcv6SZiTFZETAdfu-Y,89139
 mathutils/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 mathutils/bvhtree/__init__.pyi,sha256=UtzuOlaUjgPwVQZnDiZhPrzgrFmgpyVY7z9WqoZzNsI,4933
-mathutils/geometry/__init__.pyi,sha256=hlZ8PzbCxTbzG_0PE6CAbeRKtDBIFTMgO5WRi4xo8sQ,23278
+mathutils/geometry/__init__.pyi,sha256=q6y5a8T54ZNoIlqkfjx2nZ8iF7G-uHfeFrN7SJqrapc,23278
 mathutils/interpolate/__init__.pyi,sha256=3MaN3gfetfW_J0ZGye7U9Ae-O5cT7Ok2nyRWjy6HuV4,535
 mathutils/kdtree/__init__.pyi,sha256=R7efrHFwgdpF3LKlQzW25s-GxVCECQgTuXOwSGoKJTk,2247
 mathutils/noise/__init__.pyi,sha256=nDUTZpaghLXZwQG_8sVJnR-vdPeN7qk0p343sAsovgI,12725
@@ -358,7 +358,7 @@ rna_prop_ui/__init__.pyi,sha256=lShhkbbeJ_ANi2dy4J4HIkyp1HZrMqCfhcf8QpAQsj0,1281
 rna_prop_ui/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 rna_xml/__init__.pyi,sha256=idYsAZj-_egBKMA2pQl2P9IoNhZxXIkBSALFuq-ylO8,577
 rna_xml/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-fake_bpy_module-20250102.dist-info/METADATA,sha256=1fKA05mKKHNVXBaqpRbAweLQqSG-czloMO-cNkbD0y0,7289
-fake_bpy_module-20250102.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
-fake_bpy_module-20250102.dist-info/top_level.txt,sha256=SZm3DVRKif7dFSjYKiIIg3_7uqjIwRAwOnCIcT4hRNM,500
-fake_bpy_module-20250102.dist-info/RECORD,,
+fake_bpy_module-20250104.dist-info/METADATA,sha256=ByjyqfihwRYzg-aBQwdhknd6bp849bGfe4Y2o0QNcNU,7289
+fake_bpy_module-20250104.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
+fake_bpy_module-20250104.dist-info/top_level.txt,sha256=SZm3DVRKif7dFSjYKiIIg3_7uqjIwRAwOnCIcT4hRNM,500
+fake_bpy_module-20250104.dist-info/RECORD,,

freestyle/utils/__init__.pyi

@@ -124,7 +124,7 @@ def material_from_fedge(fe):
     """get the diffuse RGBA color from an FEdge"""
 
 def normal_at_I0D(it): ...
-def pairwise(iterable, types={Stroke, StrokeVertexIterator}):
+def pairwise(iterable, types={StrokeVertexIterator, Stroke}):
     """Yields a tuple containing the previous and current object"""
 
 def rgb_to_bw(r, g, b):

gpu/types/__init__.pyi

@@ -276,11 +276,11 @@ class GPUShader:
         :rtype: int
         """
 
-    def attrs_info_get(self) -> tuple[tuple[str, str | None], int]:
+    def attrs_info_get(self) -> tuple[tuple[str, str | None], ...]:
         """Information about the attributes used in the Shader.
 
         :return: tuples containing information about the attributes in order (name, type)
-        :rtype: tuple[tuple[str, str | None], int]
+        :rtype: tuple[tuple[str, str | None], ...]
         """
 
     def bind(self):

mathutils/__init__.pyi

@@ -3890,13 +3890,13 @@ class Vector:
         :rtype: Quaternion
         """
 
-    def to_tuple(self, precision: int = -1) -> tuple[float, int]:
+    def to_tuple(self, precision: int = -1) -> tuple[float, ...]:
         """Return this vector as a tuple with.
 
         :param precision: The number to round the value to in [-1, 21].
         :type precision: int
         :return: the values of the vector rounded by precision
-        :rtype: tuple[float, int]
+        :rtype: tuple[float, ...]
         """
 
     def zero(self):

mathutils/geometry/__init__.pyi

@@ -65,12 +65,12 @@ def box_fit_2d(
     """
 
 def box_pack_2d(
-    boxes: list[list[float, float, float, float, int]],
+    boxes: list[list[float, float, float, float, ...]],
 ) -> tuple[float, float]:
     """Returns a tuple with the width and height of the packed bounding box.
 
     :param boxes: list of boxes, each box is a list where the first 4 items are [X, Y, width, height, ...] other items are ignored. The X & Y values in this list are modified to set the packed positions.
-    :type boxes: list[list[float, float, float, float, int]]
+    :type boxes: list[list[float, float, float, float, ...]]
     :return: The width and height of the packed bounding box.
     :rtype: tuple[float, float]
     """