fake-bpy-module 20240417__py3-none-any.whl → 20240418__py3-none-any.whl

bpy/app/icons/__init__.pyi

@@ -4,7 +4,7 @@ GenericType = typing.TypeVar("GenericType")
 
 def new_triangles(
     range: tuple, coords: typing.Sequence[bytes], colors: typing.Sequence[bytes]
-):
+) -> int:
     """Create a new icon from triangle geometry.
 
     :param range: Pair of ints.
@@ -14,16 +14,18 @@ def new_triangles(
     :param colors: Sequence of ints (12 for one triangles) for RGBA.
     :type colors: typing.Sequence[bytes]
     :return: Unique icon value (pass to interface icon_value argument).
+    :rtype: int
     """
 
     ...
 
-def new_triangles_from_file(filepath: str):
+def new_triangles_from_file(filepath: str) -> int:
     """Create a new icon from triangle geometry.
 
     :param filepath: File path.
     :type filepath: str
     :return: Unique icon value (pass to interface icon_value argument).
+    :rtype: int
     """
 
     ...

bpy/app/timers/__init__.pyi

@@ -1,18 +1,53 @@
+"""
+
+--------------------
+
+```../examples/bpy.app.timers.1.py```
+
+
+--------------------
+
+```../examples/bpy.app.timers.2.py```
+
+
+--------------------
+
+```../examples/bpy.app.timers.3.py```
+
+
+--------------------
+
+```../examples/bpy.app.timers.4.py```
+
+
+--------------------
+
+You should never modify Blender data at arbitrary points in time in separate threads.
+However you can use a queue to collect all the actions that should be executed when Blender is in the right state again.
+Pythons queue.Queue can be used here, because it implements the required locking semantics.
+
+```../examples/bpy.app.timers.5.py```
+
+"""
+
 import typing
 
 GenericType = typing.TypeVar("GenericType")
 
-def is_registered(function) -> bool:
+def is_registered(function: int) -> bool:
     """Check if this function is registered as a timer.
 
     :param function: Function to check.
+    :type function: int
     :return: True when this function is registered, otherwise False.
     :rtype: bool
     """
 
     ...
 
-def register(function: typing.Callable, first_interval=0, persistent: bool = False):
+def register(
+    function: typing.Callable, first_interval: float = 0, persistent: bool = False
+):
     """Add a new function that will be called after the specified amount of seconds.
     The function gets no arguments and is expected to return either None or a float.
     If None is returned, the timer will be unregistered.
@@ -22,6 +57,7 @@ def register(function: typing.Callable, first_interval=0, persistent: bool = Fal
         :param function: The function that should called.
         :type function: typing.Callable
         :param first_interval: Seconds until the callback should be called the first time.
+        :type first_interval: float
         :param persistent: Don't remove timer when a new file is loaded.
         :type persistent: bool
     """

bpy/app/translations/__init__.pyi

@@ -1,3 +1,61 @@
+"""
+This object contains some data/methods regarding internationalization in Blender, and allows every py script
+to feature translations for its own UI messages.
+
+
+--------------------
+
+[WARNING]
+Most of this object should only be useful if you actually manipulate i18n stuff from Python.
+If you are a regular add-on, you should only bother about contexts member,
+and the register/unregister functions! The pgettext family of functions
+should only be used in rare, specific cases (like e.g. complex "composited" UI strings...).
+
+To add translations to your python script, you must define a dictionary formatted like that:
+{locale: {msg_key: msg_translation, ...}, ...}
+
+ where:
+
+* locale is either a lang iso code (e.g. fr
+
+), a lang+country code (e.g. pt_BR
+
+),
+a lang+variant code (e.g. sr@latin
+
+), or a full code (e.g. uz_UZ@cyrilic
+
+).
+* msg_key is a tuple (context, org message) - use, as much as possible, the predefined contexts.
+* msg_translation is the translated message in given language!
+
+Then, call bpy.app.translations.register(__name__, your_dict)
+
+ in your register()
+
+ function, and
+bpy.app.translations.unregister(__name__)
+
+ in your unregister()
+
+ one.
+
+The Manage UI translations
+
+ add-on has several functions to help you collect strings to translate, and
+generate the needed python code (the translation dictionary), as well as optional intermediary po files
+if you want some... See
+How to Translate Blender and
+Using i18n in Blender Code
+for more info.
+
+
+--------------------
+
+```../examples/bpy.app.translations.py```
+
+"""
+
 import typing
 
 GenericType = typing.TypeVar("GenericType")

bpy/msgbus/__init__.pyi

@@ -1,3 +1,49 @@
+"""
+The message bus system can be used to receive notifications when properties of
+Blender datablocks are changed via the data API.
+
+
+--------------------
+
+The message bus system is triggered by updates via the RNA system. This means
+that the following updates will result in a notification on the message bus:
+
+* Changes via the Python API, for example some_object.location.x += 3
+
+.
+* Changes via the sliders, fields, and buttons in the user interface.
+
+The following updates do not trigger message bus notifications:
+
+* Moving objects in the 3D Viewport.
+* Changes performed by the animation system.
+
+
+--------------------
+
+Below is an example of subscription to changes in the active object's location.
+
+```../examples/bpy.msgbus.1.py```
+
+Some properties are converted to Python objects when you retrieve them. This
+needs to be avoided in order to create the subscription, by using
+datablock.path_resolve("property_name", False)
+
+:
+
+```../examples/bpy.msgbus.2.py```
+
+It is also possible to create subscriptions on a property of all instances of a
+certain type:
+
+```../examples/bpy.msgbus.3.py```
+
+[NOTE]
+All subscribers will be cleared on file-load. Subscribers can be re-registered on load,
+see bpy.app.handlers.load_post.
+
+"""
+
 import typing
 
 GenericType = typing.TypeVar("GenericType")

bpy/ops/__init__.pyi

@@ -1,3 +1,154 @@
+"""
+
+--------------------
+
+Provides python access to calling operators, this includes operators written in
+C, Python or macros.
+
+Only keyword arguments can be used to pass operator properties.
+
+Operators don't have return values as you might expect,
+instead they return a set() which is made up of:
+{'RUNNING_MODAL', 'CANCELLED', 'FINISHED', 'PASS_THROUGH'}
+
+.
+Common return values are {'FINISHED'}
+
+ and {'CANCELLED'}
+
+, the latter
+meaning that the operator execution was aborted without making any changes or
+saving an undo history entry.
+
+Calling an operator in the wrong context will raise a RuntimeError
+
+,
+there is a poll() method to avoid this problem.
+
+Note that the operator ID (bl_idname) in this example is mesh.subdivide
+
+,
+bpy.ops
+
+ is just the access path for python.
+
+
+--------------------
+
+For calling operators keywords are used for operator properties and
+positional arguments are used to define how the operator is called.
+
+There are 2 optional positional arguments (documented in detail below).
+
+```
+bpy.ops.test.operator(execution_context, undo)
+```
+
+* execution_context - str
+
+ (enum).
+* undo - bool
+
+ type.
+
+Each of these arguments is optional, but must be given in the order above.
+
+```../examples/bpy.ops.py```
+
+
+--------------------
+
+It is possible to override context members that the operator sees, so that they
+act on specified rather than the selected or active data, or to execute an
+operator in the different part of the user interface.
+
+The context overrides are passed as a dictionary, with keys matching the context
+member names in bpy.context.
+For example to override bpy.context.active_object
+
+,
+you would pass {'active_object': object}
+
+ to bpy.types.Context.temp_override.
+
+[NOTE]
+You will nearly always want to use a copy of the actual current context as basis
+(otherwise, you'll have to find and gather all needed data yourself).
+
+```../examples/bpy.ops.1.py```
+
+
+--------------------
+
+When calling an operator you may want to pass the execution context.
+
+This determines the context that is given for the operator to run in, and whether
+invoke() is called or only execute().
+
+EXEC_DEFAULT
+
+ is used by default, running only the execute()
+
+ method, but you may
+want the operator to take user interaction with INVOKE_DEFAULT
+
+ which will also
+call invoke() if existing.
+
+The execution context is one of:
+
+* INVOKE_DEFAULT
+
+
+* INVOKE_REGION_WIN
+
+
+* INVOKE_REGION_CHANNELS
+
+
+* INVOKE_REGION_PREVIEW
+
+
+* INVOKE_AREA
+
+
+* INVOKE_SCREEN
+
+
+* EXEC_DEFAULT
+
+
+* EXEC_REGION_WIN
+
+
+* EXEC_REGION_CHANNELS
+
+
+* EXEC_REGION_PREVIEW
+
+
+* EXEC_AREA
+
+
+* EXEC_SCREEN
+
+
+
+```../examples/bpy.ops.2.py```
+
+It is also possible to run an operator in a particular part of the user
+interface. For this we need to pass the window, area and sometimes a region.
+
+```../examples/bpy.ops.3.py```
+
+bpy.ops.*
+
+:caption: Submodules
+:maxdepth: 1
+:glob:
+
+"""
+
 import typing
 from . import action
 from . import anim