circuitpython-stubs 9.2.7__tar.gz → 10.0.0a3__tar.gz

circuitpython_stubs-10.0.0a3/PKG-INFO

@@ -0,0 +1,15 @@
+Metadata-Version: 2.4
+Name: circuitpython-stubs
+Version: 10.0.0a3
+Summary: PEP 561 type stubs for CircuitPython
+Home-page: https://github.com/adafruit/circuitpython
+Author-email: circuitpython@adafruit.com
+Maintainer: CircuitPythonistas
+Maintainer-email: circuitpython@adafruit.com
+License: MIT
+Dynamic: author-email
+Dynamic: home-page
+Dynamic: license
+Dynamic: maintainer
+Dynamic: maintainer-email
+Dynamic: summary

circuitpython_stubs-10.0.0a3/audiodelays/__init__.pyi

@@ -0,0 +1,383 @@
+"""Support for audio delay effects
+
+The `audiodelays` module contains classes to provide access to audio delay effects.
+
+"""
+
+from __future__ import annotations
+
+from typing import Optional, Tuple
+
+import circuitpython_typing
+import synthio
+
+class Chorus:
+    """An Chorus effect"""
+
+    def __init__(
+        self,
+        max_delay_ms: int = 50,
+        delay_ms: synthio.BlockInput = 50.0,
+        voices: synthio.BlockInput = 1.0,
+        buffer_size: int = 512,
+        sample_rate: int = 8000,
+        bits_per_sample: int = 16,
+        samples_signed: bool = True,
+        channel_count: int = 1,
+    ) -> None:
+        """Create a Chorus effect by playing the current sample along with one or more samples
+           (the voices) from the delay buffer. The voices played are evenly spaced across the delay
+           buffer. So for 2 voices you would hear the current sample and the one delay milliseconds back.
+           The delay timing of the chorus can be changed at runtime with the delay_ms parameter but the delay
+           can never exceed the max_delay_ms parameter. The maximum delay you can set is limited by available
+           memory.
+
+        :param int max_delay_ms: The maximum time the chorus can be in milliseconds
+        :param synthio.BlockInput delay_ms: The current time of the chorus delay in milliseconds. Must be less the max_delay_ms.
+        :param synthio.BlockInput voices: The number of voices playing split evenly over the delay buffer.
+        :param synthio.BlockInput mix: How much of the wet audio to include along with the original signal.
+        :param int buffer_size: The total size in bytes of each of the two playback buffers to use
+        :param int sample_rate: The sample rate to be used
+        :param int channel_count: The number of channels the source samples contain. 1 = mono; 2 = stereo.
+        :param int bits_per_sample: The bits per sample of the effect
+        :param bool samples_signed: Effect is signed (True) or unsigned (False)
+
+        Playing adding an chorus to a synth::
+
+          import time
+          import board
+          import audiobusio
+          import synthio
+          import audiodelays
+
+          audio = audiobusio.I2SOut(bit_clock=board.GP20, word_select=board.GP21, data=board.GP22)
+          synth = synthio.Synthesizer(channel_count=1, sample_rate=44100)
+          chorus = audiodelays.Chorus(max_delay_ms=50, delay_ms=5, buffer_size=1024, channel_count=1, sample_rate=44100)
+          chorus.play(synth)
+          audio.play(chorus)
+
+          note = synthio.Note(261)
+          while True:
+              synth.press(note)
+              time.sleep(0.25)
+              synth.release(note)
+              time.sleep(5)"""
+        ...
+
+    def deinit(self) -> None:
+        """Deinitialises the Chorus."""
+        ...
+
+    def __enter__(self) -> Chorus:
+        """No-op used by Context Managers."""
+        ...
+
+    def __exit__(self) -> None:
+        """Automatically deinitializes when exiting a context. See
+        :ref:`lifetime-and-contextmanagers` for more info."""
+        ...
+    delay_ms: synthio.BlockInput
+    """The current time of the chorus delay in milliseconds. Must be less the max_delay_ms."""
+
+    voices: synthio.BlockInput
+    """The number of voices playing split evenly over the delay buffer."""
+    mix: synthio.BlockInput
+    """The rate the echo mix between 0 and 1 where 0 is only sample and 1 is all effect."""
+    playing: bool
+    """True when the effect is playing a sample. (read-only)"""
+
+    def play(
+        self, sample: circuitpython_typing.AudioSample, *, loop: bool = False
+    ) -> None:
+        """Plays the sample once when loop=False and continuously when loop=True.
+        Does not block. Use `playing` to block.
+
+        The sample must match the encoding settings given in the constructor."""
+        ...
+
+    def stop(self) -> None:
+        """Stops playback of the sample."""
+        ...
+
+class Echo:
+    """An Echo effect"""
+
+    def __init__(
+        self,
+        max_delay_ms: int = 500,
+        delay_ms: synthio.BlockInput = 250.0,
+        decay: synthio.BlockInput = 0.7,
+        mix: synthio.BlockInput = 0.25,
+        buffer_size: int = 512,
+        sample_rate: int = 8000,
+        bits_per_sample: int = 16,
+        samples_signed: bool = True,
+        channel_count: int = 1,
+    ) -> None:
+        """Create a Echo effect where you hear the original sample play back, at a lesser volume after
+           a set number of millisecond delay. The delay timing of the echo can be changed at runtime
+           with the delay_ms parameter but the delay can never exceed the max_delay_ms parameter. The
+           maximum delay you can set is limited by available memory.
+
+           Each time the echo plays back the volume is reduced by the decay setting (echo * decay).
+
+           The mix parameter allows you to change how much of the unchanged sample passes through to
+           the output to how much of the effect audio you hear as the output.
+
+        :param int max_delay_ms: The maximum time the echo can be in milliseconds
+        :param synthio.BlockInput delay_ms: The current time of the echo delay in milliseconds. Must be less the max_delay_ms
+        :param synthio.BlockInput decay: The rate the echo fades. 0.0 = instant; 1.0 = never.
+        :param synthio.BlockInput mix: The mix as a ratio of the sample (0.0) to the effect (1.0).
+        :param int buffer_size: The total size in bytes of each of the two playback buffers to use
+        :param int sample_rate: The sample rate to be used
+        :param int channel_count: The number of channels the source samples contain. 1 = mono; 2 = stereo.
+        :param int bits_per_sample: The bits per sample of the effect
+        :param bool samples_signed: Effect is signed (True) or unsigned (False)
+        :param bool freq_shift: Do echos change frequency as the echo delay changes
+
+        Playing adding an echo to a synth::
+
+          import time
+          import board
+          import audiobusio
+          import synthio
+          import audiodelays
+
+          audio = audiobusio.I2SOut(bit_clock=board.GP20, word_select=board.GP21, data=board.GP22)
+          synth = synthio.Synthesizer(channel_count=1, sample_rate=44100)
+          echo = audiodelays.Echo(max_delay_ms=1000, delay_ms=850, decay=0.65, buffer_size=1024, channel_count=1, sample_rate=44100, mix=0.7, freq_shift=False)
+          echo.play(synth)
+          audio.play(echo)
+
+          note = synthio.Note(261)
+          while True:
+              synth.press(note)
+              time.sleep(0.25)
+              synth.release(note)
+              time.sleep(5)"""
+        ...
+
+    def deinit(self) -> None:
+        """Deinitialises the Echo."""
+        ...
+
+    def __enter__(self) -> Echo:
+        """No-op used by Context Managers."""
+        ...
+
+    def __exit__(self) -> None:
+        """Automatically deinitializes when exiting a context. See
+        :ref:`lifetime-and-contextmanagers` for more info."""
+        ...
+    delay_ms: synthio.BlockInput
+    """Delay of the echo in milliseconds. (read-only)"""
+
+    decay: synthio.BlockInput
+    """The rate the echo fades between 0 and 1 where 0 is instant and 1 is never."""
+    mix: synthio.BlockInput
+    """The rate the echo mix between 0 and 1 where 0 is only sample, 0.5 is an equal mix of the sample and the effect and 1 is all effect."""
+    freq_shift: bool
+    """Does the echo change frequencies as the delay changes."""
+    playing: bool
+    """True when the effect is playing a sample. (read-only)"""
+
+    def play(
+        self, sample: circuitpython_typing.AudioSample, *, loop: bool = False
+    ) -> None:
+        """Plays the sample once when loop=False and continuously when loop=True.
+        Does not block. Use `playing` to block.
+
+        The sample must match the encoding settings given in the constructor."""
+        ...
+
+    def stop(self) -> None:
+        """Stops playback of the sample. The echo continues playing."""
+        ...
+
+class MultiTapDelay:
+    """A delay with multiple buffer positions to create a rhythmic effect."""
+
+    def __init__(
+        self,
+        max_delay_ms: int = 500,
+        delay_ms: synthio.BlockInput = 250.0,
+        decay: synthio.BlockInput = 0.7,
+        mix: synthio.BlockInput = 0.25,
+        taps: Optional[Tuple[float | Tuple[float, float], ...]] = None,
+        buffer_size: int = 512,
+        sample_rate: int = 8000,
+        bits_per_sample: int = 16,
+        samples_signed: bool = True,
+        channel_count: int = 1,
+    ) -> None:
+        """Create a delay effect where you hear the original sample play back at varying times, or "taps".
+           These tap positions and levels can be used to create rhythmic effects.
+           The timing of the delay can be changed at runtime with the delay_ms parameter but the delay can
+           never exceed the max_delay_ms parameter. The maximum delay you can set is limited by available
+           memory.
+
+           Each time the delay plays back the volume is reduced by the decay setting (delay * decay).
+
+           The mix parameter allows you to change how much of the unchanged sample passes through to
+           the output to how much of the effect audio you hear as the output.
+
+        :param int max_delay_ms: The maximum time the delay can be in milliseconds.
+        :param float delay_ms: The current time of the delay in milliseconds. Must be less than max_delay_ms.
+        :param synthio.BlockInput decay: The rate the delay fades. 0.0 = instant; 1.0 = never.
+        :param synthio.BlockInput mix: The mix as a ratio of the sample (0.0) to the effect (1.0).
+        :param tuple taps: The positions and levels to tap into the delay buffer.
+        :param int buffer_size: The total size in bytes of each of the two playback buffers to use.
+        :param int sample_rate: The sample rate to be used.
+        :param int channel_count: The number of channels the source samples contain. 1 = mono; 2 = stereo.
+        :param int bits_per_sample: The bits per sample of the effect.
+        :param bool samples_signed: Effect is signed (True) or unsigned (False).
+
+        Playing adding a multi-tap delay to a synth::
+
+          import time
+          import board
+          import audiobusio
+          import synthio
+          import audiodelays
+
+          audio = audiobusio.I2SOut(bit_clock=board.GP20, word_select=board.GP21, data=board.GP22)
+          synth = synthio.Synthesizer(channel_count=1, sample_rate=44100)
+          effect = audiodelays.MultiTapDelay(max_delay_ms=500, delay_ms=500, decay=0.65, mix=0.5, taps=((2/3, 0.7), 1), buffer_size=1024, channel_count=1, sample_rate=44100)
+          effect.play(synth)
+          audio.play(effect)
+
+          note = synthio.Note(261)
+          while True:
+              synth.press(note)
+              time.sleep(0.05)
+              synth.release(note)
+              time.sleep(5)"""
+        ...
+
+    def deinit(self) -> None:
+        """Deinitialises the MultiTapDelay."""
+        ...
+
+    def __enter__(self) -> MultiTapDelay:
+        """No-op used by Context Managers."""
+        ...
+
+    def __exit__(self) -> None:
+        """Automatically deinitializes when exiting a context. See
+        :ref:`lifetime-and-contextmanagers` for more info."""
+        ...
+    delay_ms: float
+    """Time to delay the incoming signal in milliseconds. Must be less than max_delay_ms."""
+
+    decay: synthio.BlockInput
+    """The rate the echo fades between 0 and 1 where 0 is instant and 1 is never."""
+    mix: synthio.BlockInput
+    """The mix of the effect between 0 and 1 where 0 is only sample, 0.5 is an equal mix of the sample and the effect and 1 is all effect."""
+    taps: Tuple[float | int | Tuple[float | int, float | int], ...]
+    """The position or position and level of delay taps.
+    The position is a number from 0 (start) to 1 (end) as a relative position in the delay buffer.
+    The level is a number from 0 (silence) to 1 (full volume).
+    If only a float or integer is provided as an element of the tuple, the level is assumed to be 1.
+    When retrieving the value of this property, the level will always be included."""
+
+    playing: bool
+    """True when the effect is playing a sample. (read-only)"""
+
+    def play(
+        self, sample: circuitpython_typing.AudioSample, *, loop: bool = False
+    ) -> None:
+        """Plays the sample once when loop=False and continuously when loop=True.
+        Does not block. Use `playing` to block.
+
+        The sample must match the encoding settings given in the constructor."""
+        ...
+
+    def stop(self) -> None:
+        """Stops playback of the sample. The echo continues playing."""
+        ...
+
+class PitchShift:
+    """A pitch shift effect"""
+
+    def __init__(
+        self,
+        semitones: synthio.BlockInput = 0.0,
+        mix: synthio.BlockInput = 1.0,
+        window: int = 1024,
+        overlap: int = 128,
+        buffer_size: int = 512,
+        sample_rate: int = 8000,
+        bits_per_sample: int = 16,
+        samples_signed: bool = True,
+        channel_count: int = 1,
+    ) -> None:
+        """Create a pitch shift effect where the original sample play back is altered to change the
+           the perceived pitch by a factor of semi-tones (1/12th of an octave). This effect will cause
+           a slight delay in the output depending on the size of the window and overlap buffers.
+
+           The mix parameter allows you to change how much of the unchanged sample passes through to
+           the output to how much of the effect audio you hear as the output.
+
+        :param synthio.BlockInput semitones: The amount of pitch shifting in semitones (1/12th of an octave)
+        :param synthio.BlockInput mix: The mix as a ratio of the sample (0.0) to the effect (1.0)
+        :param int window: The total size in bytes of the window buffer used alter the playback pitch
+        :param int overlap: The total size in bytes of the overlap buffer used to prevent popping in the output. If set as 0, no overlap will be used.
+        :param int buffer_size: The total size in bytes of each of the two playback buffers to use
+        :param int sample_rate: The sample rate to be used
+        :param int channel_count: The number of channels the source samples contain. 1 = mono; 2 = stereo.
+        :param int bits_per_sample: The bits per sample of the effect
+        :param bool samples_signed: Effect is signed (True) or unsigned (False)
+
+        Shifting the pitch of a synth by 5 semitones::
+
+          import time
+          import board
+          import audiobusio
+          import synthio
+          import audiodelays
+
+          audio = audiobusio.I2SOut(bit_clock=board.GP0, word_select=board.GP1, data=board.GP2)
+          synth = synthio.Synthesizer(channel_count=1, sample_rate=44100)
+          pitch_shift = audiodelays.PitchShift(semitones=5.0, mix=0.5, window=2048, overlap=256, buffer_size=1024, channel_count=1, sample_rate=44100)
+          pitch_shift.play(synth)
+          audio.play(pitch_shift)
+
+          while True:
+              for notenum in (60, 64, 67, 71):
+                  synth.press(notenum)
+                  time.sleep(0.25)
+                  synth.release_all()"""
+        ...
+
+    def deinit(self) -> None:
+        """Deinitialises the PitchShift."""
+        ...
+
+    def __enter__(self) -> PitchShift:
+        """No-op used by Context Managers."""
+        ...
+
+    def __exit__(self) -> None:
+        """Automatically deinitializes when exiting a context. See
+        :ref:`lifetime-and-contextmanagers` for more info."""
+        ...
+    semitones: synthio.BlockInput
+    """The amount of pitch shifting in semitones (1/12th of an octave)."""
+
+    mix: synthio.BlockInput
+    """The output mix between 0 and 1 where 0 is only sample and 1 is all effect."""
+    playing: bool
+    """True when the effect is playing a sample. (read-only)"""
+
+    def play(
+        self, sample: circuitpython_typing.AudioSample, *, loop: bool = False
+    ) -> None:
+        """Plays the sample once when loop=False and continuously when loop=True.
+        Does not block. Use `playing` to block.
+
+        The sample must match the encoding settings given in the constructor."""
+        ...
+
+    def stop(self) -> None:
+        """Stops playback of the sample."""
+        ...

circuitpython_stubs-10.0.0a3/audiofilters/__init__.pyi

@@ -0,0 +1,293 @@
+"""Support for audio filter effects
+
+The `audiofilters` module contains classes to provide access to audio filter effects.
+
+"""
+
+from __future__ import annotations
+
+from typing import Optional, Tuple
+
+import circuitpython_typing
+import synthio
+
+class DistortionMode:
+    """The method of distortion used by the `audiofilters.Distortion` effect."""
+
+    CLIP: DistortionMode
+    """Digital distortion effect which cuts off peaks at the top and bottom of the waveform."""
+
+    LOFI: DistortionMode
+    """Low-resolution digital distortion effect (bit depth reduction). You can use it to emulate the sound of early digital audio devices."""
+
+    OVERDRIVE: DistortionMode
+    """Emulates the warm distortion produced by a field effect transistor, which is commonly used in solid-state musical instrument amplifiers. The `audiofilters.Distortion.drive` property has no effect in this mode."""
+
+    WAVESHAPE: DistortionMode
+    """Waveshaper distortions are used mainly by electronic musicians to achieve an extra-abrasive sound."""
+
+class Distortion:
+    """A Distortion effect"""
+
+    def __init__(
+        self,
+        drive: synthio.BlockInput = 0.0,
+        pre_gain: synthio.BlockInput = 0.0,
+        post_gain: synthio.BlockInput = 0.0,
+        mode: DistortionMode = DistortionMode.CLIP,
+        soft_clip: bool = False,
+        mix: synthio.BlockInput = 1.0,
+        buffer_size: int = 512,
+        sample_rate: int = 8000,
+        bits_per_sample: int = 16,
+        samples_signed: bool = True,
+        channel_count: int = 1,
+    ) -> None:
+        """Create a Distortion effect where the original sample is manipulated to create a distorted
+           sound according to the DistortionMode.
+
+           The mix parameter allows you to change how much of the unchanged sample passes through to
+           the output to how much of the effect audio you hear as the output.
+
+        :param synthio.BlockInput drive: Distortion power. Value can range from 0.0 to 1.0.
+        :param synthio.BlockInput pre_gain: Increases or decreases the volume before the effect, in decibels. Value can range from -60 to 60.
+        :param synthio.BlockInput post_gain: Increases or decreases the volume after the effect, in decibels. Value can range from -80 to 24.
+        :param DistortionMode mode: Distortion type.
+        :param bool soft_clip: Whether or not to soft clip (True) or hard clip (False) the output.
+        :param synthio.BlockInput mix: The mix as a ratio of the sample (0.0) to the effect (1.0).
+        :param int buffer_size: The total size in bytes of each of the two playback buffers to use
+        :param int sample_rate: The sample rate to be used
+        :param int channel_count: The number of channels the source samples contain. 1 = mono; 2 = stereo.
+        :param int bits_per_sample: The bits per sample of the effect
+        :param bool samples_signed: Effect is signed (True) or unsigned (False)
+
+        Playing adding a distortion to a synth::
+
+          import time
+          import board
+          import audiobusio
+          import synthio
+          import audiofilters
+
+          audio = audiobusio.I2SOut(bit_clock=board.GP20, word_select=board.GP21, data=board.GP22)
+          synth = synthio.Synthesizer(channel_count=1, sample_rate=44100)
+          effect = audiofilters.Distortion(drive=0.5, mix=1.0, buffer_size=1024, channel_count=1, sample_rate=44100)
+          effect.play(synth)
+          audio.play(effect)
+
+          note = synthio.Note(261)
+          while True:
+              synth.press(note)
+              time.sleep(0.25)
+              synth.release(note)
+              time.sleep(5)"""
+        ...
+
+    def deinit(self) -> None:
+        """Deinitialises the Distortion."""
+        ...
+
+    def __enter__(self) -> Distortion:
+        """No-op used by Context Managers."""
+        ...
+
+    def __exit__(self) -> None:
+        """Automatically deinitializes when exiting a context. See
+        :ref:`lifetime-and-contextmanagers` for more info."""
+        ...
+    drive: synthio.BlockInput
+    """Distortion power. Value can range from 0.0 to 1.0."""
+    pre_gain: synthio.BlockInput
+    """Increases or decreases the volume before the effect, in decibels. Value can range from -60 to 60."""
+    post_gain: synthio.BlockInput
+    """Increases or decreases the volume after the effect, in decibels. Value can range from -80 to 24."""
+    mode: DistortionMode
+    """Distortion type."""
+    soft_clip: bool
+    """Whether or not to soft clip (True) or hard clip (False) the output."""
+    mix: synthio.BlockInput
+    """The rate the filtered signal mix between 0 and 1 where 0 is only sample and 1 is all effect."""
+    playing: bool
+    """True when the effect is playing a sample. (read-only)"""
+
+    def play(
+        self, sample: circuitpython_typing.AudioSample, *, loop: bool = False
+    ) -> None:
+        """Plays the sample once when loop=False and continuously when loop=True.
+        Does not block. Use `playing` to block.
+
+        The sample must match the encoding settings given in the constructor."""
+        ...
+
+    def stop(self) -> None:
+        """Stops playback of the sample."""
+        ...
+
+class Filter:
+    """A Filter effect"""
+
+    def __init__(
+        self,
+        filter: Optional[synthio.Biquad | Tuple[synthio.Biquad]] = None,
+        mix: synthio.BlockInput = 1.0,
+        buffer_size: int = 512,
+        sample_rate: int = 8000,
+        bits_per_sample: int = 16,
+        samples_signed: bool = True,
+        channel_count: int = 1,
+    ) -> None:
+        """Create a Filter effect where the original sample is processed through a biquad filter
+           created by a synthio.Synthesizer object. This can be used to generate a low-pass,
+           high-pass, or band-pass filter.
+
+           The mix parameter allows you to change how much of the unchanged sample passes through to
+           the output to how much of the effect audio you hear as the output.
+
+        :param Optional[synthio.Biquad|Tuple[synthio.Biquad]] filter: A normalized biquad filter object or tuple of normalized biquad filter objects. The sample is processed sequentially by each filter to produce the output samples.
+        :param synthio.BlockInput mix: The mix as a ratio of the sample (0.0) to the effect (1.0).
+        :param int buffer_size: The total size in bytes of each of the two playback buffers to use
+        :param int sample_rate: The sample rate to be used
+        :param int channel_count: The number of channels the source samples contain. 1 = mono; 2 = stereo.
+        :param int bits_per_sample: The bits per sample of the effect
+        :param bool samples_signed: Effect is signed (True) or unsigned (False)
+
+        Playing adding a filter to a synth::
+
+          import time
+          import board
+          import audiobusio
+          import synthio
+          import audiofilters
+
+          audio = audiobusio.I2SOut(bit_clock=board.GP20, word_select=board.GP21, data=board.GP22)
+          synth = synthio.Synthesizer(channel_count=1, sample_rate=44100)
+          effect = audiofilters.Filter(buffer_size=1024, channel_count=1, sample_rate=44100, mix=1.0)
+          effect.filter = synth.low_pass_filter(frequency=2000, Q=1.25)
+          effect.play(synth)
+          audio.play(effect)
+
+          note = synthio.Note(261)
+          while True:
+              synth.press(note)
+              time.sleep(0.25)
+              synth.release(note)
+              time.sleep(5)"""
+        ...
+
+    def deinit(self) -> None:
+        """Deinitialises the Filter."""
+        ...
+
+    def __enter__(self) -> Filter:
+        """No-op used by Context Managers."""
+        ...
+
+    def __exit__(self) -> None:
+        """Automatically deinitializes when exiting a context. See
+        :ref:`lifetime-and-contextmanagers` for more info."""
+        ...
+    filter: synthio.Biquad | Tuple[synthio.Biquad] | None
+    """A normalized biquad filter object or tuple of normalized biquad filter objects. The sample is processed sequentially by each filter to produce the output samples."""
+
+    mix: synthio.BlockInput
+    """The rate the filtered signal mix between 0 and 1 where 0 is only sample and 1 is all effect."""
+    playing: bool
+    """True when the effect is playing a sample. (read-only)"""
+
+    def play(
+        self, sample: circuitpython_typing.AudioSample, *, loop: bool = False
+    ) -> None:
+        """Plays the sample once when loop=False and continuously when loop=True.
+        Does not block. Use `playing` to block.
+
+        The sample must match the encoding settings given in the constructor."""
+        ...
+
+    def stop(self) -> None:
+        """Stops playback of the sample."""
+        ...
+
+class Phaser:
+    """A Phaser effect"""
+
+    def __init__(
+        self,
+        frequency: synthio.BlockInput = 1000.0,
+        feedback: synthio.BlockInput = 0.7,
+        mix: synthio.BlockInput = 1.0,
+        stages: int = 6,
+        buffer_size: int = 512,
+        sample_rate: int = 8000,
+        bits_per_sample: int = 16,
+        samples_signed: bool = True,
+        channel_count: int = 1,
+    ) -> None:
+        """Create a Phaser effect where the original sample is processed through a variable
+           number of all-pass filter stages. This slightly delays the signal so that it is out
+           of phase with the original signal. When the amount of phase is modulated and mixed
+           back into the original signal with the mix parameter, it creates a distinctive
+           phasing sound.
+
+        :param synthio.BlockInput frequency: The target frequency which is affected by the effect in hz.
+        :param int stages: The number of all-pass filters which will be applied to the signal.
+        :param synthio.BlockInput feedback: The amount that the previous output of the filters is mixed back into their input along with the unprocessed signal.
+        :param synthio.BlockInput mix: The mix as a ratio of the sample (0.0) to the effect (1.0).
+        :param int buffer_size: The total size in bytes of each of the two playback buffers to use
+        :param int sample_rate: The sample rate to be used
+        :param int channel_count: The number of channels the source samples contain. 1 = mono; 2 = stereo.
+        :param int bits_per_sample: The bits per sample of the effect
+        :param bool samples_signed: Effect is signed (True) or unsigned (False)
+
+        Playing adding a phaser to a synth::
+
+          import time
+          import board
+          import audiobusio
+          import audiofilters
+          import synthio
+
+          audio = audiobusio.I2SOut(bit_clock=board.GP20, word_select=board.GP21, data=board.GP22)
+          synth = synthio.Synthesizer(channel_count=1, sample_rate=44100)
+          effect = audiofilters.Phaser(channel_count=1, sample_rate=44100)
+          effect.frequency = synthio.LFO(offset=1000.0, scale=600.0, rate=0.5)
+          effect.play(synth)
+          audio.play(effect)
+
+          synth.press(48)"""
+        ...
+
+    def deinit(self) -> None:
+        """Deinitialises the Phaser."""
+        ...
+
+    def __enter__(self) -> Phaser:
+        """No-op used by Context Managers."""
+        ...
+
+    def __exit__(self) -> None:
+        """Automatically deinitializes when exiting a context. See
+        :ref:`lifetime-and-contextmanagers` for more info."""
+        ...
+    frequency: synthio.BlockInput
+    """The target frequency in hertz at which the phaser is delaying the signal."""
+    feedback: synthio.BlockInput
+    """The amount of which the incoming signal is fed back into the phasing filters from 0.1 to 0.9."""
+    mix: synthio.BlockInput
+    """The amount that the effect signal is mixed into the output between 0 and 1 where 0 is only the original sample and 1 is all effect."""
+    stages: int
+    """The number of allpass filters to pass the signal through. More stages requires more processing but produces a more pronounced effect. Requires a minimum value of 1."""
+    playing: bool
+    """True when the effect is playing a sample. (read-only)"""
+
+    def play(
+        self, sample: circuitpython_typing.AudioSample, *, loop: bool = False
+    ) -> None:
+        """Plays the sample once when loop=False and continuously when loop=True.
+        Does not block. Use `playing` to block.
+
+        The sample must match the encoding settings given in the constructor."""
+        ...
+
+    def stop(self) -> None:
+        """Stops playback of the sample."""
+        ...