fake-bpy-module 20240326__py3-none-any.whl → 20240329__py3-none-any.whl

aud/__init__.pyi

@@ -96,17 +96,14 @@ class DynamicMusic:
         :param scene: The scene sound.
         :type scene: Sound
         :return: The new scene id.
-        :rtype: int
         """
         ...
 
-    def addTransition(self, ini: int, end: int, transition: Sound) -> Sound:
+    def addTransition(self, ini, end, transition: Sound) -> Sound:
         """Adds a new scene.
 
         :param ini: the initial scene foor the transition.
-        :type ini: int
         :param end: The final scene for the transition.
-        :type end: int
         :param transition: The transition sound.
         :type transition: Sound
         :return: false if the ini or end scenes don't exist, true othrwise.
@@ -163,17 +160,13 @@ class HRTF:
         """
         ...
 
-    def addImpulseResponseFromSound(
-        self, sound: Sound, azimuth: float, elevation: float
-    ) -> float:
+    def addImpulseResponseFromSound(self, sound: Sound, azimuth, elevation):
         """Adds a new hrtf to the HRTF object
 
         :param sound: The sound that contains the hrtf.
         :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
         :return: Whether the action succeeded.
         :rtype: bool
         """
@@ -272,13 +265,11 @@ class ImpulseResponse:
 class PlaybackManager:
     """A PlabackManager object allows to easily control groups os sounds organized in categories."""
 
-    def addCategory(self, volume: float) -> float:
+    def addCategory(self, volume):
         """Adds a category with a custom volume.
 
         :param volume: The volume for ther new category.
-        :type volume: float
         :return: The key of the new category.
-        :rtype: int
         """
         ...
 
@@ -286,66 +277,57 @@ class PlaybackManager:
         """Cleans all the invalid and finished sound from the playback manager."""
         ...
 
-    def getVolume(self, catKey: int) -> int:
+    def getVolume(self, catKey):
         """Retrieves the volume of a category.
 
         :param catKey: the key of the category.
-        :type catKey: int
         :return: The volume of the cateogry.
-        :rtype: float
         """
         ...
 
-    def pause(self, catKey: int) -> int:
+    def pause(self, catKey):
         """Pauses playback of the category.
 
         :param catKey: the key of the category.
-        :type catKey: int
         :return: Whether the action succeeded.
         :rtype: bool
         """
         ...
 
-    def play(self, sound: Sound, catKey: int) -> int:
+    def play(self, sound: Sound, catKey):
         """Plays a sound through the playback manager and assigns it to a category.
 
                 :param sound: The sound to play.
                 :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
                 :return: The playback handle with which playback can be controlled with.
                 :rtype: Handle
         """
         ...
 
-    def resume(self, catKey: int) -> int:
+    def resume(self, catKey):
         """Resumes playback of the catgory.
 
         :param catKey: the key of the category.
-        :type catKey: int
         :return: Whether the action succeeded.
         :rtype: bool
         """
         ...
 
-    def setVolume(self, volume: float, catKey: int) -> int:
+    def setVolume(self, volume, catKey):
         """Changes the volume of a category.
 
         :param volume: the new volume value.
-        :type volume: float
         :param catKey: the key of the category.
-        :type catKey: int
         :return: Whether the action succeeded.
-        :rtype: int
         """
         ...
 
-    def stop(self, catKey: int) -> int:
+    def stop(self, catKey):
         """Stops playback of the category.
 
         :param catKey: the key of the category.
-        :type catKey: int
         :return: Whether the action succeeded.
         :rtype: bool
         """
@@ -482,87 +464,72 @@ class Sound:
         ...
 
     @classmethod
-    def sawtooth(cls, frequency: float, rate: int = 48000) -> int:
+    def sawtooth(cls, frequency, rate=48000):
         """Creates a sawtooth sound which plays a sawtooth wave.
 
                 :param frequency: The frequency of the sawtooth wave in Hz.
-                :type frequency: float
                 :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
         """
         ...
 
     @classmethod
-    def silence(cls, rate: int = 48000) -> int:
+    def silence(cls, rate=48000):
         """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
         """
         ...
 
     @classmethod
-    def sine(cls, frequency: float, rate: int = 48000) -> int:
+    def sine(cls, frequency, rate=48000):
         """Creates a sine sound which plays a sine wave.
 
                 :param frequency: The frequency of the sine wave in Hz.
-                :type frequency: float
                 :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
         """
         ...
 
     @classmethod
-    def square(cls, frequency: float, rate: int = 48000) -> int:
+    def square(cls, frequency, rate=48000):
         """Creates a square sound which plays a square wave.
 
                 :param frequency: The frequency of the square wave in Hz.
-                :type frequency: float
                 :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
         """
         ...
 
     @classmethod
-    def triangle(cls, frequency: float, rate: int = 48000) -> int:
+    def triangle(cls, frequency, rate=48000):
         """Creates a triangle sound which plays a triangle wave.
 
                 :param frequency: The frequency of the triangle wave in Hz.
-                :type frequency: float
                 :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
         """
         ...
 
-    def ADSR(
-        self, attack: float, decay: float, sustain: float, release: float
-    ) -> float:
+    def ADSR(self, attack, decay, sustain, release):
         """Attack-Decay-Sustain-Release envelopes the volume of a sound.
         Note: there is currently no way to trigger the release with this API.
 
                 :param attack: The attack time in seconds.
-                :type attack: float
                 :param decay: The decay time in seconds.
-                :type decay: float
                 :param sustain: The sustain level.
-                :type sustain: float
                 :param release: The release level.
-                :type release: float
                 :return: The created `Sound` object.
                 :rtype: Sound
         """
@@ -621,55 +588,44 @@ class Sound:
         """
         ...
 
-    def delay(self, time: float) -> float:
+    def delay(self, time):
         """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
         """
         ...
 
-    def envelope(
-        self, attack: float, release: float, threshold: float, arthreshold: float
-    ) -> float:
+    def envelope(self, attack, release, threshold, arthreshold):
         """Delays by playing adding silence in front of the other sound's data.
 
         :param attack: The attack factor.
-        :type attack: float
         :param release: The release factor.
-        :type release: float
         :param threshold: The general threshold value.
-        :type threshold: float
         :param arthreshold: The attack/release threshold value.
-        :type arthreshold: float
         :return: The created `Sound` object.
         :rtype: Sound
         """
         ...
 
-    def fadein(self, start: float, length: float) -> float:
+    def fadein(self, start, length):
         """Fades a sound in by raising the volume linearly in the given
         time interval.
 
                 :param start: Time in seconds when the fading should start.
-                :type start: float
                 :param length: Time in seconds how long the fading should last.
-                :type length: float
                 :return: The created `Sound` object.
                 :rtype: Sound
         """
         ...
 
-    def fadeout(self, start: float, length: float) -> float:
+    def fadeout(self, start, length):
         """Fades a sound in by lowering the volume linearly in the given
         time interval.
 
                 :param start: Time in seconds when the fading should start.
-                :type start: float
                 :param length: Time in seconds how long the fading should last.
-                :type length: float
                 :return: The created `Sound` object.
                 :rtype: Sound
         """
@@ -694,14 +650,12 @@ class Sound:
         """
         ...
 
-    def highpass(self, frequency: float, Q: float = 0.5) -> float:
+    def highpass(self, frequency, Q=0.5):
         """Creates a second order highpass filter based on the transfer
         function H(s) = s^2 / (s^2 + s/Q + 1)
 
                 :param frequency: The cut off trequency of the highpass.
-                :type frequency: float
                 :param Q: Q factor of the lowpass.
-                :type Q: float
                 :return: The created `Sound` object.
                 :rtype: Sound
         """
@@ -717,13 +671,11 @@ class Sound:
         """
         ...
 
-    def limit(self, start: float, end: float) -> float:
+    def limit(self, start, end):
         """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
         :return: The created `Sound` object.
         :rtype: Sound
         """
@@ -739,13 +691,11 @@ class Sound:
         """
         ...
 
-    def lowpass(self, frequency: float, Q: float = 0.5) -> float:
+    def lowpass(self, frequency, Q=0.5):
         """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
         :return: The created `Sound` object.
         :rtype: Sound
         """
@@ -789,33 +739,30 @@ class Sound:
         """
         ...
 
-    def pitch(self, factor: float) -> float:
+    def pitch(self, factor):
         """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
         """
         ...
 
-    def rechannel(self, channels: int) -> int:
+    def rechannel(self, channels):
         """Rechannels the sound.
 
         :param channels: The new channel configuration.
-        :type channels: int
         :return: The created `Sound` object.
         :rtype: Sound
         """
         ...
 
-    def resample(self, rate: float, quality: int) -> int:
+    def resample(self, rate: float, quality):
         """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
         :return: The created `Sound` object.
         :rtype: Sound
         """
@@ -837,24 +784,22 @@ class Sound:
         """
         ...
 
-    def threshold(self, threshold: float = 0) -> float:
+    def threshold(self, threshold=0):
         """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.
 
                 :param threshold: Threshold value over which an amplitude counts
         non-zero.
-                :type threshold: float
                 :return: The created `Sound` object.
                 :rtype: Sound
         """
         ...
 
-    def volume(self, volume: float) -> float:
+    def volume(self, volume):
         """Changes the volume of a sound.
 
         :param volume: The new volume..
-        :type volume: float
         :return: The created `Sound` object.
         :rtype: Sound
         """
@@ -863,32 +808,25 @@ class Sound:
     def write(
         self,
         filename: str,
-        rate: int,
-        channels: int,
-        format: int,
-        container: int,
-        codec: int,
-        bitrate: int,
-        buffersize: int,
+        rate,
+        channels,
+        format,
+        container,
+        codec,
+        bitrate,
+        buffersize,
     ):
         """Writes the sound to a file.
 
         :param filename: The path to write to.
         :type filename: str
         :param rate: The sample rate to write with.
-        :type rate: int
         :param channels: The number of channels to write with.
-        :type channels: int
         :param format: The sample format to write with.
-        :type format: int
         :param container: The container format for the file.
-        :type container: int
         :param codec: The codec to use in the file.
-        :type codec: int
         :param bitrate: The bitrate to write with.
-        :type bitrate: int
         :param buffersize: The size of the writing buffer.
-        :type buffersize: int
         """
         ...