fake-bpy-module 20241230__py3-none-any.whl → 20250103__py3-none-any.whl

bpy/types/__init__.pyi

@@ -5547,86 +5547,273 @@ print(positions_data)
 This example shows an implementation of USDHook
 
  to extend USD
-export and import functionalty.
+export and import functionality.
+
+
+--------------------
 
 One may optionally define any or all of the following callback functions
 in the USDHook
 
  subclass.
 
-Hook function on_export()
 
- is called before the USD export finalizes,
-allowing modifications to the USD stage immediately before it is
-saved.  This function takes as an argument an instance of an
-internally defined class USDSceneExportContext
+--------------------
 
- which provides the
-following accessors to the scene data:
+Called before the USD export finalizes, allowing modifications to the USD
+stage immediately before it is saved.
 
-* get_stage()
+Args:
 
- returns the USD stage to be saved.
-* get_depsgraph()
+* export_context
 
- returns the Blender scene dependency graph.
+ (USDSceneExportContext): Provides access to the stage and dependency graph
 
-Hook function on_material_export()
+Returns:
 
- is called for each material that is exported,
-allowing modifications to the USD material, such as shader generation.
-It is called with three arguments:
+* True
 
--export_context
+ on success or False
 
-: An instance of the internally defined type USDMaterialExportContext
+ if the operation was bypassed or otherwise failed to complete
 
-.
--bl_material
 
-: The source Blender material.
--usd_material
+--------------------
 
-: The target USD material to be exported.
+Called for each material that is exported, allowing modifications to the USD material,
+such as shader generation.
 
-USDMaterialExportContext
+Args:
 
- implements a get_stage()
+* export_context
 
- function which returns the
-USD stage to be saved.
+ (USDMaterialExportContext): Provides access to the stage and a texture export utility function
+* bl_material
+
+ (bpy.types.Material
+
+): The source Blender material
+* usd_material
+
+ (pxr.UsdShade.Material
+
+): The target USD material to be exported
+
+Returns:
+
+* True
+
+ on success or False
+
+ if the operation was bypassed or otherwise failed to complete
 
 Note that the target USD material might already have connected shaders created by the USD exporter or
 by other material export hooks.
 
-Hook function on_import()
 
- is called after the USD import finalizes. This function takes
-as an argument an instance of an internally defined class USDSceneImportContext
+--------------------
+
+Called after the USD import finalizes.
+
+Args:
+
+* import_context
+
+ (USDSceneImportContext):
+Provides access to the stage and a map associating USD prim paths and Blender IDs
+
+Returns:
+
+* True
+
+ on success or False
+
+ if the operation was bypassed or otherwise failed to complete
+
+
+--------------------
+
+Called to determine if the USDHook
+
+ implementation can convert a given USD material.
+
+Args:
+
+* import_context
+
+ (USDMaterialImportContext): Provides access to the stage and a texture import utility function
+* usd_material
+
+ (pxr.UsdShade.Material
+
+): The source USD material to be exported
+
+Returns:
+
+* True
+
+ if the hook can convert the material or False
+
+ otherwise
+
+If any hook returns True
+
+ from material_import_poll
+
+, the USD importer will skip standard USD Preview Surface
+
+
+or MaterialX
+
+ import and invoke the hook's on_material_import method to convert the material instead.
+
+
+--------------------
+
+Called for each material that is imported, to allow converting the USD material to nodes on the Blender material.
+To ensure that this function gets called, the hook must also implement the material_import_poll()
+
+
+callback to return True
+
+ for the given USD material.
+
+Args:
+
+* import_context
+
+ (USDMaterialImportContext): Provides access to the stage and a texture import utility function
+* bl_material
+
+ (bpy.types.Material
+
+): The target Blender material with an empty node tree
+* usd_material
+
+ (pxr.UsdShade.Material
+
+): The source USD material to be imported
+
+Returns:
+
+* True
+
+ on success or False
+
+ if the conversion failed or otherwise did not complete
+
+
+--------------------
+
+Instances of the following built-in classes are provided as arguments to the callbacks.
+
+
+--------------------
 
- which provides the
-following accessors to the scene data:
+Argument for on_export.
+
+Methods:
+
+* get_stage()
+
+: returns the USD stage to be saved
+* get_depsgraph()
+
+: returns the Blender scene dependency graph
+
+
+--------------------
+
+Argument for on_material_export.
+
+Methods:
+
+* get_stage()
+
+: returns the USD stage to be saved
+* export_texture(image: bpy.types.Image)
+
+: Returns the USD asset path for the given texture image
+
+The export_texture
+
+ function will save in-memory images and may copy texture assets,
+depending on the current USD export options.
+For example, by default calling export_texture(/foo/bar.png)
+
+ will copy the file to a textures
+
+
+directory next to the exported USD and will return the relative path ./textures/bar.png
+
+.
+
+
+--------------------
+
+Argument for on_import.
+
+Methods:
 
 * get_prim_map()
 
- returns a dict where the key is an imported USD Prim path and the value a list of
-    the IDs created by the imported prim.
+ returns a dict
+
+ where the key is an imported USD Prim path and the value a list
 
+
+of the IDs created by the imported prim.
 * get_stage()
 
  returns the USD stage which was imported.
 
-The hook functions should return True
 
- on success or False
+--------------------
+
+Argument for material_import_poll and on_material_import.
+
+Methods:
+
+* get_stage()
+
+:
+returns the USD stage to be saved.
+* import_texture(asset_path: str)
+
+:
+for the given USD texture asset path, returns a tuple[str, bool]
+
+,
+containing the asset's local path and a bool indicating whether the path references a temporary file.
+
+The import_texture
+
+ function may copy the texture to the local file system if the given asset path is a
+package-relative path for a USDZ archive, depending on the current USD Import Textures
 
- if the operation was bypassed or
-otherwise failed to complete.  Exceptions raised by these functions will be reported in Blender, with
-the exception details printed to the console.
+ options.
+When the Import Textures
+
+ mode is Packed
+
+, the texture is saved to a temporary location and the
+second element of the returned tuple is True
+
+, indicating that the file is temporary, in which
+case it may be necessary to pack the image. The original asset path will be returned unchanged if it's
+already a local file or if it could not be copied to a local destination.
+
+
+--------------------
+
+Exceptions raised by these functions will be reported in Blender with the exception details printed to the console.
+
+
+--------------------
 
 The USDHookExample
 
- class in this example impements the fllowing functions:
+ class in the example below implements the following functions:
 
 * on_export()
 
@@ -5635,10 +5822,24 @@ The USDHookExample
 
  function to create a simple MaterialX
 
- shader on the givne USD material.
+ shader on the given USD material.
 * on_import()
 
  function to create a text object to display the stage's custom layer data.
+* material_import_poll()
+
+ returns True
+
+ if the given USD material has an mtlx
+
+ context.
+* on_material_import()
+
+ function to convert a simple MaterialX
+
+ shader with a base_color
+
+ input.
 
 ```../examples/bpy.types.USDHook.py```
 
@@ -157916,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.
@@ -157939,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
         """
@@ -186704,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:
         """
 
@@ -208694,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:
@@ -208705,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.
@@ -209038,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:
@@ -209049,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.
@@ -209140,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:
@@ -209151,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.
@@ -209348,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:
@@ -209359,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.
@@ -209519,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:
@@ -209530,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.
@@ -209705,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:
@@ -209716,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.
@@ -209989,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:
@@ -210000,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.
@@ -210116,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:
@@ -210127,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.
@@ -210230,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:
@@ -210241,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.
@@ -210433,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:
@@ -210444,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.
@@ -210766,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:
@@ -210777,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.
@@ -210838,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:
@@ -210849,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.
@@ -210953,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:
@@ -210964,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.
@@ -211209,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:
@@ -211220,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.
@@ -211353,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:
@@ -211364,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.
@@ -211553,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:
@@ -211564,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.
@@ -212258,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:
@@ -212269,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.
@@ -230397,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:
@@ -230410,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`)