fake-bpy-module 20240321__py3-none-any.whl → 20240322__py3-none-any.whl

aud/__init__.pyi

@@ -46,16 +46,16 @@ The speed of sound in air is typically 343.3 m/s."""
         """
         ...
 
-    def play(self, sound: "Sound", keep: bool = False) -> "Handle":
+    def play(self, sound: Sound, keep: bool = False) -> bool:
         """Plays a sound.
 
                 :param sound: The sound to play.
-                :type sound: 'Sound'
+                :type sound: Sound
                 :param keep: See `Handle.keep`.
                 :type keep: bool
-                :rtype: 'Handle'
                 :return: The playback handle with which playback can be
         controlled with.
+                :rtype: Handle
         """
         ...
 
@@ -90,17 +90,17 @@ class DynamicMusic:
     volume: typing.Any
     """ The volume of the scene."""
 
-    def addScene(self, scene: "Sound") -> int:
+    def addScene(self, scene: Sound) -> Sound:
         """Adds a new scene.
 
         :param scene: The scene sound.
-        :type scene: 'Sound'
-        :rtype: int
+        :type scene: Sound
         :return: The new scene id.
+        :rtype: int
         """
         ...
 
-    def addTransition(self, ini: int, end: int, transition: "Sound") -> bool:
+    def addTransition(self, ini: int, end: int, transition: Sound) -> Sound:
         """Adds a new scene.
 
         :param ini: the initial scene foor the transition.
@@ -108,76 +108,74 @@ class DynamicMusic:
         :param end: The final scene for the transition.
         :type end: int
         :param transition: The transition sound.
-        :type transition: 'Sound'
-        :rtype: bool
+        :type transition: Sound
         :return: false if the ini or end scenes don't exist, true othrwise.
+        :rtype: bool
         """
         ...
 
     def pause(self) -> bool:
         """Pauses playback of the scene.
 
-        :rtype: bool
         :return: Whether the action succeeded.
+        :rtype: bool
         """
         ...
 
     def resume(self) -> bool:
         """Resumes playback of the scene.
 
-        :rtype: bool
         :return: Whether the action succeeded.
+        :rtype: bool
         """
         ...
 
     def stop(self) -> bool:
         """Stops playback of the scene.
 
-        :rtype: bool
         :return: Whether the action succeeded.
+        :rtype: bool
         """
         ...
 
 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: typing.Union[str, str], directory):
         """Loads all HRTFs from a directory.
 
         :param extension: The file extension of the hrtfs.
-        :type extension: str
+        :type extension: typing.Union[str, str]
         :param directory: The path to where the HRTF files are located.
-        :type directory:
-        :rtype: 'HRTF'
         :return: The loaded `HRTF` object.
+        :rtype: HRTF
         """
         ...
 
-    def loadLeftHrtfSet(self, extension: str, directory) -> "HRTF":
+    def loadLeftHrtfSet(self, extension: typing.Union[str, str], directory):
         """Loads all HRTFs from a directory.
 
         :param extension: The file extension of the hrtfs.
-        :type extension: str
+        :type extension: typing.Union[str, str]
         :param directory: The path to where the HRTF files are located.
-        :type directory:
-        :rtype: 'HRTF'
         :return: The loaded `HRTF` object.
+        :rtype: HRTF
         """
         ...
 
     def addImpulseResponseFromSound(
-        self, sound: "Sound", azimuth: float, elevation: float
-    ) -> bool:
+        self, sound: Sound, azimuth: float, elevation: float
+    ) -> float:
         """Adds a new hrtf to the HRTF object
 
         :param sound: The sound that contains the hrtf.
-        :type sound: 'Sound'
+        :type sound: Sound
         :param azimuth: The azimuth angle of the hrtf.
         :type azimuth: float
         :param elevation: The elevation angle of the hrtf.
         :type elevation: float
-        :rtype: bool
         :return: Whether the action succeeded.
+        :rtype: bool
         """
         ...
 
@@ -242,27 +240,27 @@ This can be used to seek the sound to some position and start playback again."""
     volume_minimum: typing.Any
     """ The minimum volume of the source.:attr:`Device.distance_model`"""
 
-    def pause(self) -> bool:
+    def pause(self):
         """Pauses playback.
 
-        :rtype: bool
         :return: Whether the action succeeded.
+        :rtype: bool
         """
         ...
 
     def resume(self) -> bool:
         """Resumes playback.
 
-        :rtype: bool
         :return: Whether the action succeeded.
+        :rtype: bool
         """
         ...
 
     def stop(self) -> bool:
         """Stops playback.
 
-        :rtype: bool
         :return: Whether the action succeeded.
+        :rtype: bool
         """
         ...
 
@@ -274,13 +272,13 @@ class ImpulseResponse:
 class PlaybackManager:
     """A PlabackManager object allows to easily control groups os sounds organized in categories."""
 
-    def addCategory(self, volume: float) -> int:
+    def addCategory(self, volume: float) -> float:
         """Adds a category with a custom volume.
 
         :param volume: The volume for ther new category.
         :type volume: float
-        :rtype: int
         :return: The key of the new category.
+        :rtype: int
         """
         ...
 
@@ -288,46 +286,46 @@ class PlaybackManager:
         """Cleans all the invalid and finished sound from the playback manager."""
         ...
 
-    def getVolume(self, catKey: int) -> float:
+    def getVolume(self, catKey: int) -> int:
         """Retrieves the volume of a category.
 
         :param catKey: the key of the category.
         :type catKey: int
-        :rtype: float
         :return: The volume of the cateogry.
+        :rtype: float
         """
         ...
 
-    def pause(self, catKey: int) -> bool:
+    def pause(self, catKey: int) -> int:
         """Pauses playback of the category.
 
         :param catKey: the key of the category.
         :type catKey: int
-        :rtype: bool
         :return: Whether the action succeeded.
+        :rtype: bool
         """
         ...
 
-    def play(self, sound: "Sound", catKey: int) -> "Handle":
+    def play(self, sound: Sound, catKey: int) -> int:
         """Plays a sound through the playback manager and assigns it to a category.
 
                 :param sound: The sound to play.
-                :type sound: 'Sound'
+                :type sound: Sound
                 :param catKey: the key of the category in which the sound will be added,
         if it doesn't exist, a new one will be created.
                 :type catKey: int
-                :rtype: 'Handle'
                 :return: The playback handle with which playback can be controlled with.
+                :rtype: Handle
         """
         ...
 
-    def resume(self, catKey: int) -> bool:
+    def resume(self, catKey: int) -> int:
         """Resumes playback of the catgory.
 
         :param catKey: the key of the category.
         :type catKey: int
-        :rtype: bool
         :return: Whether the action succeeded.
+        :rtype: bool
         """
         ...
 
@@ -338,18 +336,18 @@ class PlaybackManager:
         :type volume: float
         :param catKey: the key of the category.
         :type catKey: int
-        :rtype: int
         :return: Whether the action succeeded.
+        :rtype: int
         """
         ...
 
-    def stop(self, catKey: int) -> bool:
+    def stop(self, catKey: int) -> int:
         """Stops playback of the category.
 
         :param catKey: the key of the category.
         :type catKey: int
-        :rtype: bool
         :return: Whether the action succeeded.
+        :rtype: bool
         """
         ...
 
@@ -379,11 +377,11 @@ This factor is a scaling factor for the velocity vectors in doppler calculation.
     """ The speed of sound of the sequence.
 The speed of sound in air is typically 343.3 m/s."""
 
-    def add(self) -> "SequenceEntry":
+    def add(self):
         """Adds a new entry to the sequence.
 
-        :rtype: 'SequenceEntry'
         :return: The entry added.
+        :rtype: SequenceEntry
         """
         ...
 
@@ -451,37 +449,40 @@ class Sound:
     specs: typing.Any
     """ The sample specification of the sound as a tuple with rate and channel count."""
 
-    def buffer(self, data: typing.Any, rate: float) -> "Sound":
+    @classmethod
+    def buffer(cls, data, rate: float) -> float:
         """Creates a sound from a data buffer.
 
         :param data: The data as two dimensional numpy array.
-        :type data: typing.Any
         :param rate: The sample rate.
         :type rate: float
-        :rtype: 'Sound'
         :return: The created `Sound` object.
+        :rtype: Sound
         """
         ...
 
-    def file(self, filename: str) -> "Sound":
+    @classmethod
+    def file(cls, filename: str) -> str:
         """Creates a sound object of a sound file.
 
         :param filename: Path of the file.
         :type filename: str
-        :rtype: 'Sound'
         :return: The created `Sound` object.
+        :rtype: Sound
         """
         ...
 
-    def list(self) -> "Sound":
+    @classmethod
+    def list(cls) -> Sound:
         """Creates an empty sound list that can contain several sounds.
 
-        :rtype: 'Sound'
         :return: The created `Sound` object.
+        :rtype: Sound
         """
         ...
 
-    def sawtooth(self, frequency: float, rate: int = 48000) -> "Sound":
+    @classmethod
+    def sawtooth(cls, frequency: float, rate: int = 48000) -> int:
         """Creates a sawtooth sound which plays a sawtooth wave.
 
                 :param frequency: The frequency of the sawtooth wave in Hz.
@@ -489,23 +490,25 @@ class Sound:
                 :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
-                :rtype: 'Sound'
                 :return: The created `Sound` object.
+                :rtype: Sound
         """
         ...
 
-    def silence(self, rate: int = 48000) -> "Sound":
+    @classmethod
+    def silence(cls, rate: int = 48000) -> int:
         """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
-                :rtype: 'Sound'
                 :return: The created `Sound` object.
+                :rtype: Sound
         """
         ...
 
-    def sine(self, frequency: float, rate: int = 48000) -> "Sound":
+    @classmethod
+    def sine(cls, frequency: float, rate: int = 48000) -> int:
         """Creates a sine sound which plays a sine wave.
 
                 :param frequency: The frequency of the sine wave in Hz.
@@ -513,12 +516,13 @@ class Sound:
                 :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
-                :rtype: 'Sound'
                 :return: The created `Sound` object.
+                :rtype: Sound
         """
         ...
 
-    def square(self, frequency: float, rate: int = 48000) -> "Sound":
+    @classmethod
+    def square(cls, frequency: float, rate: int = 48000) -> int:
         """Creates a square sound which plays a square wave.
 
                 :param frequency: The frequency of the square wave in Hz.
@@ -526,12 +530,13 @@ class Sound:
                 :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
-                :rtype: 'Sound'
                 :return: The created `Sound` object.
+                :rtype: Sound
         """
         ...
 
-    def triangle(self, frequency: float, rate: int = 48000) -> "Sound":
+    @classmethod
+    def triangle(cls, frequency: float, rate: int = 48000) -> int:
         """Creates a triangle sound which plays a triangle wave.
 
                 :param frequency: The frequency of the triangle wave in Hz.
@@ -539,14 +544,14 @@ class Sound:
                 :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
-                :rtype: 'Sound'
                 :return: The created `Sound` object.
+                :rtype: Sound
         """
         ...
 
     def ADSR(
         self, attack: float, decay: float, sustain: float, release: float
-    ) -> "Sound":
+    ) -> float:
         """Attack-Decay-Sustain-Release envelopes the volume of a sound.
         Note: there is currently no way to trigger the release with this API.
 
@@ -558,79 +563,77 @@ class Sound:
                 :type sustain: float
                 :param release: The release level.
                 :type release: float
-                :rtype: 'Sound'
                 :return: The created `Sound` object.
+                :rtype: Sound
         """
         ...
 
-    def accumulate(self, additive=False) -> "Sound":
+    def accumulate(self, additive=False):
         """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,
         but positive ones with a factor of two.Note that with additivity the signal is not monotonic anymore.
 
                 :param additive: Whether the accumulation should be additive or not.
-                :type additive:
-                :rtype: 'Sound'
                 :return: The created `Sound` object.
+                :rtype: Sound
         """
         ...
 
-    def addSound(self, sound: "Sound"):
+    def addSound(self, sound: Sound):
         """Adds a new sound to a sound list.
 
         :param sound: The sound that will be added to the list.
-        :type sound: 'Sound'
+        :type sound: Sound
         """
         ...
 
-    def binaural(self) -> "Sound":
+    def binaural(self) -> Sound:
         """Creates a binaural sound using another sound as source. The original sound must be mono
 
-        :rtype: 'Sound'
         :return: The created `Sound` object.
+        :rtype: Sound
         """
         ...
 
-    def cache(self) -> "Sound":
+    def cache(self) -> Sound:
         """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.
 
-                :rtype: 'Sound'
                 :return: The created `Sound` object.
+                :rtype: Sound
         """
         ...
 
-    def convolver(self) -> "Sound":
+    def convolver(self) -> Sound:
         """Creates a sound that will apply convolution to another sound.
 
-        :rtype: 'Sound'
         :return: The created `Sound` object.
+        :rtype: Sound
         """
         ...
 
-    def data(self) -> typing.Any:
+    def data(self) -> Sound:
         """Retrieves the data of the sound as numpy array.
 
-        :rtype: typing.Any
         :return: A two dimensional numpy float array.
         """
         ...
 
-    def delay(self, time: float) -> "Sound":
+    def delay(self, time: float) -> float:
         """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
-        :rtype: 'Sound'
         :return: The created `Sound` object.
+        :rtype: Sound
         """
         ...
 
     def envelope(
         self, attack: float, release: float, threshold: float, arthreshold: float
-    ) -> "Sound":
+    ) -> float:
         """Delays by playing adding silence in front of the other sound's data.
 
         :param attack: The attack factor.
@@ -641,12 +644,12 @@ class Sound:
         :type threshold: float
         :param arthreshold: The attack/release threshold value.
         :type arthreshold: float
-        :rtype: 'Sound'
         :return: The created `Sound` object.
+        :rtype: Sound
         """
         ...
 
-    def fadein(self, start: float, length: float) -> "Sound":
+    def fadein(self, start: float, length: float) -> float:
         """Fades a sound in by raising the volume linearly in the given
         time interval.
 
@@ -654,12 +657,12 @@ class Sound:
                 :type start: float
                 :param length: Time in seconds how long the fading should last.
                 :type length: float
-                :rtype: 'Sound'
                 :return: The created `Sound` object.
+                :rtype: Sound
         """
         ...
 
-    def fadeout(self, start: float, length: float) -> "Sound":
+    def fadeout(self, start: float, length: float) -> float:
         """Fades a sound in by lowering the volume linearly in the given
         time interval.
 
@@ -667,12 +670,14 @@ class Sound:
                 :type start: float
                 :param length: Time in seconds how long the fading should last.
                 :type length: float
-                :rtype: 'Sound'
                 :return: The created `Sound` object.
+                :rtype: Sound
         """
         ...
 
-    def filter(self, b: typing.List[float], a: typing.List[float] = 1) -> "Sound":
+    def filter(
+        self, b: typing.List[float], a: typing.List[float] = 1
+    ) -> typing.List[float]:
         """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.
@@ -684,12 +689,12 @@ class Sound:
                 :type b: typing.List[float]
                 :param a: The denominator filter coefficients.
                 :type a: typing.List[float]
-                :rtype: 'Sound'
                 :return: The created `Sound` object.
+                :rtype: Sound
         """
         ...
 
-    def highpass(self, frequency: float, Q: float = 0.5) -> "Sound":
+    def highpass(self, frequency: float, Q: float = 0.5) -> float:
         """Creates a second order highpass filter based on the transfer
         function H(s) = s^2 / (s^2 + s/Q + 1)
 
@@ -697,143 +702,142 @@ class Sound:
                 :type frequency: float
                 :param Q: Q factor of the lowpass.
                 :type Q: float
-                :rtype: 'Sound'
                 :return: The created `Sound` object.
+                :rtype: Sound
         """
         ...
 
-    def join(self, sound: "Sound") -> "Sound":
+    def join(self, sound: Sound) -> Sound:
         """Plays two factories in sequence.
 
         :param sound: The sound to play second.
-        :type sound: 'Sound'
-        :rtype: 'Sound'
+        :type sound: Sound
         :return: The created `Sound` object.
+        :rtype: Sound
         """
         ...
 
-    def limit(self, start: float, end: float) -> "Sound":
+    def limit(self, start: float, end: float) -> float:
         """Limits a sound within a specific start and end time.
 
         :param start: Start time in seconds.
         :type start: float
         :param end: End time in seconds.
         :type end: float
-        :rtype: 'Sound'
         :return: The created `Sound` object.
+        :rtype: Sound
         """
         ...
 
-    def loop(self, count: typing.Any) -> "Sound":
+    def loop(self, count):
         """Loops a sound.
 
                 :param count: How often the sound should be looped.
         Negative values mean endlessly.
-                :type count: typing.Any
-                :rtype: 'Sound'
                 :return: The created `Sound` object.
+                :rtype: Sound
         """
         ...
 
-    def lowpass(self, frequency: float, Q: float = 0.5) -> "Sound":
+    def lowpass(self, frequency: float, Q: float = 0.5) -> float:
         """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.
         :type frequency: float
         :param Q: Q factor of the lowpass.
         :type Q: float
-        :rtype: 'Sound'
         :return: The created `Sound` object.
+        :rtype: Sound
         """
         ...
 
-    def mix(self, sound: "Sound") -> "Sound":
+    def mix(self, sound: Sound) -> Sound:
         """Mixes two factories.
 
         :param sound: The sound to mix over the other.
-        :type sound: 'Sound'
-        :rtype: 'Sound'
+        :type sound: Sound
         :return: The created `Sound` object.
+        :rtype: Sound
         """
         ...
 
-    def modulate(self, sound: "Sound") -> "Sound":
+    def modulate(self, sound: Sound) -> Sound:
         """Modulates two factories.
 
         :param sound: The sound to modulate over the other.
-        :type sound: 'Sound'
-        :rtype: 'Sound'
+        :type sound: Sound
         :return: The created `Sound` object.
+        :rtype: Sound
         """
         ...
 
-    def mutable(self) -> "Sound":
+    def mutable(self) -> Sound:
         """Creates a sound that will be restarted when sought backwards.
         If the original sound is a sound list, the playing sound can change.
 
-                :rtype: 'Sound'
                 :return: The created `Sound` object.
+                :rtype: Sound
         """
         ...
 
-    def pingpong(self) -> "Sound":
+    def pingpong(self) -> Sound:
         """Plays a sound forward and then backward.
         This is like joining a sound with its reverse.
 
-                :rtype: 'Sound'
                 :return: The created `Sound` object.
+                :rtype: Sound
         """
         ...
 
-    def pitch(self, factor: float) -> "Sound":
+    def pitch(self, factor: float) -> float:
         """Changes the pitch of a sound with a specific factor.
 
         :param factor: The factor to change the pitch with.
         :type factor: float
-        :rtype: 'Sound'
         :return: The created `Sound` object.
+        :rtype: Sound
         """
         ...
 
-    def rechannel(self, channels: int) -> "Sound":
+    def rechannel(self, channels: int) -> int:
         """Rechannels the sound.
 
         :param channels: The new channel configuration.
         :type channels: int
-        :rtype: 'Sound'
         :return: The created `Sound` object.
+        :rtype: Sound
         """
         ...
 
-    def resample(self, rate: float, quality: int) -> "Sound":
+    def resample(self, rate: float, quality: int) -> int:
         """Resamples the sound.
 
         :param rate: The new sample rate.
         :type rate: float
         :param quality: Resampler performance vs quality choice (0=fastest, 3=slowest).
         :type quality: int
-        :rtype: 'Sound'
         :return: The created `Sound` object.
+        :rtype: Sound
         """
         ...
 
-    def reverse(self) -> "Sound":
+    def reverse(self) -> Sound:
         """Plays a sound reversed.
 
-        :rtype: 'Sound'
         :return: The created `Sound` object.
+        :rtype: Sound
         """
         ...
 
-    def sum(self) -> "Sound":
+    def sum(self) -> Sound:
         """Sums the samples of a sound.
 
-        :rtype: 'Sound'
         :return: The created `Sound` object.
+        :rtype: Sound
         """
         ...
 
-    def threshold(self, threshold: float = 0) -> "Sound":
+    def threshold(self, threshold: float = 0) -> float:
         """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.
@@ -841,18 +845,18 @@ class Sound:
                 :param threshold: Threshold value over which an amplitude counts
         non-zero.
                 :type threshold: float
-                :rtype: 'Sound'
                 :return: The created `Sound` object.
+                :rtype: Sound
         """
         ...
 
-    def volume(self, volume: float) -> "Sound":
+    def volume(self, volume: float) -> float:
         """Changes the volume of a sound.
 
         :param volume: The new volume..
         :type volume: float
-        :rtype: 'Sound'
         :return: The created `Sound` object.
+        :rtype: Sound
         """
         ...
 
@@ -905,7 +909,10 @@ class ThreadPool:
 
     ...
 
-class error: ...
+class error:
+    """ """
+
+    ...
 
 AP_LOCATION: typing.Any
 """ Constant value 3