Traktor/myenv/Lib/site-packages/pygame/examples/midi.py

933 lines
30 KiB
Python
Raw Permalink Normal View History

2024-05-26 05:12:46 +02:00
#!/usr/bin/env python
""" pygame.examples.midi
midi input, and a separate example of midi output.
By default it runs the output example.
python -m pygame.examples.midi --output
python -m pygame.examples.midi --input
python -m pygame.examples.midi --input
"""
from dataclasses import dataclass
import sys
import os
from typing import Any, Dict, List, Literal, Optional, Set, Tuple, Union
import pygame as pg
import pygame.midi
# black and white piano keys use b/w color values directly
BACKGROUNDCOLOR = "slategray"
def print_device_info():
pygame.midi.init()
_print_device_info()
pygame.midi.quit()
def _print_device_info():
for i in range(pygame.midi.get_count()):
r = pygame.midi.get_device_info(i)
(interf, name, input, output, opened) = r
in_out = ""
if input:
in_out = "(input)"
if output:
in_out = "(output)"
print(
"%2i: interface :%s:, name :%s:, opened :%s: %s"
% (i, interf, name, opened, in_out)
)
def input_main(device_id=None):
pg.init()
pygame.midi.init()
_print_device_info()
if device_id is None:
input_id = pygame.midi.get_default_input_id()
else:
input_id = device_id
print(f"using input_id :{input_id}:")
i = pygame.midi.Input(input_id)
pg.display.set_mode((1, 1))
going = True
while going:
events = pygame.event.get()
for e in events:
if e.type in [pg.QUIT]:
going = False
if e.type in [pg.KEYDOWN]:
going = False
if e.type in [pygame.midi.MIDIIN]:
print(e)
if i.poll():
midi_events = i.read(10)
# convert them into pygame events.
midi_evs = pygame.midi.midis2events(midi_events, i.device_id)
for m_e in midi_evs:
pygame.event.post(m_e)
del i
pygame.midi.quit()
def output_main(device_id=None):
"""Execute a musical keyboard example for the Church Organ instrument
This is a piano keyboard example, with a two octave keyboard, starting at
note F3. Left mouse down over a key starts a note, left up stops it. The
notes are also mapped to the computer keyboard keys, assuming an American
English PC keyboard (sorry everyone else, but I don't know if I can map to
absolute key position instead of value.) The white keys are on the second
row, TAB to BACKSLASH, starting with note F3. The black keys map to the top
row, '1' to BACKSPACE, starting with F#3. 'r' is middle C. Close the
window or press ESCAPE to quit the program. Key velocity (note
amplitude) varies vertically on the keyboard image, with minimum velocity
at the top of a key and maximum velocity at bottom.
Default Midi output, no device_id given, is to the default output device
for the computer.
"""
# A note to new pygamers:
#
# All the midi module stuff is in this function. It is unnecessary to
# understand how the keyboard display works to appreciate how midi
# messages are sent.
# The keyboard is drawn by a Keyboard instance. This instance maps Midi
# notes to musical keyboard keys. A regions surface maps window position
# to (Midi note, velocity) pairs. A key_mapping dictionary does the same
# for computer keyboard keys. Midi sound is controlled with direct method
# calls to a pygame.midi.Output instance.
#
# Things to consider when using pygame.midi:
#
# 1) Initialize the midi module with a to pygame.midi.init().
# 2) Create a midi.Output instance for the desired output device port.
# 3) Select instruments with set_instrument() method calls.
# 4) Play notes with note_on() and note_off() method calls.
# 5) Call pygame.midi.Quit() when finished. Though the midi module tries
# to ensure that midi is properly shut down, it is best to do it
# explicitly. A try/finally statement is the safest way to do this.
#
# GRAND_PIANO = 0
CHURCH_ORGAN = 19
instrument = CHURCH_ORGAN
# instrument = GRAND_PIANO
start_note = 53 # F3 (white key note), start_note != 0
n_notes = 24 # Two octaves (14 white keys)
key_mapping = make_key_mapping(
[
pg.K_TAB,
pg.K_1,
pg.K_q,
pg.K_2,
pg.K_w,
pg.K_3,
pg.K_e,
pg.K_r,
pg.K_5,
pg.K_t,
pg.K_6,
pg.K_y,
pg.K_u,
pg.K_8,
pg.K_i,
pg.K_9,
pg.K_o,
pg.K_0,
pg.K_p,
pg.K_LEFTBRACKET,
pg.K_EQUALS,
pg.K_RIGHTBRACKET,
pg.K_BACKSPACE,
pg.K_BACKSLASH,
],
start_note,
)
pg.init()
pygame.midi.init()
_print_device_info()
if device_id is None:
port = pygame.midi.get_default_output_id()
else:
port = device_id
print(f"using output_id :{port}:")
midi_out = pygame.midi.Output(port, 0)
try:
midi_out.set_instrument(instrument)
keyboard = Keyboard(start_note, n_notes)
screen = pg.display.set_mode(keyboard.rect.size)
screen.fill(BACKGROUNDCOLOR)
pg.display.flip()
background = pg.Surface(screen.get_size())
background.fill(BACKGROUNDCOLOR)
dirty_rects = []
keyboard.draw(screen, background, dirty_rects)
pg.display.update(dirty_rects)
regions = pg.Surface(screen.get_size()) # initial color (0,0,0)
keyboard.map_regions(regions)
pg.event.set_blocked(pg.MOUSEMOTION)
mouse_note = 0
on_notes = set()
while True:
e = pg.event.wait()
if e.type == pg.MOUSEBUTTONDOWN:
mouse_note, velocity, __, __ = regions.get_at(e.pos)
if mouse_note and mouse_note not in on_notes:
keyboard.key_down(mouse_note)
midi_out.note_on(mouse_note, velocity)
on_notes.add(mouse_note)
else:
mouse_note = 0
elif e.type == pg.MOUSEBUTTONUP:
if mouse_note:
midi_out.note_off(mouse_note)
keyboard.key_up(mouse_note)
on_notes.remove(mouse_note)
mouse_note = 0
elif e.type == pg.QUIT:
break
elif e.type == pg.KEYDOWN:
if e.key == pg.K_ESCAPE:
break
try:
note, velocity = key_mapping[e.key]
except KeyError:
pass
else:
if note not in on_notes:
keyboard.key_down(note)
midi_out.note_on(note, velocity)
on_notes.add(note)
elif e.type == pg.KEYUP:
try:
note, __ = key_mapping[e.key]
except KeyError:
pass
else:
if note in on_notes and note != mouse_note:
keyboard.key_up(note)
midi_out.note_off(note, 0)
on_notes.remove(note)
dirty_rects = []
keyboard.draw(screen, background, dirty_rects)
pg.display.update(dirty_rects)
finally:
del midi_out
pygame.midi.quit()
def make_key_mapping(keys, start_note):
"""Return a dictionary of (note, velocity) by computer keyboard key code"""
mapping = {}
for i, key in enumerate(keys):
mapping[key] = (start_note + i, 127)
return mapping
class NullKey:
"""A dummy key that ignores events passed to it by other keys
A NullKey instance is the left key instance used by default
for the left most keyboard key.
"""
def _right_white_down(self):
pass
def _right_white_up(self):
pass
def _right_black_down(self):
pass
def _right_black_up(self):
pass
null_key = NullKey()
@dataclass
class KeyData:
"""Used for passing in data to subclasses of the Key class."""
is_white_key: bool
c_width: int
c_height: int
c_down_state_initial: int
c_down_state_rect_initial: pg.Rect
c_notify_down_method: str
c_notify_up_method: str
c_updates: Set[Any]
c_event_down: Dict[int, Tuple[int, pg.Rect]]
c_event_up: Dict[int, Tuple[int, pg.Rect]]
c_image_strip: pg.Surface
c_event_right_white_down: Dict[int, Tuple[int, Union[pg.Rect, None]]]
c_event_right_white_up: Dict[int, Tuple[int, Union[pg.Rect, None]]]
c_event_right_black_down: Dict[int, Tuple[int, Union[pg.Rect, None]]]
c_event_right_black_up: Dict[int, Tuple[int, Union[pg.Rect, None]]]
class Key:
"""A key widget, maintains key state and draws the key's image
Constructor arguments:
ident - A unique key identifier. Any immutable type suitable as a key.
posn - The location of the key on the display surface.
key_left - Optional, the adjacent white key to the left. Changes in
up and down state are propagated to that key.
A key has an associated position and state. Related to state is the
image drawn. State changes are managed with method calls, one method
per event type. The up and down event methods are public. Other
internal methods are for passing on state changes to the key_left
key instance.
"""
key_data: KeyData
def __init__(self, ident, posn, key_left=None):
"""Return a new Key instance
The initial state is up, with all adjacent keys to the right also
up.
"""
if key_left is None:
key_left = null_key
rect = pg.Rect(posn[0], posn[1], self.key_data.c_width, self.key_data.c_height)
self.rect = rect
self._state = self.key_data.c_down_state_initial
self._source_rect = self.key_data.c_down_state_rect_initial
self._ident = ident
self._hash = hash(ident)
self._notify_down = getattr(key_left, self.key_data.c_notify_down_method)
self._notify_up = getattr(key_left, self.key_data.c_notify_up_method)
self._key_left = key_left
self._background_rect = pg.Rect(
rect.left, rect.bottom - 10, self.key_data.c_width, 10
)
self.key_data.c_updates.add(self)
self.is_white = self.key_data.is_white_key
def down(self):
"""Signal that this key has been depressed (is down)"""
self._state, source_rect = self.key_data.c_event_down[self._state]
if source_rect is not None:
self._source_rect = source_rect
self.key_data.c_updates.add(self)
self._notify_down()
def up(self):
"""Signal that this key has been released (is up)"""
self._state, source_rect = self.key_data.c_event_up[self._state]
if source_rect is not None:
self._source_rect = source_rect
self.key_data.c_updates.add(self)
self._notify_up()
def _right_white_down(self):
"""Signal that the adjacent white key has been depressed
This method is for internal propagation of events between
key instances.
"""
self._state, source_rect = self.key_data.c_event_right_white_down[self._state]
if source_rect is not None:
self._source_rect = source_rect
self.key_data.c_updates.add(self)
def _right_white_up(self):
"""Signal that the adjacent white key has been released
This method is for internal propagation of events between
key instances.
"""
self._state, source_rect = self.key_data.c_event_right_white_up[self._state]
if source_rect is not None:
self._source_rect = source_rect
self.key_data.c_updates.add(self)
def _right_black_down(self):
"""Signal that the adjacent black key has been depressed
This method is for internal propagation of events between
key instances.
"""
self._state, source_rect = self.key_data.c_event_right_black_down[self._state]
if source_rect is not None:
self._source_rect = source_rect
self.key_data.c_updates.add(self)
def _right_black_up(self):
"""Signal that the adjacent black key has been released
This method is for internal propagation of events between
key instances.
"""
self._state, source_rect = self.key_data.c_event_right_black_up[self._state]
if source_rect is not None:
self._source_rect = source_rect
self.key_data.c_updates.add(self)
def __eq__(self, other):
"""True if same identifiers"""
return self._ident == other._ident
def __hash__(self):
"""Return the immutable hash value"""
return self._hash
def __str__(self):
"""Return the key's identifier and position as a string"""
return "<Key %s at (%d, %d)>" % (self._ident, self.rect.top, self.rect.left)
def draw(self, surf, background, dirty_rects):
"""Redraw the key on the surface surf
The background is redrawn. The altered region is added to the
dirty_rects list.
"""
surf.blit(background, self._background_rect, self._background_rect)
surf.blit(self.key_data.c_image_strip, self.rect, self._source_rect)
dirty_rects.append(self.rect)
def key_class(updates, image_strip, image_rects: List[pg.Rect], is_white_key=True):
"""Return a keyboard key widget class
Arguments:
updates - a set into which a key instance adds itself if it needs
redrawing.
image_strip - The surface containing the images of all key states.
image_rects - A list of Rects giving the regions within image_strip that
are relevant to this key class.
is_white_key (default True) - Set false if this is a black key.
This function automates the creation of a key widget class for the
three basic key types. A key has two basic states, up or down (
depressed). Corresponding up and down images are drawn for each
of these two states. But to give the illusion of depth, a key
may have shadows cast upon it by the adjacent keys to its right.
These shadows change depending on the up/down state of the key and
its neighbors. So a key may support multiple images and states
depending on the shadows. A key type is determined by the length
of image_rects and the value of is_white.
"""
# Naming convention: Variables used by the Key class as part of a
# closure start with 'c_'.
# State logic and shadows:
#
# A key may cast a shadow upon the key to its left. A black key casts a
# shadow on an adjacent white key. The shadow changes depending of whether
# the black or white key is depressed. A white key casts a shadow on the
# white key to its left if it is up and the left key is down. Therefore
# a keys state, and image it will draw, is determined entirely by its
# itself and the key immediately adjacent to it on the right. A white key
# is always assumed to have an adjacent white key.
#
# There can be up to eight key states, representing all permutations
# of the three fundamental states of self up/down, adjacent white
# right up/down, adjacent black up/down.
#
down_state_none = 0
down_state_self = 1
down_state_white = down_state_self << 1
down_state_self_white = down_state_self | down_state_white
down_state_black = down_state_white << 1
down_state_self_black = down_state_self | down_state_black
down_state_white_black = down_state_white | down_state_black
down_state_all = down_state_self | down_state_white_black
# Some values used in the class.
#
c_down_state_initial = down_state_none
c_down_state_rect_initial = image_rects[0]
c_updates = updates
c_image_strip = image_strip
c_width, c_height = image_rects[0].size
# A key propagates its up/down state change to the adjacent white key on
# the left by calling the adjacent key's _right_black_down or
# _right_white_down method.
#
if is_white_key:
key_color = "white"
else:
key_color = "black"
c_notify_down_method = f"_right_{key_color}_down"
c_notify_up_method = f"_right_{key_color}_up"
# Images:
#
# A black key only needs two images, for the up and down states. Its
# appearance is unaffected by the adjacent keys to its right, which cast no
# shadows upon it.
#
# A white key with a no adjacent black to its right only needs three
# images, for self up, self down, and both self and adjacent white down.
#
# A white key with both a black and white key to its right needs six
# images: self up, self up and adjacent black down, self down, self and
# adjacent white down, self and adjacent black down, and all three down.
#
# Each 'c_event' dictionary maps the current key state to a new key state,
# along with corresponding image, for the related event. If no redrawing
# is required for the state change then the image rect is simply None.
#
c_event_down: Dict[int, Tuple[int, pygame.Rect]] = {
down_state_none: (down_state_self, image_rects[1])
}
c_event_up: Dict[int, Tuple[int, pygame.Rect]] = {
down_state_self: (down_state_none, image_rects[0])
}
c_event_right_white_down: Dict[int, Tuple[int, Union[pygame.Rect, None]]] = {
down_state_none: (down_state_none, None),
down_state_self: (down_state_self, None),
}
c_event_right_white_up = c_event_right_white_down.copy()
c_event_right_black_down = c_event_right_white_down.copy()
c_event_right_black_up = c_event_right_white_down.copy()
if len(image_rects) > 2:
c_event_down[down_state_white] = (down_state_self_white, image_rects[2])
c_event_up[down_state_self_white] = (down_state_white, image_rects[0])
c_event_right_white_down[down_state_none] = (down_state_white, None)
c_event_right_white_down[down_state_self] = (
down_state_self_white,
image_rects[2],
)
c_event_right_white_up[down_state_white] = (down_state_none, None)
c_event_right_white_up[down_state_self_white] = (
down_state_self,
image_rects[1],
)
c_event_right_black_down[down_state_white] = (down_state_white, None)
c_event_right_black_down[down_state_self_white] = (down_state_self_white, None)
c_event_right_black_up[down_state_white] = (down_state_white, None)
c_event_right_black_up[down_state_self_white] = (down_state_self_white, None)
if len(image_rects) > 3:
c_event_down[down_state_black] = (down_state_self_black, image_rects[4])
c_event_down[down_state_white_black] = (down_state_all, image_rects[5])
c_event_up[down_state_self_black] = (down_state_black, image_rects[3])
c_event_up[down_state_all] = (down_state_white_black, image_rects[3])
c_event_right_white_down[down_state_black] = (down_state_white_black, None)
c_event_right_white_down[down_state_self_black] = (
down_state_all,
image_rects[5],
)
c_event_right_white_up[down_state_white_black] = (down_state_black, None)
c_event_right_white_up[down_state_all] = (down_state_self_black, image_rects[4])
c_event_right_black_down[down_state_none] = (down_state_black, image_rects[3])
c_event_right_black_down[down_state_self] = (
down_state_self_black,
image_rects[4],
)
c_event_right_black_down[down_state_white] = (
down_state_white_black,
image_rects[3],
)
c_event_right_black_down[down_state_self_white] = (
down_state_all,
image_rects[5],
)
c_event_right_black_up[down_state_black] = (down_state_none, image_rects[0])
c_event_right_black_up[down_state_self_black] = (
down_state_self,
image_rects[1],
)
c_event_right_black_up[down_state_white_black] = (
down_state_white,
image_rects[0],
)
c_event_right_black_up[down_state_all] = (down_state_self_white, image_rects[2])
class OurKey(Key):
key_data = KeyData(
is_white_key,
c_width,
c_height,
c_down_state_initial,
c_down_state_rect_initial,
c_notify_down_method,
c_notify_up_method,
c_updates,
c_event_down,
c_event_up,
c_image_strip,
c_event_right_white_down,
c_event_right_white_up,
c_event_right_black_down,
c_event_right_black_up,
)
return OurKey
def key_images() -> Tuple[pg.Surface, Dict[str, pg.Rect]]:
"""Return a keyboard keys image strip and a mapping of image locations
The return tuple is a pygame.Surface and a dictionary keyed by key name and valued by a pygame.Rect.
This function encapsulates the constants relevant to the keyboard image
file. There are five key types. One is the black key. The other four
white keys are determined by the proximity of the black keys. The plain
white key has no black key adjacent to it. A white-left and white-right
key has a black key to the left or right of it respectively. A white-center
key has a black key on both sides. A key may have up to six related
images depending on the state of adjacent keys to its right.
"""
my_dir = os.path.split(os.path.abspath(__file__))[0]
strip_file = os.path.join(my_dir, "data", "midikeys.png")
white_key_width = 42
white_key_height = 160
black_key_width = 22
black_key_height = 94
strip = pg.image.load(strip_file)
names = [
"black none",
"black self",
"white none",
"white self",
"white self-white",
"white-left none",
"white-left self",
"white-left black",
"white-left self-black",
"white-left self-white",
"white-left all",
"white-center none",
"white-center self",
"white-center black",
"white-center self-black",
"white-center self-white",
"white-center all",
"white-right none",
"white-right self",
"white-right self-white",
]
rects = {}
for i in range(2):
rects[names[i]] = pg.Rect(
i * white_key_width, 0, black_key_width, black_key_height
)
for i in range(2, len(names)):
rects[names[i]] = pg.Rect(
i * white_key_width, 0, white_key_width, white_key_height
)
return strip, rects
class Keyboard:
"""Musical keyboard widget
Constructor arguments:
start_note: midi note value of the starting note on the keyboard.
n_notes: number of notes (keys) on the keyboard.
A Keyboard instance draws the musical keyboard and maintains the state of
all the keyboard keys. Individual keys can be in a down (depressed) or
up (released) state.
"""
_image_strip, _rects = key_images()
white_key_width, white_key_height = _rects["white none"].size
black_key_width, black_key_height = _rects["black none"].size
_updates: Set[Any] = set()
# There are five key classes, representing key shape:
# black key (BlackKey), plain white key (WhiteKey), white key to the left
# of a black key (WhiteKeyLeft), white key between two black keys
# (WhiteKeyCenter), and white key to the right of a black key
# (WhiteKeyRight).
BlackKey = key_class(
_updates, _image_strip, [_rects["black none"], _rects["black self"]], False
)
WhiteKey = key_class(
_updates,
_image_strip,
[_rects["white none"], _rects["white self"], _rects["white self-white"]],
)
WhiteKeyLeft = key_class(
_updates,
_image_strip,
[
_rects["white-left none"],
_rects["white-left self"],
_rects["white-left self-white"],
_rects["white-left black"],
_rects["white-left self-black"],
_rects["white-left all"],
],
)
WhiteKeyCenter = key_class(
_updates,
_image_strip,
[
_rects["white-center none"],
_rects["white-center self"],
_rects["white-center self-white"],
_rects["white-center black"],
_rects["white-center self-black"],
_rects["white-center all"],
],
)
WhiteKeyRight = key_class(
_updates,
_image_strip,
[
_rects["white-right none"],
_rects["white-right self"],
_rects["white-right self-white"],
],
)
def __init__(self, start_note: int, n_notes: int):
"""Return a new Keyboard instance with n_note keys"""
self._start_note = start_note
self._end_note = start_note + n_notes - 1
self._add_keys()
def _add_keys(self) -> None:
"""Populate the keyboard with key instances
Set the _keys and rect attributes.
"""
# Keys are entered in a list, where index is Midi note. Since there are
# only 128 possible Midi notes the list length is manageable. Unassigned
# note positions should never be accessed, so are set None to ensure
# the bug is quickly detected.
#
key_map: list[Key | Literal[None]] = [None] * 128
start_note = self._start_note
end_note = self._end_note
black_offset = self.black_key_width // 2
prev_white_key = None
x = y = 0
if is_white_key(start_note):
is_prev_white = True
else:
x += black_offset
is_prev_white = False
for note in range(start_note, end_note + 1):
ident = note # For now notes uniquely identify keyboard keys.
if is_white_key(note):
if is_prev_white:
if note == end_note or is_white_key(note + 1):
key = self.WhiteKey(ident, (x, y), prev_white_key)
else:
key = self.WhiteKeyLeft(ident, (x, y), prev_white_key)
else:
if note == end_note or is_white_key(note + 1):
key = self.WhiteKeyRight(ident, (x, y), prev_white_key)
else:
key = self.WhiteKeyCenter(ident, (x, y), prev_white_key)
is_prev_white = True
x += self.white_key_width
prev_white_key = key
else:
key = self.BlackKey(ident, (x - black_offset, y), prev_white_key)
is_prev_white = False
key_map[note] = key
self._keys = key_map
the_key = key_map[self._end_note]
if the_key is None:
kb_width = 0
else:
kb_width = the_key.rect.right
kb_height = self.white_key_height
self.rect = pg.Rect(0, 0, kb_width, kb_height)
def map_regions(self, regions):
"""Draw the key regions onto surface regions.
Regions must have at least 3 byte pixels. Each pixel of the keyboard
rectangle is set to the color (note, velocity, 0). The regions surface
must be at least as large as (0, 0, self.rect.left, self.rect.bottom)
"""
# First draw the white key regions. Then add the overlapping
# black key regions.
#
cutoff = self.black_key_height
black_keys = []
for note in range(self._start_note, self._end_note + 1):
key = self._keys[note]
if key is not None and key.is_white:
fill_region(regions, note, key.rect, cutoff)
else:
black_keys.append((note, key))
for note, key in black_keys:
if key is not None:
fill_region(regions, note, key.rect, cutoff)
def draw(self, surf, background, dirty_rects):
"""Redraw all altered keyboard keys"""
changed_keys = self._updates
while changed_keys:
changed_keys.pop().draw(surf, background, dirty_rects)
def key_down(self, note):
"""Signal a key down event for note"""
key = self._keys[note]
if key is not None:
key.down()
def key_up(self, note):
"""Signal a key up event for note"""
key = self._keys[note]
if key is not None:
key.up()
def fill_region(regions, note, rect, cutoff):
"""Fill the region defined by rect with a (note, velocity, 0) color
The velocity varies from a small value at the top of the region to
127 at the bottom. The vertical region 0 to cutoff is split into
three parts, with velocities 42, 84 and 127. Everything below cutoff
has velocity 127.
"""
x, y, width, height = rect
if cutoff is None:
cutoff = height
delta_height = cutoff // 3
regions.fill((note, 42, 0), (x, y, width, delta_height))
regions.fill((note, 84, 0), (x, y + delta_height, width, delta_height))
regions.fill(
(note, 127, 0), (x, y + 2 * delta_height, width, height - 2 * delta_height)
)
def is_white_key(note):
"""True if note is represented by a white key"""
key_pattern = [
True,
False,
True,
True,
False,
True,
False,
True,
True,
False,
True,
False,
]
return key_pattern[(note - 21) % len(key_pattern)]
def usage():
print("--input [device_id] : Midi message logger")
print("--output [device_id] : Midi piano keyboard")
print("--list : list available midi devices")
def main(mode="output", device_id=None):
"""Run a Midi example
Arguments:
mode - if 'output' run a midi keyboard output example
'input' run a midi event logger input example
'list' list available midi devices
(default 'output')
device_id - midi device number; if None then use the default midi input or
output device for the system
"""
if mode == "input":
input_main(device_id)
elif mode == "output":
output_main(device_id)
elif mode == "list":
print_device_info()
else:
raise ValueError(f"Unknown mode option '{mode}'")
if __name__ == "__main__":
device_id: Optional[int] = None
try:
device_id = int(sys.argv[-1])
except ValueError:
device_id = None
if "--input" in sys.argv or "-i" in sys.argv:
input_main(device_id)
elif "--output" in sys.argv or "-o" in sys.argv:
output_main(device_id)
elif "--list" in sys.argv or "-l" in sys.argv:
print_device_info()
else:
usage()
pg.quit()