From f0e1aca2476bf27d52bfa1a8ad671a576b2f20e4 Mon Sep 17 00:00:00 2001 From: Miika Alonen Date: Sat, 25 Feb 2023 23:47:28 +0200 Subject: [PATCH] Major refactoring Added more items to shorter repeat syntax: 124:3 A=(1 2) A:4 Prefixes now work for more items: q..r qs(1 2 3) Duration support for list operations: (q1 e3)+(1 4 3 5) --- tests/test_parser.py | 16 +++-- ziffers/classes.py | 135 +++++++++++++++++++++++++------------- ziffers/mapper.py | 132 +++++++++++++++++++++++++------------ ziffers/parser.py | 14 ++++ ziffers/spec/ziffers.lark | 15 ++--- 5 files changed, 210 insertions(+), 102 deletions(-) diff --git a/tests/test_parser.py b/tests/test_parser.py index f1a4c89..19d716b 100644 --- a/tests/test_parser.py +++ b/tests/test_parser.py @@ -1,6 +1,6 @@ """ Test cases for the parser """ import pytest -from ziffers import zparse +from ziffers import zparse, collect # pylint: disable=missing-function-docstring, line-too-long, invalid-name @@ -52,18 +52,19 @@ def test_parsing_text(pattern: str): ], ) def test_pitch_classes(pattern: str, expected: list): - assert zparse(pattern).pitch_classes() == expected + assert collect(zparse(pattern),len(expected)*2,"pitch_class") == expected*2 @pytest.mark.parametrize( "pattern,expected", [ ("__6 _0 _1 _2 _3 _4 _5 _6 0 1 2 3 4 5 6 ^0 ^1 ^2 ^3 ^4 ^5 ^6 ^^0", [-2, -1, -1, -1, -1, -1, -1, -1, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 2]), - ("_ 1 _2 <3>3 ^^4", [-1, -1, 3, 2]), + ("_ 1 _2 <3>3 ^^4", [-1, -2, 3, 1]), + ("^ 1 ^1 3 _2 ^^1 _2 <-1> 2 ^4", [1, 2, 1, 0, 3, 0, -1, 0]), ] ) def test_pitch_octaves(pattern: str, expected: list): - assert zparse(pattern).octaves() == expected + assert collect(zparse(pattern),len(expected)*2,"octave") == expected*2 @pytest.mark.parametrize( @@ -71,11 +72,11 @@ def test_pitch_octaves(pattern: str, expected: list): [ ("w [1 [2 3]]", [0.5, 0.25, 0.25]), ("1.0 [1 [2 3]] 4 [3 [4 5]]", [0.5, 0.25, 0.25, 1.0, 0.5, 0.25, 0.25]), - ("0.5 (0 0.25 3)+1", [0.5, 0.5]) + ("0.5 (0 0.25 3)+1", [0.5, 0.25]) ] ) def test_subdivisions(pattern: str, expected: list): - assert zparse(pattern).durations() == expected + assert collect(zparse(pattern),len(expected)*2,"duration") == expected*2 @pytest.mark.parametrize( "pattern,expected", @@ -85,7 +86,7 @@ def test_subdivisions(pattern: str, expected: list): ] ) def test_repeats(pattern: str, expected: list): - assert zparse(pattern).notes() == expected + assert collect(zparse(pattern),len(expected)*2,"note") == expected*2 @pytest.mark.parametrize( @@ -104,3 +105,4 @@ def test_looping_durations(pattern: str, expected: list): for i in range(12): durations.append(parsed[i].duration) assert durations == expected + diff --git a/ziffers/classes.py b/ziffers/classes.py index 7f032f9..76fa898 100644 --- a/ziffers/classes.py +++ b/ziffers/classes.py @@ -15,6 +15,7 @@ class Meta: """Abstract class for all Ziffers items""" kwargs: dict = field(default=None, repr=False) + local_options: dict = field(default_factory=dict) def __post_init__(self): if self.kwargs: @@ -26,12 +27,26 @@ class Meta: if hasattr(self, key): setattr(self, key, value) - def update_options(self, new_values): + def update_options(self, options): """Updates attribute values only if value is None""" - for key, value in new_values.items(): + merged_options = self.local_options | options + for key, value in merged_options.items(): if hasattr(self, key): - if getattr(self, key) is None: - setattr(self, key, value) + if key == "octave": + local_value = self.local_options.get("octave", False) + oct_change = self.local_options.get("octave_change", False) + if oct_change: + setattr(self, key, oct_change) + elif local_value: + setattr(self, key, value + local_value) + else: + setattr(self, key, value) + elif getattr(self, key) is None: + local_value = self.local_options.get(key, False) + if local_value: + setattr(self, key, local_value) + else: + setattr(self, key, value) def dict(self): """Returns safe dict from the dataclass""" @@ -56,6 +71,14 @@ class Item(Meta): self.replace_options(options) return self + def get_options(self) -> dict: + """Return local options from item + + Returns: + dict: Options as a dict + """ + keys = ["octave","modifier","key","scale","duration"] + return {key: getattr(self, key) for key in keys if hasattr(self, key)} @dataclass(kw_only=True) class Whitespace: @@ -118,17 +141,17 @@ class Pitch(Event): pitch_class: int octave: int = field(default=None) - modifier: int = field(default=0) + modifier: int = field(default=None) note: int = field(default=None) key: str = field(default=None) scale: str | list = field(default=None) freq: float = field(default=None) - + beat: float = field(default=None) def __post_init__(self): super().__post_init__() if self.text is None: self.text = str(self.pitch_class) - self.update_note() + self.update_note() def update_note(self, force: bool = False): """Update note if Key, Scale and Pitch-class are present""" @@ -147,6 +170,8 @@ class Pitch(Event): ) self.freq = midi_to_freq(note) self.note = note + if self.duration is not None: + self.beat = self.duration*4 def check_note(self, options: dict): """Check for note modification""" @@ -302,16 +327,20 @@ class Sequence(Meta): def __post_init__(self): super().__post_init__() self.text = self.__collect_text() + self.update_local_options() def __getitem__(self, index): return self.values[index] - def update_values(self, new_values): + def update_local_options(self): """Update value attributes from dict""" - for key, value in new_values.items(): + if self.local_options: for obj in self.values: - if key != "text" and hasattr(obj, key): - setattr(obj, key, value) + if isinstance(obj, Event): + if obj.local_options: + obj.local_options = obj.local_options | self.local_options.copy() + else: + obj.local_options = self.local_options.copy() def __collect_text(self) -> str: """Collect text value from values""" @@ -337,18 +366,12 @@ class Sequence(Meta): yield from item.evaluate(options) elif isinstance(item, RepeatedSequence): item.evaluate_values(options) - # TODO: Refactor this. Parsing and validating cycles for integers only? - if isinstance(item.repeats, Cyclic): - repeats = item.repeats.get_value().get_value(options) - else: - repeats = item.repeats.get_value(options) + repeats = item.repeats.get_value(options) + repeats = _resolve_repeat_value(repeats) yield from _normal_repeat(item.evaluated_values, repeats, options) elif isinstance(item, RepeatedListSequence): repeats = item.repeats.get_value(options) - while isinstance(repeats, Cyclic): - repeats = item.repeats.get_value(options) - if isinstance(repeats, Pitch): - repeats = repeats.get_value(options) + repeats = _resolve_repeat_value(repeats) yield from _generative_repeat(item, repeats, options) elif isinstance(item, Subdivision): item.evaluate_values(options) @@ -375,17 +398,26 @@ class Sequence(Meta): elif isinstance(item, Euclid): yield from _euclidean_items(item, options) elif isinstance(item, Modification): - options = _update_options(item, options) + options = _parse_options(item, options) elif isinstance(item, Meta): # Filters whitespace yield _update_item(item, options) + def _resolve_repeat_value(item): + while isinstance(item, Cyclic): + item = item.get_value(options) + if isinstance(item, Pitch): + return item.get_value(options) + if not isinstance(item, Integer): + return 2 + return item + def _update_item(item, options): """Update or create new pitch""" if set(("key", "scale")) <= options.keys(): if isinstance(item, Pitch): item.update_options(options) item.update_note() - if options.get("pre_eval",False): + if options.get("pre_eval", False): item.duration = options["duration"] if isinstance(item, Rest): item.update_options(options) @@ -422,7 +454,7 @@ class Sequence(Meta): for item in items: yield from _resolve_item(item, options) - def _update_options(current: Item, options: dict) -> dict: + def _parse_options(current: Item, options: dict) -> dict: """Update options based on current item""" if isinstance(current, (OctaveChange, DurationChange)): options[current.key] = current.value @@ -439,26 +471,32 @@ class Sequence(Meta): def _create_pitch(current: Item, options: dict) -> Pitch: """Create pitch based on values and options""" - if "modifier" in options: - c_modifier = options["modifier"] + merged_options = options | self.local_options + + if "modifier" in merged_options: + c_modifier = merged_options["modifier"] else: c_modifier = 0 if hasattr(current, "modifier") and current.modifier is not None: c_modifier += current.modifier - if "octave" in options: - c_octave = options["octave"] + if "octave" in merged_options: + c_octave = merged_options["octave"] + if "octave" in options: + c_octave = options["octave"] + c_octave else: c_octave = 0 if hasattr(current, "octave") and current.octave is not None: c_octave += current.octave - current_value = current.get_value(options) + + current_value = current.get_value(merged_options) + note = note_from_pc( - root=options["key"], + root=merged_options["key"], pitch_class=current_value, - intervals=options["scale"], + intervals=merged_options["scale"], modifier=c_modifier, octave=c_octave, ) @@ -469,7 +507,7 @@ class Sequence(Meta): freq=midi_to_freq(note), octave=c_octave, modifier=c_modifier, - kwargs=options, + kwargs=merged_options, ) return new_pitch @@ -542,7 +580,7 @@ class Ziffers(Sequence): self.loop_i = index % self.cycle_length new_cycle = floor(index / self.cycle_length) if new_cycle > self.cycle_i or new_cycle < self.cycle_i: - self.re_eval(self.options) + self.re_eval() self.cycle_i = new_cycle self.cycle_length = len(self.evaluated_values) self.loop_i = index % self.cycle_length @@ -568,11 +606,9 @@ class Ziffers(Sequence): self.start_options = self.options.copy() self.init_tree(self.options) - def re_eval(self, options=None): + def re_eval(self): """Re-evaluate the iterator""" self.options = self.start_options.copy() - if options: - self.options.update(options) self.init_tree(self.options) def init_tree(self, options): @@ -631,6 +667,10 @@ class Ziffers(Sequence): """Return list of pitch durations as floats""" return [val.duration for val in self.evaluated_values if isinstance(val, Event)] + def beats(self) -> list[float]: + """Return list of pitch durations as floats""" + return [val.beat for val in self.evaluated_values if isinstance(val, Event)] + def pairs(self) -> list[tuple]: """Return list of pitches and durations""" return [ @@ -757,14 +797,17 @@ class Range(Item): def evaluate(self, options): """Evaluates range and generates a generator of Pitches""" + merged_options = options | self.local_options + if options["octave"]: + merged_options["octave"] += options["octave"] if self.start < self.end: for i in range(self.start, self.end + 1): - yield Pitch(pitch_class=i, kwargs=options) + yield Pitch(pitch_class=i, local_options=merged_options) elif self.start > self.end: for i in reversed(range(self.end, self.start + 1)): - yield Pitch(pitch_class=i, kwargs=options) + yield Pitch(pitch_class=i, local_options=merged_options) else: - yield Pitch(pitch_class=self.start, kwargs=options) + yield Pitch(pitch_class=self.start, local_options=merged_options) @dataclass(kw_only=True) @@ -783,25 +826,27 @@ class ListOperation(Sequence): def evaluate(self, options=DEFAULT_OPTIONS.copy()): """Evaluates the operation""" - def filter_operation(input_list): + def filter_operation(input_list, options): flattened_list = [] - # TODO: ADD Options here and evaluate events? for item in input_list: if isinstance(item, (list, Sequence)): if isinstance(item, ListOperation): flattened_list.extend(item.evaluated_values) else: - flattened_list.append(filter_operation(item)) + flattened_list.append(filter_operation(item, options)) elif isinstance(item, Cyclic): value = item.get_value() if isinstance(value, Sequence): - flattened_list.extend(filter_operation(value)) + flattened_list.extend(filter_operation(value, options)) elif isinstance(value, (Event, RandomInteger, Integer)): flattened_list.append(value) + elif isinstance(item, Modification): + options = options | item.as_options() elif isinstance(item, Range): flattened_list.extend(list(item.evaluate(options))) elif isinstance(item, (Event, RandomInteger, Integer)): + item.update_options(options) flattened_list.append(item) if isinstance(input_list, Sequence): @@ -811,7 +856,7 @@ class ListOperation(Sequence): operators = self.values[1::2] # Fetch every second operator element values = self.values[::2] # Fetch every second list element - values = filter_operation(values) # Filter out + values = filter_operation(values, options) # Filter out if len(values) == 1: return values[0] # If right hand doesnt contain anything sensible left = values[0] # Start results with the first array @@ -823,10 +868,9 @@ class ListOperation(Sequence): (right.values if isinstance(right, Sequence) else [right]), left ) left = [ - # TODO: Get options from x value? Pitch( pitch_class=operation(x.get_value(options), y.get_value(options)), - kwargs=options, + kwargs=y.get_options() ) for (x, y) in pairs ] @@ -911,7 +955,6 @@ class RepeatedSequence(Sequence): repeats: RandomInteger | Integer = field(default_factory=Integer(value=1, text="1")) wrap_start: str = field(default="[:", repr=False) wrap_end: str = field(default=":]", repr=False) - local_options: dict = field(default_factory=dict, init=False) evaluated_values: list = None diff --git a/ziffers/mapper.py b/ziffers/mapper.py index 6099850..7cf4b07 100644 --- a/ziffers/mapper.py +++ b/ziffers/mapper.py @@ -1,5 +1,4 @@ """ Lark transformer for mapping Lark tokens to Ziffers objects """ -from typing import Optional from lark import Transformer from .classes import ( Ziffers, @@ -29,7 +28,7 @@ from .classes import ( Euclid, RepeatedSequence, VariableAssignment, - Variable + Variable, ) from .common import flatten, sum_dict from .defaults import DEFAULT_DURS, OPERATORS @@ -50,51 +49,82 @@ class ZiffersTransformer(Transformer): def rest(self, items): """Return duration event""" - if len(items)>0: - chars = items[0] - val = DEFAULT_DURS[chars[0]] - # TODO: Add support for dots - #if len(chars)>1: - # dots = len(chars)-1 - # val = val * (2.0 - (1.0 / (2 * dots))) - return Rest(text=chars+"r", duration=val) + if len(items) > 0: + prefixes = sum_dict(items) + text_prefix = prefixes.pop("text") + prefixes["prefix"] = text_prefix + return Rest(text=text_prefix + "r", local_options=prefixes) return Rest(text="r") - return Rest(text=chars+"r", duration=val) + def random_integer(self, items) -> RandomInteger: + """Parses random integer syntax""" + if len(items) > 1: + prefixes = sum_dict(items[0:-1]) # If there are prefixes + text_prefix = prefixes.pop("text") + prefixes["prefix"] = text_prefix + val = items[-1][1:-1].split(",") + return RandomInteger( + min=int(val[0]), + max=int(val[1]), + text=text_prefix + items[-1], + local_options=prefixes, + ) + else: + val = items[0][1:-1].split(",") + return RandomInteger(min=int(val[0]), max=int(val[1]), text=items[0]) - def rest_duration(self,items): + def random_integer_re(self, items): + """Return random integer notation from regex""" return items[0].value - def random_integer(self, item) -> RandomInteger: - """Parses random integer syntax""" - val = item[0][1:-1].split(",") - return RandomInteger(min=int(val[0]), max=int(val[1]), text=item[0].value) - - def range(self, item) -> Range: + def range(self, items) -> Range: """Parses range syntax""" - val = item[0].split("..") - return Range(start=int(val[0]), end=int(val[1]), text=item[0].value) + if len(items) > 1: + prefixes = sum_dict(items[0:-1]) # If there are prefixes + text_prefix = prefixes.pop("text") + prefixes["prefix"] = text_prefix + val = items[-1].split("..") + return Range( + start=int(val[0]), + end=int(val[1]), + text=text_prefix + items[-1], + local_options=prefixes, + ) + # Else + val = items[0].split("..") + return Range(start=int(val[0]), end=int(val[1]), text=items[0]) + + def range_re(self, items): + """Return range value from regex""" + return items[0].value def cycle(self, items) -> Cyclic: """Parses cycle""" values = items[0] return Cyclic(values=values) - def pitch_class(self, item): + def pitch_class(self, items): """Parses pitch class""" # If there are prefixes - if len(item) > 1: + if len(items) > 1: # Collect&sum prefixes from any order: _qee^s4 etc. - result = sum_dict(item) - return Pitch(**result) + prefixes = sum_dict(items[0:-1]) # If there are prefixes + text_prefix = prefixes.pop("text") + prefixes["prefix"] = text_prefix + p = Pitch( + pitch_class=items[-1]["pitch_class"], + text=text_prefix + items[-1]["text"], + local_options=prefixes, + ) + return p - val = item[0] + val = items[0] return Pitch(**val) def pitch(self, items): """Return pitch class info""" - text_value = items[0].value.replace("T","10").replace("E","11") + text_value = items[0].value.replace("T", "10").replace("E", "11") return {"pitch_class": int(text_value), "text": items[0].value} def prefix(self, items): @@ -104,7 +134,10 @@ class ZiffersTransformer(Transformer): def oct_change(self, items): """Parses octave change""" octave = items[0] - return [OctaveChange(value=octave["octave"], text=octave["text"]), items[1]] + return [ + OctaveChange(value=octave["octave_change"], text=octave["text"]), + items[1], + ] def oct_mod(self, items): """Parses octave modification""" @@ -114,7 +147,7 @@ class ZiffersTransformer(Transformer): def escaped_octave(self, items): """Return octave info""" value = items[0][1:-1] - return {"octave": int(value), "text": items[0].value} + return {"octave_change": int(value), "text": items[0].value} def octave(self, items): """Return octaves ^ and _""" @@ -124,7 +157,7 @@ class ZiffersTransformer(Transformer): def modifier(self, items): """Return modifiers # and b""" value = 1 if items[0].value == "#" else -1 - return {"modifier": value} + return {"modifier": value, "text": items[0].value} def chord(self, items): """Parses chord""" @@ -229,9 +262,7 @@ class ZiffersTransformer(Transformer): def subdivision(self, items): """Parse subdivision""" values = flatten(items[0]) - return Subdivision( - values=values, wrap_start="[", wrap_end="]" - ) + return Subdivision(values=values, wrap_start="[", wrap_end="]") def subitems(self, items): """Return subdivision items""" @@ -257,19 +288,26 @@ class ZiffersTransformer(Transformer): val = token[0].value return Atom(value=val, text=val) - # Variable assignment def assignment(self, items): + """Creates variable assignment""" var = items[0] op = items[1] content = items[2] - return VariableAssignment(variable=var, value=content, text=var.text+"="+content.text, pre_eval=True if op == "=" else False) + return VariableAssignment( + variable=var, + value=content, + text=var.text + "=" + content.text, + pre_eval=True if op == "=" else False, + ) - def ass_op(self,items): + def ass_op(self, items): + """Return parsed type for assignment: = or ~""" return items[0].value def variable(self, items): + """Return parsed variable name""" return Variable(name=items[0].value, text=items[0].value) # List rules @@ -278,9 +316,14 @@ class ZiffersTransformer(Transformer): """Parse list sequence notation, ex: (1 2 3)""" if len(items) > 1: prefixes = sum_dict(items[0:-1]) + text_prefix = prefixes.pop("text") + prefixes["prefix"] = text_prefix values = items[-1] - seq = ListSequence(values=values, wrap_start=prefixes["text"] + "(") - seq.update_values(prefixes) + seq = ListSequence( + values=values, + wrap_start=prefixes["prefix"] + "(", + local_options=prefixes, + ) return seq else: seq = ListSequence(values=items[0]) @@ -295,12 +338,13 @@ class ZiffersTransformer(Transformer): values=items[-2], repeats=items[-1], wrap_end=":" + items[-1].text + ")", + local_options=prefixes, ) else: seq = RepeatedListSequence( - values=items[-2], repeats=Integer(text="2", value=2) + values=items[-2], + repeats=Integer(text="2", value=2, local_options=prefixes), ) - seq.update_values(prefixes) return seq else: if items[-1] is not None: @@ -351,7 +395,7 @@ class ZiffersTransformer(Transformer): """Parse list operation""" return ListOperation(values=items) - def right_op(self,items): + def right_op(self, items): """Get right value for the operation""" return items[0] @@ -382,4 +426,10 @@ class ZiffersTransformer(Transformer): return RepeatedSequence(values=items[0], repeats=Integer(value=2, text="2")) def repeat_item(self, items): - return RepeatedListSequence(values=[items[0]],repeats=items[1], wrap_start="", wrap_end=":"+items[1].text) \ No newline at end of file + """Parse repeat item syntax to sequence, ex: 1:4 (1 2 3):5""" + return RepeatedListSequence( + values=[items[0]], + repeats=items[1], + wrap_start="", + wrap_end=":" + items[1].text, + ) diff --git a/ziffers/parser.py b/ziffers/parser.py index 758b4d9..7654d09 100644 --- a/ziffers/parser.py +++ b/ziffers/parser.py @@ -52,3 +52,17 @@ def zparse(expr: str, **opts) -> Ziffers: def z(expr: str, **opts) -> Ziffers: """Shortened method name for zparse""" return zparse(expr, **opts) + + +def yield_items(gen: Ziffers, num: int, key: str = None) -> list: + """Yield n items from parsed Ziffers""" + for i in range(num): + if key is not None: + yield getattr(gen[i],key,None) + else: + yield gen[i] + +def collect(gen: Ziffers, num: int, key: str = None) -> list: + """Collect n-item from parsed Ziffers""" + return list(yield_items(gen,num,key)) + \ No newline at end of file diff --git a/ziffers/spec/ziffers.lark b/ziffers/spec/ziffers.lark index 3c83df9..9dbc3e8 100644 --- a/ziffers/spec/ziffers.lark +++ b/ziffers/spec/ziffers.lark @@ -17,16 +17,13 @@ variable: /[A-Z]/ // Durations - // TODO: Refactor dchar as: /([mklpdcwyhnqaefsxtgujzo](\.)*)(?=\d)/ duration_chars: dotted_dur+ dotted_dur: dchar dot* decimal: /-?[0-9]+\.[0-9]+/ dchar: /[mklpdcwyhnqaefsxtgujzo]/ dot: "." - rest: rest_duration? "r" - // TODO: Refactor (\.)* when other durchars uses lookaheads - rest_duration: /([mklpdcwyhnqaefsxtgujzo])(?=r)/ + rest: prefix* "r" // Chords chord: pitch_class pitch_class+ @@ -42,7 +39,7 @@ // Repeats repeat: "[:" sequence ":" [number] "]" - repeat_item: (pitch_class | list | random_integer | cycle | rest | subdivision) ":" number + repeat_item: (pitch_class | list | list_op | random_integer | cycle | rest | subdivision | chord | named_roman | variable | range) ":" number // List list: prefix* "(" sequence ")" @@ -71,11 +68,13 @@ oct_change: escaped_octave WS dur_change: (decimal | char_change) char_change: dchar_not_prefix+ - dchar_not_prefix: /([mklpdcwyhnqaefsxtgujzo](\.)*)(?![\dr])/ + dchar_not_prefix: /([mklpdcwyhnqaefsxtgujzo](\.)*)(?=[ >])/ // Generative rules - random_integer: /\(-?[0-9]+,-?[0-9]+\)/ - range: /-?[0-9]+\.\.-?[0-9]+/ + random_integer: prefix* random_integer_re + random_integer_re: /\(-?[0-9]+,-?[0-9]+\)/ + range: prefix* range_re + range_re: /-?[0-9]+\.\.-?[0-9]+/ cycle: "<" sequence ">" random_pitch: /(\?)(?!\d)/ random_percent: /(%)(?!\d)/