fake-bpy-module 20240417__py3-none-any.whl → 20240419__py3-none-any.whl

_bpy_internal/__init__.pyi

@@ -0,0 +1,4 @@
+import typing
+from . import freedesktop
+
+GenericType = typing.TypeVar("GenericType")

_bpy_internal/freedesktop/__init__.pyi

@@ -0,0 +1,88 @@
+import typing
+
+GenericType = typing.TypeVar("GenericType")
+
+def argparse_create():
+    """ """
+
+    ...
+
+def call_handle_checked(fn, do_register, all_users):
+    """ """
+
+    ...
+
+def filepath_ensure_removed(path):
+    """ """
+
+    ...
+
+def filepath_repr(filepath):
+    """ """
+
+    ...
+
+def handle_bin(do_register, all_users):
+    """ """
+
+    ...
+
+def handle_desktop_file(do_register, all_users):
+    """ """
+
+    ...
+
+def handle_icon(do_register, all_users):
+    """ """
+
+    ...
+
+def handle_mime_association_default(do_register, all_users):
+    """ """
+
+    ...
+
+def handle_mime_association_xml(do_register, all_users):
+    """ """
+
+    ...
+
+def handle_thumbnailer(do_register, all_users):
+    """ """
+
+    ...
+
+def main():
+    """ """
+
+    ...
+
+def main_run_as_root(do_register):
+    """ """
+
+    ...
+
+def path_exists_or_is_link(path):
+    """ """
+
+    ...
+
+def register(all_users):
+    """ """
+
+    ...
+
+def register_impl(do_register, all_users):
+    """ """
+
+    ...
+
+def system_path_contains(dirpath):
+    """ """
+
+    ...
+
+def unregister(all_users):
+    """ """
+
+    ...

aud/__init__.pyi

@@ -1,3 +1,16 @@
+"""
+Audaspace (pronounced "outer space") is a high level audio library.
+
+
+--------------------
+
+This script shows how to use the classes: Device, Sound and
+Handle.
+
+```../examples/aud.py```
+
+"""
+
 import typing
 
 GenericType = typing.TypeVar("GenericType")
@@ -46,7 +59,7 @@ The speed of sound in air is typically 343.3 m/s."""
         """
         ...
 
-    def play(self, sound: Sound, keep: bool = False) -> bool:
+    def play(self, sound: Sound, keep: bool = False) -> Handle:
         """Plays a sound.
 
                 :param sound: The sound to play.
@@ -90,20 +103,23 @@ class DynamicMusic:
     volume: typing.Any
     """ The volume of the scene."""
 
-    def addScene(self, scene: Sound) -> Sound:
+    def addScene(self, scene: Sound) -> int:
         """Adds a new scene.
 
         :param scene: The scene sound.
         :type scene: Sound
         :return: The new scene id.
+        :rtype: int
         """
         ...
 
-    def addTransition(self, ini, end, transition: Sound) -> Sound:
+    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.
@@ -138,7 +154,7 @@ class DynamicMusic:
 class HRTF:
     """An HRTF object represents a set of head related transfer functions as impulse responses. It's used for binaural sound"""
 
-    def loadLeftHrtfSet(self, extension: typing.Union[str, str], directory):
+    def loadLeftHrtfSet(self, extension: typing.Union[str, str], directory) -> HRTF:
         """Loads all HRTFs from a directory.
 
         :param extension: The file extension of the hrtfs.
@@ -149,7 +165,7 @@ class HRTF:
         """
         ...
 
-    def loadLeftHrtfSet(self, extension: typing.Union[str, str], directory):
+    def loadLeftHrtfSet(self, extension: typing.Union[str, str], directory) -> HRTF:
         """Loads all HRTFs from a directory.
 
         :param extension: The file extension of the hrtfs.
@@ -160,13 +176,17 @@ class HRTF:
         """
         ...
 
-    def addImpulseResponseFromSound(self, sound: Sound, azimuth, elevation):
+    def addImpulseResponseFromSound(
+        self, sound: Sound, azimuth: float, elevation: float
+    ) -> bool:
         """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
         """
@@ -233,7 +253,7 @@ 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):
+    def pause(self) -> bool:
         """Pauses playback.
 
         :return: Whether the action succeeded.
@@ -265,11 +285,13 @@ class ImpulseResponse:
 class PlaybackManager:
     """A PlabackManager object allows to easily control groups os sounds organized in categories."""
 
-    def addCategory(self, volume):
+    def addCategory(self, volume: float) -> int:
         """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
         """
         ...
 
@@ -277,57 +299,66 @@ class PlaybackManager:
         """Cleans all the invalid and finished sound from the playback manager."""
         ...
 
-    def getVolume(self, catKey):
+    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
         """
         ...
 
-    def pause(self, catKey):
+    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):
+    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
                 :return: The playback handle with which playback can be controlled with.
                 :rtype: Handle
         """
         ...
 
-    def resume(self, catKey):
+    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, catKey):
+    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):
+    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
         """
@@ -359,7 +390,7 @@ 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):
+    def add(self) -> SequenceEntry:
         """Adds a new entry to the sequence.
 
         :return: The entry added.
@@ -432,7 +463,7 @@ class Sound:
     """ The sample specification of the sound as a tuple with rate and channel count."""
 
     @classmethod
-    def buffer(cls, data, rate: float) -> float:
+    def buffer(cls, data, rate: float) -> Sound:
         """Creates a sound from a data buffer.
 
         :param data: The data as two dimensional numpy array.
@@ -444,7 +475,7 @@ class Sound:
         ...
 
     @classmethod
-    def file(cls, filename: str) -> str:
+    def file(cls, filename: str) -> Sound:
         """Creates a sound object of a sound file.
 
         :param filename: Path of the file.
@@ -464,78 +495,93 @@ class Sound:
         ...
 
     @classmethod
-    def sawtooth(cls, frequency, rate=48000):
+    def sawtooth(cls, frequency: float, rate: int = 48000) -> 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
                 :return: The created `Sound` object.
                 :rtype: Sound
         """
         ...
 
     @classmethod
-    def silence(cls, rate=48000):
+    def silence(cls, rate: int = 48000) -> Sound:
         """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, rate=48000):
+    def sine(cls, frequency: float, rate: int = 48000) -> 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
                 :return: The created `Sound` object.
                 :rtype: Sound
         """
         ...
 
     @classmethod
-    def square(cls, frequency, rate=48000):
+    def square(cls, frequency: float, rate: int = 48000) -> 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
                 :return: The created `Sound` object.
                 :rtype: Sound
         """
         ...
 
     @classmethod
-    def triangle(cls, frequency, rate=48000):
+    def triangle(cls, frequency: float, rate: int = 48000) -> 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
                 :return: The created `Sound` object.
                 :rtype: Sound
         """
         ...
 
-    def ADSR(self, attack, decay, sustain, release):
+    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
                 :return: The created `Sound` object.
                 :rtype: Sound
         """
         ...
 
-    def accumulate(self, additive=False):
+    def accumulate(self, additive=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,
@@ -581,59 +627,68 @@ class Sound:
         """
         ...
 
-    def data(self) -> Sound:
+    def data(self):
         """Retrieves the data of the sound as numpy array.
 
         :return: A two dimensional numpy float array.
         """
         ...
 
-    def delay(self, time):
+    def delay(self, time: float) -> Sound:
         """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, release, threshold, arthreshold):
+    def envelope(
+        self, attack: float, release: float, threshold: float, arthreshold: float
+    ) -> Sound:
         """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, length):
+    def fadein(self, start: float, length: float) -> Sound:
         """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, length):
+    def fadeout(self, start: float, length: float) -> Sound:
         """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
         """
         ...
 
-    def filter(
-        self, b: typing.List[float], a: typing.List[float] = 1
-    ) -> typing.List[float]:
+    def filter(self, b: typing.List[float], a: typing.List[float] = 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.
@@ -650,12 +705,14 @@ class Sound:
         """
         ...
 
-    def highpass(self, frequency, Q=0.5):
+    def highpass(self, frequency: float, Q: float = 0.5) -> Sound:
         """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
         """
@@ -671,17 +728,19 @@ class Sound:
         """
         ...
 
-    def limit(self, start, end):
+    def limit(self, start: float, end: float) -> Sound:
         """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
         """
         ...
 
-    def loop(self, count):
+    def loop(self, count) -> Sound:
         """Loops a sound.
 
                 :param count: How often the sound should be looped.
@@ -691,11 +750,13 @@ class Sound:
         """
         ...
 
-    def lowpass(self, frequency, Q=0.5):
+    def lowpass(self, frequency: float, Q: float = 0.5) -> Sound:
         """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
         """
@@ -739,30 +800,33 @@ class Sound:
         """
         ...
 
-    def pitch(self, factor):
+    def pitch(self, factor: float) -> Sound:
         """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):
+    def rechannel(self, channels: int) -> Sound:
         """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):
+    def resample(self, rate: float, quality: int) -> Sound:
         """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
         """
@@ -784,22 +848,24 @@ class Sound:
         """
         ...
 
-    def threshold(self, threshold=0):
+    def threshold(self, threshold: float = 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.
 
                 :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):
+    def volume(self, volume: float) -> Sound:
         """Changes the volume of a sound.
 
         :param volume: The new volume..
+        :type volume: float
         :return: The created `Sound` object.
         :rtype: Sound
         """
@@ -808,25 +874,32 @@ class Sound:
     def write(
         self,
         filename: str,
-        rate,
-        channels,
-        format,
-        container,
-        codec,
-        bitrate,
-        buffersize,
+        rate: int,
+        channels: int,
+        format: int,
+        container: int,
+        codec: int,
+        bitrate: int,
+        buffersize: int,
     ):
         """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
         """
         ...