SYMBOL INDEX (600 symbols across 26 files)

FILE: docs/conf.py
  function badge_flstudio (line 94) | def badge_flstudio(app, what, name, obj, options, lines):
  function add_annotations (line 125) | def add_annotations(app, what, name, obj, options, signature, return_ann...
  function autodoc_markdown (line 148) | def autodoc_markdown(app, what, name, obj, options, lines):
  function remove_model_signature (line 160) | def remove_model_signature(app, what, name, obj, options, signature, ret...
  function remove_enum_signature (line 169) | def remove_enum_signature(app, what, name, obj, options, signature, retu...
  function include_obsolete_ids (line 175) | def include_obsolete_ids(app, what, name, obj, skip, options):
  function show_model_dunders (line 181) | def show_model_dunders(app, what, name, obj, skip, options):
  function setup (line 187) | def setup(app):

FILE: pyflp/__init__.py
  function parse (line 71) | def parse(file: pathlib.Path | str) -> Project:
  function save (line 176) | def save(project: Project, file: pathlib.Path | str) -> None:

FILE: pyflp/_adapters.py
  class List2Tuple (line 34) | class List2Tuple(SimpleAdapter[Any, Tuple[int, int]]):
    method _decode (line 35) | def _decode(self, obj: c.ListContainer[int], *_: Any) -> tuple[int, int]:
    method _encode (line 39) | def _encode(self, obj: tuple[int, int], *_: Any) -> c.ListContainer[int]:
  class LinearMusical (line 43) | class LinearMusical(SimpleAdapter[int, MusicalTime]):
    method _encode (line 44) | def _encode(self, obj: MusicalTime, *_: Any) -> int:
    method _decode (line 50) | def _decode(self, obj: int, *_: Any) -> MusicalTime:
  class Log2 (line 56) | class Log2(SimpleAdapter[int, float]):
    method __init__ (line 57) | def __init__(self, subcon: Any, factor: int) -> None:
    method _encode (line 61) | def _encode(self, obj: float, *_: Any) -> int:
    method _decode (line 64) | def _decode(self, obj: int, *_: Any) -> float:
  class LogNormal (line 70) | class LogNormal(SimpleAdapter[List[int], float]):
    method __init__ (line 71) | def __init__(self, subcon: Any, bound: tuple[int, int]) -> None:
    method _encode (line 75) | def _encode(self, obj: float, *_: Any) -> list[int]:
    method _decode (line 85) | def _decode(self, obj: list[int], *_: Any) -> float:
  class StdEnum (line 96) | class StdEnum(SimpleAdapter[int, ET]):
    method _encode (line 97) | def _encode(self, obj: ET, *_: Any) -> int:
    method _decode (line 100) | def _decode(self, obj: int, *_: Any) -> ET:

FILE: pyflp/_descriptors.py
  class ROProperty (line 31) | class ROProperty(Protocol[T_co]):
    method __get__ (line 34) | def __get__(self, ins: Any, owner: Any = None) -> T_co | Self | None:
  class RWProperty (line 39) | class RWProperty(ROProperty[T], Protocol):
    method __set__ (line 42) | def __set__(self, ins: Any, value: T) -> None:
  class NamedPropMixin (line 46) | class NamedPropMixin:
    method __init__ (line 47) | def __init__(self, prop: str | None = None) -> None:
    method __set_name__ (line 50) | def __set_name__(self, _: Any, name: str) -> None:
  class PropBase (line 55) | class PropBase(abc.ABC, RWProperty[T]):
    method __init__ (line 56) | def __init__(self, *ids: EventEnum, default: T | None = None, readonly...
    method _get_event (line 62) | def _get_event(self, ins: ItemModel[VE]) -> ItemModel[VE]:
    method _get_event (line 66) | def _get_event(self, ins: EventModel) -> AnyEvent | None:
    method _get_event (line 69) | def _get_event(self, ins: ItemModel[VE] | EventModel):
    method default (line 84) | def default(self) -> T | None:  # Configure version based defaults here
    method _get (line 88) | def _get(self, ev_or_ins: Any) -> T | None:
    method _set (line 92) | def _set(self, ev_or_ins: Any, value: T) -> None:
    method __get__ (line 96) | def __get__(self, ins: Any, owner: Any = None) -> T | Self | None:
    method __set__ (line 110) | def __set__(self, ins: Any, value: T) -> None:
  class FlagProp (line 121) | class FlagProp(PropBase[bool]):
    method __init__ (line 124) | def __init__(
    method _get (line 146) | def _get(self, ev_or_ins: Any) -> bool | None:
    method _set (line 156) | def _set(self, ev_or_ins: Any, value: bool) -> None:
  class KWProp (line 172) | class KWProp(NamedPropMixin, RWProperty[T]):
    method __get__ (line 178) | def __get__(self, ins: ModelBase | None, owner: Any = None) -> T | Self:
    method __set__ (line 186) | def __set__(self, ins: ModelBase, value: T) -> None:
  class EventProp (line 192) | class EventProp(PropBase[T]):
    method _get (line 195) | def _get(self, ev_or_ins: AnyEvent) -> T | None:
    method _set (line 198) | def _set(self, ev_or_ins: AnyEvent, value: T) -> None:
  class NestedProp (line 202) | class NestedProp(ROProperty[EMT_co]):
    method __init__ (line 203) | def __init__(self, type: type[EMT_co], *ids: EventEnum) -> None:
    method __get__ (line 207) | def __get__(self, ins: EventModel, owner: Any = None) -> EMT_co:
  class StructProp (line 214) | class StructProp(PropBase[T], NamedPropMixin):
    method __init__ (line 217) | def __init__(self, *ids: EventEnum, prop: str | None = None, **kwds: A...
    method _get (line 221) | def _get(self, ev_or_ins: ItemModel[Any]) -> T | None:
    method _set (line 224) | def _set(self, ev_or_ins: ItemModel[Any], value: T) -> None:

FILE: pyflp/_events.py
  class _EventEnumMeta (line 53) | class _EventEnumMeta(enum.EnumMeta):
    method __contains__ (line 54) | def __contains__(self, obj: object) -> bool:
  class EventEnum (line 63) | class EventEnum(int, enum.Enum, metaclass=_EventEnumMeta):
    method __new__ (line 73) | def __new__(cls, id: int, type: type[AnyEvent] | None = None):
    method _missing_ (line 83) | def _missing_(cls, value: object) -> EventEnum | None:
  class EventBase (line 102) | class EventBase(Generic[T]):
    method __init__ (line 108) | def __init__(self, id: EventEnum, data: bytes, **kwds: Any) -> None:
    method __eq__ (line 127) | def __eq__(self, o: object) -> bool:
    method __ne__ (line 132) | def __ne__(self, o: object) -> bool:
    method __bytes__ (line 137) | def __bytes__(self) -> bytes:
    method __repr__ (line 147) | def __repr__(self) -> str:
    method size (line 151) | def size(self) -> int:
  class ByteEventBase (line 167) | class ByteEventBase(EventBase[T]):
    method __init__ (line 172) | def __init__(self, id: EventEnum, data: bytes) -> None:
  class BoolEvent (line 185) | class BoolEvent(ByteEventBase[bool]):
  class I8Event (line 191) | class I8Event(ByteEventBase[int]):
  class U8Event (line 197) | class U8Event(ByteEventBase[int]):
  class WordEventBase (line 203) | class WordEventBase(EventBase[int], abc.ABC):
    method __init__ (line 208) | def __init__(self, id: EventEnum, data: bytes) -> None:
  class I16Event (line 221) | class I16Event(WordEventBase):
  class U16Event (line 227) | class U16Event(WordEventBase):
  class DWordEventBase (line 233) | class DWordEventBase(EventBase[T], abc.ABC):
    method __init__ (line 238) | def __init__(self, id: EventEnum, data: bytes) -> None:
  class F32Event (line 251) | class F32Event(DWordEventBase[float]):
  class I32Event (line 257) | class I32Event(DWordEventBase[int]):
  class U32Event (line 263) | class U32Event(DWordEventBase[int]):
  class U16TupleEvent (line 269) | class U16TupleEvent(DWordEventBase[Tuple[int, int]]):
  class ColorEvent (line 279) | class ColorEvent(DWordEventBase[RGBA]):
  class StrEventBase (line 289) | class StrEventBase(EventBase[str]):
    method __init__ (line 294) | def __init__(self, id: EventEnum, data: bytes) -> None:
  class AsciiEvent (line 306) | class AsciiEvent(StrEventBase):
  class UnicodeEvent (line 317) | class UnicodeEvent(StrEventBase):
  class StructEventBase (line 328) | class StructEventBase(EventBase[AnyContainer], AnyDict):
    method __init__ (line 335) | def __init__(self, id: EventEnum, data: bytes) -> None:
    method __setitem__ (line 339) | def __setitem__(self, key: str, value: Any) -> None:
  class ListEventBase (line 349) | class ListEventBase(EventBase[AnyListContainer], AnyList):
    method __init__ (line 360) | def __init__(self, id: EventEnum, data: bytes, **kwds: Any) -> None:
  class UnknownDataEvent (line 381) | class UnknownDataEvent(EventBase[bytes]):
  class IndexedEvent (line 388) | class IndexedEvent:
  function yields_child (line 396) | def yields_child(func: Callable[Concatenate[EventTree, P], Iterator[Even...
  class EventTree (line 407) | class EventTree:
    method __init__ (line 418) | def __init__(
    method __contains__ (line 435) | def __contains__(self, id: EventEnum) -> bool:
    method __eq__ (line 439) | def __eq__(self, o: object) -> bool:
    method __iadd__ (line 446) | def __iadd__(self, *events: AnyEvent) -> None:
    method __iter__ (line 451) | def __iter__(self) -> Iterator[AnyEvent]:
    method __len__ (line 454) | def __len__(self) -> int:
    method __repr__ (line 457) | def __repr__(self) -> str:
    method _get_ie (line 460) | def _get_ie(self, *ids: EventEnum) -> Iterator[IndexedEvent]:
    method _recursive (line 463) | def _recursive(self, action: Callable[[EventTree], None]) -> None:
    method append (line 471) | def append(self, event: AnyEvent) -> None:
    method count (line 475) | def count(self, id: EventEnum) -> int:
    method divide (line 480) | def divide(self, separator: EventEnum, *ids: EventEnum) -> Iterator[Ev...
    method first (line 496) | def first(self, id: EventEnum) -> AnyEvent:
    method get (line 507) | def get(self, *ids: EventEnum) -> Iterator[AnyEvent]:
    method group (line 512) | def group(self, *ids: EventEnum) -> Iterator[EventTree]:
    method insert (line 517) | def insert(self, pos: int, e: AnyEvent) -> None:
    method pop (line 529) | def pop(self, id: EventEnum, pos: int = 0) -> AnyEvent:
    method remove (line 544) | def remove(self, id: EventEnum, pos: int = 0) -> None:
    method separate (line 549) | def separate(self, id: EventEnum) -> Iterator[EventTree]:
    method subtree (line 553) | def subtree(self, select: Callable[[AnyEvent], bool | None]) -> EventT...
    method subtrees (line 569) | def subtrees(
    method ids (line 595) | def ids(self) -> frozenset[EventEnum]:
    method indexes (line 599) | def indexes(self) -> frozenset[int]:

FILE: pyflp/_models.py
  class ModelBase (line 40) | class ModelBase(abc.ABC):
    method __init__ (line 41) | def __init__(self, *args: Any, **kw: Any) -> None:
  class ItemModel (line 45) | class ItemModel(ModelBase, Generic[VE]):
    method __init__ (line 48) | def __init__(self, item: c.Container[Any], index: int, parent: VE, **k...
    method __getitem__ (line 61) | def __getitem__(self, prop: str):
    method __setitem__ (line 64) | def __setitem__(self, prop: str, value: Any) -> None:
  class EventModel (line 73) | class EventModel(ModelBase):
    method __init__ (line 74) | def __init__(self, events: EventTree, **kw: Any) -> None:
    method __eq__ (line 78) | def __eq__(self, o: object) -> bool:
  class ModelCollection (line 90) | class ModelCollection(Iterable[MT_co], Protocol[MT_co]):
    method __getitem__ (line 92) | def __getitem__(self, i: int | str) -> MT_co:
    method __getitem__ (line 96) | def __getitem__(self, i: slice) -> Sequence[MT_co]:
  function supports_slice (line 100) | def supports_slice(func: Callable[[ModelCollection[MT_co], str | int | s...
  class ModelReprMixin (line 120) | class ModelReprMixin:
    method __repr__ (line 123) | def __repr__(self) -> str:

FILE: pyflp/arrangement.py
  class PLSelectionEvent (line 66) | class PLSelectionEvent(StructEventBase):
  class PlaylistEvent (line 70) | class PlaylistEvent(ListEventBase):
    method __init__ (line 89) | def __init__(self, id: EventEnum, data: bytes) -> None:
  class TrackMotion (line 94) | class TrackMotion(ct.EnumBase):
  class TrackPress (line 105) | class TrackPress(ct.EnumBase):
  class TrackSync (line 113) | class TrackSync(ct.EnumBase):
  class HeightAdapter (line 123) | class HeightAdapter(ct.Adapter[float, float, str, str]):
    method _decode (line 124) | def _decode(self, obj: float, *_: Any) -> str:
    method _encode (line 127) | def _encode(self, obj: str, *_: Any) -> float:
  class TrackEvent (line 131) | class TrackEvent(StructEventBase):
  class ArrangementsID (line 153) | class ArrangementsID(EventEnum):
  class ArrangementID (line 163) | class ArrangementID(EventEnum):
  class TrackID (line 171) | class TrackID(EventEnum):
  class PLItemBase (line 176) | class PLItemBase(ItemModel[PlaylistEvent], ModelReprMixin):
    method offsets (line 187) | def offsets(self) -> tuple[float, float]:
    method offsets (line 195) | def offsets(self, value: tuple[float, float]) -> None:
  class ChannelPLItem (line 202) | class ChannelPLItem(PLItemBase, ModelReprMixin):
    method channel (line 209) | def channel(self) -> Channel:
    method channel (line 213) | def channel(self, channel: Channel) -> None:
  class PatternPLItem (line 218) | class PatternPLItem(PLItemBase, ModelReprMixin):
    method pattern (line 225) | def pattern(self) -> Pattern:
    method pattern (line 229) | def pattern(self, pattern: Pattern) -> None:
  class _TrackColorProp (line 234) | class _TrackColorProp(StructProp[RGBA]):
    method _get (line 235) | def _get(self, ev_or_ins: Any) -> RGBA | None:
    method _set (line 240) | def _set(self, ev_or_ins: Any, value: RGBA) -> None:
  class _TrackKW (line 244) | class _TrackKW(TypedDict):
  class Track (line 248) | class Track(EventModel, ModelCollection[PLItemBase]):
    method __init__ (line 254) | def __init__(self, events: EventTree, **kw: Unpack[_TrackKW]) -> None:
    method __getitem__ (line 257) | def __getitem__(self, index: int | slice | str):
    method __iter__ (line 262) | def __iter__(self) -> Iterator[PLItemBase]:
    method __len__ (line 266) | def __len__(self) -> int:
    method __repr__ (line 269) | def __repr__(self) -> str:
  class _ArrangementKW (line 338) | class _ArrangementKW(TypedDict):
  class Arrangement (line 344) | class Arrangement(EventModel):
    method __init__ (line 352) | def __init__(self, events: EventTree, **kw: Unpack[_ArrangementKW]) ->...
    method __repr__ (line 355) | def __repr__(self) -> str:
    method timemarkers (line 370) | def timemarkers(self) -> Iterator[TimeMarker]:
    method tracks (line 374) | def tracks(self) -> Iterator[Track]:
  class TimeSignature (line 403) | class TimeSignature(EventModel, ModelReprMixin):
    method __str__ (line 406) | def __str__(self) -> str:
  class Arrangements (line 428) | class Arrangements(EventModel, ModelCollection[Arrangement]):
    method __init__ (line 431) | def __init__(self, events: EventTree, **kw: Unpack[_ArrangementKW]) ->...
    method __getitem__ (line 435) | def __getitem__(self, i: int | str | slice) -> Arrangement:
    method __iter__ (line 458) | def __iter__(self) -> Iterator[Arrangement]:
    method __len__ (line 481) | def __len__(self) -> int:
    method __repr__ (line 491) | def __repr__(self) -> str:
    method current (line 495) | def current(self) -> Arrangement | None:
    method loop_pos (line 511) | def loop_pos(self) -> tuple[int, int] | None:
    method loop_pos (line 529) | def loop_pos(self, value: tuple[int, int]) -> None:
    method max_tracks (line 539) | def max_tracks(self) -> Literal[500, 199]:

FILE: pyflp/channel.py
  class ChannelNotFound (line 80) | class ChannelNotFound(ModelNotFound, KeyError):
  class AutomationEvent (line 84) | class AutomationEvent(StructEventBase):
    method _get_position (line 86) | def _get_position(stream: c.StreamType, index: int) -> float:
  class DelayEvent (line 122) | class DelayEvent(StructEventBase):
  class _EnvLFOFlags (line 133) | class _EnvLFOFlags(enum.IntFlag):
  class LFOShape (line 141) | class LFOShape(ct.EnumBase):
  class EnvelopeLFOEvent (line 150) | class EnvelopeLFOEvent(StructEventBase):
  class LevelAdjustsEvent (line 172) | class LevelAdjustsEvent(StructEventBase):
  class FilterType (line 182) | class FilterType(ct.EnumBase):
  class LevelsEvent (line 193) | class LevelsEvent(StructEventBase):
  class ArpDirection (line 205) | class ArpDirection(ct.EnumBase):
  class DeclickMode (line 217) | class DeclickMode(ct.EnumBase):
  class _DelayFlags (line 227) | class _DelayFlags(enum.IntFlag):
  class StretchMode (line 233) | class StretchMode(ct.EnumBase):
  class ParametersEvent (line 247) | class ParametersEvent(StructEventBase):
  class _PolyphonyFlags (line 291) | class _PolyphonyFlags(enum.IntFlag):
  class PolyphonyEvent (line 297) | class PolyphonyEvent(StructEventBase):
  class TrackingEvent (line 305) | class TrackingEvent(StructEventBase):
  class ChannelID (line 315) | class ChannelID(EventEnum):
  class DisplayGroupID (line 378) | class DisplayGroupID(EventEnum):
  class RackID (line 383) | class RackID(EventEnum):
  class ReverbType (line 390) | class ReverbType(enum.IntEnum):
  class ChannelType (line 402) | class ChannelType(ct.EnumBase):  # cuz Type would be a super generic name
  class _FXFlags (line 416) | class _FXFlags(enum.IntFlag):
  class _LayerFlags (line 423) | class _LayerFlags(enum.IntFlag):
  class _SamplerFlags (line 428) | class _SamplerFlags(enum.IntFlag):
  class DisplayGroup (line 436) | class DisplayGroup(EventModel, ModelReprMixin):
    method __str__ (line 437) | def __str__(self) -> str:
  class Arp (line 445) | class Arp(EventModel, ModelReprMixin):
  class Delay (line 474) | class Delay(EventModel, ModelReprMixin):
    method mod_x (line 500) | def mod_x(self) -> int:
    method mod_x (line 505) | def mod_x(self, value: int) -> None:
    method mod_y (line 510) | def mod_y(self) -> int:
    method mod_y (line 515) | def mod_y(self, value: int) -> None:
  class Filter (line 554) | class Filter(EventModel, ModelReprMixin):
  class LevelAdjusts (line 570) | class LevelAdjusts(EventModel, ModelReprMixin):
  class Time (line 584) | class Time(EventModel, ModelReprMixin):
  class Reverb (line 619) | class Reverb(EventModel, ModelReprMixin):
    method type (line 626) | def type(self) -> ReverbType | None:
    method type (line 632) | def type(self, value: ReverbType) -> None:
    method mix (line 639) | def mix(self) -> int | None:
    method mix (line 650) | def mix(self, value: int) -> None:
  class FX (line 657) | class FX(EventModel, ModelReprMixin):
  class Envelope (line 788) | class Envelope(EventModel, ModelReprMixin):
  class SamplerLFO (line 911) | class SamplerLFO(EventModel, ModelReprMixin):
  class Polyphony (line 971) | class Polyphony(EventModel, ModelReprMixin):
  class Tracking (line 999) | class Tracking(EventModel, ModelReprMixin):
  class Keyboard (line 1035) | class Keyboard(EventModel, ModelReprMixin):
  class Playback (line 1065) | class Playback(EventModel, ModelReprMixin):
  class TimeStretching (line 1084) | class TimeStretching(EventModel, ModelReprMixin):
  class Content (line 1110) | class Content(EventModel, ModelReprMixin):
  class AutomationLFO (line 1141) | class AutomationLFO(EventModel, ModelReprMixin):
  class AutomationPoint (line 1153) | class AutomationPoint(ItemModel[AutomationEvent], ModelReprMixin):
    method __setitem__ (line 1154) | def __setitem__(self, prop: str, value: Any) -> None:
  class Channel (line 1171) | class Channel(EventModel):
    method __repr__ (line 1174) | def __repr__(self) -> str:
    method group (line 1202) | def group(self) -> DisplayGroup:  # TODO Setter
    method pan (line 1235) | def pan(self) -> int | None:
    method pan (line 1250) | def pan(self, value: int) -> None:
    method volume (line 1263) | def volume(self) -> int | None:
    method volume (line 1278) | def volume(self, value: int) -> None:
    method zipped (line 1292) | def zipped(self) -> bool:
    method display_name (line 1302) | def display_name(self) -> str | None:
  class Automation (line 1307) | class Automation(Channel, ModelCollection[AutomationPoint]):
    method __getitem__ (line 1319) | def __getitem__(self, i: int | slice) -> AutomationPoint:
    method __iter__ (line 1325) | def __iter__(self) -> Iterator[AutomationPoint]:
  class Layer (line 1335) | class Layer(Channel, ModelCollection[Channel]):
    method __getitem__ (line 1344) | def __getitem__(self, i: int | str | slice) -> Channel:
    method __iter__ (line 1359) | def __iter__(self) -> Iterator[Channel]:
    method __len__ (line 1364) | def __len__(self) -> int:
    method __repr__ (line 1371) | def __repr__(self) -> str:
  class _SamplerInstrument (line 1381) | class _SamplerInstrument(Channel):
    method pitch_shift (line 1407) | def pitch_shift(self) -> int | None:
    method pitch_shift (line 1417) | def pitch_shift(self, value: int) -> None:
    method tracking (line 1432) | def tracking(self) -> dict[str, Tracking] | None:
  class Instrument (line 1442) | class Instrument(_SamplerInstrument):
  class Sampler (line 1450) | class Sampler(_SamplerInstrument):
    method __repr__ (line 1456) | def __repr__(self) -> str:
    method envelopes (line 1468) | def envelopes(self) -> dict[EnvelopeName, Envelope] | None:
    method lfos (line 1497) | def lfos(self) -> dict[LFOName, SamplerLFO] | None:
    method sample_path (line 1512) | def sample_path(self) -> pathlib.Path | None:
    method sample_path (line 1523) | def sample_path(self, value: pathlib.Path) -> None:
  class ChannelRack (line 1535) | class ChannelRack(EventModel, ModelCollection[Channel]):
    method __repr__ (line 1541) | def __repr__(self) -> str:
    method __getitem__ (line 1545) | def __getitem__(self, i: str | int | slice) -> Channel:
    method __iter__ (line 1560) | def __iter__(self) -> Iterator[Channel]:
    method __len__ (line 1589) | def __len__(self) -> int:
    method automations (line 1600) | def automations(self) -> Iterator[Automation]:
    method groups (line 1608) | def groups(self) -> Iterator[DisplayGroup]:
    method instruments (line 1616) | def instruments(self) -> Iterator[Instrument]:
    method layers (line 1621) | def layers(self) -> Iterator[Layer]:
    method samplers (line 1626) | def samplers(self) -> Iterator[Sampler]:

FILE: pyflp/controller.py
  class MIDIControllerEvent (line 29) | class MIDIControllerEvent(StructEventBase):
  class RemoteControllerEvent (line 33) | class RemoteControllerEvent(StructEventBase):
  class ControllerID (line 46) | class ControllerID(EventEnum):
  class RemoteController (line 51) | class RemoteController(EventModel, ModelReprMixin):
    method parameter (line 58) | def parameter(self) -> int | None:
    method controls_vst (line 67) | def controls_vst(self) -> bool | None:

FILE: pyflp/exceptions.py
  class Error (line 33) | class Error(Exception):
  class EventIDOutOfRange (line 44) | class EventIDOutOfRange(Error, ValueError):
    method __init__ (line 47) | def __init__(self, id: int, *expected: int) -> None:
  class InvalidEventChunkSize (line 51) | class InvalidEventChunkSize(Error, BufferError):
    method __init__ (line 54) | def __init__(self, expected: int, got: int) -> None:
  class PropertyCannotBeSet (line 58) | class PropertyCannotBeSet(Error, AttributeError):
    method __init__ (line 59) | def __init__(self, *ids: enum.Enum | int) -> None:
  class DataCorrupted (line 63) | class DataCorrupted(Error):
  class HeaderCorrupted (line 67) | class HeaderCorrupted(DataCorrupted, ValueError):
    method __init__ (line 74) | def __init__(self, desc: str) -> None:
  class NoModelsFound (line 78) | class NoModelsFound(DataCorrupted, LookupError):
  class ModelNotFound (line 82) | class ModelNotFound(DataCorrupted, IndexError):
  class VersionNotDetected (line 86) | class VersionNotDetected(DataCorrupted):

FILE: pyflp/mixer.py
  class _InsertFlags (line 66) | class _InsertFlags(enum.IntFlag):
  class _MixerParamsID (line 87) | class _MixerParamsID(ct.EnumBase):
  class InsertFlagsEvent (line 105) | class InsertFlagsEvent(StructEventBase):
  class InsertRoutingEvent (line 113) | class InsertRoutingEvent(ListEventBase):
  class _InsertItems (line 118) | class _InsertItems:
  class MixerParamsEvent (line 125) | class MixerParamsEvent(ListEventBase):
    method __init__ (line 136) | def __init__(self, id: Any, data: bytearray) -> None:
  class InsertID (line 153) | class InsertID(EventEnum):
  class MixerID (line 164) | class MixerID(EventEnum):
  class SlotID (line 170) | class SlotID(EventEnum):
  class InsertDock (line 175) | class InsertDock(enum.Enum):
  class _InsertEQBandKW (line 187) | class _InsertEQBandKW(TypedDict, total=False):
  class _InsertEQBandProp (line 193) | class _InsertEQBandProp(NamedPropMixin, RWProperty[int]):
    method __get__ (line 194) | def __get__(self, ins: InsertEQBand, owner: Any = None) -> int | None:
    method __set__ (line 199) | def __set__(self, ins: InsertEQBand, value: int) -> None:
  class InsertEQBand (line 203) | class InsertEQBand(ModelBase, ModelReprMixin):
    method __init__ (line 204) | def __init__(self, **kw: Unpack[_InsertEQBandKW]) -> None:
    method size (line 208) | def size(self) -> int:
  class _InsertEQPropArgs (line 235) | class _InsertEQPropArgs(NamedTuple):
  class _InsertEQProp (line 241) | class _InsertEQProp(NamedPropMixin, ROProperty[InsertEQBand]):
    method __init__ (line 242) | def __init__(self, ids: _InsertEQPropArgs) -> None:
    method __get__ (line 246) | def __get__(self, ins: InsertEQ, owner: Any = None) -> InsertEQBand:
  class InsertEQ (line 262) | class InsertEQ(ModelBase, ModelReprMixin):
    method __init__ (line 271) | def __init__(self, params: _InsertItems) -> None:
    method size (line 275) | def size(self) -> int:
  class _MixerParamProp (line 294) | class _MixerParamProp(RWProperty[T]):
    method __init__ (line 295) | def __init__(self, id: int) -> None:
    method __get__ (line 298) | def __get__(self, ins: Insert, owner: object = None) -> T | None:
    method __set__ (line 306) | def __set__(self, ins: Insert, value: T) -> None:
  class Slot (line 314) | class Slot(EventModel):
    method __init__ (line 320) | def __init__(self, events: EventTree, params: list[dict[str, Any]] | N...
    method __repr__ (line 323) | def __repr__(self) -> str:
  class _InsertKW (line 365) | class _InsertKW(TypedDict):
  class Insert (line 375) | class Insert(EventModel, ModelCollection[Slot]):
    method __init__ (line 381) | def __init__(self, events: EventTree, **kw: Unpack[_InsertKW]) -> None:
    method __repr__ (line 385) | def __repr__(self) -> str:
    method __getitem__ (line 389) | def __getitem__(self, i: int | str) -> Slot:
    method iid (line 406) | def iid(self) -> int:
    method __iter__ (line 410) | def __iter__(self) -> Iterator[Slot]:
    method __len__ (line 415) | def __len__(self) -> int:
    method dock (line 438) | def dock(self) -> InsertDock | None:
    method eq (line 464) | def eq(self) -> InsertEQ:
    method routes (line 511) | def routes(self) -> Iterator[int]:
  class _MixerKW (line 554) | class _MixerKW(TypedDict):
  class Mixer (line 560) | class Mixer(EventModel, ModelCollection[Insert]):
    method __init__ (line 578) | def __init__(self, events: EventTree, **kw: Unpack[_MixerKW]) -> None:
    method __getitem__ (line 583) | def __getitem__(self, i: int | str | slice) -> Insert:
    method __iter__ (line 600) | def __iter__(self) -> Iterator[Insert]:
    method __len__ (line 618) | def __len__(self) -> int:
    method __str__ (line 628) | def __str__(self) -> str:
    method max_inserts (line 635) | def max_inserts(self) -> int:
    method max_slots (line 655) | def max_slots(self) -> int:

FILE: pyflp/pattern.py
  class ControllerEvent (line 49) | class ControllerEvent(ListEventBase):
  class _NoteFlags (line 63) | class _NoteFlags(enum.IntFlag):
  class NotesEvent (line 67) | class NotesEvent(ListEventBase):
  class PatternsID (line 88) | class PatternsID(EventEnum):
  class PatternID (line 95) | class PatternID(EventEnum):
  class Note (line 110) | class Note(ItemModel[NotesEvent]):
    method __repr__ (line 113) | def __repr__(self) -> str:
    method __str__ (line 118) | def __str__(self) -> str:
    method key (line 140) | def key(self) -> str:
    method key (line 152) | def key(self, value: int | str) -> None:
  class Controller (line 223) | class Controller(ItemModel[ControllerEvent], ModelReprMixin):
    method __str__ (line 224) | def __str__(self) -> str:
  class Pattern (line 234) | class Pattern(EventModel):
    method __repr__ (line 237) | def __repr__(self) -> str:
    method controllers (line 262) | def controllers(self) -> Iterator[Controller]:
    method iid (line 269) | def iid(self) -> int:
    method iid (line 279) | def iid(self, value: int) -> None:
    method notes (line 299) | def notes(self) -> Iterator[Note]:
    method timemarkers (line 312) | def timemarkers(self) -> Iterator[TimeMarker]:
  class Patterns (line 317) | class Patterns(EventModel, ModelCollection[Pattern]):
    method __str__ (line 318) | def __str__(self) -> str:
    method __getitem__ (line 323) | def __getitem__(self, i: int | str | slice) -> Pattern:
    method __iter__ (line 340) | def __iter__(self) -> Iterator[Pattern]:
    method __len__ (line 357) | def __len__(self) -> int:
    method current (line 377) | def current(self) -> Pattern | None:

FILE: pyflp/plugin.py
  class _WrapperFlags (line 61) | class _WrapperFlags(enum.IntFlag):
  class BooBassEvent (line 76) | class BooBassEvent(StructEventBase):
  class FruitKickEvent (line 85) | class FruitKickEvent(StructEventBase):
  class FruityBalanceEvent (line 98) | class FruityBalanceEvent(StructEventBase):
  class FruityBloodOverdriveEvent (line 102) | class FruityBloodOverdriveEvent(StructEventBase):
  class FruityCenterEvent (line 116) | class FruityCenterEvent(StructEventBase):
  class FruityFastDistEvent (line 122) | class FruityFastDistEvent(StructEventBase):
  class FruityNotebook2Event (line 132) | class FruityNotebook2Event(StructEventBase):
  class FruitySendEvent (line 149) | class FruitySendEvent(StructEventBase):
  class FruitySoftClipperEvent (line 158) | class FruitySoftClipperEvent(StructEventBase):
  class FruityStereoEnhancerEvent (line 162) | class FruityStereoEnhancerEvent(StructEventBase):
  class PluckedEvent (line 173) | class PluckedEvent(StructEventBase):
  class SoundgoodizerEvent (line 183) | class SoundgoodizerEvent(StructEventBase):
  class WrapperPage (line 195) | class WrapperPage(ct.EnumBase):
  class WrapperEvent (line 212) | class WrapperEvent(StructEventBase):
  class _VSTPluginEventID (line 226) | class _VSTPluginEventID(ct.EnumBase):
  class _VSTFlags (line 242) | class _VSTFlags(enum.IntFlag):
  class _VSTFlags2 (line 265) | class _VSTFlags2(enum.IntFlag):
  class VSTPluginEvent (line 270) | class VSTPluginEvent(StructEventBase):
    method __init__ (line 315) | def __init__(self, id: Any, data: bytearray) -> None:
  class PluginID (line 328) | class PluginID(EventEnum):
  class _IPlugin (line 343) | class _IPlugin(Protocol):
  class _WrapperProp (line 351) | class _WrapperProp(FlagProp):
    method __init__ (line 352) | def __init__(self, flag: _WrapperFlags, **kw: Any) -> None:
  class _PluginBase (line 356) | class _PluginBase(EventModel, Generic[_PE_co]):
    method __init__ (line 357) | def __init__(self, events: EventTree, **kw: Any) -> None:
  class PluginProp (line 415) | class PluginProp(RWProperty[AnyPlugin]):
    method __init__ (line 416) | def __init__(self, *types: type[AnyPlugin]) -> None:
    method _get_plugin_events (line 420) | def _get_plugin_events(ins: EventModel) -> EventTree:
    method __get__ (line 423) | def __get__(self, ins: EventModel, owner: Any = None) -> AnyPlugin | N...
    method __set__ (line 440) | def __set__(self, ins: EventModel, value: AnyPlugin) -> None:
  class _NativePluginProp (line 450) | class _NativePluginProp(StructProp[T]):
    method __init__ (line 451) | def __init__(self, prop: str | None = None, **kwds: Any) -> None:
  class _VSTPluginProp (line 455) | class _VSTPluginProp(RWProperty[T], NamedPropMixin):
    method __init__ (line 456) | def __init__(self, id: _VSTPluginEventID, prop: str | None = None) -> ...
    method __get__ (line 460) | def __get__(self, ins: EventModel, _=None) -> T:
    method _get (line 467) | def _get(self, value: Any) -> T:
    method __set__ (line 470) | def __set__(self, ins: EventModel, value: T) -> None:
    method _set (line 473) | def _set(self, event: VSTPluginEvent, value: T) -> None:
  class _VSTFlagProp (line 480) | class _VSTFlagProp(_VSTPluginProp[bool]):
    method __init__ (line 481) | def __init__(
    method _get (line 488) | def _get(self, value: Any) -> bool:
    method _set (line 492) | def _set(self, event: VSTPluginEvent, value: bool) -> None:
  class PluginIOInfo (line 505) | class PluginIOInfo(EventModel):
  class VSTPlugin (line 510) | class VSTPlugin(_PluginBase[VSTPluginEvent], _IPlugin):
    method __repr__ (line 519) | def __repr__(self) -> str:
    class _AutomationOptions (line 522) | class _AutomationOptions(EventModel):
    class _CompatibilityOptions (line 531) | class _CompatibilityOptions(EventModel):
    class _MIDIOptions (line 569) | class _MIDIOptions(EventModel):
    class _ProcessingOptions (line 603) | class _ProcessingOptions(EventModel):
    class _UIOptions (line 653) | class _UIOptions(EventModel):
    method __init__ (line 680) | def __init__(self, events: EventTree, **kw: Any) -> None:
  class BooBass (line 718) | class BooBass(_PluginBase[BooBassEvent], _IPlugin, ModelReprMixin):
  class FruitKick (line 747) | class FruitKick(_PluginBase[FruitKickEvent], _IPlugin, ModelReprMixin):
  class FruityBalance (line 811) | class FruityBalance(_PluginBase[FruityBalanceEvent], _IPlugin, ModelRepr...
  class FruityBloodOverdrive (line 836) | class FruityBloodOverdrive(_PluginBase[FruityBloodOverdriveEvent], _IPlu...
  class FruityCenter (line 902) | class FruityCenter(_PluginBase[FruityCenterEvent], _IPlugin, ModelReprMi...
  class FruityFastDist (line 913) | class FruityFastDist(_PluginBase[FruityFastDistEvent], _IPlugin, ModelRe...
  class FruityNotebook2 (line 956) | class FruityNotebook2(_PluginBase[FruityNotebook2Event], _IPlugin, Model...
  class FruitySend (line 973) | class FruitySend(_PluginBase[FruitySendEvent], _IPlugin, ModelReprMixin):
  class FruitySoftClipper (line 1010) | class FruitySoftClipper(_PluginBase[FruitySoftClipperEvent], _IPlugin, M...
  class FruityStereoEnhancer (line 1035) | class FruityStereoEnhancer(_PluginBase[FruityStereoEnhancerEvent], _IPlu...
  class Plucked (line 1086) | class Plucked(_PluginBase[PluckedEvent], _IPlugin, ModelReprMixin):
  class Soundgoodizer (line 1119) | class Soundgoodizer(_PluginBase[SoundgoodizerEvent], _IPlugin, ModelRepr...
  function get_event_by_internal_name (line 1135) | def get_event_by_internal_name(name: str) -> type[AnyEvent]:

FILE: pyflp/project.py
  class TimestampEvent (line 65) | class TimestampEvent(StructEventBase):
  class PanLaw (line 70) | class PanLaw(ct.EnumBase):
  class FileFormat (line 78) | class FileFormat(enum.IntEnum):
  class ProjectID (line 114) | class ProjectID(EventEnum):
  class _ProjectKW (line 138) | class _ProjectKW(TypedDict):
  class Project (line 144) | class Project(EventModel):
    method __init__ (line 147) | def __init__(self, events: EventTree, **kw: Unpack[_ProjectKW]) -> None:
    method __repr__ (line 150) | def __repr__(self) -> str:
    method __str__ (line 153) | def __str__(self) -> str:
    method arrangements (line 157) | def arrangements(self) -> Arrangements:
    method channel_count (line 192) | def channel_count(self) -> int:
    method channel_count (line 203) | def channel_count(self, value: int) -> None:
    method channels (line 209) | def channels(self) -> ChannelRack:
    method created_on (line 237) | def created_on(self) -> datetime.datetime | None:
    method data_path (line 250) | def data_path(self) -> pathlib.Path | None:
    method data_path (line 261) | def data_path(self, value: str | pathlib.Path) -> None:
    method licensee (line 289) | def licensee(self) -> str | None:
    method licensee (line 314) | def licensee(self, value: str) -> None:
    method mixer (line 342) | def mixer(self) -> Mixer:
    method patterns (line 359) | def patterns(self) -> Patterns:
    method ppq (line 385) | def ppq(self) -> int:
    method ppq (line 412) | def ppq(self, value: int) -> None:
    method tempo (line 434) | def tempo(self) -> int | float | None:
    method tempo (line 461) | def tempo(self, value: int | float) -> None:
    method time_spent (line 484) | def time_spent(self) -> datetime.timedelta | None:
    method version (line 506) | def version(self) -> FLVersion:
    method version (line 526) | def version(self, value: FLVersion | str | tuple[int, ...]) -> None:

FILE: pyflp/timemarker.py
  class TimeMarkerID (line 28) | class TimeMarkerID(EventEnum):
  class TimeMarkerType (line 35) | class TimeMarkerType(enum.IntEnum):
  class TimeMarker (line 43) | class TimeMarker(EventModel, ModelReprMixin):
    method __str__ (line 49) | def __str__(self) -> str:
    method position (line 65) | def position(self) -> int | None:
    method type (line 73) | def type(self) -> TimeMarkerType | None:

FILE: pyflp/types.py
  class FLVersion (line 33) | class FLVersion:
    method __str__ (line 39) | def __str__(self) -> str:
  class MusicalTime (line 46) | class MusicalTime(NamedTuple):
  class RGBA (line 57) | class RGBA(NamedTuple):
    method from_bytes (line 64) | def from_bytes(buf: bytes) -> RGBA:
    method __bytes__ (line 67) | def __bytes__(self) -> bytes:

FILE: tests/conftest.py
  function project (line 18) | def project():
  function arrangements (line 23) | def arrangements(project: Project):
  function rack (line 28) | def rack(project: Project):
  function mixer (line 33) | def mixer(project: Project):
  function inserts (line 38) | def inserts(mixer: Mixer):
  function patterns (line 43) | def patterns(project: Project):
  function get_model (line 47) | def get_model(suffix: str, type: type[MT], *only: EventEnum) -> MT:

FILE: tests/test_arrangement.py
  function test_arrangements (line 20) | def test_arrangements(arrangements: Arrangements):
  function arrangement (line 30) | def arrangement(arrangements: Arrangements):
  function tracks (line 38) | def tracks(arrangement: Callable[[int], Arrangement]):
  function test_track_color (line 42) | def test_track_color(tracks: tuple[Track, ...]):
  function test_track_content_locked (line 51) | def test_track_content_locked(tracks: tuple[Track, ...]):
  function test_track_enabled (line 58) | def test_track_enabled(tracks: tuple[Track, ...]):
  function test_track_grouped (line 63) | def test_track_grouped(tracks: tuple[Track, ...]):
  function test_track_height (line 68) | def test_track_height(tracks: tuple[Track, ...]):
  function test_track_icon (line 78) | def test_track_icon(tracks: tuple[Track, ...]):
  function test_track_items (line 83) | def test_track_items(tracks: tuple[Track, ...]):
  function test_track_locked (line 102) | def test_track_locked(tracks: tuple[Track, ...]):
  function test_track_motion (line 107) | def test_track_motion(tracks: tuple[Track, ...]):
  function test_track_name (line 116) | def test_track_name(tracks: tuple[Track, ...]):
  function test_track_position_sync (line 143) | def test_track_position_sync(tracks: tuple[Track, ...]):
  function test_track_press (line 152) | def test_track_press(tracks: tuple[Track, ...]):
  function test_track_tolerant (line 161) | def test_track_tolerant(tracks: tuple[Track, ...]):
  function test_track_queued (line 166) | def test_track_queued(tracks: tuple[Track, ...]):
  function test_first_arrangement (line 171) | def test_first_arrangement(arrangement: Callable[[int], Arrangement]):
  function test_second_arrangement (line 178) | def test_second_arrangement(arrangement: Callable[[int], Arrangement]):

FILE: tests/test_channel.py
  function _load_channel (line 27) | def _load_channel(preset: str, type: type[CT]):
  function load_channel (line 33) | def load_channel(preset: str):
  function load_automation (line 37) | def load_automation(preset: str):
  function load_instrument (line 41) | def load_instrument(preset: str):
  function load_layer (line 45) | def load_layer(preset: str):
  function load_sampler (line 49) | def load_sampler(preset: str):
  function test_channels (line 53) | def test_channels(project: Project, rack: ChannelRack):
  function test_automation_lfo (line 61) | def test_automation_lfo():
  function test_automation_points (line 66) | def test_automation_points():
  function test_channel_color (line 71) | def test_channel_color():
  function test_channel_enabled (line 75) | def test_channel_enabled():
  function test_channel_group (line 79) | def test_channel_group(rack: ChannelRack):
  function test_channel_icon (line 89) | def test_channel_icon():
  function test_channel_pan (line 93) | def test_channel_pan():
  function test_channel_volume (line 98) | def test_channel_volume():
  function test_channel_zipped (line 103) | def test_channel_zipped(rack: ChannelRack):
  function test_instrument_delay (line 111) | def test_instrument_delay():
  function test_instrument_keyboard (line 123) | def test_instrument_keyboard():
  function test_instrument_polyphony (line 132) | def test_instrument_polyphony():
  function test_instrument_routing (line 140) | def test_instrument_routing():
  function test_instrument_time (line 144) | def test_instrument_time():
  function test_instrument_tracking (line 152) | def test_instrument_tracking():
  function test_layer_crossfade (line 167) | def test_layer_crossfade():
  function test_layer_random (line 171) | def test_layer_random():
  function test_sampler_content (line 175) | def test_sampler_content():
  function test_sampler_cut_group (line 184) | def test_sampler_cut_group():
  function test_sampler_envelopes (line 188) | def test_sampler_envelopes():
  function test_sampler_filter (line 216) | def test_sampler_filter():
  function test_sampler_fx (line 223) | def test_sampler_fx():
  function test_sampler_lfo (line 250) | def test_sampler_lfo():
  function test_sampler_path (line 273) | def test_sampler_path():
  function test_sampler_pitch_shift (line 279) | def test_sampler_pitch_shift():
  function test_sampler_playback (line 284) | def test_sampler_playback():
  function test_sampler_stretching (line 291) | def test_sampler_stretching():

FILE: tests/test_corrupted.py
  function test_invalid_header_magic (line 13) | def test_invalid_header_magic():
  function test_invalid_header_size (line 18) | def test_invalid_header_size():
  function test_invalid_format (line 23) | def test_invalid_format():
  function test_invalid_ppq (line 28) | def test_invalid_ppq():
  function test_invalid_data_magic (line 34) | def test_invalid_data_magic():
  function test_invalid_data_size (line 39) | def test_invalid_data_size():

FILE: tests/test_events.py
  function test_id_out_of_range (line 9) | def test_id_out_of_range():
  function test_invalid_chunk_size (line 17) | def test_invalid_chunk_size():
  function test_event_tree (line 22) | def test_event_tree():

FILE: tests/test_mixer.py
  function get_insert (line 11) | def get_insert(preset: str):
  function test_insert_bypassed (line 25) | def test_insert_bypassed():
  function test_insert_channels_swapped (line 29) | def test_insert_channels_swapped():
  function test_insert_color (line 33) | def test_insert_color():
  function test_insert_dock (line 37) | def test_insert_dock(inserts: tuple[Insert, ...]):
  function test_insert_enabled (line 48) | def test_insert_enabled():
  function test_insert_locked (line 52) | def test_insert_locked():
  function test_insert_pan (line 56) | def test_insert_pan():
  function test_insert_polarity_reversed (line 61) | def test_insert_polarity_reversed():
  function test_insert_routes (line 65) | def test_insert_routes(inserts: tuple[Insert, ...]):
  function test_insert_stereo_separation (line 69) | def test_insert_stereo_separation():
  function test_insert_eq (line 74) | def test_insert_eq():
  function test_mixer (line 87) | def test_mixer(mixer: Mixer):

FILE: tests/test_models.py
  function test_flversion (line 6) | def test_flversion():

FILE: tests/test_pattern.py
  function get_notes (line 9) | def get_notes(score: str):
  function test_patterns (line 13) | def test_patterns(patterns: Patterns):
  function test_pattern_color (line 19) | def test_pattern_color(patterns: Patterns):
  function test_pattern_names (line 23) | def test_pattern_names(patterns: Patterns):
  function test_pattern_timemarkers (line 33) | def test_pattern_timemarkers(patterns: Patterns):
  function test_empty_pattern (line 37) | def test_empty_pattern():
  function test_note_color (line 41) | def test_note_color():
  function test_note_fine_pitch (line 45) | def test_note_fine_pitch():
  function test_note_group (line 49) | def test_note_group():
  function test_note_length (line 53) | def test_note_length():
  function test_note_mod_x (line 57) | def test_note_mod_x():
  function test_note_mod_y (line 61) | def test_note_mod_y():
  function test_note_key (line 65) | def test_note_key():
  function test_note_pan (line 70) | def test_note_pan():
  function test_note_position (line 74) | def test_note_position():
  function test_note_rack_channel (line 79) | def test_note_rack_channel():
  function test_note_release (line 83) | def test_note_release():
  function test_note_slide (line 87) | def test_note_slide():
  function test_note_velocity (line 91) | def test_note_velocity():

FILE: tests/test_plugin.py
  function get_plugin (line 28) | def get_plugin(preset_file: str, type: type[T]):
  function test_boobass (line 32) | def test_boobass():
  function test_fruit_kick (line 37) | def test_fruit_kick():
  function test_fruity_balance (line 47) | def test_fruity_balance():
  function test_fruity_blood_overdrive (line 53) | def test_fruity_blood_overdrive():
  function test_fruity_center (line 62) | def test_fruity_center():
  function test_fruity_fast_dist (line 67) | def test_fruity_fast_dist():
  function test_fruity_send (line 76) | def test_fruity_send():
  function test_fruity_soft_clipper (line 84) | def test_fruity_soft_clipper():
  function test_fruity_stereo_enhancer (line 90) | def test_fruity_stereo_enhancer():
  function test_plucked (line 100) | def test_plucked():
  function test_soundgoodizer (line 109) | def test_soundgoodizer():
  function test_vst_plugin (line 115) | def test_vst_plugin():
  function test_fruity_wrapper (line 125) | def test_fruity_wrapper():

FILE: tests/test_project.py
  function test_project (line 13) | def test_project(project: Project):
  function test_null_check (line 62) | def test_null_check(project: Project, tmp_path: pathlib.Path):