Unify naming of all InputDevice/OutputDevice classes

.flake8

@@ -0,0 +1,3 @@
+[flake8]
+max-line-length = 120
+ignore = E265, E302, E305, F405, W292, E226, E731, W504

examples/01.ex-basics.py

@@ -47,7 +47,7 @@
 # A Timeline schedules events at a specified tempo. By default, events
 # are send to the system's default MIDI output.
 #------------------------------------------------------------------------
-output = iso.io.midi.MidiOut()
+output = iso.io.midi.MidiOutputDevice()
 timeline = iso.Timeline(120, output)
 
 #------------------------------------------------------------------------

examples/05.ex-piano-phase.py

@@ -17,7 +17,7 @@
 #------------------------------------------------------------------------
 # Melody line
 #------------------------------------------------------------------------
-seq = iso.PSequence([-7, -5, 0, 2, 3, -5, -7, 2, 0, -5, 3, 2])
+sequence = iso.PSequence([-7, -5, 0, 2, 3, -5, -7, 2, 0, -5, 3, 2])
 
 #------------------------------------------------------------------------
 # Create a timeline at 160BPM
@@ -30,16 +30,16 @@
 # by two every note... try removing the .copy() and see what happens!
 #------------------------------------------------------------------------
 timeline.schedule({
-    "note": seq.copy() + 60,
+    "note": sequence.copy() + 60,
     "duration": 0.5
 })
 timeline.schedule({
-    "note": seq.copy() + 72,
+    "note": sequence.copy() + 72,
     "duration": 0.5 * 1.01
 })
 
 #------------------------------------------------------------------------
 # Start playing via default MIDI out, and block forever.
 # Alternatively, use timeline.background() to retain foreground control.
 #------------------------------------------------------------------------
-timeline.run()
+timeline.run()

examples/10.ex-lsystem-stochastic.py

@@ -7,7 +7,7 @@
 #------------------------------------------------------------------------
 
 import isobar as iso
-from isobar.io.midi import MidiOut
+from isobar.io.midi import MidiOutputDevice
 
 import logging
 logging.basicConfig(level=logging.INFO, format="[%(asctime)s] %(message)s")

examples/20.ex-midi-input.py

@@ -5,32 +5,49 @@
 #------------------------------------------------------------------------
 
 import isobar as iso
-from isobar.io.midi import MidiIn
+from isobar.io.midi import MidiInputDevice
 
 import logging
+import time
+
 logging.basicConfig(level=logging.INFO, format="[%(asctime)s] %(message)s")
 
-midi_in = MidiIn()
+midi_in = MidiInputDevice()
+
 notes = []
+durations = []
+last_note_time = None
+
+print("Listening for notes on %s. Press Ctrl-C to stop." % midi_in.device_name)
 
 try:
     while True:
         note = midi_in.receive()
         if note is not None:
-            print("Received note: %s" % note.note)
+            print(" - Read note: %s" % note.note)
             notes.append(note)
+            if last_note_time is not None:
+                durations.append(time.time() - last_note_time)
+            last_note_time = time.time()
 
 except KeyboardInterrupt:
     pass
 
-print()
-print("----------------------------------------------------")
-print("Ctrl-C detected, now playing back")
-print("----------------------------------------------------")
-
-t = iso.Timeline(120)
-t.sched({
-    "note": iso.PSequence([ note.note for note in notes ], 1),
-    "duration": 0.5
-})
-t.run()
+if last_note_time:
+    durations.append(time.time() - last_note_time)
+
+    print()
+    print("----------------------------------------------------")
+    print("Ctrl-C detected, now playing back")
+    print("----------------------------------------------------")
+
+    timeline = iso.Timeline(60)
+    timeline.stop_when_done = True
+    timeline.schedule({
+        "note": iso.PSequence([note.note for note in notes], 1),
+        "duration": iso.PSequence(durations, 1)
+    })
+    timeline.run()
+else:
+    print()
+    print("No notes detected")

examples/21.ex-midi-clock-sync-in.py

@@ -3,16 +3,17 @@
 #------------------------------------------------------------------------
 # MIDI clock sync input example.
 # Start an external MIDI clock with this device as the clock target.
-# The MidiIn object estimates the input tempo via a moving average.
+# The MidiInputDevice object estimates the input tempo via a moving average.
 #------------------------------------------------------------------------
 
 import isobar as iso
-from isobar.io.midi import MidiIn
+from isobar.io.midi import MidiInputDevice
 
 import logging
+
 logging.basicConfig(level=logging.INFO, format="[%(asctime)s] %(message)s")
 
-midi_in = MidiIn()
+midi_in = MidiInputDevice()
 
 print("Start a MIDI clock device with %s as the clock destination" % midi_in.device_name)
 print("Awaiting clock signal...")

examples/22.ex-midi-markov-learner.py

@@ -10,16 +10,16 @@
 #------------------------------------------------------------------------
 
 import isobar as iso
-from isobar.io.midi import MidiIn, MidiOut
+from isobar.io.midi import MidiInputDevice, MidiOutputDevice
 
 import logging
 
 logging.basicConfig(level=logging.INFO, format="[%(asctime)s] %(message)s")
 
 import time
 
-midi_in = MidiIn()
-midi_out = MidiOut()
+midi_in = MidiInputDevice()
+midi_out = MidiOutputDevice()
 
 learner = iso.MarkovParallelLearners(3)
 clock0 = time.time()
@@ -56,11 +56,11 @@
 if len(pitch.nodes) == 0:
     print("No notes detected")
 else:
-    t = iso.Timeline(120, midi_out)
-    t.sched({
+    timeline = iso.Timeline(120, midi_out)
+    timeline.schedule({
         "note": pitch,
         "duration": dur,
         "amplitude": amp,
         "channel": 0
     })
-    t.run()
+    timeline.run()

examples/30.ex-midifile-read.py

@@ -7,7 +7,7 @@
 #------------------------------------------------------------------------
 
 import isobar as iso
-from isobar.io import MidiFileIn
+from isobar.io import MidiFileInputDevice
 
 import argparse
 import logging

examples/31.ex-midifile-write.py

@@ -7,15 +7,15 @@
 #------------------------------------------------------------------------
 
 import isobar as iso
-from isobar.io import MidiFileOut
+from isobar.io import MidiFileOutputDevice
 
 import logging
 logging.basicConfig(level=logging.INFO, format="[%(asctime)s] %(message)s")
 
 key = iso.Key("C", "major")
 
 filename = "output.mid"
-output = MidiFileOut(filename)
+output = MidiFileOutputDevice(filename)
 
 timeline = iso.Timeline(iso.MAX_CLOCK_RATE, output_device=output)
 timeline.sched({

examples/32.ex-midifile-markov.py

@@ -8,7 +8,7 @@
 
 import argparse
 import isobar as iso
-from isobar.io.midifile.input import MidiFileIn
+from isobar.io.midifile.input import MidiFileInputDevice
 
 import logging
 logging.basicConfig(level=logging.DEBUG, format="[%(asctime)s] %(message)s")
@@ -20,7 +20,7 @@
 #------------------------------------------------------------------------
 # Quantize durations to the nearest 1/8th note.
 #------------------------------------------------------------------------
-pattern = MidiFileIn(args.filename).read(quantize=1/8)
+pattern = MidiFileInputDevice(args.filename).read(quantize=1 / 8)
 pattern = iso.PDict(pattern)
 
 #------------------------------------------------------------------------
@@ -48,7 +48,8 @@
     "duration": dur_learner.markov,
     "amplitude": amp_learner.markov
 })
+
 try:
     timeline.run()
-except:
+except KeyboardInterrupt:
     timeline.output_device.all_notes_off()

isobar/io/__init__.py

@@ -3,15 +3,15 @@
 
 from .output import OutputDevice
 from .dummy import DummyOutputDevice
-from .midi import MidiIn, MidiOut, get_midi_output_names, get_midi_input_names
-from .midifile import MidiFileIn, MidiFileOut, PatternWriterMIDI
-from .osc import OSCOut
-from .socketio import SocketIOOut
+from .midi import MidiInputDevice, MidiOutputDevice, get_midi_output_names, get_midi_input_names
+from .midifile import MidiFileInputDevice, MidiFileOutputDevice, PatternWriterMIDI
+from .osc import OSCOutputDevice
+from .socketio import SocketIOOutputDevice
 from .signalflow import SignalflowOutputDevice
 from .midinote import MidiNote
 from .supercollider import SuperColliderOutputDevice
 
-__all__ = ["OutputDevice", "DummyOutputDevice", "MidiIn", "MidiOut"]
+__all__ = ["OutputDevice", "DummyOutputDevice", "MidiInputDevice", "MidiOutputDevice"]
 __all__ += ["get_midi_output_names", "get_midi_input_names"]
-__all__ += ["MidiFileIn", "MidiFileOut", "PatternWriterMIDI"]
-__all__ += ["OSCOut", "SocketIOOut", "SignalflowOutputDevice", "MidiNote", "SuperColliderOutputDevice"]
+__all__ += ["MidiFileInputDevice", "MidiFileOutputDevice", "PatternWriterMIDI"]
+__all__ += ["OSCOutputDevice", "SocketIOOutputDevice", "SignalflowOutputDevice", "MidiNote", "SuperColliderOutputDevice"]

isobar/io/midi/__init__.py

@@ -1,5 +1,5 @@
-from .input import MidiIn
-from .output import MidiOut
+from .input import MidiInputDevice
+from .output import MidiOutputDevice
 
 import mido
 
@@ -23,4 +23,4 @@ def get_midi_input_names():
     input_names = mido.get_input_names()
     return input_names
 
-__all__ = ["MidiIn", "MidiOut", "get_midi_input_names", "get_midi_output_names"]
+__all__ = ["MidiInputDevice", "MidiOutputDevice", "get_midi_input_names", "get_midi_output_names"]

isobar/io/midi/input.py

@@ -9,7 +9,7 @@
 
 log = logging.getLogger(__name__)
 
-class MidiIn:
+class MidiInputDevice:
     def __init__(self, device_name=None, clock_target=None, virtual=False):
         """
         Create a MIDI input device.
@@ -20,7 +20,7 @@ def __init__(self, device_name=None, clock_target=None, virtual=False):
                                The default MIDI output device name can also be specified
                                with the environmental variable ISOBAR_DEFAULT_MIDI_IN.
             clock_target:      Target to send clocking events to. To sync a specific
-                               Timeline to a MidiIn device, use
+                               Timeline to a MidiInputDevice device, use
                                `timeline.clock_source = midi_in`.
             virtual (bool):    Whether to create a "virtual" rtmidi device.
         """

isobar/io/midi/output.py

@@ -7,7 +7,7 @@
 
 log = logging.getLogger(__name__)
 
-class MidiOut (OutputDevice):
+class MidiOutputDevice (OutputDevice):
     def __init__(self, device_name=None, send_clock=False, virtual=False):
         """
         Create a MIDI output device.

isobar/io/midifile/__init__.py

@@ -1,4 +1,4 @@
-from .input import MidiFileIn
-from .output import MidiFileOut, PatternWriterMIDI
+from .input import MidiFileInputDevice
+from .output import MidiFileOutputDevice, PatternWriterMIDI
 
-__all__ = ["MidiFileIn", "MidiFileOut", "PatternWriterMIDI"]
+__all__ = ["MidiFileInputDevice", "MidiFileOutputDevice", "PatternWriterMIDI"]

isobar/io/midifile/input.py

@@ -7,7 +7,7 @@
 
 log = logging.getLogger(__name__)
 
-class MidiFileIn:
+class MidiFileInputDevice:
     """ Read events from a MIDI file.
         Requires mido. """
 

isobar/io/midifile/output.py

@@ -6,7 +6,7 @@
 
 log = logging.getLogger(__name__)
 
-class MidiFileOut (OutputDevice):
+class MidiFileOutputDevice (OutputDevice):
     """ Write events to a MIDI file.
         """
 

isobar/io/osc/__init__.py

@@ -1,3 +1,3 @@
-from .output import OSCOut
+from .output import OSCOutputDevice
 
-__all__ = ["OSCOut"]
+__all__ = ["OSCOutputDevice"]

isobar/io/osc/output.py

@@ -5,9 +5,9 @@
 except ModuleNotFoundError:
     pass
 
-class OSCOut (OutputDevice):
+class OSCOutputDevice (OutputDevice):
     """
-    OSCOut: Wraps MIDI messages in OSC.
+    OSCOutputDevice: Wraps MIDI messages in OSC.
     /note [ note, velocity, channel ]
     /control [ control, value, channel ]
     """

isobar/io/socketio/__init__.py

@@ -1,3 +1,3 @@
-from .output import SocketIOOut
+from .output import SocketIOOutputDevice
 
-__all__ = ["SocketIOOut"]
+__all__ = ["SocketIOOutputDevice"]

isobar/io/socketio/output.py

@@ -1,7 +1,7 @@
 from ..output import OutputDevice
 
-class SocketIOOut (OutputDevice):
-    """ SocketIOOut: Support for sending note on/off events via websockets.
+class SocketIOOutputDevice (OutputDevice):
+    """ SocketIOOutputDevice: Support for sending note on/off events via websockets.
     Two types of event are sent at the moment:
 
     note [ index, velocity, channel ] : The MIDI note number depressed.

isobar/io/supercollider/output.py

@@ -11,7 +11,7 @@
 
 class SuperColliderOutputDevice (OutputDevice):
     """
-    OSCOut: Wraps MIDI messages in OSC.
+    OSCOutputDevice: Wraps MIDI messages in OSC.
     /note [ note, velocity, channel ]
     /control [ control, value, channel ]
     """

isobar/pattern/core.py

@@ -364,8 +364,8 @@ def load(self, filename, quantize=None):
         Args:
             filename (str): Filename to read from (.mid)
         """
-        from isobar.io.midifile import MidiFileIn
-        reader = MidiFileIn(filename)
+        from isobar.io.midifile import MidiFileInputDevice
+        reader = MidiFileInputDevice(filename)
         self.dict = reader.read(quantize=quantize)
 
     def save(self, filename):
@@ -376,8 +376,8 @@ def save(self, filename):
             filename (str): Filename to write to (.mid)
             quantize (float): Quantization level. 1.0 = quantize to beat, 0.25 = quantize to quarter-beat, etc.
         """
-        from isobar.io.midifile import MidiFileOut
-        writer = MidiFileOut(filename)
+        from isobar.io.midifile import MidiFileOutputDevice
+        writer = MidiFileOutputDevice(filename)
         clock = isobar.DummyClock()
         timeline = isobar.Timeline(self, output_device=writer, clock_source=clock)
         timeline.schedule(self)