class RedditReader:
def __init__(self):
self.looper = Looper(wait=0.01)
self.client = HttpsSocketAsync(self.looper, 'www.reddit.com')
def request_top_post(self, subreddit, n=4):
url = '/r/{0}/top.json?sort=top&t=day&limit={1}'.format(subreddit, n)
self.client.request("GET", url, ExtensibleCallback(self.on_response))
def on_response(self, response):
if response.status == 200:
json_body = json.loads(response.read())
self.on_json(json_body)
else:
self.on_http_error(None, response)
def on_json(self, response):
for post in response['data']['children']:
data = post["data"]
print u"/r/{subreddit:<12} {ups:>4}↕{downs:<3} {title} ({url})".format(
**data)
def run(self):
self.looper.enqueue_now(self.request_top_post, "python")
self.looper.enqueue_now(self.request_top_post, "programming")
self.looper.enqueue_now(self.request_top_post, "java")
self.looper.enqueue_now(self.request_top_post, "android")
self.looper.enqueue_now(self.request_top_post, "vive")
self.looper.loop()
def on_http_error(self, url, response):
print "Error {0} at {1}".format(response.status, url)
for header in response.getheaders():
print header
self.looper.stop()
def main():
looper = Looper(16, 4)
display = CursesDisplay(looper)
arduino_input = ArduinoInput(lambda x: callback(x, looper, display))
arduino_input.choose_port()
arduino_input.start()
looper.print_record_info()
#
try:
display.run()
except KeyboardInterrupt:
pass
arduino_input.stop()
looper.stop()
def stop(self): Looper.stop(self) self.mout.close() pygame.midi.quit()
class LooperTest(unittest.TestCase):
def setUp(self):
self.looper = Looper(wait=0)
def dummy(self):
pass
def dummy2(self):
pass
def stopper(self):
self.looper.stop()
def test_empty_loop_exits(self):
self.looper.loop()
def test_stop_stops(self):
self.looper.enqueue_now(self.stopper)
self.looper.enqueue_now(self.dummy)
self.looper.enqueue_now(self.dummy)
self.looper.loop()
self.assertEquals(2, self.looper.size())
def test_enqueue_now(self):
# race condition - will fail sometimes
time = Time.now()
self.looper.enqueue_now(self.dummy)
self.assertEquals(1, self.looper.size())
self.assertEquals(time, self.looper._queue[0].time)
def test_enqueue_next(self):
self.looper.enqueue_now(self.dummy)
self.looper.enqueue_next(self.dummy2)
self.assertEquals(2, self.looper.size())
self.assertEquals(0, self.looper._queue[0].time)
self.assertEquals(self.dummy2, self.looper._queue[0].func)
def test_enqueue_with_millis(self):
# race condition - will fail sometimes
time = Time.millis_from_now(1000)
self.looper.enqueue(1000, self.dummy)
self.assertEquals(1, self.looper.size())
self.assertEquals(time, self.looper._queue[0].time)
def test_enqueue_with_datetime(self):
d = datetime(2016, 1, 1, 12, 12, 12)
self.looper.enqueue(d, self.dummy)
self.assertEquals(1, self.looper.size())
self.assertEquals(Time.on_date(d), self.looper._queue[0].time)
def test_enqueue_with_date(self):
d = date(2016, 1, 1)
self.looper.enqueue(d, self.dummy)
self.assertEquals(1, self.looper.size())
self.assertEquals(Time.on_date(d), self.looper._queue[0].time)
def test_enqueue_with_timedelta(self):
# race condition - will fail sometimes
d = timedelta(milliseconds=340)
self.looper.enqueue(d, self.dummy)
self.assertEquals(1, self.looper.size())
self.assertEquals(Time.after_timedelta(d), self.looper._queue[0].time)
def test_enqueue_at(self):
# race condition - will fail sometimes
time = Time.millis_from_now(1000)
self.looper.enqueue_at(time, self.dummy)
self.assertEquals(1, self.looper.size())
self.assertEquals(time, self.looper._queue[0].time)
def test_size(self):
self.assertEquals(0, self.looper.size())
self.looper.enqueue_now(self.stopper)
self.assertEquals(1, self.looper.size())
self.looper.enqueue_now(self.stopper)
self.assertEquals(2, self.looper.size())
self.looper.loop()
self.assertEquals(1, self.looper.size())
class App:
def __init__(self):
self.ipc = IpcServer(
) # Start IPC to webserver (server-side): mandatory but there might not be a client connecting to it
self.osc = OscServer(
) # Start app OSC server: mandatory but there might not be a client connecting to it
self.looper = Looper(
) # Start sooperlooper: optional (disable with --no-looper)
self.recorder = Recorder(
) # Init audio recorder: always on but no background activity
self.drum_sequencer = DrumSequencer(
) # Init audio/drums player: always on but no background activity
# Only start MIDI receiver thread if USBMIDI device (foot pedal) is connected
self.midi_receiver = MidiReceiver(
'USBMIDI', self) if utility.check_midi(['USBMIDI']) else None
self._handlers = {}
def quit(self):
logging.info('Exiting')
if self.looper and self.looper.is_running:
self.looper.stop()
self.ipc.stop()
sys.exit(0)
def send_event(self, event_target, event_payload):
logging.debug('Event: {} {}'.format(event_target, event_payload))
if event_target == MidiMapping.EVENT_TARGET_PRESET:
self._handlers['presets'].trigger_preset(event_payload)
elif event_target == MidiMapping.EVENT_TARGET_MIDI_LOOP:
self._handlers['midi'].toggle(event_payload)
elif event_target == MidiMapping.EVENT_TARGET_LOOPER:
self._handlers['looper'].send_osc(event_payload)
elif event_target == MidiMapping.EVENT_TARGET_DRUMS:
self._handlers['drums'].play_song()
def _parse_arguments(self):
parser = argparse.ArgumentParser()
parser.add_argument('-v',
help='verbose',
action='store_true',
default=False)
parser.add_argument('--no-looper',
help='don\'t start looper',
action='store_true',
default=False)
return parser.parse_args()
def main(self):
# Parse program arguments
self.args = self._parse_arguments()
logging.debug(self.args)
# System checks
assert utility.check_sound_card('card 0:'), 'No ALSA device found'
# assert check_sound_card('card 1:'), 'USB DAC not found'
# assert utility.check_processes(['jackd']), 'jackd must be running'
assert utility.check_midi(['System',
'Midi Through']), 'No MIDI devices found'
# assert check_midi(['USBMIDI']), 'USB foot controller not found'
Menu.ui = TkUi(fullscreen=True, fontsize=56)
self.ipc.start()
if not self.args.no_looper:
self.looper.start()
main_menu = Menu('main')
submenus = {
name: Menu(name, main_menu)
for name in [
'midi', 'presets', 'looper', 'record', 'drums', 'utilities',
'system'
]
}
# Create main menu
BaseMenuHandler.app = self
self._handlers['midi'] = MidiExpanderHandler(submenus['midi'])
self._handlers['presets'] = PresetsHandler(submenus['presets'])
self._handlers['looper'] = LooperHandler(submenus['looper'])
self._handlers['record'] = RecordHandler(submenus['record'])
self._handlers['drums'] = DrumsHandler(submenus['drums'],
self.drum_sequencer)
self._handlers['utilities'] = UtilitiesHandler(submenus['utilities'])
self._handlers['system'] = SystemHandler(submenus['system'])
self._handlers['record'].recorder = self.recorder
main_menu.make_ui()
Menu.ui.mainloop()
