fake-bpy-module 20240719__py3-none-any.whl → 20240721__py3-none-any.whl

aud/__init__.pyi

@@ -157,25 +157,25 @@ class DynamicMusic:
 class HRTF:
     """An HRTF object represents a set of head related transfer functions as impulse responses. It's used for binaural sound"""
 
-    def loadLeftHrtfSet(self, extension: str, directory) -> HRTF:
+    def loadLeftHrtfSet(self, extension: str, directory) -> typing.Self:
         """Loads all HRTFs from a directory.
 
         :param extension: The file extension of the hrtfs.
         :type extension: str
         :param directory: The path to where the HRTF files are located.
         :return: The loaded `HRTF` object.
-        :rtype: HRTF
+        :rtype: typing.Self
         """
         ...
 
-    def loadRightHrtfSet(self, extension: str, directory) -> HRTF:
+    def loadRightHrtfSet(self, extension: str, directory) -> typing.Self:
         """Loads all HRTFs from a directory.
 
         :param extension: The file extension of the hrtfs.
         :type extension: str
         :param directory: The path to where the HRTF files are located.
         :return: The loaded `HRTF` object.
-        :rtype: HRTF
+        :rtype: typing.Self
         """
         ...
 
@@ -466,39 +466,39 @@ class Sound:
     """ The sample specification of the sound as a tuple with rate and channel count."""
 
     @classmethod
-    def buffer(cls, data, rate: float) -> Sound:
+    def buffer(cls, data, rate: float) -> typing.Self:
         """Creates a sound from a data buffer.
 
         :param data: The data as two dimensional numpy array.
         :param rate: The sample rate.
         :type rate: float
         :return: The created `Sound` object.
-        :rtype: Sound
+        :rtype: typing.Self
         """
         ...
 
     @classmethod
-    def file(cls, filename: str) -> Sound:
+    def file(cls, filename: str) -> typing.Self:
         """Creates a sound object of a sound file.
 
         :param filename: Path of the file.
         :type filename: str
         :return: The created `Sound` object.
-        :rtype: Sound
+        :rtype: typing.Self
         """
         ...
 
     @classmethod
-    def list(cls) -> Sound:
+    def list(cls) -> typing.Self:
         """Creates an empty sound list that can contain several sounds.
 
         :return: The created `Sound` object.
-        :rtype: Sound
+        :rtype: typing.Self
         """
         ...
 
     @classmethod
-    def sawtooth(cls, frequency: float, rate: int = 48000) -> Sound:
+    def sawtooth(cls, frequency: float, rate: int = 48000) -> typing.Self:
         """Creates a sawtooth sound which plays a sawtooth wave.
 
                 :param frequency: The frequency of the sawtooth wave in Hz.
@@ -507,24 +507,24 @@ class Sound:
         value to the playback device's samling rate to avoid resamping.
                 :type rate: int
                 :return: The created `Sound` object.
-                :rtype: Sound
+                :rtype: typing.Self
         """
         ...
 
     @classmethod
-    def silence(cls, rate: int = 48000) -> Sound:
+    def silence(cls, rate: int = 48000) -> typing.Self:
         """Creates a silence sound which plays simple silence.
 
                 :param rate: The sampling rate in Hz. It's recommended to set this
         value to the playback device's samling rate to avoid resamping.
                 :type rate: int
                 :return: The created `Sound` object.
-                :rtype: Sound
+                :rtype: typing.Self
         """
         ...
 
     @classmethod
-    def sine(cls, frequency: float, rate: int = 48000) -> Sound:
+    def sine(cls, frequency: float, rate: int = 48000) -> typing.Self:
         """Creates a sine sound which plays a sine wave.
 
                 :param frequency: The frequency of the sine wave in Hz.
@@ -533,12 +533,12 @@ class Sound:
         value to the playback device's samling rate to avoid resamping.
                 :type rate: int
                 :return: The created `Sound` object.
-                :rtype: Sound
+                :rtype: typing.Self
         """
         ...
 
     @classmethod
-    def square(cls, frequency: float, rate: int = 48000) -> Sound:
+    def square(cls, frequency: float, rate: int = 48000) -> typing.Self:
         """Creates a square sound which plays a square wave.
 
                 :param frequency: The frequency of the square wave in Hz.
@@ -547,12 +547,12 @@ class Sound:
         value to the playback device's samling rate to avoid resamping.
                 :type rate: int
                 :return: The created `Sound` object.
-                :rtype: Sound
+                :rtype: typing.Self
         """
         ...
 
     @classmethod
-    def triangle(cls, frequency: float, rate: int = 48000) -> Sound:
+    def triangle(cls, frequency: float, rate: int = 48000) -> typing.Self:
         """Creates a triangle sound which plays a triangle wave.
 
                 :param frequency: The frequency of the triangle wave in Hz.
@@ -561,13 +561,13 @@ class Sound:
         value to the playback device's samling rate to avoid resamping.
                 :type rate: int
                 :return: The created `Sound` object.
-                :rtype: Sound
+                :rtype: typing.Self
         """
         ...
 
     def ADSR(
         self, attack: float, decay: float, sustain: float, release: float
-    ) -> Sound:
+    ) -> typing.Self:
         """Attack-Decay-Sustain-Release envelopes the volume of a sound.
         Note: there is currently no way to trigger the release with this API.
 
@@ -580,11 +580,11 @@ class Sound:
                 :param release: The release level.
                 :type release: float
                 :return: The created `Sound` object.
-                :rtype: Sound
+                :rtype: typing.Self
         """
         ...
 
-    def accumulate(self, additive=False) -> Sound:
+    def accumulate(self, additive=False) -> typing.Self:
         """Accumulates a sound by summing over positive input
         differences thus generating a monotonic sigal.
         If additivity is set to true negative input differences get added too,
@@ -592,41 +592,41 @@ class Sound:
 
                 :param additive: Whether the accumulation should be additive or not.
                 :return: The created `Sound` object.
-                :rtype: Sound
+                :rtype: typing.Self
         """
         ...
 
-    def addSound(self, sound: Sound):
+    def addSound(self, sound: typing.Self):
         """Adds a new sound to a sound list.
 
         :param sound: The sound that will be added to the list.
-        :type sound: Sound
+        :type sound: typing.Self
         """
         ...
 
-    def binaural(self) -> Sound:
+    def binaural(self) -> typing.Self:
         """Creates a binaural sound using another sound as source. The original sound must be mono
 
         :return: The created `Sound` object.
-        :rtype: Sound
+        :rtype: typing.Self
         """
         ...
 
-    def cache(self) -> Sound:
+    def cache(self) -> typing.Self:
         """Caches a sound into RAM.This saves CPU usage needed for decoding and file access if the
         underlying sound reads from a file on the harddisk,
         but it consumes a lot of memory.
 
                 :return: The created `Sound` object.
-                :rtype: Sound
+                :rtype: typing.Self
         """
         ...
 
-    def convolver(self) -> Sound:
+    def convolver(self) -> typing.Self:
         """Creates a sound that will apply convolution to another sound.
 
         :return: The created `Sound` object.
-        :rtype: Sound
+        :rtype: typing.Self
         """
         ...
 
@@ -637,19 +637,19 @@ class Sound:
         """
         ...
 
-    def delay(self, time: float) -> Sound:
+    def delay(self, time: float) -> typing.Self:
         """Delays by playing adding silence in front of the other sound's data.
 
         :param time: How many seconds of silence should be added before the sound.
         :type time: float
         :return: The created `Sound` object.
-        :rtype: Sound
+        :rtype: typing.Self
         """
         ...
 
     def envelope(
         self, attack: float, release: float, threshold: float, arthreshold: float
-    ) -> Sound:
+    ) -> typing.Self:
         """Delays by playing adding silence in front of the other sound's data.
 
         :param attack: The attack factor.
@@ -661,11 +661,11 @@ class Sound:
         :param arthreshold: The attack/release threshold value.
         :type arthreshold: float
         :return: The created `Sound` object.
-        :rtype: Sound
+        :rtype: typing.Self
         """
         ...
 
-    def fadein(self, start: float, length: float) -> Sound:
+    def fadein(self, start: float, length: float) -> typing.Self:
         """Fades a sound in by raising the volume linearly in the given
         time interval.
 
@@ -674,11 +674,11 @@ class Sound:
                 :param length: Time in seconds how long the fading should last.
                 :type length: float
                 :return: The created `Sound` object.
-                :rtype: Sound
+                :rtype: typing.Self
         """
         ...
 
-    def fadeout(self, start: float, length: float) -> Sound:
+    def fadeout(self, start: float, length: float) -> typing.Self:
         """Fades a sound in by lowering the volume linearly in the given
         time interval.
 
@@ -687,11 +687,11 @@ class Sound:
                 :param length: Time in seconds how long the fading should last.
                 :type length: float
                 :return: The created `Sound` object.
-                :rtype: Sound
+                :rtype: typing.Self
         """
         ...
 
-    def filter(self, b: list[float], a: list[float] = 1) -> Sound:
+    def filter(self, b: list[float], a: list[float] = 1) -> typing.Self:
         """Filters a sound with the supplied IIR filter coefficients.
         Without the second parameter you'll get a FIR filter.If the first value of the a sequence is 0,
         it will be set to 1 automatically.
@@ -704,11 +704,11 @@ class Sound:
                 :param a: The denominator filter coefficients.
                 :type a: list[float]
                 :return: The created `Sound` object.
-                :rtype: Sound
+                :rtype: typing.Self
         """
         ...
 
-    def highpass(self, frequency: float, Q: float = 0.5) -> Sound:
+    def highpass(self, frequency: float, Q: float = 0.5) -> typing.Self:
         """Creates a second order highpass filter based on the transfer
         function H(s) = s^2 / (s^2 + s/Q + 1)
 
@@ -717,21 +717,21 @@ class Sound:
                 :param Q: Q factor of the lowpass.
                 :type Q: float
                 :return: The created `Sound` object.
-                :rtype: Sound
+                :rtype: typing.Self
         """
         ...
 
-    def join(self, sound: Sound) -> Sound:
+    def join(self, sound: typing.Self) -> typing.Self:
         """Plays two factories in sequence.
 
         :param sound: The sound to play second.
-        :type sound: Sound
+        :type sound: typing.Self
         :return: The created `Sound` object.
-        :rtype: Sound
+        :rtype: typing.Self
         """
         ...
 
-    def limit(self, start: float, end: float) -> Sound:
+    def limit(self, start: float, end: float) -> typing.Self:
         """Limits a sound within a specific start and end time.
 
         :param start: Start time in seconds.
@@ -739,22 +739,22 @@ class Sound:
         :param end: End time in seconds.
         :type end: float
         :return: The created `Sound` object.
-        :rtype: Sound
+        :rtype: typing.Self
         """
         ...
 
-    def loop(self, count: int) -> Sound:
+    def loop(self, count: int) -> typing.Self:
         """Loops a sound.
 
                 :param count: How often the sound should be looped.
         Negative values mean endlessly.
                 :type count: int
                 :return: The created `Sound` object.
-                :rtype: Sound
+                :rtype: typing.Self
         """
         ...
 
-    def lowpass(self, frequency: float, Q: float = 0.5) -> Sound:
+    def lowpass(self, frequency: float, Q: float = 0.5) -> typing.Self:
         """Creates a second order lowpass filter based on the transfer    function H(s) = 1 / (s^2 + s/Q + 1)
 
         :param frequency: The cut off trequency of the lowpass.
@@ -762,69 +762,69 @@ class Sound:
         :param Q: Q factor of the lowpass.
         :type Q: float
         :return: The created `Sound` object.
-        :rtype: Sound
+        :rtype: typing.Self
         """
         ...
 
-    def mix(self, sound: Sound) -> Sound:
+    def mix(self, sound: typing.Self) -> typing.Self:
         """Mixes two factories.
 
         :param sound: The sound to mix over the other.
-        :type sound: Sound
+        :type sound: typing.Self
         :return: The created `Sound` object.
-        :rtype: Sound
+        :rtype: typing.Self
         """
         ...
 
-    def modulate(self, sound: Sound) -> Sound:
+    def modulate(self, sound: typing.Self) -> typing.Self:
         """Modulates two factories.
 
         :param sound: The sound to modulate over the other.
-        :type sound: Sound
+        :type sound: typing.Self
         :return: The created `Sound` object.
-        :rtype: Sound
+        :rtype: typing.Self
         """
         ...
 
-    def mutable(self) -> Sound:
+    def mutable(self) -> typing.Self:
         """Creates a sound that will be restarted when sought backwards.
         If the original sound is a sound list, the playing sound can change.
 
                 :return: The created `Sound` object.
-                :rtype: Sound
+                :rtype: typing.Self
         """
         ...
 
-    def pingpong(self) -> Sound:
+    def pingpong(self) -> typing.Self:
         """Plays a sound forward and then backward.
         This is like joining a sound with its reverse.
 
                 :return: The created `Sound` object.
-                :rtype: Sound
+                :rtype: typing.Self
         """
         ...
 
-    def pitch(self, factor: float) -> Sound:
+    def pitch(self, factor: float) -> typing.Self:
         """Changes the pitch of a sound with a specific factor.
 
         :param factor: The factor to change the pitch with.
         :type factor: float
         :return: The created `Sound` object.
-        :rtype: Sound
+        :rtype: typing.Self
         """
         ...
 
-    def rechannel(self, channels: int) -> Sound:
+    def rechannel(self, channels: int) -> typing.Self:
         """Rechannels the sound.
 
         :param channels: The new channel configuration.
         :type channels: int
         :return: The created `Sound` object.
-        :rtype: Sound
+        :rtype: typing.Self
         """
         ...
 
-    def resample(self, rate: float, quality: int) -> Sound:
+    def resample(self, rate: float, quality: int) -> typing.Self:
         """Resamples the sound.
 
         :param rate: The new sample rate.
@@ -832,27 +832,27 @@ class Sound:
         :param quality: Resampler performance vs quality choice (0=fastest, 3=slowest).
         :type quality: int
         :return: The created `Sound` object.
-        :rtype: Sound
+        :rtype: typing.Self
         """
         ...
 
-    def reverse(self) -> Sound:
+    def reverse(self) -> typing.Self:
         """Plays a sound reversed.
 
         :return: The created `Sound` object.
-        :rtype: Sound
+        :rtype: typing.Self
         """
         ...
 
-    def sum(self) -> Sound:
+    def sum(self) -> typing.Self:
         """Sums the samples of a sound.
 
         :return: The created `Sound` object.
-        :rtype: Sound
+        :rtype: typing.Self
         """
         ...
 
-    def threshold(self, threshold: float = 0) -> Sound:
+    def threshold(self, threshold: float = 0) -> typing.Self:
         """Makes a threshold wave out of an audio wave by setting all samples
         with a amplitude >= threshold to 1, all <= -threshold to -1 and
         all between to 0.
@@ -861,17 +861,17 @@ class Sound:
         non-zero.
                 :type threshold: float
                 :return: The created `Sound` object.
-                :rtype: Sound
+                :rtype: typing.Self
         """
         ...
 
-    def volume(self, volume: float) -> Sound:
+    def volume(self, volume: float) -> typing.Self:
         """Changes the volume of a sound.
 
         :param volume: The new volume..
         :type volume: float
         :return: The created `Sound` object.
-        :rtype: Sound
+        :rtype: typing.Self
         """
         ...
 

bmesh/types/__init__.pyi

@@ -204,11 +204,11 @@ class BMEdge:
         """
         ...
 
-    def copy_from(self, other: BMEdge):
+    def copy_from(self, other: typing.Self):
         """Copy values from another element of matching type.
 
         :param other:
-        :type other: BMEdge
+        :type other: typing.Self
         """
         ...
 
@@ -595,7 +595,7 @@ class BMFace:
         """
         ...
 
-    def copy(self, verts: bool = True, edges: bool = True) -> BMFace:
+    def copy(self, verts: bool = True, edges: bool = True) -> typing.Self:
         """Make a copy of this face.
 
         :param verts: When set, the faces verts will be duplicated too.
@@ -603,23 +603,23 @@ class BMFace:
         :param edges: When set, the faces edges will be duplicated too.
         :type edges: bool
         :return: The newly created face.
-        :rtype: BMFace
+        :rtype: typing.Self
         """
         ...
 
-    def copy_from(self, other: BMFace):
+    def copy_from(self, other: typing.Self):
         """Copy values from another element of matching type.
 
         :param other:
-        :type other: BMFace
+        :type other: typing.Self
         """
         ...
 
-    def copy_from_face_interp(self, face: BMFace, vert: bool = True):
+    def copy_from_face_interp(self, face: typing.Self, vert: bool = True):
         """Interpolate the customdata from another face onto this one (faces should overlap).
 
         :param face: The face to interpolate data from.
-        :type face: BMFace
+        :type face: typing.Self
         :param vert: When True, also copy vertex data.
         :type vert: bool
         """
@@ -1041,7 +1041,7 @@ class BMLayerCollection:
         """
         ...
 
-    def new(self, name: str | None) -> BMLayerItem:
+    def new(self, name: str | None = "") -> BMLayerItem:
         """Create a new layer
 
         :param name: Optional name argument (will be made unique).
@@ -1085,11 +1085,11 @@ class BMLayerItem:
     :type: str
     """
 
-    def copy_from(self, other: BMLayerItem):
+    def copy_from(self, other: typing.Self):
         """Return a copy of the layer
 
         :param other: Another layer to copy from.
-        :type other: BMLayerItem
+        :type other: typing.Self
         """
         ...
 
@@ -1126,28 +1126,28 @@ class BMLoop:
     :type: bool
     """
 
-    link_loop_next: BMLoop
+    link_loop_next: typing.Self
     """ The next face corner (read-only).
 
-    :type: BMLoop
+    :type: typing.Self
     """
 
-    link_loop_prev: BMLoop
+    link_loop_prev: typing.Self
     """ The previous face corner (read-only).
 
-    :type: BMLoop
+    :type: typing.Self
     """
 
-    link_loop_radial_next: BMLoop
+    link_loop_radial_next: typing.Self
     """ The next loop around the edge (read-only).
 
-    :type: BMLoop
+    :type: typing.Self
     """
 
-    link_loop_radial_prev: BMLoop
+    link_loop_radial_prev: typing.Self
     """ The previous loop around the edge (read-only).
 
-    :type: BMLoop
+    :type: typing.Self
     """
 
     link_loops: BMElemSeq[BMLoop]
@@ -1195,11 +1195,11 @@ class BMLoop:
         """
         ...
 
-    def copy_from(self, other: BMLoop):
+    def copy_from(self, other: typing.Self):
         """Copy values from another element of matching type.
 
         :param other:
-        :type other: BMLoop
+        :type other: typing.Self
         """
         ...
 
@@ -1379,11 +1379,11 @@ class BMVert:
         """
         ...
 
-    def copy_from(self, other: BMVert):
+    def copy_from(self, other: typing.Self):
         """Copy values from another element of matching type.
 
         :param other:
-        :type other: BMVert
+        :type other: typing.Self
         """
         ...
 
@@ -1617,11 +1617,11 @@ class BMesh:
         """Clear all mesh data."""
         ...
 
-    def copy(self) -> BMesh:
+    def copy(self) -> typing.Self:
         """
 
         :return: A copy of this BMesh.
-        :rtype: BMesh
+        :rtype: typing.Self
         """
         ...
 

bpy/app/timers/__init__.pyi

@@ -37,11 +37,11 @@ import typing_extensions
 GenericType1 = typing.TypeVar("GenericType1")
 GenericType2 = typing.TypeVar("GenericType2")
 
-def is_registered(function: collections.abc.Callable[[], float]) -> bool:
+def is_registered(function: collections.abc.Callable[[], float | None]) -> bool:
     """Check if this function is registered as a timer.
 
     :param function: Function to check.
-    :type function: collections.abc.Callable[[], float]
+    :type function: collections.abc.Callable[[], float | None]
     :return: True when this function is registered, otherwise False.
     :rtype: bool
     """
@@ -49,7 +49,7 @@ def is_registered(function: collections.abc.Callable[[], float]) -> bool:
     ...
 
 def register(
-    function: collections.abc.Callable[[], float],
+    function: collections.abc.Callable[[], float | None],
     first_interval: float | None = 0,
     persistent: bool | None = False,
 ):
@@ -60,7 +60,7 @@ def register(
     functools.partial can be used to assign some parameters.
 
         :param function: The function that should called.
-        :type function: collections.abc.Callable[[], float]
+        :type function: collections.abc.Callable[[], float | None]
         :param first_interval: Seconds until the callback should be called the first time.
         :type first_interval: float | None
         :param persistent: Don't remove timer when a new file is loaded.
@@ -69,11 +69,11 @@ def register(
 
     ...
 
-def unregister(function: collections.abc.Callable[[], float]):
+def unregister(function: collections.abc.Callable[[], float | None]):
     """Unregister timer.
 
     :param function: Function to unregister.
-    :type function: collections.abc.Callable[[], float]
+    :type function: collections.abc.Callable[[], float | None]
     """
 
     ...