gingo 1.0.0__cp310-cp310-win_amd64.whl

gingo/__init__.py

@@ -0,0 +1,106 @@
+"""🪇 Gingo — Music theory library for Python.
+
+A comprehensive toolset for working with music theory programmatically:
+notes, intervals, chords, scales, and harmonic fields.
+
+Examples:
+    >>> from gingo import Note, Chord, Scale, Field
+    >>> Note("Bb").natural()
+    'A#'
+    >>> Chord("Cm7").notes()
+    [Note("C"), Note("D#"), Note("G"), Note("A#")]
+    >>> Scale("C", "major").degree(5)
+    Note("G")
+    >>> [c.name() for c in Field("C", "major").chords()]
+    ['CM', 'Dm', 'Em', 'FM', 'GM', 'Am', 'Bdim']
+"""
+
+from gingo._gingo import (
+    Note,
+    Interval,
+    Chord,
+    ChordComparison,
+    Scale,
+    ScaleType,
+    Modality,
+    Field,
+    HarmonicFunction,
+    BorrowedInfo,
+    PivotInfo,
+    FieldComparison,
+    Tree,
+    HarmonicPath,
+    Duration,
+    Tempo,
+    TimeSignature,
+    NoteEvent,
+    ChordEvent,
+    Rest,
+    Sequence,
+)
+
+try:
+    from importlib.metadata import version as _version
+    __version__ = _version("gingo")
+except Exception:
+    __version__ = "0.0.0"
+__author__ = "Saulo Verissimo"
+
+__all__ = [
+    "Note",
+    "Interval",
+    "Chord",
+    "ChordComparison",
+    "Scale",
+    "ScaleType",
+    "Modality",
+    "Field",
+    "HarmonicFunction",
+    "BorrowedInfo",
+    "PivotInfo",
+    "FieldComparison",
+    "Tree",
+    "HarmonicPath",
+    "Duration",
+    "Tempo",
+    "TimeSignature",
+    "NoteEvent",
+    "ChordEvent",
+    "Rest",
+    "Sequence",
+]
+
+# ---------------------------------------------------------------------------
+# Audio monkey-patch: .play() and .to_wav() on domain classes
+# Available when gingo.audio can be imported (always — zero-dep synthesis).
+# ---------------------------------------------------------------------------
+
+try:
+    from gingo.audio import play as _play_fn, to_wav as _to_wav_fn
+
+    def _make_play(_cls):  # noqa: N802
+        def play(self, **kwargs):
+            """Play this object through the system audio output.
+
+            See :func:`gingo.audio.play` for keyword arguments.
+            """
+            return _play_fn(self, **kwargs)
+        return play
+
+    def _make_to_wav(_cls):  # noqa: N802
+        def to_wav(self, path, **kwargs):
+            """Render this object to a WAV file.
+
+            See :func:`gingo.audio.to_wav` for keyword arguments.
+            """
+            return _to_wav_fn(self, path, **kwargs)
+        return to_wav
+
+    for _cls in (Note, Chord, Scale, Field, Tree, Sequence,
+                 NoteEvent, ChordEvent, Rest):
+        _cls.play = _make_play(_cls)
+        _cls.to_wav = _make_to_wav(_cls)
+
+    del _make_play, _make_to_wav, _cls
+except Exception:
+    pass

gingo/__init__.pyi

@@ -0,0 +1,476 @@
+"""Type stubs for the Gingo C++ extension module."""
+
+from typing import Any, Dict, Iterator, List, Optional, Tuple, Union, overload
+from enum import Enum
+from pathlib import Path
+
+from gingo.audio import Envelope, Waveform
+
+class ScaleType(Enum):
+    Major: int
+    NaturalMinor: int
+    HarmonicMinor: int
+    MelodicMinor: int
+    Diminished: int
+    HarmonicMajor: int
+    WholeTone: int
+    Augmented: int
+    Blues: int
+    Chromatic: int
+
+class Modality(Enum):
+    Diatonic: int
+    Pentatonic: int
+
+class Note:
+    def __init__(self, name: str) -> None: ...
+    def name(self) -> str: ...
+    def natural(self) -> str: ...
+    def sound(self) -> str: ...
+    def semitone(self) -> int: ...
+    def frequency(self, octave: int = 4, tuning: float = 440.0) -> float: ...
+    def is_enharmonic(self, other: "Note") -> bool: ...
+    def transpose(self, semitones: int) -> "Note": ...
+    def distance(self, other: "Note") -> int: ...
+    @staticmethod
+    def fifths() -> List[str]: ...
+    def __eq__(self, other: object) -> bool: ...
+    def __ne__(self, other: object) -> bool: ...
+    def __repr__(self) -> str: ...
+    def __str__(self) -> str: ...
+    def __hash__(self) -> int: ...
+    def __lt__(self, other: "Note") -> bool: ...
+    def __le__(self, other: "Note") -> bool: ...
+    def __gt__(self, other: "Note") -> bool: ...
+    def __ge__(self, other: "Note") -> bool: ...
+    def __int__(self) -> int: ...
+    def play(self, *, octave: int = 4, duration: float = 0.5, waveform: Union[Waveform, str] = ..., amplitude: float = 0.8, envelope: Optional[Envelope] = None, strum: float = 0.03, gap: float = 0.05, tuning: float = 440.0, sample_rate: int = 44100) -> None: ...
+    def to_wav(self, path: Union[str, Path], *, octave: int = 4, duration: float = 0.5, waveform: Union[Waveform, str] = ..., amplitude: float = 0.8, envelope: Optional[Envelope] = None, strum: float = 0.03, gap: float = 0.05, tuning: float = 440.0, sample_rate: int = 44100) -> None: ...
+    def __float__(self) -> float: ...
+    @overload
+    def __add__(self, semitones: int) -> "Note": ...
+    @overload
+    def __add__(self, interval: "Interval") -> "Note": ...
+    def __radd__(self, semitones: int) -> "Note": ...
+    @overload
+    def __sub__(self, semitones: int) -> "Note": ...
+    @overload
+    def __sub__(self, interval: "Interval") -> "Note": ...
+    @overload
+    def __sub__(self, other: "Note") -> "Interval": ...
+
+class Interval:
+    @overload
+    def __init__(self, label: str) -> None: ...
+    @overload
+    def __init__(self, semitones: int) -> None: ...
+    @overload
+    def __init__(self, from_note: Note, to_note: Note) -> None: ...
+    def label(self) -> str: ...
+    def anglo_saxon(self) -> str: ...
+    def semitones(self) -> int: ...
+    def degree(self) -> int: ...
+    def octave(self) -> int: ...
+    def simple(self) -> "Interval": ...
+    def is_compound(self) -> bool: ...
+    def invert(self) -> "Interval": ...
+    def consonance(self, include_fourth: bool = False) -> str: ...
+    def is_consonant(self, include_fourth: bool = False) -> bool: ...
+    def full_name(self) -> str: ...
+    def full_name_pt(self) -> str: ...
+    def __add__(self, other: "Interval") -> "Interval": ...
+    def __sub__(self, other: "Interval") -> "Interval": ...
+    @overload
+    def __eq__(self, other: "Interval") -> bool: ...
+    @overload
+    def __eq__(self, other: int) -> bool: ...
+    def __eq__(self, other: object) -> bool: ...
+    @overload
+    def __ne__(self, other: "Interval") -> bool: ...
+    @overload
+    def __ne__(self, other: int) -> bool: ...
+    def __ne__(self, other: object) -> bool: ...
+    def __repr__(self) -> str: ...
+    def __str__(self) -> str: ...
+    def __hash__(self) -> int: ...
+    def __lt__(self, other: "Interval") -> bool: ...
+    def __le__(self, other: "Interval") -> bool: ...
+    def __gt__(self, other: "Interval") -> bool: ...
+    def __ge__(self, other: "Interval") -> bool: ...
+    def __int__(self) -> int: ...
+
+class ChordComparison:
+    common_notes: List[Note]
+    exclusive_a: List[Note]
+    exclusive_b: List[Note]
+    root_distance: int
+    root_direction: int
+    same_quality: bool
+    same_size: bool
+    common_intervals: List[str]
+    enharmonic: bool
+    subset: str
+    voice_leading: int
+    transformation: str
+    inversion: bool
+    interval_vector_a: List[int]
+    interval_vector_b: List[int]
+    same_interval_vector: bool
+    transposition: int
+    dissonance_a: float
+    dissonance_b: float
+    def to_dict(self) -> Dict[str, Any]: ...
+    def __repr__(self) -> str: ...
+
+class Chord:
+    @overload
+    def __init__(self, name: str) -> None: ...
+    @overload
+    def __init__(self, name: List[str]) -> None: ...
+    @overload
+    def __init__(self, name: List[Note]) -> None: ...
+    def name(self) -> str: ...
+    def root(self) -> Note: ...
+    def type(self) -> str: ...
+    def notes(self) -> List[Note]: ...
+    def formal_notes(self) -> List[Note]: ...
+    def intervals(self) -> List[Interval]: ...
+    def interval_labels(self) -> List[str]: ...
+    def size(self) -> int: ...
+    def contains(self, note: Note) -> bool: ...
+    def compare(self, other: "Chord") -> ChordComparison: ...
+    def transpose(self, semitones: int) -> "Chord": ...
+    def __add__(self, semitones: int) -> "Chord": ...
+    def __sub__(self, semitones: int) -> "Chord": ...
+    @staticmethod
+    def identify(note_names: List[str]) -> "Chord": ...
+    def __eq__(self, other: object) -> bool: ...
+    def __ne__(self, other: object) -> bool: ...
+    def __repr__(self) -> str: ...
+    def __str__(self) -> str: ...
+    def play(self, *, octave: int = 4, duration: float = 0.5, waveform: Union[Waveform, str] = ..., amplitude: float = 0.8, envelope: Optional[Envelope] = None, strum: float = 0.03, gap: float = 0.05, tuning: float = 440.0, sample_rate: int = 44100) -> None: ...
+    def to_wav(self, path: Union[str, Path], *, octave: int = 4, duration: float = 0.5, waveform: Union[Waveform, str] = ..., amplitude: float = 0.8, envelope: Optional[Envelope] = None, strum: float = 0.03, gap: float = 0.05, tuning: float = 440.0, sample_rate: int = 44100) -> None: ...
+    def __hash__(self) -> int: ...
+    def __len__(self) -> int: ...
+    def __contains__(self, note: Union[Note, str]) -> bool: ...
+    def __iter__(self) -> Iterator[Note]: ...
+    def __reversed__(self) -> Iterator[Note]: ...
+    @overload
+    def __getitem__(self, index: int) -> Note: ...
+    @overload
+    def __getitem__(self, index: slice) -> List[Note]: ...
+
+class Scale:
+    @overload
+    def __init__(self, tonic: str, type: ScaleType, modality: Modality = ...) -> None: ...
+    @overload
+    def __init__(self, tonic: str, type: str, modality: str = "diatonic") -> None: ...
+    def tonic(self) -> Note: ...
+    def type(self) -> ScaleType: ...
+    def modality(self) -> Modality: ...
+    def parent(self) -> ScaleType: ...
+    def mode_number(self) -> int: ...
+    def is_pentatonic(self) -> bool: ...
+    def mode_name(self) -> str: ...
+    def quality(self) -> str: ...
+    def brightness(self) -> int: ...
+    def colors(self, reference: Union["Scale", str]) -> List[Note]: ...
+    def notes(self) -> List[Note]: ...
+    def formal_notes(self) -> List[Note]: ...
+    def degree(self, *degrees: int) -> Note: ...
+    def walk(self, start: int, *steps: int) -> Note: ...
+    def size(self) -> int: ...
+    def contains(self, note: Note) -> bool: ...
+    def degree_of(self, note: Note) -> Optional[int]: ...
+    def mode(self, degree_or_name: Union[int, str]) -> "Scale": ...
+    def pentatonic(self) -> "Scale": ...
+    def signature(self) -> int: ...
+    def relative(self) -> "Scale": ...
+    def parallel(self) -> "Scale": ...
+    def neighbors(self) -> Tuple["Scale", "Scale"]: ...
+    def mask(self) -> List[int]: ...
+    @staticmethod
+    def identify(notes: Union[List[str], List[Note]]) -> "Scale": ...
+    @staticmethod
+    def parse_type(name: str) -> ScaleType: ...
+    @staticmethod
+    def parse_modality(name: str) -> Modality: ...
+    def __repr__(self) -> str: ...
+    def __str__(self) -> str: ...
+    def __len__(self) -> int: ...
+    def __eq__(self, other: object) -> bool: ...
+    def __ne__(self, other: object) -> bool: ...
+    def play(self, *, octave: int = 4, duration: float = 0.5, waveform: Union[Waveform, str] = ..., amplitude: float = 0.8, envelope: Optional[Envelope] = None, strum: float = 0.03, gap: float = 0.05, tuning: float = 440.0, sample_rate: int = 44100) -> None: ...
+    def to_wav(self, path: Union[str, Path], *, octave: int = 4, duration: float = 0.5, waveform: Union[Waveform, str] = ..., amplitude: float = 0.8, envelope: Optional[Envelope] = None, strum: float = 0.03, gap: float = 0.05, tuning: float = 440.0, sample_rate: int = 44100) -> None: ...
+    def __hash__(self) -> int: ...
+    def __contains__(self, note: Union[Note, str]) -> bool: ...
+    def __iter__(self) -> Iterator[Note]: ...
+    @overload
+    def __getitem__(self, index: int) -> Note: ...
+    @overload
+    def __getitem__(self, index: slice) -> List[Note]: ...
+    def __reversed__(self) -> Iterator[Note]: ...
+
+class HarmonicFunction(Enum):
+    Tonic: int
+    Subdominant: int
+    Dominant: int
+    @property
+    def short(self) -> str: ...
+
+class BorrowedInfo:
+    scale_type: str
+    degree: int
+    function: HarmonicFunction
+    role: str
+    def to_dict(self) -> Dict[str, Any]: ...
+    def __repr__(self) -> str: ...
+
+class PivotInfo:
+    tonic: str
+    scale_type: str
+    degree_a: int
+    degree_b: int
+    def to_dict(self) -> Dict[str, Any]: ...
+    def __repr__(self) -> str: ...
+
+class FieldComparison:
+    degree_a: Optional[int]
+    degree_b: Optional[int]
+    function_a: Optional[HarmonicFunction]
+    function_b: Optional[HarmonicFunction]
+    role_a: Optional[str]
+    role_b: Optional[str]
+    degree_distance: Optional[int]
+    same_function: Optional[bool]
+    relative: bool
+    progression: bool
+    root_motion: str
+    secondary_dominant: str
+    applied_diminished: str
+    diatonic_a: bool
+    diatonic_b: bool
+    borrowed_a: Optional[BorrowedInfo]
+    borrowed_b: Optional[BorrowedInfo]
+    pivot: List[PivotInfo]
+    tritone_sub: bool
+    chromatic_mediant: str
+    foreign_a: List[Note]
+    foreign_b: List[Note]
+    def to_dict(self) -> Dict[str, Any]: ...
+    def __repr__(self) -> str: ...
+
+class Field:
+    def __init__(self, tonic: str, type: str) -> None: ...
+    def tonic(self) -> Note: ...
+    def scale(self) -> Scale: ...
+    def chords(self) -> List[Chord]: ...
+    def sevenths(self) -> List[Chord]: ...
+    def chord(self, degree: int) -> Chord: ...
+    def seventh(self, degree: int) -> Chord: ...
+    @overload
+    def applied(self, function: str, target: int) -> Chord: ...
+    @overload
+    def applied(self, function: str, target: str) -> Chord: ...
+    @overload
+    def applied(self, function: int, target: int) -> Chord: ...
+    def applied(self, function: Union[str, int], target: Union[str, int]) -> Chord: ...
+    @overload
+    def function(self, degree_or_chord: int) -> HarmonicFunction: ...
+    @overload
+    def function(self, degree_or_chord: str) -> Optional[HarmonicFunction]: ...
+    @overload
+    def function(self, degree_or_chord: Chord) -> Optional[HarmonicFunction]: ...
+    def function(self, degree_or_chord: Union[int, str, Chord]) -> Optional[HarmonicFunction]: ...
+    @overload
+    def role(self, degree_or_chord: int) -> str: ...
+    @overload
+    def role(self, degree_or_chord: str) -> Optional[str]: ...
+    @overload
+    def role(self, degree_or_chord: Chord) -> Optional[str]: ...
+    def role(self, degree_or_chord: Union[int, str, Chord]) -> Optional[str]: ...
+    def compare(self, a: Chord, b: Chord) -> FieldComparison: ...
+    def signature(self) -> int: ...
+    def relative(self) -> "Field": ...
+    def parallel(self) -> "Field": ...
+    def neighbors(self) -> Tuple["Field", "Field"]: ...
+    def size(self) -> int: ...
+    @staticmethod
+    def identify(items: Union[List[str], List[Note], List[Chord]]) -> "Field": ...
+    @staticmethod
+    def deduce(items: Union[List[str], List[Note], List[Chord]], limit: int = 10) -> List["FieldMatch"]: ...
+    def __repr__(self) -> str: ...
+    def __str__(self) -> str: ...
+    def __len__(self) -> int: ...
+    def __eq__(self, other: object) -> bool: ...
+    def __ne__(self, other: object) -> bool: ...
+    def __hash__(self) -> int: ...
+    def play(self, *, octave: int = 4, duration: float = 0.5, waveform: Union[Waveform, str] = ..., amplitude: float = 0.8, envelope: Optional[Envelope] = None, strum: float = 0.03, gap: float = 0.05, tuning: float = 440.0, sample_rate: int = 44100) -> None: ...
+    def to_wav(self, path: Union[str, Path], *, octave: int = 4, duration: float = 0.5, waveform: Union[Waveform, str] = ..., amplitude: float = 0.8, envelope: Optional[Envelope] = None, strum: float = 0.03, gap: float = 0.05, tuning: float = 440.0, sample_rate: int = 44100) -> None: ...
+    def __contains__(self, chord: Union[Chord, str]) -> bool: ...
+    def __iter__(self) -> Iterator[Chord]: ...
+    def __reversed__(self) -> Iterator[Chord]: ...
+    @overload
+    def __getitem__(self, index: int) -> Chord: ...
+    @overload
+    def __getitem__(self, index: slice) -> List[Chord]: ...
+    @overload
+    def __getitem__(self, roman: str) -> Chord: ...
+    @overload
+    def __getitem__(self, applied: Tuple[str, str]) -> Chord: ...
+    @overload
+    def __getitem__(self, applied: Tuple[str, int]) -> Chord: ...
+    @overload
+    def __getitem__(self, applied: Tuple[int, int]) -> Chord: ...
+
+class FieldMatch:
+    field: Field
+    score: float
+    matched: int
+    total: int
+    roles: List[str]
+    def to_dict(self) -> Dict[str, Any]: ...
+    def __repr__(self) -> str: ...
+
+class HarmonicPath:
+    id: int
+    branch: str
+    chord: Chord
+    interval_labels: List[str]
+    note_names: List[str]
+    def __repr__(self) -> str: ...
+
+class Tree:
+    @overload
+    def __init__(self, tonic: str, type: ScaleType) -> None: ...
+    @overload
+    def __init__(self, tonic: str, type: str) -> None: ...
+    def tonic(self) -> Note: ...
+    def type(self) -> ScaleType: ...
+    def branches(self) -> List[str]: ...
+    def paths(self, branch_origin: str) -> List[HarmonicPath]: ...
+    def shortest_path(self, from_: str, to: str) -> List[str]: ...
+    def is_valid_progression(self, branches: List[str]) -> bool: ...
+    def function(self, branch: str) -> HarmonicFunction: ...
+    def branches_with_function(self, func: HarmonicFunction) -> List[str]: ...
+    def to_dot(self, show_functions: bool = False) -> str: ...
+    def to_mermaid(self) -> str: ...
+    def play(self, *, octave: int = 4, duration: float = 0.5, waveform: Union[Waveform, str] = ..., amplitude: float = 0.8, envelope: Optional[Envelope] = None, strum: float = 0.03, gap: float = 0.05, tuning: float = 440.0, sample_rate: int = 44100) -> None: ...
+    def to_wav(self, path: Union[str, Path], *, octave: int = 4, duration: float = 0.5, waveform: Union[Waveform, str] = ..., amplitude: float = 0.8, envelope: Optional[Envelope] = None, strum: float = 0.03, gap: float = 0.05, tuning: float = 440.0, sample_rate: int = 44100) -> None: ...
+    def __repr__(self) -> str: ...
+    def __str__(self) -> str: ...
+
+class Duration:
+    @overload
+    def __init__(self, name: str, dots: int = 0, tuplet: int = 0) -> None: ...
+    @overload
+    def __init__(self, numerator: int, denominator: int) -> None: ...
+    def name(self) -> str: ...
+    def dots(self) -> int: ...
+    def tuplet(self) -> int: ...
+    def beats(self, reference_value: float = 1.0) -> float: ...
+    def rational(self) -> Tuple[int, int]: ...
+    def numerator(self) -> int: ...
+    def denominator(self) -> int: ...
+    @staticmethod
+    def standard_names() -> List[str]: ...
+    def __add__(self, other: "Duration") -> "Duration": ...
+    def __mul__(self, factor: float) -> "Duration": ...
+    def __eq__(self, other: object) -> bool: ...
+    def __ne__(self, other: object) -> bool: ...
+    def __lt__(self, other: "Duration") -> bool: ...
+    def __repr__(self) -> str: ...
+    def __str__(self) -> str: ...
+
+class Tempo:
+    @overload
+    def __init__(self, bpm: float) -> None: ...
+    @overload
+    def __init__(self, marking: str) -> None: ...
+    def bpm(self) -> float: ...
+    def marking(self) -> str: ...
+    def seconds(self, duration: Duration) -> float: ...
+    def ms_per_beat(self) -> float: ...
+    @staticmethod
+    def bpm_to_marking(bpm: float) -> str: ...
+    @staticmethod
+    def marking_to_bpm(marking: str) -> float: ...
+    def __eq__(self, other: object) -> bool: ...
+    def __ne__(self, other: object) -> bool: ...
+    def __repr__(self) -> str: ...
+    def __str__(self) -> str: ...
+    def __float__(self) -> float: ...
+    def __int__(self) -> int: ...
+
+class TimeSignature:
+    def __init__(self, beats_per_bar: int, beat_unit: int) -> None: ...
+    def beats_per_bar(self) -> int: ...
+    def beat_unit(self) -> int: ...
+    def signature(self) -> Tuple[int, int]: ...
+    def bar_duration(self) -> Duration: ...
+    def classification(self) -> str: ...
+    def common_name(self) -> str: ...
+    def __eq__(self, other: object) -> bool: ...
+    def __ne__(self, other: object) -> bool: ...
+    def __repr__(self) -> str: ...
+    def __str__(self) -> str: ...
+
+class NoteEvent:
+    def __init__(self, note: Note, duration: Duration, octave: int = 4) -> None: ...
+    def note(self) -> Note: ...
+    def octave(self) -> int: ...
+    def midi_number(self) -> int: ...
+    def duration(self) -> Duration: ...
+    def frequency(self, tuning: float = 440.0) -> float: ...
+    def play(self, *, octave: int = 4, duration: float = 0.5, waveform: Union[Waveform, str] = ..., amplitude: float = 0.8, envelope: Optional[Envelope] = None, strum: float = 0.03, gap: float = 0.05, tuning: float = 440.0, sample_rate: int = 44100) -> None: ...
+    def to_wav(self, path: Union[str, Path], *, octave: int = 4, duration: float = 0.5, waveform: Union[Waveform, str] = ..., amplitude: float = 0.8, envelope: Optional[Envelope] = None, strum: float = 0.03, gap: float = 0.05, tuning: float = 440.0, sample_rate: int = 44100) -> None: ...
+    def __eq__(self, other: object) -> bool: ...
+    def __ne__(self, other: object) -> bool: ...
+    def __repr__(self) -> str: ...
+    def __str__(self) -> str: ...
+
+class ChordEvent:
+    def __init__(self, chord: Chord, duration: Duration, octave: int = 4) -> None: ...
+    def chord(self) -> Chord: ...
+    def octave(self) -> int: ...
+    def duration(self) -> Duration: ...
+    def note_events(self) -> List[NoteEvent]: ...
+    def play(self, *, octave: int = 4, duration: float = 0.5, waveform: Union[Waveform, str] = ..., amplitude: float = 0.8, envelope: Optional[Envelope] = None, strum: float = 0.03, gap: float = 0.05, tuning: float = 440.0, sample_rate: int = 44100) -> None: ...
+    def to_wav(self, path: Union[str, Path], *, octave: int = 4, duration: float = 0.5, waveform: Union[Waveform, str] = ..., amplitude: float = 0.8, envelope: Optional[Envelope] = None, strum: float = 0.03, gap: float = 0.05, tuning: float = 440.0, sample_rate: int = 44100) -> None: ...
+    def __eq__(self, other: object) -> bool: ...
+    def __ne__(self, other: object) -> bool: ...
+    def __repr__(self) -> str: ...
+    def __str__(self) -> str: ...
+
+class Rest:
+    def __init__(self, duration: Duration) -> None: ...
+    def duration(self) -> Duration: ...
+    def play(self, *, octave: int = 4, duration: float = 0.5, waveform: Union[Waveform, str] = ..., amplitude: float = 0.8, envelope: Optional[Envelope] = None, strum: float = 0.03, gap: float = 0.05, tuning: float = 440.0, sample_rate: int = 44100) -> None: ...
+    def to_wav(self, path: Union[str, Path], *, octave: int = 4, duration: float = 0.5, waveform: Union[Waveform, str] = ..., amplitude: float = 0.8, envelope: Optional[Envelope] = None, strum: float = 0.03, gap: float = 0.05, tuning: float = 440.0, sample_rate: int = 44100) -> None: ...
+    def __eq__(self, other: object) -> bool: ...
+    def __ne__(self, other: object) -> bool: ...
+    def __repr__(self) -> str: ...
+    def __str__(self) -> str: ...
+
+class Sequence:
+    def __init__(self, tempo: Tempo = ..., time_signature: TimeSignature = ...) -> None: ...
+    def tempo(self) -> Tempo: ...
+    def set_tempo(self, tempo: Tempo) -> None: ...
+    def time_signature(self) -> TimeSignature: ...
+    def set_time_signature(self, ts: TimeSignature) -> None: ...
+    def add(self, event: Union[NoteEvent, ChordEvent, Rest]) -> None: ...
+    def remove(self, index: int) -> None: ...
+    def clear(self) -> None: ...
+    def total_duration(self) -> float: ...
+    def total_seconds(self) -> float: ...
+    def bar_count(self) -> int: ...
+    def transpose(self, semitones: int) -> "Sequence": ...
+    def play(self, *, octave: int = 4, duration: float = 0.5, waveform: Union[Waveform, str] = ..., amplitude: float = 0.8, envelope: Optional[Envelope] = None, strum: float = 0.03, gap: float = 0.05, tuning: float = 440.0, sample_rate: int = 44100) -> None: ...
+    def to_wav(self, path: Union[str, Path], *, octave: int = 4, duration: float = 0.5, waveform: Union[Waveform, str] = ..., amplitude: float = 0.8, envelope: Optional[Envelope] = None, strum: float = 0.03, gap: float = 0.05, tuning: float = 440.0, sample_rate: int = 44100) -> None: ...
+    def __len__(self) -> int: ...
+    @overload
+    def __getitem__(self, index: int) -> Union[NoteEvent, ChordEvent, Rest]: ...
+    def __eq__(self, other: object) -> bool: ...
+    def __ne__(self, other: object) -> bool: ...
+    def __repr__(self) -> str: ...
+    def __str__(self) -> str: ...