352 lines
7.8 KiB
Python
352 lines
7.8 KiB
Python
from dataclasses import dataclass, field
|
|
import operator
|
|
from typing import Any
|
|
import random
|
|
from .defaults import DEFAULT_OPTIONS
|
|
import itertools
|
|
|
|
@dataclass
|
|
class Meta:
|
|
"""Abstract class for all Ziffers items"""
|
|
|
|
def update(self, new_values):
|
|
"""Update attributes from dict"""
|
|
for key, value in new_values.items():
|
|
if hasattr(self, key):
|
|
setattr(self, key, value)
|
|
|
|
def update_new(self, new_values):
|
|
"""Updates new attributes from dict"""
|
|
for key, value in new_values.items():
|
|
if hasattr(self, key):
|
|
if getattr(self,key) == None:
|
|
setattr(self, key, value)
|
|
|
|
@dataclass
|
|
class Item(Meta):
|
|
"""Class for all Ziffers text based items"""
|
|
|
|
text: str
|
|
|
|
|
|
@dataclass
|
|
class Whitespace(Item):
|
|
"""Class for whitespace"""
|
|
|
|
item_type: str = None
|
|
|
|
|
|
@dataclass
|
|
class DurationChange(Item):
|
|
"""Class for changing duration"""
|
|
|
|
value: float
|
|
key: str = "duration"
|
|
item_type: str = "change"
|
|
|
|
@dataclass
|
|
class OctaveChange(Item):
|
|
"""Class for changing octave"""
|
|
|
|
value: int
|
|
key: str = "octave"
|
|
item_type: str = "change"
|
|
|
|
|
|
@dataclass
|
|
class OctaveMod(Item):
|
|
"""Class for modifying octave"""
|
|
|
|
value: int
|
|
key: str = "octave"
|
|
item_type: str = "add"
|
|
|
|
@dataclass
|
|
class Event(Item):
|
|
"""Abstract class for events with duration"""
|
|
|
|
duration: float = None
|
|
|
|
|
|
@dataclass
|
|
class Pitch(Event):
|
|
"""Class for pitch in time"""
|
|
|
|
pc: int = None
|
|
duration: float = None
|
|
octave: int = None
|
|
|
|
|
|
@dataclass
|
|
class RandomPitch(Event):
|
|
"""Class for random pitch"""
|
|
|
|
pc: int = None
|
|
|
|
|
|
@dataclass
|
|
class RandomPercent(Item):
|
|
"""Class for random percent"""
|
|
|
|
percent: float = None
|
|
|
|
|
|
@dataclass
|
|
class Chord(Event):
|
|
"""Class for chords"""
|
|
|
|
pcs: list[Pitch] = None
|
|
|
|
|
|
@dataclass
|
|
class Function(Event):
|
|
"""Class for functions"""
|
|
|
|
run: str = None
|
|
|
|
@dataclass
|
|
class Sequence(Meta):
|
|
"""Class for sequences of items"""
|
|
|
|
values: list[Item]
|
|
text: str = None
|
|
wrap_start: str = field(default=None, repr=False)
|
|
wrap_end: str = field(default=None, repr=False)
|
|
local_index: int = 0
|
|
|
|
def __post_init__(self):
|
|
self.text = self.collect_text()
|
|
# TODO: Filter out whitespace if not needed?
|
|
# self.values = list(filter(lambda elm: not isinstance(elm, Whitespace), self.values))
|
|
|
|
def __iter__(self):
|
|
return self
|
|
|
|
def __next__(self):
|
|
if self.local_index<len(self.values):
|
|
next_item = self.values[self.local_index]
|
|
self.local_index += 1
|
|
return next_item
|
|
else:
|
|
self.local_index = 0
|
|
raise StopIteration
|
|
|
|
def update_values(self, new_values):
|
|
"""Update value attributes from dict"""
|
|
for key, value in new_values.items():
|
|
for obj in self.values:
|
|
if key != "text" and hasattr(obj, key):
|
|
setattr(obj, key, value)
|
|
|
|
def collect_text(self) -> str:
|
|
text = "".join([val.text for val in self.values])
|
|
if self.wrap_start != None:
|
|
text = self.wrap_start + text
|
|
if self.wrap_end != None:
|
|
text = text + self.wrap_end
|
|
return text
|
|
|
|
@dataclass
|
|
class ListSequence(Sequence):
|
|
"""Class for Ziffers list sequences"""
|
|
|
|
wrap_start: str = field(default="(", repr=False)
|
|
wrap_end: str = field(default=")", repr=False)
|
|
|
|
|
|
@dataclass
|
|
class RepeatedListSequence(Sequence):
|
|
"""Class for Ziffers list sequences"""
|
|
|
|
repeats: Item = None
|
|
wrap_start: str = field(default="(:", repr=False)
|
|
wrap_end: str = field(default=":)", repr=False)
|
|
|
|
|
|
@dataclass
|
|
class Subdivision(Item):
|
|
"""Class for subdivisions"""
|
|
|
|
values: list[Event]
|
|
|
|
|
|
@dataclass
|
|
class Cyclic(Sequence):
|
|
"""Class for cyclic sequences"""
|
|
|
|
cycle: int = 0
|
|
wrap_start: str = field(default="<", repr=False)
|
|
wrap_end: str = field(default=">", repr=False)
|
|
|
|
def __post_init__(self):
|
|
super().__post_init__()
|
|
# TODO: Do spaced need to be filtered out?
|
|
self.values = [val for val in self.values if isinstance(val,Whitespace)]
|
|
|
|
def value(self):
|
|
return self.values[self.cycle]
|
|
|
|
def next_cycle(self, cycle: int):
|
|
self.cycle = self.cycle+1
|
|
|
|
|
|
@dataclass
|
|
class RandomInteger(Item):
|
|
"""Class for random integer"""
|
|
|
|
min: int
|
|
max: int
|
|
|
|
def __post_init__(self):
|
|
if self.min>self.max:
|
|
new_max = self.min
|
|
self.min = self.max
|
|
self.max = new_max
|
|
|
|
def value(self):
|
|
return random.randint(self.min,self.max)
|
|
|
|
|
|
@dataclass
|
|
class Range(Item):
|
|
"""Class for range"""
|
|
|
|
start: int = None
|
|
end: int = None
|
|
|
|
|
|
ops = {
|
|
"+": operator.add,
|
|
"-": operator.sub,
|
|
"*": operator.mul,
|
|
"/": operator.truediv,
|
|
"%": operator.mod,
|
|
}
|
|
|
|
|
|
@dataclass
|
|
class Operator(Item):
|
|
"""Class for math operators"""
|
|
|
|
value: ... = field(init=False, repr=False)
|
|
|
|
def __post_init__(self):
|
|
self.value = ops[self.text]
|
|
|
|
|
|
@dataclass
|
|
class ListOperation(Sequence):
|
|
"""Class for list operations"""
|
|
|
|
def run(self):
|
|
pass
|
|
|
|
|
|
@dataclass
|
|
class Operation(Item):
|
|
"""Class for lisp-like operations: (+ 1 2 3) etc."""
|
|
|
|
values: list
|
|
operator: operator
|
|
|
|
|
|
@dataclass
|
|
class Eval(Sequence):
|
|
"""Class for evaluation notation"""
|
|
|
|
result: ... = None
|
|
wrap_start: str = field(default="{", repr=False)
|
|
wrap_end: str = field(default="}", repr=False)
|
|
|
|
def __post_init__(self):
|
|
super().__post_init__()
|
|
self.result = eval(self.text)
|
|
|
|
|
|
@dataclass
|
|
class Atom(Item):
|
|
"""Class for evaluable atoms"""
|
|
|
|
value: ...
|
|
|
|
|
|
@dataclass
|
|
class Integer(Item):
|
|
"""Class for integers"""
|
|
|
|
value: int
|
|
|
|
|
|
@dataclass
|
|
class Euclid(Item):
|
|
"""Class for euclidean cycles"""
|
|
|
|
pulses: int
|
|
length: int
|
|
onset: list
|
|
offset: list = None
|
|
rotate: int = None
|
|
|
|
|
|
@dataclass
|
|
class RepeatedSequence(Sequence):
|
|
"""Class for repeats"""
|
|
|
|
repeats: Item = None
|
|
wrap_start: str = field(default="[:", repr=False)
|
|
wrap_end: str = field(default=":]", repr=False)
|
|
|
|
@dataclass
|
|
class Ziffers(Meta):
|
|
"""Main class for holding options and the current state"""
|
|
|
|
sequence: Sequence
|
|
options: dict = field(default_factory=DEFAULT_OPTIONS)
|
|
loop_i: int = 0
|
|
current: Item = None
|
|
it: iter = None
|
|
|
|
def __post_init__(self):
|
|
self.it = iter(self.sequence)
|
|
|
|
def __iter__(self):
|
|
return self
|
|
|
|
def __next__(self):
|
|
try:
|
|
self.current = next(self.it)
|
|
|
|
# Skip whitespace and collect duration & octave changes
|
|
while isinstance(self.current,(Whitespace,DurationChange,OctaveChange,OctaveMod)):
|
|
if self.current.item_type == "change":
|
|
self.options[self.current.key] = self.current.value
|
|
elif self.current.item_type == "add":
|
|
self.options[self.current.key] = self.current.value
|
|
self.current = next(self.it)
|
|
|
|
except StopIteration: # Start from the beginning
|
|
self.current = next(self.it)
|
|
|
|
self.current.update_new(self.options)
|
|
|
|
self.loop_i += 1
|
|
return self.current
|
|
|
|
def take(self,num: int) -> list:
|
|
return list(itertools.islice(iter(self), num))
|
|
|
|
def set_defaults(self,options: dict):
|
|
self.options = DEFAULT_OPTIONS | options
|
|
|
|
# TODO: Handle options and generated values
|
|
def pcs(self) -> list[int]:
|
|
return [val.pc for val in self.sequence.values if isinstance(val,Pitch)]
|
|
|
|
def durations(self) -> list[float]:
|
|
return [val.dur for val in self.sequence.values if isinstance(val,Pitch)]
|
|
|
|
def pairs(self) -> list[tuple]:
|
|
return [(val.pc,val.dur) for val in self.sequence.values if isinstance(val,Pitch)]
|
|
|
|
def octaves(self) -> list[int]:
|
|
return [val.octave for val in self.sequence.values if isinstance(val,Pitch)] |