fake-bpy-module 20240803__py3-none-any.whl → 20240805__py3-none-any.whl

_bpy_internal/extensions/__init__.pyi

@@ -2,6 +2,7 @@ import typing
 import collections.abc
 import typing_extensions
 from . import junction_module
+from . import stale_file_manager
 from . import wheel_manager
 
 GenericType1 = typing.TypeVar("GenericType1")

_bpy_internal/extensions/stale_file_manager/__init__.pyi

@@ -0,0 +1,39 @@
+import typing
+import collections.abc
+import typing_extensions
+
+GenericType1 = typing.TypeVar("GenericType1")
+GenericType2 = typing.TypeVar("GenericType2")
+
+class StaleFiles:
+    def filepath_add(self, path_abs, *, rename):
+        """
+
+        :param path_abs:
+        :param rename:
+        """
+        ...
+
+    def is_empty(self): ...
+    def is_modified(self): ...
+    def state_load(self, *, check_exists):
+        """
+
+        :param check_exists:
+        """
+        ...
+
+    def state_load_add_and_store(self, *, paths):
+        """
+
+        :param paths:
+        """
+        ...
+
+    def state_remove_all(self): ...
+    def state_store(self, *, check_exists):
+        """
+
+        :param check_exists:
+        """
+        ...

_bpy_internal/extensions/wheel_manager/__init__.pyi

@@ -5,7 +5,9 @@ import typing_extensions
 GenericType1 = typing.TypeVar("GenericType1")
 GenericType2 = typing.TypeVar("GenericType2")
 
-def apply_action(*, local_dir, local_dir_site_packages, wheel_list): ...
+def apply_action(
+    *, local_dir, local_dir_site_packages, wheel_list, remove_error_fn, debug
+): ...
 def wheel_list_deduplicate_as_skip_set(wheel_list):
     """Return all wheel paths to skip."""
 

addon_utils/__init__.pyi

@@ -71,3 +71,5 @@ def reset_all(*, reload_scripts=False):
     """Sets the addon state based on the user preferences."""
 
     ...
+
+def stale_pending_stage_paths(path_base, paths): ...

aud/__init__.pyi

@@ -157,25 +157,25 @@ 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: str, directory) -> typing.Self:
+    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.Self
+        :rtype: typing_extensions.Self
         """
         ...
 
-    def loadRightHrtfSet(self, extension: str, directory) -> typing.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.Self
+        :rtype: typing_extensions.Self
         """
         ...
 
@@ -466,39 +466,39 @@ class Sound:
     """ The sample specification of the sound as a tuple with rate and channel count."""
 
     @classmethod
-    def buffer(cls, data, rate: float) -> typing.Self:
+    def buffer(cls, data, rate: float) -> typing_extensions.Self:
         """Creates a sound from a data buffer.
 
         :param data: The data as two dimensional numpy array.
         :param rate: The sample rate.
         :type rate: float
         :return: The created `Sound` object.
-        :rtype: typing.Self
+        :rtype: typing_extensions.Self
         """
         ...
 
     @classmethod
-    def file(cls, filename: str) -> typing.Self:
+    def file(cls, filename: str) -> typing_extensions.Self:
         """Creates a sound object of a sound file.
 
         :param filename: Path of the file.
         :type filename: str
         :return: The created `Sound` object.
-        :rtype: typing.Self
+        :rtype: typing_extensions.Self
         """
         ...
 
     @classmethod
-    def list(cls) -> typing.Self:
+    def list(cls) -> typing_extensions.Self:
         """Creates an empty sound list that can contain several sounds.
 
         :return: The created `Sound` object.
-        :rtype: typing.Self
+        :rtype: typing_extensions.Self
         """
         ...
 
     @classmethod
-    def sawtooth(cls, frequency: float, rate: int = 48000) -> typing.Self:
+    def sawtooth(cls, frequency: float, rate: int = 48000) -> typing_extensions.Self:
         """Creates a sawtooth sound which plays a sawtooth wave.
 
                 :param frequency: The frequency of the sawtooth wave in Hz.
@@ -507,24 +507,24 @@ class Sound:
         value to the playback device's samling rate to avoid resamping.
                 :type rate: int
                 :return: The created `Sound` object.
-                :rtype: typing.Self
+                :rtype: typing_extensions.Self
         """
         ...
 
     @classmethod
-    def silence(cls, rate: int = 48000) -> typing.Self:
+    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
                 :return: The created `Sound` object.
-                :rtype: typing.Self
+                :rtype: typing_extensions.Self
         """
         ...
 
     @classmethod
-    def sine(cls, frequency: float, rate: int = 48000) -> typing.Self:
+    def sine(cls, frequency: float, rate: int = 48000) -> typing_extensions.Self:
         """Creates a sine sound which plays a sine wave.
 
                 :param frequency: The frequency of the sine wave in Hz.
@@ -533,12 +533,12 @@ class Sound:
         value to the playback device's samling rate to avoid resamping.
                 :type rate: int
                 :return: The created `Sound` object.
-                :rtype: typing.Self
+                :rtype: typing_extensions.Self
         """
         ...
 
     @classmethod
-    def square(cls, frequency: float, rate: int = 48000) -> typing.Self:
+    def square(cls, frequency: float, rate: int = 48000) -> typing_extensions.Self:
         """Creates a square sound which plays a square wave.
 
                 :param frequency: The frequency of the square wave in Hz.
@@ -547,12 +547,12 @@ class Sound:
         value to the playback device's samling rate to avoid resamping.
                 :type rate: int
                 :return: The created `Sound` object.
-                :rtype: typing.Self
+                :rtype: typing_extensions.Self
         """
         ...
 
     @classmethod
-    def triangle(cls, frequency: float, rate: int = 48000) -> typing.Self:
+    def triangle(cls, frequency: float, rate: int = 48000) -> typing_extensions.Self:
         """Creates a triangle sound which plays a triangle wave.
 
                 :param frequency: The frequency of the triangle wave in Hz.
@@ -561,13 +561,13 @@ class Sound:
         value to the playback device's samling rate to avoid resamping.
                 :type rate: int
                 :return: The created `Sound` object.
-                :rtype: typing.Self
+                :rtype: typing_extensions.Self
         """
         ...
 
     def ADSR(
         self, attack: float, decay: float, sustain: float, release: float
-    ) -> typing.Self:
+    ) -> typing_extensions.Self:
         """Attack-Decay-Sustain-Release envelopes the volume of a sound.
         Note: there is currently no way to trigger the release with this API.
 
@@ -580,11 +580,11 @@ class Sound:
                 :param release: The release level.
                 :type release: float
                 :return: The created `Sound` object.
-                :rtype: typing.Self
+                :rtype: typing_extensions.Self
         """
         ...
 
-    def accumulate(self, additive=False) -> typing.Self:
+    def accumulate(self, additive=False) -> typing_extensions.Self:
         """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,
@@ -592,41 +592,41 @@ class Sound:
 
                 :param additive: Whether the accumulation should be additive or not.
                 :return: The created `Sound` object.
-                :rtype: typing.Self
+                :rtype: typing_extensions.Self
         """
         ...
 
-    def addSound(self, sound: typing.Self):
+    def addSound(self, sound: typing_extensions.Self):
         """Adds a new sound to a sound list.
 
         :param sound: The sound that will be added to the list.
-        :type sound: typing.Self
+        :type sound: typing_extensions.Self
         """
         ...
 
-    def binaural(self) -> typing.Self:
+    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.Self
+        :rtype: typing_extensions.Self
         """
         ...
 
-    def cache(self) -> typing.Self:
+    def cache(self) -> typing_extensions.Self:
         """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.
 
                 :return: The created `Sound` object.
-                :rtype: typing.Self
+                :rtype: typing_extensions.Self
         """
         ...
 
-    def convolver(self) -> typing.Self:
+    def convolver(self) -> typing_extensions.Self:
         """Creates a sound that will apply convolution to another sound.
 
         :return: The created `Sound` object.
-        :rtype: typing.Self
+        :rtype: typing_extensions.Self
         """
         ...
 
@@ -637,19 +637,19 @@ class Sound:
         """
         ...
 
-    def delay(self, time: float) -> typing.Self:
+    def delay(self, time: float) -> typing_extensions.Self:
         """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: typing.Self
+        :rtype: typing_extensions.Self
         """
         ...
 
     def envelope(
         self, attack: float, release: float, threshold: float, arthreshold: float
-    ) -> typing.Self:
+    ) -> typing_extensions.Self:
         """Delays by playing adding silence in front of the other sound's data.
 
         :param attack: The attack factor.
@@ -661,11 +661,11 @@ class Sound:
         :param arthreshold: The attack/release threshold value.
         :type arthreshold: float
         :return: The created `Sound` object.
-        :rtype: typing.Self
+        :rtype: typing_extensions.Self
         """
         ...
 
-    def fadein(self, start: float, length: float) -> typing.Self:
+    def fadein(self, start: float, length: float) -> typing_extensions.Self:
         """Fades a sound in by raising the volume linearly in the given
         time interval.
 
@@ -674,11 +674,11 @@ class Sound:
                 :param length: Time in seconds how long the fading should last.
                 :type length: float
                 :return: The created `Sound` object.
-                :rtype: typing.Self
+                :rtype: typing_extensions.Self
         """
         ...
 
-    def fadeout(self, start: float, length: float) -> typing.Self:
+    def fadeout(self, start: float, length: float) -> typing_extensions.Self:
         """Fades a sound in by lowering the volume linearly in the given
         time interval.
 
@@ -687,11 +687,11 @@ class Sound:
                 :param length: Time in seconds how long the fading should last.
                 :type length: float
                 :return: The created `Sound` object.
-                :rtype: typing.Self
+                :rtype: typing_extensions.Self
         """
         ...
 
-    def filter(self, b: list[float], a: list[float] = 1) -> typing.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,
         it will be set to 1 automatically.
@@ -704,11 +704,11 @@ class Sound:
                 :param a: The denominator filter coefficients.
                 :type a: list[float]
                 :return: The created `Sound` object.
-                :rtype: typing.Self
+                :rtype: typing_extensions.Self
         """
         ...
 
-    def highpass(self, frequency: float, Q: float = 0.5) -> typing.Self:
+    def highpass(self, frequency: float, Q: float = 0.5) -> typing_extensions.Self:
         """Creates a second order highpass filter based on the transfer
         function H(s) = s^2 / (s^2 + s/Q + 1)
 
@@ -717,21 +717,21 @@ class Sound:
                 :param Q: Q factor of the lowpass.
                 :type Q: float
                 :return: The created `Sound` object.
-                :rtype: typing.Self
+                :rtype: typing_extensions.Self
         """
         ...
 
-    def join(self, sound: typing.Self) -> typing.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.Self
+        :type sound: typing_extensions.Self
         :return: The created `Sound` object.
-        :rtype: typing.Self
+        :rtype: typing_extensions.Self
         """
         ...
 
-    def limit(self, start: float, end: float) -> typing.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.
@@ -739,22 +739,22 @@ class Sound:
         :param end: End time in seconds.
         :type end: float
         :return: The created `Sound` object.
-        :rtype: typing.Self
+        :rtype: typing_extensions.Self
         """
         ...
 
-    def loop(self, count: int) -> typing.Self:
+    def loop(self, count: int) -> typing_extensions.Self:
         """Loops a sound.
 
                 :param count: How often the sound should be looped.
         Negative values mean endlessly.
                 :type count: int
                 :return: The created `Sound` object.
-                :rtype: typing.Self
+                :rtype: typing_extensions.Self
         """
         ...
 
-    def lowpass(self, frequency: float, Q: float = 0.5) -> typing.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.
@@ -762,69 +762,69 @@ class Sound:
         :param Q: Q factor of the lowpass.
         :type Q: float
         :return: The created `Sound` object.
-        :rtype: typing.Self
+        :rtype: typing_extensions.Self
         """
         ...
 
-    def mix(self, sound: typing.Self) -> typing.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.Self
+        :type sound: typing_extensions.Self
         :return: The created `Sound` object.
-        :rtype: typing.Self
+        :rtype: typing_extensions.Self
         """
         ...
 
-    def modulate(self, sound: typing.Self) -> typing.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.Self
+        :type sound: typing_extensions.Self
         :return: The created `Sound` object.
-        :rtype: typing.Self
+        :rtype: typing_extensions.Self
         """
         ...
 
-    def mutable(self) -> typing.Self:
+    def mutable(self) -> typing_extensions.Self:
         """Creates a sound that will be restarted when sought backwards.
         If the original sound is a sound list, the playing sound can change.
 
                 :return: The created `Sound` object.
-                :rtype: typing.Self
+                :rtype: typing_extensions.Self
         """
         ...
 
-    def pingpong(self) -> typing.Self:
+    def pingpong(self) -> typing_extensions.Self:
         """Plays a sound forward and then backward.
         This is like joining a sound with its reverse.
 
                 :return: The created `Sound` object.
-                :rtype: typing.Self
+                :rtype: typing_extensions.Self
         """
         ...
 
-    def pitch(self, factor: float) -> typing.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.Self
+        :rtype: typing_extensions.Self
         """
         ...
 
-    def rechannel(self, channels: int) -> typing.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.Self
+        :rtype: typing_extensions.Self
         """
         ...
 
-    def resample(self, rate: float, quality: int) -> typing.Self:
+    def resample(self, rate: float, quality: int) -> typing_extensions.Self:
         """Resamples the sound.
 
         :param rate: The new sample rate.
@@ -832,27 +832,27 @@ class Sound:
         :param quality: Resampler performance vs quality choice (0=fastest, 3=slowest).
         :type quality: int
         :return: The created `Sound` object.
-        :rtype: typing.Self
+        :rtype: typing_extensions.Self
         """
         ...
 
-    def reverse(self) -> typing.Self:
+    def reverse(self) -> typing_extensions.Self:
         """Plays a sound reversed.
 
         :return: The created `Sound` object.
-        :rtype: typing.Self
+        :rtype: typing_extensions.Self
         """
         ...
 
-    def sum(self) -> typing.Self:
+    def sum(self) -> typing_extensions.Self:
         """Sums the samples of a sound.
 
         :return: The created `Sound` object.
-        :rtype: typing.Self
+        :rtype: typing_extensions.Self
         """
         ...
 
-    def threshold(self, threshold: float = 0) -> typing.Self:
+    def threshold(self, threshold: float = 0) -> typing_extensions.Self:
         """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.
@@ -861,17 +861,17 @@ class Sound:
         non-zero.
                 :type threshold: float
                 :return: The created `Sound` object.
-                :rtype: typing.Self
+                :rtype: typing_extensions.Self
         """
         ...
 
-    def volume(self, volume: float) -> typing.Self:
+    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.Self
+        :rtype: typing_extensions.Self
         """
         ...