[tool.coverage.report]

skip_covered = true

exclude_lines = ["pragma: no cover", "if False:", "if __name__ == .__main__.:", "raise NotImplementedError"]

[tool.ruff.format]

quote-style = "single"

[build-system]

requires = ["hatchling"]

build-backend = "hatchling.build"

parser = argparse.ArgumentParser(add_help=False)

parser.add_argument(

"-l",

"--list-devices",

action="store_true",

help="show list of audio devices and exit",

'-l',

'--list-devices',

action='store_true',

help='show list of audio devices and exit',

)

args, remaining = parser.parse_known_args()

if args.list_devices:

formatter_class=argparse.RawDescriptionHelpFormatter,

parents=[parser],

)

parser.add_argument("filename", metavar="FILENAME", help="audio file to be played back")

parser.add_argument('filename', metavar='FILENAME', help='audio file to be played back')

parser.add_argument(

"-d", "--device", type=int_or_str, help="output device (numeric ID or substring)"

'-d', '--device', type=int_or_str, help='output device (numeric ID or substring)'

)

args = parser.parse_args(remaining)

with stream:

event.wait() # Wait until playback is finished

except KeyboardInterrupt:

parser.exit(1, "\nInterrupted by user")

parser.exit(1, '\nInterrupted by user')

except Exception as e:

parser.exit(1, type(e).__name__ + ": " + str(e))

parser.exit(1, type(e).__name__ + ': ' + str(e))

class Grid(App):

theme = "textual-light"

theme = 'textual-light'

CSS = CSS

def __init__(self, *a: Any, **ka: Any) -> None:

s.grid_size_rows = 3

if __name__ == "__main__":

if __name__ == '__main__':

Grid().run()

if tones <= 0:

return ()

if tones == 1:

return ("1",)

return ('1',)

if tones == 2:

return ("11", "2")

return ('11', '2')

def count() -> Iterator[str]:

yield from (f"1{i}" for i in count_scales(tones - 1))

yield from (f"2{i}" for i in count_scales(tones - 2))

yield from (f'1{i}' for i in count_scales(tones - 1))

yield from (f'2{i}' for i in count_scales(tones - 2))

return tuple(count())

def count_to_notes(s: str) -> str:

if len(s) < 7:

notes = "CDEFGA"[: len(s)]

notes = 'CDEFGA'[: len(s)]

else:

notes = UPPER[2 : len(s)] + "AB"

notes = UPPER[2 : len(s)] + 'AB'

def parts() -> Iterator[str]:

for char, n in zip(s, notes):

yield n

if char == "2":

yield "_"

if char == '2':

yield '_'

return "".join(parts())

return ''.join(parts())

if __name__ == "__main__":

if __name__ == '__main__':

import sys

_, *a = sys.argv

count = int(a[0]) if a else 12

for tones in range(count):

it = (count_to_notes(i) for i in count_scales(tones + 1))

print(tones + 1, *it, sep="\n ")

print(tones + 1, *it, sep='\n ')

def main():

print("Hello from tuney!")

print('Hello from tuney!')

if __name__ == "__main__":

if __name__ == '__main__':

main()

from tuney.scale import twelve_tet as tt

NOTES = ["C1", "C#3", "G♯5", "C-2", "F♭10"]

NOTES = ['C1', 'C#3', 'G♯5', 'C-2', 'F♭10']

def canonical(s: str) -> str:

return s

@pytest.mark.parametrize("note", NOTES)

@pytest.mark.parametrize('note', NOTES)

def test_twelve_tet(note):

number = tt.name_to_number(note)

name = tt.number_to_name(number)

assert tt.name_to_number(name) == number

assert note == "F♭10" or name == canonical(note)

assert note == 'F♭10' or name == canonical(note)

def test_text_timings():

tt = TextTimings(other={"!": 2000}, random_seed=23)

tt = TextTimings(other={'!': 2000}, random_seed=23)

# actual = [int(i.time) for i in tt.lines_to_times(TEXT)]

letters, begins, ends = zip(*tt(TEXT), strict=True)

text = "".join(letters)

text = ''.join(letters)

begins = [int(i) for i in begins]

ends = [int(i) for i in ends]

assert text == "One, .\nThree!"

assert text == 'One, .\nThree!'

assert (begins, ends) == (BEGINS, ENDS)

pass

if __name__ == "__main__":

if __name__ == '__main__':

main()

import sounddevice as sd

_T = TypeVar("_T", bound=sd._StreamBase)

_T = TypeVar('_T', bound=sd._StreamBase)

@dc.dataclass

class DeviceMaker(Generic[_T]):

@classmethod

def type(cls) -> type[_T]:

bases = getattr(cls, "__orig_bases__", None)

bases = getattr(cls, '__orig_bases__', None)

assert bases is not None

return get_args(bases[0])[0]

pass

if __name__ == "__main__":

if __name__ == '__main__':

print(OutputStreamMaker.type())

return success

if __name__ == "__main__":

if __name__ == '__main__':

import sys

for a in sys.argv[1:]:

print("open", a)

print('open', a)

FilePlayer(a).run()