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

aud/__init__.pyi

@@ -1,4 +1,3 @@
-import sys
 import typing
 
 GenericType = typing.TypeVar("GenericType")
@@ -10,10 +9,11 @@ class Device:
     """ The channel count of the device."""
 
     distance_model: typing.Any
-    """ The distance model of the device."""
+    """ The distance model of the device.`OpenAL Documentation <https://www.openal.org/documentation/>`__"""
 
     doppler_factor: typing.Any
-    """ The doppler factor of the device. This factor is a scaling factor for the velocity vectors in doppler calculation. So a value bigger than 1 will exaggerate the effect as it raises the velocity."""
+    """ The doppler factor of the device.
+This factor is a scaling factor for the velocity vectors in doppler calculation. So a value bigger than 1 will exaggerate the effect as it raises the velocity."""
 
     format: typing.Any
     """ The native sample format of the device."""
@@ -31,24 +31,31 @@ class Device:
     """ The sampling rate of the device in Hz."""
 
     speed_of_sound: typing.Any
-    """ The speed of sound of the device. The speed of sound in air is typically 343.3 m/s."""
+    """ The speed of sound of the device.
+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 read from the streams until :meth:`unlock` is called. This is useful if you want to do start/stop/pause/resume some sounds at the same time."""
+        """Locks the device so that it's 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.
+
+        """
         ...
 
-    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'
-        :param keep: `Handle.keep`.
-        :type keep: bool
-        :rtype: 'Handle'
-        :return: The playback handle with which playback can be controlled with.
+                :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
         """
         ...
 
@@ -57,11 +64,16 @@ class Device:
         ...
 
     def unlock(self):
-        """Unlocks the device after a lock call, see :meth:`lock` for details."""
+        """Unlocks the device after a lock call, see `lock` for
+        details.
+
+        """
         ...
 
 class DynamicMusic:
-    """The DynamicMusic object allows to play music depending on a current scene, scene changes are managed by the class, with the possibility of custom transitions. The default transition is a crossfade effect, and the default scene is silent and has id 0"""
+    """The DynamicMusic object allows to play music depending on a current scene, scene changes are managed by the class, with the possibility of custom transitions.
+    The default transition is a crossfade effect, and the default scene is silent and has id 0
+    """
 
     fadeTime: typing.Any
     """ The length in seconds of the crossfade transition"""
@@ -78,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.
@@ -96,80 +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: typing.Any) -> "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
-        :param extension: The file extension of the hrtfs.
-        :type extension: str
-        :param directory:  The path to where the HRTF files are located.
-        :type directory: typing.Any
-        :rtype: 'HRTF'
-        :return: `HRTF` object.
+        :type extension: typing.Union[str, str]
+        :param directory: The path to where the HRTF files are located.
+        :return: The loaded `HRTF` object.
+        :rtype: HRTF
         """
         ...
 
-    def loadLeftHrtfSet(self, extension: str, directory: typing.Any) -> "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
-        :param extension: The file extension of the hrtfs.
-        :type extension: str
-        :param directory:  The path to where the HRTF files are located.
-        :type directory: typing.Any
-        :rtype: 'HRTF'
-        :return: `HRTF` object.
+        :type extension: typing.Union[str, str]
+        :param directory: The path to where the HRTF files are located.
+        :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
         """
         ...
 
@@ -177,25 +183,29 @@ class Handle:
     """Handle objects are playback handles that can be used to control playback of a sound. If a sound is played back multiple times then there are as many handles."""
 
     attenuation: typing.Any
-    """ This factor is used for distance based attenuation of the source."""
+    """ This factor is used for distance based attenuation of the source.:attr:`Device.distance_model`"""
 
     cone_angle_inner: typing.Any
-    """ The opening angle of the inner cone of the source. If the cone values of a source are set there are two (audible) cones with the apex at the :attr:`location` of the source and with infinite height, heading in the direction of the source's :attr:`orientation`. In the inner cone the volume is normal. Outside the outer cone the volume will be :attr:`cone_volume_outer` and in the area between the volume will be interpolated linearly."""
+    """ The opening angle of the inner cone of the source. If the cone values of a source are set there are two (audible) cones with the apex at the `location` of the source and with infinite height, heading in the direction of the source's `orientation`.
+In the inner cone the volume is normal. Outside the outer cone the volume will be `cone_volume_outer` and in the area between the volume will be interpolated linearly."""
 
     cone_angle_outer: typing.Any
-    """ The opening angle of the outer cone of the source."""
+    """ The opening angle of the outer cone of the source.:attr:`cone_angle_inner`"""
 
     cone_volume_outer: typing.Any
-    """ The volume outside the outer cone of the source."""
+    """ The volume outside the outer cone of the source.:attr:`cone_angle_inner`"""
 
     distance_maximum: typing.Any
-    """ The maximum distance of the source. If the listener is further away the source volume will be 0."""
+    """ The maximum distance of the source.
+If the listener is further away the source volume will be 0.:attr:`Device.distance_model`"""
 
     distance_reference: typing.Any
-    """ The reference distance of the source. At this distance the volume will be exactly :attr:`volume`."""
+    """ The reference distance of the source.
+At this distance the volume will be exactly `volume`.:attr:`Device.distance_model`"""
 
     keep: typing.Any
-    """ Whether the sound should be kept paused in the device when its end is reached. This can be used to seek the sound to some position and start playback again."""
+    """ Whether the sound should be kept paused in the device when its end is reached.
+This can be used to seek the sound to some position and start playback again."""
 
     location: typing.Any
     """ The source's location in 3D space, a 3D tuple of floats."""
@@ -225,32 +235,32 @@ class Handle:
     """ The volume of the sound."""
 
     volume_maximum: typing.Any
-    """ The maximum volume of the source."""
+    """ The maximum volume of the source.:attr:`Device.distance_model`"""
 
     volume_minimum: typing.Any
-    """ The minimum volume of the source."""
+    """ 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
         """
         ...
 
@@ -262,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
         """
         ...
 
@@ -276,45 +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'
-        :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.
+                :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) -> 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
         """
         ...
 
@@ -325,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
         """
         ...
 
@@ -347,10 +358,11 @@ class Sequence:
     """ The channel count of the sequence."""
 
     distance_model: typing.Any
-    """ The distance model of the sequence."""
+    """ The distance model of the sequence.`OpenAL Documentation <https://www.openal.org/documentation/>`__"""
 
     doppler_factor: typing.Any
-    """ The doppler factor of the sequence. This factor is a scaling factor for the velocity vectors in doppler calculation. So a value bigger than 1 will exaggerate the effect as it raises the velocity."""
+    """ The doppler factor of the sequence.
+This factor is a scaling factor for the velocity vectors in doppler calculation. So a value bigger than 1 will exaggerate the effect as it raises the velocity."""
 
     fps: typing.Any
     """ The listeners's location in 3D space, a 3D tuple of floats."""
@@ -362,66 +374,48 @@ class Sequence:
     """ The sampling rate of the sequence in Hz."""
 
     speed_of_sound: typing.Any
-    """ The speed of sound of the sequence. The speed of sound in air is typically 343.3 m/s."""
+    """ 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.
 
-        :param sound: The sound this entry should play.
-        :type sound: 'Sound'
-        :param begin: The start time.
-        :type begin: float
-        :param end: The end time or a negative value if determined by the sound.
-        :type end: float
-        :param skip: How much seconds should be skipped at the beginning.
-        :type skip: float
-        :rtype: 'SequenceEntry'
         :return: The entry added.
+        :rtype: SequenceEntry
         """
         ...
 
     def remove(self):
-        """Removes an entry from the sequence.
-
-        :param entry: The entry to remove.
-        :type entry: 'SequenceEntry'
-        """
+        """Removes an entry from the sequence."""
         ...
 
     def setAnimationData(self):
-        """Writes animation data to a sequence.
-
-        :param type: The type of animation data.
-        :type type: int
-        :param frame: The frame this data is for.
-        :type frame: int
-        :param data: The data to write.
-        :type data: typing.List[float]
-        :param animated: Whether the attribute is animated.
-        :type animated: bool
-        """
+        """Writes animation data to a sequence."""
         ...
 
 class SequenceEntry:
     """SequenceEntry objects represent an entry of a sequenced sound."""
 
     attenuation: typing.Any
-    """ This factor is used for distance based attenuation of the source."""
+    """ This factor is used for distance based attenuation of the source.:attr:`Device.distance_model`"""
 
     cone_angle_inner: typing.Any
-    """ The opening angle of the inner cone of the source. If the cone values of a source are set there are two (audible) cones with the apex at the :attr:`location` of the source and with infinite height, heading in the direction of the source's :attr:`orientation`. In the inner cone the volume is normal. Outside the outer cone the volume will be :attr:`cone_volume_outer` and in the area between the volume will be interpolated linearly."""
+    """ The opening angle of the inner cone of the source. If the cone values of a source are set there are two (audible) cones with the apex at the `location` of the source and with infinite height, heading in the direction of the source's `orientation`.
+In the inner cone the volume is normal. Outside the outer cone the volume will be `cone_volume_outer` and in the area between the volume will be interpolated linearly."""
 
     cone_angle_outer: typing.Any
-    """ The opening angle of the outer cone of the source."""
+    """ The opening angle of the outer cone of the source.:attr:`cone_angle_inner`"""
 
     cone_volume_outer: typing.Any
-    """ The volume outside the outer cone of the source."""
+    """ The volume outside the outer cone of the source.:attr:`cone_angle_inner`"""
 
     distance_maximum: typing.Any
-    """ The maximum distance of the source. If the listener is further away the source volume will be 0."""
+    """ The maximum distance of the source.
+If the listener is further away the source volume will be 0.:attr:`Device.distance_model`"""
 
     distance_reference: typing.Any
-    """ The reference distance of the source. At this distance the volume will be exactly :attr:`volume`."""
+    """ The reference distance of the source.
+At this distance the volume will be exactly `volume`.:attr:`Device.distance_model`"""
 
     muted: typing.Any
     """ Whether the entry is muted."""
@@ -433,35 +427,17 @@ class SequenceEntry:
     """ The sound the entry is representing and will be played in the sequence."""
 
     volume_maximum: typing.Any
-    """ The maximum volume of the source."""
+    """ The maximum volume of the source.:attr:`Device.distance_model`"""
 
     volume_minimum: typing.Any
-    """ The minimum volume of the source."""
+    """ The minimum volume of the source.:attr:`Device.distance_model`"""
 
     def move(self):
-        """Moves the entry.
-
-        :param begin: The new start time.
-        :type begin: float
-        :param end: The new end time or a negative value if unknown.
-        :type end: float
-        :param skip: How many seconds to skip at the beginning.
-        :type skip: float
-        """
+        """Moves the entry."""
         ...
 
     def setAnimationData(self):
-        """Writes animation data to a sequenced entry.
-
-        :param type: The type of animation data.
-        :type type: int
-        :param frame: The frame this data is for.
-        :type frame: int
-        :param data: The data to write.
-        :type data: typing.List[float]
-        :param animated: Whether the attribute is animated.
-        :type animated: bool
-        """
+        """Writes animation data to a sequenced entry."""
         ...
 
 class Sound:
@@ -474,198 +450,190 @@ class Sound:
     """ The sample specification of the sound as a tuple with rate and channel count."""
 
     @classmethod
-    def buffer(cls, data: typing.Any, rate: float) -> "Sound":
+    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: `Sound` object.
+        :return: The created `Sound` object.
+        :rtype: Sound
         """
         ...
 
     @classmethod
-    def file(cls, filename: str) -> "Sound":
+    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: `Sound` object.
+        :return: The created `Sound` object.
+        :rtype: Sound
         """
         ...
 
     @classmethod
-    def list(cls) -> "Sound":
+    def list(cls) -> Sound:
         """Creates an empty sound list that can contain several sounds.
 
-        :param random: whether the playback will be random or not.
-        :type random: int
-        :rtype: 'Sound'
-        :return: `Sound` object.
+        :return: The created `Sound` object.
+        :rtype: Sound
         """
         ...
 
     @classmethod
-    def sawtooth(cls, frequency: float, rate: int = 48000) -> "Sound":
+    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.
-        :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
-        :rtype: 'Sound'
-        :return: `Sound` object.
+                :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) -> "Sound":
+    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: `Sound` object.
+                :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) -> "Sound":
+    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.
-        :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
-        :rtype: 'Sound'
-        :return: `Sound` object.
+                :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) -> "Sound":
+    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.
-        :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
-        :rtype: 'Sound'
-        :return: `Sound` object.
+                :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) -> "Sound":
+    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.
-        :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
-        :rtype: 'Sound'
-        :return: `Sound` object.
+                :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
-    ) -> "Sound":
-        """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
-        :rtype: 'Sound'
-        :return: `Sound` object.
+    ) -> float:
+        """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
         """
         ...
 
-    def accumulate(self, additive: typing.Any = False) -> "Sound":
-        """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.
+    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 time:
-        :type time: bool
-        :param additive:  Whether the accumulation should be additive or not.
-        :type additive: typing.Any
-        :rtype: 'Sound'
-        :return: `Sound` object.
+                :param additive: Whether the accumulation should be additive or not.
+                :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
 
-        :param hrtf:
-        :type hrtf: 'HRTF'
-        :param source: An object representing the source position of the sound.
-        :type source: 'Source'
-        :param threadPool: A thread pool used to parallelize convolution.
-        :type threadPool: 'ThreadPool'
-        :param hrtfs:  An HRTF set.
-        :type hrtfs: typing.Any
-        :rtype: 'Sound'
-        :return: `Sound` object.
+        :return: The created `Sound` object.
+        :rtype: 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.
+    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: `Sound` object.
+                :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.
 
-        :param impulseResponse: The filter with which convolve the sound.
-        :type impulseResponse: 'ImpulseResponse'
-        :param threadPool: A thread pool used to parallelize convolution.
-        :type threadPool: 'ThreadPool'
-        :rtype: 'Sound'
-        :return: `Sound` object.
+        :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: `Sound` object.
+        :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.
@@ -676,204 +644,219 @@ class Sound:
         :type threshold: float
         :param arthreshold: The attack/release threshold value.
         :type arthreshold: float
-        :rtype: 'Sound'
-        :return: `Sound` object.
+        :return: The created `Sound` object.
+        :rtype: Sound
         """
         ...
 
-    def fadein(self, start: float, length: float) -> "Sound":
-        """Fades a sound in by raising the volume linearly in the given time interval.
+    def fadein(self, start: float, length: float) -> float:
+        """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
-        :rtype: 'Sound'
-        :return: `Sound` object.
+                :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) -> "Sound":
-        """Fades a sound in by lowering the volume linearly in the given time interval.
+    def fadeout(self, start: float, length: float) -> float:
+        """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
-        :rtype: 'Sound'
-        :return: `Sound` object.
+                :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 filter(self, b: typing.List[float], a=(1)) -> "Sound":
-        """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. 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.
-
-        :param b: The nominator filter coefficients.
-        :type b: typing.List[float]
-        :param a: The denominator filter coefficients.
-        :type a: typing.List[float]
-        :rtype: 'Sound'
-        :return: `Sound` object.
+    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.
+        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.
+
+                :param b: The nominator filter coefficients.
+                :type b: typing.List[float]
+                :param a: The denominator filter coefficients.
+                :type a: typing.List[float]
+                :return: The created `Sound` object.
+                :rtype: Sound
         """
         ...
 
-    def highpass(self, frequency: float, Q: float = 0.5) -> "Sound":
-        """Creates a second order highpass filter based on the transfer function :math:`H(s) = s^2 / (s^2 + s/Q + 1)`
+    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)
 
-        :param frequency: The cut off trequency of the highpass.
-        :type frequency: float
-        :param Q: Q factor of the lowpass.
-        :type Q: float
-        :rtype: 'Sound'
-        :return: `Sound` object.
+                :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
         """
         ...
 
-    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'
-        :return: `Sound` object.
+        :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: `Sound` object.
+        :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: `Sound` object.
+                :param count: How often the sound should be looped.
+        Negative values mean endlessly.
+                :return: The created `Sound` object.
+                :rtype: Sound
         """
         ...
 
-    def lowpass(self, frequency: float, Q: float = 0.5) -> "Sound":
-        """Creates a second order lowpass filter based on the transfer function :math:`H(s) = 1 / (s^2 + s/Q + 1)`
+    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: `Sound` object.
+        :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'
-        :return: `Sound` object.
+        :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'
-        :return: `Sound` object.
+        :type sound: Sound
+        :return: The created `Sound` object.
+        :rtype: 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.
+    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: `Sound` object.
+                :return: The created `Sound` object.
+                :rtype: Sound
         """
         ...
 
-    def pingpong(self) -> "Sound":
-        """Plays a sound forward and then backward. This is like joining a sound with its reverse.
+    def pingpong(self) -> Sound:
+        """Plays a sound forward and then backward.
+        This is like joining a sound with its reverse.
 
-        :rtype: 'Sound'
-        :return: `Sound` object.
+                :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: `Sound` object.
+        :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: `Sound` object.
+        :return: The created `Sound` object.
+        :rtype: Sound
         """
         ...
 
-    def resample(self, rate: float, high_quality: bool) -> "Sound":
+    def resample(self, rate: float, quality: int) -> int:
         """Resamples the sound.
 
         :param rate: The new sample rate.
         :type rate: float
-        :param high_quality: When true use a higher quality but slower resampler.
-        :type high_quality: bool
-        :rtype: 'Sound'
-        :return: `Sound` object.
+        :param quality: Resampler performance vs quality choice (0=fastest, 3=slowest).
+        :type quality: int
+        :return: The created `Sound` object.
+        :rtype: Sound
         """
         ...
 
-    def reverse(self) -> "Sound":
+    def reverse(self) -> Sound:
         """Plays a sound reversed.
 
-        :rtype: 'Sound'
-        :return: `Sound` object.
+        :return: The created `Sound` object.
+        :rtype: Sound
         """
         ...
 
-    def sum(self) -> "Sound":
+    def sum(self) -> Sound:
         """Sums the samples of a sound.
 
-        :rtype: 'Sound'
-        :return: `Sound` object.
+        :return: The created `Sound` object.
+        :rtype: Sound
         """
         ...
 
-    def threshold(self, threshold=" 0") -> "Sound":
-        """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.
+    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.
 
-        :param threshold: Threshold value over which an amplitude counts non-zero.
-        :type threshold: float
-        :rtype: 'Sound'
-        :return: `Sound` object.
+                :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) -> "Sound":
+    def volume(self, volume: float) -> float:
         """Changes the volume of a sound.
 
         :param volume: The new volume..
         :type volume: float
-        :rtype: 'Sound'
-        :return: `Sound` object.
+        :return: The created `Sound` object.
+        :rtype: Sound
         """
         ...
 
@@ -926,7 +909,10 @@ class ThreadPool:
 
     ...
 
-class error: ...
+class error:
+    """ """
+
+    ...
 
 AP_LOCATION: typing.Any
 """ Constant value 3