fake-bge-module 20250312__py3-none-any.whl → 20260203__py3-none-any.whl

aud/__init__.pyi

@@ -14,6 +14,46 @@ Handle.
 import typing
 import collections.abc
 import typing_extensions
+import numpy.typing as npt
+
+class AnimateableProperty:
+    """An AnimateableProperty object stores an array of float values for animating sound properties (e.g. pan, volume, pitch-scale)"""
+
+    animated: typing.Any
+    """ Whether the property is animated."""
+
+    count: typing.Any
+    """ The count of floats for a property."""
+
+    def read(self, position: float) -> None:
+        """Reads the properties value at the given position.
+
+        :param position: The position in the animation in frames.
+        :return: A numpy array of values representing the properties value.
+        """
+
+    def readSingle(self, position: float) -> float:
+        """Reads the properties value at the given position, assuming there is exactly one value.
+
+        :param position: The position in the animation in frames.
+        :return: The value at that position.
+        """
+
+    def write(self, data, position: int) -> None:
+        """Writes the properties value.If position is also given, the property is marked animated and
+        the values are written starting at position.
+
+                :param data: numpy array of float32 values.
+                :param position: The starting position in frames.
+        """
+
+    def writeConstantRange(self, data, position_start: int, position_end: int) -> None:
+        """Fills the properties frame range with a constant value and marks it animated.
+
+        :param data: numpy array of float values representing the constant value.
+        :param position_start: The start position in frames.
+        :param position_end: The end position in frames.
+        """
 
 class Device:
     """Device objects represent an audio output backend like OpenAL or SDL, but might also represent a file output or RAM buffer output."""
@@ -50,8 +90,8 @@ The speed of sound in air is typically 343.3 m/s."""
     volume: typing.Any
     """ The overall volume of the device."""
 
-    def lock(self):
-        """Locks the device so that it's guaranteed, that no samples are
+    def lock(self) -> None:
+        """Locks the device so that its guaranteed, that no samples are
         read from the streams until `unlock` is called.
         This is useful if you want to do start/stop/pause/resume some
         sounds at the same time.
@@ -62,18 +102,15 @@ The speed of sound in air is typically 343.3 m/s."""
         """Plays a sound.
 
                 :param sound: The sound to play.
-                :type sound: Sound
                 :param keep: See `Handle.keep`.
-                :type keep: bool
                 :return: The playback handle with which playback can be
         controlled with.
-                :rtype: Handle
         """
 
-    def stopAll(self):
+    def stopAll(self) -> None:
         """Stops all playing and paused sounds."""
 
-    def unlock(self):
+    def unlock(self) -> None:
         """Unlocks the device after a lock call, see `lock` for
         details.
 
@@ -103,66 +140,53 @@ class DynamicMusic:
         """Adds a new scene.
 
         :param scene: The scene sound.
-        :type scene: Sound
         :return: The new scene id.
-        :rtype: int
         """
 
     def addTransition(self, ini: int, end: int, transition: Sound) -> bool:
         """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.
-        :rtype: bool
+        :return: false if the ini or end scenes dont exist, true otherwise.
         """
 
     def pause(self) -> bool:
         """Pauses playback of the scene.
 
         :return: Whether the action succeeded.
-        :rtype: bool
         """
 
     def resume(self) -> bool:
         """Resumes playback of the scene.
 
         :return: Whether the action succeeded.
-        :rtype: bool
         """
 
     def stop(self) -> bool:
         """Stops playback of the scene.
 
         :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"""
+    """An HRTF object represents a set of head related transfer functions as impulse responses. Its used for binaural sound"""
 
     def loadLeftHrtfSet(self, extension: str, directory) -> typing_extensions.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: typing_extensions.Self
         """
 
     def loadRightHrtfSet(self, extension: str, directory) -> typing_extensions.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: typing_extensions.Self
         """
 
     def addImpulseResponseFromSound(
@@ -171,13 +195,9 @@ class HRTF:
         """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
         """
 
 class Handle:
@@ -245,21 +265,18 @@ This can be used to seek the sound to some position and start playback again."""
         """Pauses playback.
 
         :return: Whether the action succeeded.
-        :rtype: bool
         """
 
     def resume(self) -> bool:
         """Resumes playback.
 
         :return: Whether the action succeeded.
-        :rtype: bool
         """
 
     def stop(self) -> bool:
         """Stops playback.
 
         :return: Whether the action succeeded.
-        :rtype: bool
         """
 
 class ImpulseResponse:
@@ -272,71 +289,55 @@ class PlaybackManager:
         """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
         """
 
-    def clean(self):
+    def clean(self) -> None:
         """Cleans all the invalid and finished sound from the playback manager."""
 
     def getVolume(self, catKey: int) -> float:
         """Retrieves the volume of a category.
 
         :param catKey: the key of the category.
-        :type catKey: int
-        :return: The volume of the cateogry.
-        :rtype: float
+        :return: The volume of the category.
         """
 
     def pause(self, catKey: int) -> bool:
         """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) -> Handle:
         """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
+        if it doesnt exist, a new one will be created.
                 :return: The playback handle with which playback can be controlled with.
-                :rtype: Handle
         """
 
     def resume(self, catKey: int) -> bool:
         """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:
         """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) -> bool:
         """Stops playback of the category.
 
         :param catKey: the key of the category.
-        :type catKey: int
         :return: Whether the action succeeded.
-        :rtype: bool
         """
 
 class Sequence:
@@ -369,13 +370,12 @@ The speed of sound in air is typically 343.3 m/s."""
         """Adds a new entry to the sequence.
 
         :return: The entry added.
-        :rtype: SequenceEntry
         """
 
-    def remove(self):
+    def remove(self) -> None:
         """Removes an entry from the sequence."""
 
-    def setAnimationData(self):
+    def setAnimationData(self) -> None:
         """Writes animation data to a sequence."""
 
 class SequenceEntry:
@@ -417,10 +417,10 @@ At this distance the volume will be exactly `volume`.:attr:`Device.distance_mode
     volume_minimum: typing.Any
     """ The minimum volume of the source.:attr:`Device.distance_model`"""
 
-    def move(self):
+    def move(self) -> None:
         """Moves the entry."""
 
-    def setAnimationData(self):
+    def setAnimationData(self) -> None:
         """Writes animation data to a sequenced entry."""
 
 class Sound:
@@ -438,9 +438,7 @@ class Sound:
 
         :param data: The data as two dimensional numpy array.
         :param rate: The sample rate.
-        :type rate: float
         :return: The created `Sound` object.
-        :rtype: typing_extensions.Self
         """
 
     @classmethod
@@ -448,9 +446,7 @@ class Sound:
         """Creates a sound object of a sound file.
 
         :param filename: Path of the file.
-        :type filename: str
         :return: The created `Sound` object.
-        :rtype: typing_extensions.Self
         """
 
     @classmethod
@@ -458,7 +454,6 @@ class Sound:
         """Creates an empty sound list that can contain several sounds.
 
         :return: The created `Sound` object.
-        :rtype: typing_extensions.Self
         """
 
     @classmethod
@@ -466,23 +461,18 @@ class Sound:
         """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
+                :param rate: The sampling rate in Hz. Its recommended to set this
+        value to the playback devices sampling rate to avoid resampling.
                 :return: The created `Sound` object.
-                :rtype: typing_extensions.Self
         """
 
     @classmethod
     def silence(cls, rate: int = 48000) -> typing_extensions.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
+                :param rate: The sampling rate in Hz. Its recommended to set this
+        value to the playback devices sampling rate to avoid resampling.
                 :return: The created `Sound` object.
-                :rtype: typing_extensions.Self
         """
 
     @classmethod
@@ -490,12 +480,9 @@ class Sound:
         """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
+                :param rate: The sampling rate in Hz. Its recommended to set this
+        value to the playback devices sampling rate to avoid resampling.
                 :return: The created `Sound` object.
-                :rtype: typing_extensions.Self
         """
 
     @classmethod
@@ -503,12 +490,9 @@ class Sound:
         """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
+                :param rate: The sampling rate in Hz. Its recommended to set this
+        value to the playback devices sampling rate to avoid resampling.
                 :return: The created `Sound` object.
-                :rtype: typing_extensions.Self
         """
 
     @classmethod
@@ -516,12 +500,9 @@ class Sound:
         """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
+                :param rate: The sampling rate in Hz. Its recommended to set this
+        value to the playback devices sampling rate to avoid resampling.
                 :return: The created `Sound` object.
-                :rtype: typing_extensions.Self
         """
 
     def ADSR(
@@ -531,15 +512,10 @@ class 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: typing_extensions.Self
         """
 
     def accumulate(self, additive=False) -> typing_extensions.Self:
@@ -550,21 +526,36 @@ class Sound:
 
                 :param additive: Whether the accumulation should be additive or not.
                 :return: The created `Sound` object.
-                :rtype: typing_extensions.Self
         """
 
-    def addSound(self, sound: typing_extensions.Self):
+    def addSound(self, sound: typing_extensions.Self) -> None:
         """Adds a new sound to a sound list.
 
         :param sound: The sound that will be added to the list.
-        :type sound: typing_extensions.Self
+        """
+
+    def animateableTimeStretchPitchScale(
+        self,
+        fps: float,
+        time_stretch: float,
+        pitch_scale: float,
+        quality: int,
+        preserve_formant: bool,
+    ) -> typing_extensions.Self:
+        """Applies time-stretching and pitch-scaling to the sound.
+
+        :param fps: The FPS of the animation system.
+        :param time_stretch: The factor by which to stretch or compress time.
+        :param pitch_scale: The factor by which to adjust the pitch.
+        :param quality:
+        :param preserve_formant: Whether to preserve the vocal formants during pitch-shifting.
+        :return: The created `Sound` object.
         """
 
     def binaural(self) -> typing_extensions.Self:
         """Creates a binaural sound using another sound as source. The original sound must be mono
 
         :return: The created `Sound` object.
-        :rtype: typing_extensions.Self
         """
 
     def cache(self) -> typing_extensions.Self:
@@ -573,46 +564,46 @@ class Sound:
         but it consumes a lot of memory.
 
                 :return: The created `Sound` object.
-                :rtype: typing_extensions.Self
         """
 
     def convolver(self) -> typing_extensions.Self:
         """Creates a sound that will apply convolution to another sound.
 
         :return: The created `Sound` object.
-        :rtype: typing_extensions.Self
         """
 
-    def data(self):
+    def data(self) -> None:
         """Retrieves the data of the sound as numpy array.
 
         :return: A two dimensional numpy float array.
         """
 
     def delay(self, time: float) -> typing_extensions.Self:
-        """Delays by playing adding silence in front of the other sound's data.
+        """Delays by playing adding silence in front of the other sounds data.
 
         :param time: How many seconds of silence should be added before the sound.
-        :type time: float
         :return: The created `Sound` object.
-        :rtype: typing_extensions.Self
+        """
+
+    def Echo(self, delay: float, feedback: float, mix: float) -> typing_extensions.Self:
+        """Adds Echo effect to the sound.
+
+        :param delay: The delay time in seconds.
+        :param feedback: The feedback amount (0.0 to 1.0).
+        :param mix: The wet/dry mix (0.0 to 1.0).
+        :return: The created `Sound` object.
         """
 
     def envelope(
         self, attack: float, release: float, threshold: float, arthreshold: float
     ) -> typing_extensions.Self:
-        """Delays by playing adding silence in front of the other sound's data.
+        """Delays by playing adding silence in front of the other sounds 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: typing_extensions.Self
         """
 
     def fadein(self, start: float, length: float) -> typing_extensions.Self:
@@ -620,11 +611,8 @@ class Sound:
         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: typing_extensions.Self
         """
 
     def fadeout(self, start: float, length: float) -> typing_extensions.Self:
@@ -632,27 +620,21 @@ class Sound:
         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: typing_extensions.Self
         """
 
     def filter(self, b: list[float], a: list[float] = (1)) -> typing_extensions.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,
+        Without the second parameter youll get a FIR filter.If the first value of the a sequence is 0,
         it will be set to 1 automatically.
         If the first value of the a sequence is neither 0 nor 1, all
         filter coefficients will be scaled by this value so that it is 1
-        in the end, you don't have to scale yourself.
+        in the end, you dont have to scale yourself.
 
                 :param b: The nominator filter coefficients.
-                :type b: list[float]
                 :param a: The denominator filter coefficients.
-                :type a: list[float]
                 :return: The created `Sound` object.
-                :rtype: typing_extensions.Self
         """
 
     def highpass(self, frequency: float, Q: float = 0.5) -> typing_extensions.Self:
@@ -660,31 +642,23 @@ class Sound:
         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: typing_extensions.Self
         """
 
     def join(self, sound: typing_extensions.Self) -> typing_extensions.Self:
         """Plays two factories in sequence.
 
         :param sound: The sound to play second.
-        :type sound: typing_extensions.Self
         :return: The created `Sound` object.
-        :rtype: typing_extensions.Self
         """
 
     def limit(self, start: float, end: float) -> typing_extensions.Self:
         """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: typing_extensions.Self
         """
 
     def loop(self, count: int) -> typing_extensions.Self:
@@ -692,38 +666,29 @@ class Sound:
 
                 :param count: How often the sound should be looped.
         Negative values mean endlessly.
-                :type count: int
                 :return: The created `Sound` object.
-                :rtype: typing_extensions.Self
         """
 
     def lowpass(self, frequency: float, Q: float = 0.5) -> typing_extensions.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.
-        :type frequency: float
         :param Q: Q factor of the lowpass.
-        :type Q: float
         :return: The created `Sound` object.
-        :rtype: typing_extensions.Self
         """
 
     def mix(self, sound: typing_extensions.Self) -> typing_extensions.Self:
         """Mixes two factories.
 
         :param sound: The sound to mix over the other.
-        :type sound: typing_extensions.Self
         :return: The created `Sound` object.
-        :rtype: typing_extensions.Self
         """
 
     def modulate(self, sound: typing_extensions.Self) -> typing_extensions.Self:
         """Modulates two factories.
 
         :param sound: The sound to modulate over the other.
-        :type sound: typing_extensions.Self
         :return: The created `Sound` object.
-        :rtype: typing_extensions.Self
         """
 
     def mutable(self) -> typing_extensions.Self:
@@ -731,7 +696,6 @@ class Sound:
         If the original sound is a sound list, the playing sound can change.
 
                 :return: The created `Sound` object.
-                :rtype: typing_extensions.Self
         """
 
     def pingpong(self) -> typing_extensions.Self:
@@ -739,50 +703,40 @@ class Sound:
         This is like joining a sound with its reverse.
 
                 :return: The created `Sound` object.
-                :rtype: typing_extensions.Self
         """
 
     def pitch(self, factor: float) -> typing_extensions.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: typing_extensions.Self
         """
 
     def rechannel(self, channels: int) -> typing_extensions.Self:
         """Rechannels the sound.
 
         :param channels: The new channel configuration.
-        :type channels: int
         :return: The created `Sound` object.
-        :rtype: typing_extensions.Self
         """
 
     def resample(self, rate: float, quality: int) -> typing_extensions.Self:
         """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: typing_extensions.Self
         """
 
     def reverse(self) -> typing_extensions.Self:
         """Plays a sound reversed.
 
         :return: The created `Sound` object.
-        :rtype: typing_extensions.Self
         """
 
     def sum(self) -> typing_extensions.Self:
         """Sums the samples of a sound.
 
         :return: The created `Sound` object.
-        :rtype: typing_extensions.Self
         """
 
     def threshold(self, threshold: float = 0) -> typing_extensions.Self:
@@ -792,18 +746,30 @@ class Sound:
 
                 :param threshold: Threshold value over which an amplitude counts
         non-zero.
-                :type threshold: float
                 :return: The created `Sound` object.
-                :rtype: typing_extensions.Self
+        """
+
+    def timeStretchPitchScale(
+        self,
+        time_stretch: float,
+        pitch_scale: float,
+        quality: int,
+        preserve_formant: bool,
+    ) -> typing_extensions.Self:
+        """Applies time-stretching and pitch-scaling to the sound.
+
+        :param time_stretch: The factor by which to stretch or compress time.
+        :param pitch_scale: The factor by which to adjust the pitch.
+        :param quality: Rubberband stretcher quality (STRETCHER_QUALITY_*).
+        :param preserve_formant: Whether to preserve the vocal formants during pitch-shifting.
+        :return: The created `Sound` object.
         """
 
     def volume(self, volume: float) -> typing_extensions.Self:
         """Changes the volume of a sound.
 
         :param volume: The new volume..
-        :type volume: float
         :return: The created `Sound` object.
-        :rtype: typing_extensions.Self
         """
 
     def write(
@@ -816,25 +782,17 @@ class Sound:
         codec: int,
         bitrate: int,
         buffersize: int,
-    ):
+    ) -> None:
         """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
         """
 
 class Source:
@@ -870,6 +828,14 @@ AP_PITCH: typing.Any
 """ Constant value 2
 """
 
+AP_PITCH_SCALE: typing.Any
+""" Constant value 6
+"""
+
+AP_TIME_STRETCH: typing.Any
+""" Constant value 5
+"""
+
 AP_VOLUME: typing.Any
 """ Constant value 0
 """
@@ -1097,3 +1063,15 @@ STATUS_PLAYING: typing.Any
 STATUS_STOPPED: typing.Any
 """ Constant value 3
 """
+
+STRETCHER_QUALITY_CONSISTENT: typing.Any
+""" Constant value 2
+"""
+
+STRETCHER_QUALITY_FAST: typing.Any
+""" Constant value 1
+"""
+
+STRETCHER_QUALITY_HIGH: typing.Any
+""" Constant value 0
+"""