BuboBubo/ziffers-python
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

run black on codebase

Browse Source
This commit is contained in:
Raphaël Forment
2023-02-05 16:22:01 +01:00
parent 4d74186df8
commit 3d7fe73569
10 changed files with 362 additions and 251 deletions
Download Patch File Download Diff File Expand all files Collapse all files

60
main.py
View File

@ -3,38 +3,38 @@ from rich import print
if __name__ == "__main__":
expressions = {
'Pitches': "-2 -1 0 1 2",
'Chords': "0 024 2 246",
'Note lengths': "w 0 h 1 q 2 e 3 s 4",
'Subdivision': "[1 2 [3 4]]",
'Decimal durations': "0.25 0 1 <0.333>2 3",
'Octaves': "^ 0 ^ 1 _ 2 _ 3",
'Escaped octave': "<2> 1 <1>1<-2>3",
'Roman chords': "i ii iii+4 iv+5 v+8 vi+10 vii+20",
'Named chords': "i^7 i^min i^dim i^maj7",
'Modal interchange (a-g)': "iiia ig ivf^7",
'Escape/eval': "{10 11} {1.2 2.43} {3+1*2}",
'Randoms': "% ? % ? % ?",
'Random between': "(-3,6)",
'Random selections': "[q 1 2, q 3 e 4 6]",
'Repeat': "[: 1 (2,6) 3 :4]",
'Repeat cycles': "[: <q e> (1,4) <(2 3) (3 (1,7))> :]",
'Lists': "h 1 q(0 1 2 3) 2",
'List cycles': "(: <q e> (1,4) <(2 3) (3 (1,7))> :)",
'Loop cycles (for zloop or z0-z9)': "<0 <1 <2 <3 <4 5>>>>>",
'Basic operations': "(1 2 (3 4)+2)*2 ((1 2 3)+(0 9 13))-2 ((3 4 {10})*(2 9 3))%7",
'Product operations': "(0 1 2 3)+(1 4 2 3) (0 1 2)-(0 2 1)+2",
'Euclid cycles': "(q1)<6,7>(q4 (e3 e4) q2) (q1)<6,7>(q4 q3 q2)",
'Transformations': "(0 1 2)<r> (0 1 2)<i>(-2 1)",
'List assignation': "A=(0 (1,6) 3) B=(3 ? 2) B A B B A",
'Random repeat': "(: 1 (2,6) 3 :4)",
'Conditionals': "1 {%<0.5?3} 3 4 (: 1 2 {%<0.2?3:2} :3)",
'Functions': "(0 1 2 3){x%3==0?x-2:x+2}",
'Polynomials': "(-10..10){(x**3)*(x+1)%12}",
"Pitches": "-2 -1 0 1 2",
"Chords": "0 024 2 246",
"Note lengths": "w 0 h 1 q 2 e 3 s 4",
"Subdivision": "[1 2 [3 4]]",
"Decimal durations": "0.25 0 1 <0.333>2 3",
"Octaves": "^ 0 ^ 1 _ 2 _ 3",
"Escaped octave": "<2> 1 <1>1<-2>3",
"Roman chords": "i ii iii+4 iv+5 v+8 vi+10 vii+20",
"Named chords": "i^7 i^min i^dim i^maj7",
"Modal interchange (a-g)": "iiia ig ivf^7",
"Escape/eval": "{10 11} {1.2 2.43} {3+1*2}",
"Randoms": "% ? % ? % ?",
"Random between": "(-3,6)",
"Random selections": "[q 1 2, q 3 e 4 6]",
"Repeat": "[: 1 (2,6) 3 :4]",
"Repeat cycles": "[: <q e> (1,4) <(2 3) (3 (1,7))> :]",
"Lists": "h 1 q(0 1 2 3) 2",
"List cycles": "(: <q e> (1,4) <(2 3) (3 (1,7))> :)",
"Loop cycles (for zloop or z0-z9)": "<0 <1 <2 <3 <4 5>>>>>",
"Basic operations": "(1 2 (3 4)+2)*2 ((1 2 3)+(0 9 13))-2 ((3 4 {10})*(2 9 3))%7",
"Product operations": "(0 1 2 3)+(1 4 2 3) (0 1 2)-(0 2 1)+2",
"Euclid cycles": "(q1)<6,7>(q4 (e3 e4) q2) (q1)<6,7>(q4 q3 q2)",
"Transformations": "(0 1 2)<r> (0 1 2)<i>(-2 1)",
"List assignation": "A=(0 (1,6) 3) B=(3 ? 2) B A B B A",
"Random repeat": "(: 1 (2,6) 3 :4)",
"Conditionals": "1 {%<0.5?3} 3 4 (: 1 2 {%<0.2?3:2} :3)",
"Functions": "(0 1 2 3){x%3==0?x-2:x+2}",
"Polynomials": "(-10..10){(x**3)*(x+1)%12}",
}
for ex in expressions:
try:
print(f"Parsed: "+parse_expression(expressions[ex]).text)
print(f"Parsed: " + parse_expression(expressions[ex]).text)
except Exception as e:
print(f"[red]Failed on {ex}[/red]")
#print(f"[red]Failed on {ex}[/red]: {str(e)[0:40]}...")
# print(f"[red]Failed on {ex}[/red]: {str(e)[0:40]}...")

4
repl.py
View File

@ -1,12 +1,12 @@
from ziffers import *
from rich import print
EXIT_CONDITION = ('exit', 'quit', '')
EXIT_CONDITION = ("exit", "quit", "")
if __name__ == "__main__":
print(f"[purple]== ZIFFERS REPL ==[/purple]")
while True:
expr = input('> ')
expr = input("> ")
if expr not in EXIT_CONDITION:
try:
result = parse_expression(expr)

25
tests/test_parser.py
View File

@ -1,15 +1,16 @@
from ziffers import *
import pytest
def test_can_parse():
expressions = [
"[1 [2 3]]",
"(1 (1,3) 1..3)",
"_^ q _qe^3 qww_4 _123 <1 2>",
"q _2 _ 3 ^ 343",
"2 qe2 e4",
"q 2 <3 343>",
"q (2 <3 343 (3 4)>)",
"[1 [2 3]]",
"(1 (1,3) 1..3)",
"_^ q _qe^3 qww_4 _123 <1 2>",
"q _2 _ 3 ^ 343",
"2 qe2 e4",
"q 2 <3 343>",
"q (2 <3 343 (3 4)>)",
]
results = []
for expression in expressions:
@ -21,10 +22,11 @@ def test_can_parse():
print(e)
results.append(False)
# Return true if all the results are true (succesfully parsed)
# Return true if all the results are true (succesfully parsed)
print(results)
assert all(results)
@pytest.mark.parametrize(
"pattern",
[
@ -35,12 +37,13 @@ def test_can_parse():
def test_parsing_text(pattern: str):
assert parse_expression(pattern).text == pattern
@pytest.mark.parametrize(
"pattern,expected",
[
("1 2 3", [1,2,3]),
("q2 eq3", [2,3]),
("1 2 3", [1, 2, 3]),
("q2 eq3", [2, 3]),
],
)
def test_pcs(pattern: str, expected: list):
assert parse_expression(pattern).pcs() == expected
assert parse_expression(pattern).pcs() == expected

31
tests/test_scale.py
View File

@ -1,6 +1,7 @@
from ziffers import scale
import pytest
@pytest.mark.parametrize(
"name,expected",
[
@ -14,11 +15,37 @@ import pytest
def test_notenames(name: str, expected: int):
assert scale.note_to_midi(name) == expected
@pytest.mark.parametrize(
"pcs,expected",
[
(list(range(-9,10)), [45, 47, 48, 50, 52, 53, 55, 57, 59, 60, 62, 64, 65, 67, 69, 71, 72, 74, 76]),
(
list(range(-9, 10)),
[
45,
47,
48,
50,
52,
53,
55,
57,
59,
60,
62,
64,
65,
67,
69,
71,
72,
74,
76,
],
),
],
)
def test_note_to_midi(pcs: str, expected: int):
assert [scale.note_from_pc(root=60, pitch_class=val, intervals="Ionian") for val in pcs] == expected
assert [
scale.note_from_pc(root=60, pitch_class=val, intervals="Ionian") for val in pcs
] == expected

149
ziffers/classes.py
View File

@ -2,81 +2,108 @@ from dataclasses import dataclass, field
import operator
from typing import Any
@dataclass
class Meta:
''' Abstract class for all Ziffers items'''
"""Abstract class for all Ziffers items"""
def update(self, new_values):
''' Update attributes from dict '''
"""Update attributes from dict"""
for key, value in new_values.items():
if hasattr(self, key):
setattr(self, key, value)
@dataclass
class Item(Meta):
''' Class for all Ziffers text based items '''
"""Class for all Ziffers text based items"""
text: str
@dataclass
class Whitespace(Item):
''' Class for whitespace '''
"""Class for whitespace"""
@dataclass
class DurationChange(Item):
''' Class for changing duration '''
"""Class for changing duration"""
dur: float
@dataclass
class OctaveChange(Item):
''' Class for changing octave '''
"""Class for changing octave"""
oct: int
@dataclass
class OctaveMod(Item):
''' Class for modifying octave '''
"""Class for modifying octave"""
oct: int
@dataclass
class Event(Item):
''' Abstract class for events with duration '''
"""Abstract class for events with duration"""
dur: float = None
@dataclass
class Pitch(Event):
''' Class for pitch in time '''
"""Class for pitch in time"""
pc: int = None
dur: float = None
oct: int = None
@dataclass
class RandomPitch(Event):
''' Class for random pitch '''
"""Class for random pitch"""
pc: int = None
@dataclass
class RandomPercent(Item):
''' Class for random percent '''
"""Class for random percent"""
percent: float = None
@dataclass
class Chord(Event):
''' Class for chords '''
"""Class for chords"""
pcs: list[Pitch] = None
@dataclass
class Function(Event):
''' Class for functions '''
"""Class for functions"""
run: str = None
class dataclass_property(property): # pylint: disable=invalid-name
''' Hack for dataclass setters '''
class dataclass_property(property): # pylint: disable=invalid-name
"""Hack for dataclass setters"""
def __set__(self, __obj: Any, __value: Any) -> None:
if isinstance(__value, self.__class__):
return None
return super().__set__(__obj, __value)
@dataclass
class Sequence(Meta):
''' Class for sequences of items'''
"""Class for sequences of items"""
values: list[Item]
text: str = field(init=False)
_text: str = field(default=None, init=False, repr=False)
@ -96,12 +123,12 @@ class Sequence(Meta):
self.text = self.collect_text()
def update_values(self, new_values):
''' Update value attributes from dict '''
"""Update value attributes from dict"""
for key, value in new_values.items():
for obj in self.values:
if key!="text" and hasattr(obj, key):
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:
@ -112,115 +139,145 @@ class Sequence(Meta):
def pcs(self) -> list[int]:
return [val.pc for val in self.values if type(val) is Pitch]
def durations(self) -> list[float]:
return [val.dur for val in self.values if type(val) is Pitch]
def pairs(self) -> list[tuple]:
return [(val.pc,val.dur) for val in self.values if type(val) is Pitch]
return [(val.pc, val.dur) for val in self.values if type(val) is Pitch]
@dataclass
class ListSequence(Sequence):
''' Class for Ziffers list sequences '''
"""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 '''
"""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 '''
"""Class for subdivisions"""
values: list[Event]
@dataclass
class Cyclic(Sequence):
''' Class for cyclic sequences'''
"""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 type(val)!=Item]
self.values = [val for val in self.values if type(val) != Item]
@dataclass
class RandomInteger(Item):
''' Class for random integer '''
"""Class for random integer"""
min: int
max: int
@dataclass
class Range(Item):
''' Class for range '''
"""Class for range"""
start: int
end: int
ops = {
'+' : operator.add,
'-' : operator.sub,
'*' : operator.mul,
'/' : operator.truediv,
'%' : operator.mod
"+": operator.add,
"-": operator.sub,
"*": operator.mul,
"/": operator.truediv,
"%": operator.mod,
}
@dataclass
class Operator(Item):
''' Class for math operators '''
value: ... = field(init=False, repr=False)
"""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 '''
"""Class for list operations"""
def run(self):
pass
@dataclass
class Operation(Item):
''' Class for lisp-like operations: (+ 1 2 3) etc. '''
"""Class for lisp-like operations: (+ 1 2 3) etc."""
values: list
operator: operator
@dataclass
class Eval(Sequence):
''' Class for evaluation notation '''
"""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'''
"""Class for evaluable atoms"""
value: ...
@dataclass
class Integer(Item):
''' Class for integers '''
"""Class for integers"""
value: int
@dataclass
class Euclid(Item):
''' Class for euclidean cycles '''
"""Class for euclidean cycles"""
pulses: int
length: int
onset: list
offset: list = None
rotate: int = None
@dataclass
class RepeatedSequence(Sequence):
''' Class for repeats '''
"""Class for repeats"""
repeats: Item = None
wrap_start: str = field(default="[:", repr=False)
wrap_end: str = field(default=":]", repr=False)

15
ziffers/common.py
View File

@ -1,14 +1,19 @@
def flatten(arr) -> list:
''' Flattens array'''
return flatten(arr[0]) + (flatten(arr[1:]) if len(arr) > 1 else []) if type(arr) is list else [arr]
"""Flattens array"""
return (
flatten(arr[0]) + (flatten(arr[1:]) if len(arr) > 1 else [])
if type(arr) is list
else [arr]
)
def sum_dict(arr) -> dict:
''' Sums array of dicts: [{a:3,b:3},{b:1}] -> {a:3,b:4} '''
"""Sums array of dicts: [{a:3,b:3},{b:1}] -> {a:3,b:4}"""
result = arr[0]
for hash in arr[1:]:
for key in hash.keys():
for key in hash.keys():
if key in result:
result[key] = result[key] + hash[key]
else:
result[key] = hash[key]
return result
return result

72
ziffers/defaults.py
View File

@ -1,37 +1,37 @@
default_durs = {
'm': 8.0, # 15360/1920
'k': 10240/1920, # ~5.333
'l': 4.0, # 7680/1920
'd.': 3.0, #
'p': 5120/1920, # ~2.666
'd': 2.0, # 3840/1920
'w.': 1.5, # 2280/1920
'c': 2560/1920, # ~1.333
'w': 1.0, # 1920/1920
'h..': 0.875, # 1680/1920
'h.': 0.75, # 1440/1920
'y': 1280/1920, # ~0.666
'h': 0.5, # 960/1920 - 1/2
'q..': 840/1920, # ~0.4375
'q.': 0.375, # 720/1920
'n': 640/1920, # ~0.333
'q': 0.25, # 480/1920 - 1/4
'e..': 420/1920, # = 0.218
'e.': 0.1875, # 360/1920
'a': 320/1920, # 0.167 - 1/8
'e': 0.125, # 240/1920
's..': 210/1920, # ~0.10937
's.': 180/1920, # ~0.0937
'f': 160/1920, # ~0.083 - 1/16
's': 0.0625, # 120/1920
't..': 105/1920, # ~0.0546
't.': 90/1920, # ~0.0468
'x': 80/1920, # ~0.042 - 1/32
't': 60/1920, # ~0.031
'u.': 45/1920, # ~0.023
'g': 40/1920, # ~0.021 - 1/64
'u': 30/1920, # ~0.016
'j': 15/1920, # ~0.0078 - 1/128
'o': 8/1920, # ~0.00416
'z': 0.0 # 0
}
"m": 8.0, # 15360/1920
"k": 10240 / 1920, # ~5.333
"l": 4.0, # 7680/1920
"d.": 3.0, #
"p": 5120 / 1920, # ~2.666
"d": 2.0, # 3840/1920
"w.": 1.5, # 2280/1920
"c": 2560 / 1920, # ~1.333
"w": 1.0, # 1920/1920
"h..": 0.875, # 1680/1920
"h.": 0.75, # 1440/1920
"y": 1280 / 1920, # ~0.666
"h": 0.5, # 960/1920 - 1/2
"q..": 840 / 1920, # ~0.4375
"q.": 0.375, # 720/1920
"n": 640 / 1920, # ~0.333
"q": 0.25, # 480/1920 - 1/4
"e..": 420 / 1920, # = 0.218
"e.": 0.1875, # 360/1920
"a": 320 / 1920, # 0.167 - 1/8
"e": 0.125, # 240/1920
"s..": 210 / 1920, # ~0.10937
"s.": 180 / 1920, # ~0.0937
"f": 160 / 1920, # ~0.083 - 1/16
"s": 0.0625, # 120/1920
"t..": 105 / 1920, # ~0.0546
"t.": 90 / 1920, # ~0.0468
"x": 80 / 1920, # ~0.042 - 1/32
"t": 60 / 1920, # ~0.031
"u.": 45 / 1920, # ~0.023
"g": 40 / 1920, # ~0.021 - 1/64
"u": 30 / 1920, # ~0.016
"j": 15 / 1920, # ~0.0078 - 1/128
"o": 8 / 1920, # ~0.00416
"z": 0.0, # 0
}

202
ziffers/mapper.py
View File

@ -4,211 +4,231 @@ from .common import flatten, sum_dict
from .defaults import default_durs
import operator
class ZiffersTransformer(Transformer):
def start(self,items):
def start(self, items):
return Sequence(values=items[0])
def sequence(self,items):
def sequence(self, items):
return flatten(items)
def random_integer(self,s):
def random_integer(self, s):
val = s[0][1:-1].split(",")
return RandomInteger(min=val[0],max=val[1],text=s[0].value)
return RandomInteger(min=val[0], max=val[1], text=s[0].value)
def range(self,s):
def range(self, s):
val = s[0].split("..")
return Range(start=val[0],end=val[1],text=s[0])
return Range(start=val[0], end=val[1], text=s[0])
def cycle(self, items):
values = items[0]
return Cyclic(values=values)
def pc(self, s):
if(len(s)>1):
if len(s) > 1:
# Collect&sum prefixes from any order: _qee^s4 etc.
result = sum_dict(s)
return Pitch(**result)
else:
val = s[0]
return Pitch(**val)
return Pitch(**val)
def pitch(self,s):
return {"pc":int(s[0].value),"text":s[0].value}
def pitch(self, s):
return {"pc": int(s[0].value), "text": s[0].value}
def prefix(self,s):
def prefix(self, s):
return s[0]
def oct_change(self,s):
def oct_change(self, s):
octave = s[0]
return [OctaveChange(oct=octave["oct"],text=octave["text"]),s[1]]
return [OctaveChange(oct=octave["oct"], text=octave["text"]), s[1]]
def oct_mod(self,s):
def oct_mod(self, s):
octave = s[0]
return [OctaveMod(oct=octave["oct"],text=octave["text"]),s[1]]
return [OctaveMod(oct=octave["oct"], text=octave["text"]), s[1]]
def escaped_octave(self,s):
def escaped_octave(self, s):
value = s[0][1:-1]
return {"oct": int(value), "text":s[0].value}
return {"oct": int(value), "text": s[0].value}
def octave(self,s):
value = sum([1 if char=='^' else -1 for char in s[0].value])
return {"oct": value, "text":s[0].value}
def octave(self, s):
value = sum([1 if char == "^" else -1 for char in s[0].value])
return {"oct": value, "text": s[0].value}
def chord(self,s):
return Chord(pcs=s,text="".join([val.text for val in s]))
def chord(self, s):
return Chord(pcs=s, text="".join([val.text for val in s]))
def dur_change(self,s):
def dur_change(self, s):
durs = s[0]
return DurationChange(dur=durs[1], text=durs[0])
def char_change(self,s):
def char_change(self, s):
chars = ""
durs = 0.0
for (dchar,dots) in s:
for (dchar, dots) in s:
val = default_durs[dchar]
if(dots>0):
val = val * (2.0-(1.0/(2*dots)))
chars = chars + (dchar+"."*dots)
if dots > 0:
val = val * (2.0 - (1.0 / (2 * dots)))
chars = chars + (dchar + "." * dots)
durs = durs + val
return [chars,durs]
return [chars, durs]
def dchar_not_prefix(self,s):
dur = s[0].split(".",1)
def dchar_not_prefix(self, s):
dur = s[0].split(".", 1)
dots = 0
if len(dur)>1:
dots = len(dur[1])+1
return [dur[0],dots]
if len(dur) > 1:
dots = len(dur[1]) + 1
return [dur[0], dots]
def escaped_decimal(self,s):
def escaped_decimal(self, s):
val = s[0]
val["text"] = "<"+val["text"]+">"
val["text"] = "<" + val["text"] + ">"
return val
def random_pitch(self,s):
def random_pitch(self, s):
return RandomPitch(text="?")
def random_percent(self,s):
def random_percent(self, s):
return RandomPercent(text="%")
def duration_chars(self,s):
def duration_chars(self, s):
durations = [val[1] for val in s]
characters = "".join([val[0] for val in s])
return {"dur": sum(durations), "text":characters}
return {"dur": sum(durations), "text": characters}
def dotted_dur(self,s):
def dotted_dur(self, s):
key = s[0]
val = default_durs[key]
dots = len(s)-1
if(dots>0):
val = val * (2.0-(1.0/(2*dots)))
return [key+"."*dots,val]
dots = len(s) - 1
if dots > 0:
val = val * (2.0 - (1.0 / (2 * dots)))
return [key + "." * dots, val]
def decimal(self,s):
def decimal(self, s):
val = s[0]
return {"dur": float(val),"text": val.value}
return {"dur": float(val), "text": val.value}
def dot(self,s):
def dot(self, s):
return "."
def dchar(self,s):
def dchar(self, s):
chardur = s[0].value
return chardur
def WS(self,s):
def WS(self, s):
return Whitespace(text=s[0])
def subdivision(self,items):
def subdivision(self, items):
values = flatten(items[0])
return Subdivision(values=values,text="["+"".join([val.text for val in values])+"]")
return Subdivision(
values=values, text="[" + "".join([val.text for val in values]) + "]"
)
def subitems(self,s):
def subitems(self, s):
return s
# Eval rules
def eval(self,s):
def eval(self, s):
val = s[0]
return Eval(values=val)
def operation(self,s):
def operation(self, s):
return s
def atom(self,s):
def atom(self, s):
val = s[0].value
return Atom(value=val,text=val)
return Atom(value=val, text=val)
# List rules
def list(self,items):
if len(items)>1:
def list(self, items):
if len(items) > 1:
prefixes = sum_dict(items[0:-1])
values = items[-1]
seq = ListSequence(values=values,wrap_start=prefixes["text"]+"(")
seq = ListSequence(values=values, wrap_start=prefixes["text"] + "(")
seq.update_values(prefixes)
return seq
else:
seq = ListSequence(values=items[0])
return seq
def repeated_list(self,items):
if len(items)>2:
prefixes = sum_dict(items[0:-2]) # If there are prefixes
if items[-1]!=None:
seq = RepeatedListSequence(values=items[-2],repeats=items[-1],wrap_end=":"+items[-1].text+")")
def repeated_list(self, items):
if len(items) > 2:
prefixes = sum_dict(items[0:-2]) # If there are prefixes
if items[-1] != None:
seq = RepeatedListSequence(
values=items[-2],
repeats=items[-1],
wrap_end=":" + items[-1].text + ")",
)
else:
seq = RepeatedListSequence(values=items[-2],repeats=Integer(text='1', value=1))
seq = RepeatedListSequence(
values=items[-2], repeats=Integer(text="1", value=1)
)
seq.update_values(prefixes)
return seq
else:
if items[-1]!=None:
seq = RepeatedListSequence(values=items[-2],repeats=items[-1],wrap_end=":"+items[-1].text+")")
if items[-1] != None:
seq = RepeatedListSequence(
values=items[-2],
repeats=items[-1],
wrap_end=":" + items[-1].text + ")",
)
else:
seq = RepeatedListSequence(values=items[-2],repeats=Integer(text='1', value=1))
seq = RepeatedListSequence(
values=items[-2], repeats=Integer(text="1", value=1)
)
return seq
def SIGNED_NUMBER(self, s):
val = s.value
return Integer(text=val,value=int(val))
return Integer(text=val, value=int(val))
def number(self,s):
def number(self, s):
return s
def cyclic_number(self,s):
def cyclic_number(self, s):
return Cyclic(values=s)
def lisp_operation(self,s):
def lisp_operation(self, s):
op = s[0]
values = s[1:]
return Operation(operator=op,values=values,text="(+"+"".join([v.text for v in values])+")")
return Operation(
operator=op,
values=values,
text="(+" + "".join([v.text for v in values]) + ")",
)
def operator(self,s):
def operator(self, s):
val = s[0].value
return Operator(text=val)
def list_items(self,s):
def list_items(self, s):
return Sequence(values=s)
def list_op(self,s):
def list_op(self, s):
return ListOperation(values=s)
def euclid(self,s):
def euclid(self, s):
params = s[1][1:-1].split(",")
init = {"onset":s[0],"pulses":params[0],"length":params[1]}
text = s[0].text+s[1]
if len(params)>2:
init = {"onset": s[0], "pulses": params[0], "length": params[1]}
text = s[0].text + s[1]
if len(params) > 2:
init["rotate"] = params[2]
if len(s)>2:
if len(s) > 2:
init["offset"] = s[2]
text = text+s[2].text
text = text + s[2].text
init["text"] = text
return Euclid(**init)
def euclid_operator(self,s):
def euclid_operator(self, s):
return s.value
def repeat(self,s):
if s[-1]!=None:
return RepeatedSequence(values=s[0],repeats=s[-1],wrap_end=":"+s[-1].text+"]")
def repeat(self, s):
if s[-1] != None:
return RepeatedSequence(
values=s[0], repeats=s[-1], wrap_end=":" + s[-1].text + "]"
)
else:
return RepeatedSequence(values=s[0],repeats=Integer(value=1,text='1'))
return RepeatedSequence(values=s[0], repeats=Integer(value=1, text="1"))

11
ziffers/parser.py
View File

@ -6,7 +6,14 @@ from lark import Lark
grammar_path = Path(__file__).parent
grammar = grammar_path / "ziffers.lark"
ziffers_parser = Lark.open(grammar, rel_to=__file__, start='root', parser='lalr', transformer=ZiffersTransformer())
ziffers_parser = Lark.open(
grammar,
rel_to=__file__,
start="root",
parser="lalr",
transformer=ZiffersTransformer(),
)
def parse_expression(expr):
return ziffers_parser.parse(expr)
return ziffers_parser.parse(expr)

44
ziffers/scale.py
View File

@ -1495,15 +1495,7 @@ SCALES = {
"Chromatic": 111111111111,
}
note_to_interval = {
"C": 0,
"D": 2,
"E": 4,
"F": 5,
"G": 7,
"A": 9,
"B": 11
}
note_to_interval = {"C": 0, "D": 2, "E": 4, "F": 5, "G": 7, "A": 9, "B": 11}
modifiers = {
"#": 1,
@ -1511,10 +1503,11 @@ modifiers = {
"s": 1,
}
def note_to_midi(name: str) -> int:
''' Parse note name to midi '''
items = re.match(r"^([a-gA-G])([#bs])?([1-9])?$",name)
if items==None:
"""Parse note name to midi"""
items = re.match(r"^([a-gA-G])([#bs])?([1-9])?$", name)
if items == None:
return 60
values = items.groups()
octave = int(values[2]) if values[2] else 4
@ -1522,31 +1515,30 @@ def note_to_midi(name: str) -> int:
interval = note_to_interval[values[0].capitalize()]
return 12 + octave * 12 + interval + modifier
def get_scale(name: str) -> list:
"""Get a scale from the global scale list"""
scale = SCALES.get(
name.lower().capitalize(),
SCALES["Chromatic"])
scale = SCALES.get(name.lower().capitalize(), SCALES["Chromatic"])
return list(map(int, str(scale)))
def note_from_pc(
root: int | str,
pitch_class: int,
intervals: str | list[int | float],
cents: bool = False,
octave: int = 0,
modifier: int = 0) -> int:
root: int | str,
pitch_class: int,
intervals: str | list[int | float],
cents: bool = False,
octave: int = 0,
modifier: int = 0,
) -> int:
"""Resolve a pitch class into a note from a scale"""
# Initialization
root = note_to_midi(root) if isinstance(root, str) else root
intervals = get_scale(intervals) if isinstance(
intervals, str) else intervals
intervals = get_scale(intervals) if isinstance(intervals, str) else intervals
intervals = list(map(lambda x: x / 100), intervals) if cents else intervals
# Computing the result
interval_sum = sum(intervals[0:pitch_class % len(intervals)])
interval_sum = sum(intervals[0 : pitch_class % len(intervals)])
note = (root + interval_sum if pitch_class >= 0 else root - interval_sum)
return note + octave*sum(intervals) + modifier
note = root + interval_sum if pitch_class >= 0 else root - interval_sum
return note + octave * sum(intervals) + modifier