iipyper, example structure

Author: victor-shepardson

environment.yml

@@ -16,4 +16,5 @@ dependencies:
   - pip
   - pip:
     - mido
+    - python-rtmidi
     - python-osc

examples/iipyper/iipyper-test.scd

@@ -0,0 +1,56 @@
+(
+MIDIIn.connectAll;
+b = NetAddr.new("127.0.0.1", 9999);
+Server.default.options.inDevice_("Built-in Microph");
+Server.default.options.outDevice_("Built-in Output");
+// Server.default.options.inDevice_("mic-buds");
+// Server.default.options.outDevice_("mic-buds");
+// s.boot;
+)
+
+thisProcess.openUDPPort(57121);
+
+
+(
+// MIDI from controller
+MIDIdef.noteOn(\input, {
+    arg val, num, chan, src;
+    t = Process.elapsedTime;
+    [\input, num, val, chan, src].postln;
+    b.sendMsg("/test", num, val);
+    b.sendMsg("/keyword_example", \arg1, num, \arg2, val);
+    b.sendMsg("/math/add", num, val);
+    b.sendMsg("/math/mul", num, val);
+});
+
+// OSC return from python
+OSCdef(\return, {
+    arg msg, time, addr, recvPort;
+    [\return, Process.elapsedTime-t, msg].postln;
+
+}, "/test", nil);
+
+OSCdef.newMatching(\add, {
+    arg msg, time, addr, recvPort;
+    [\add, Process.elapsedTime-t, msg].postln;
+}, "/math/add", nil);
+
+OSCdef.newMatching(\mul, {
+    arg msg, time, addr, recvPort;
+    [\mul, Process.elapsedTime-t, msg].postln;
+}, "/math/mul", nil);
+
+OSCdef(\default_send_test, {
+    arg msg, time, addr, recvPort;
+    [\default_send_test, msg].postln;
+}, "/default_send_test", nil);
+
+OSCdef(\other_send_test, {
+    arg msg, time, addr, recvPort;
+    [\other_send_test, msg].postln;
+}, "/other_send_test", nil);
+)
+
+OSCFunc.trace(false)
+
+// nil.postln

examples/iipyper/iipyper-tutorial.py

@@ -0,0 +1,95 @@
+from iipyper import OSC, MIDI, repeat, run
+
+def main(osc_host='127.0.0.1', osc_port=9999, loop_time=1, loop_msg='hello'):
+    # loop API:
+    # use the @repeat decorator to define functions which run every n seconds
+    @repeat(loop_time)
+    def _():
+        print(f'looping every {loop_time} sec: "{loop_msg}"')
+
+    @repeat(1.5)
+    def _():
+        print('looping every 1.5 sec')
+
+    # midi = MIDI()
+    # # MIDI API:
+    # # midi.note_on, midi.cc, etc
+
+    # # use as a decorator to make a midi handler
+    # @midi.handle.note_on
+    # def _(pitch, velocity, channel):
+    #     print(pitch, velocity, channel)
+
+    # # above is kind of an abuse of python syntax, could do this instead:
+    # # (which would allow filtering on port, even note)
+    # @midi.handle.note_on(pitch=range(1,128), channel=0, port='')
+    # def _(pitch, velocity, channel):
+    #     print(pitch, velocity, channel)
+
+    # use as a function to send MIDI
+
+    # @repeat(1)
+    # def step():
+    #     midi.note_on(pitch=60, velocity=100, channel=0)
+    #     midi.cc(number=0, value=127, channel=1)
+
+
+    # make an OSC object
+    osc = OSC(osc_host, osc_port)
+    # # OSC API:
+    # # osc.args, osc.kwargs
+
+    # # use as a decorator to make an osc handler
+
+    # # positional arguments
+    # # osc route is taken from function name
+    @osc.args
+    def test(address, x, y): # route is /test
+        print(address, x, y)
+        # if a value (besides None) is returned,
+        # it will be sent back as an OSC message to the sender
+        # with the route given as the first element:
+        return '/test', x-y, x+y
+
+    # named arguments as key, value pairs in OSC
+    # e.g. an OSC message ["/keyword_example", "arg2", 3]
+    # would print "/keyword_example 0 3 99"
+    @osc.kwargs
+    def keyword_example(address, arg1=0, arg2=1, arg3=99):
+        print(address, arg1, arg2, arg3)
+        # no return value: does not send OSC back
+
+    # can also give the route explictly to the decorator,
+    # supporting wildcards
+    @osc.args('/math/*')
+    def _(address, a, b):
+        print(address, a, b)
+        op = address.split('/')[-1]
+        if op=='add':
+            return address, a + b
+        if op=='mul':
+            return address, a * b
+
+    # OSC clients can be created explcitly and given names:
+    osc.create_client('supercollider', port=57120) # uses same host as server
+    # but clients will also be created automatically when possible
+
+    # # to send osc:
+    osc.send('/default_send_test', 0) # send to default (first created) client
+
+    # # send with client in the route:
+    osc.send('127.0.0.1:57120/other_send_test', 1) 
+
+    # # send to named client:
+    osc.create_client('supercollider2', port=57121)
+    osc.send('/other_send_test', 2, client='supercollider2')
+    # # alternate send syntax:
+    osc('supercollider2', '/other_send_test', 3)
+
+# it may be possible to have async/threaded option for both OSC and MIDI?
+# MIDI is threaded and OSC is async
+# but MIDI could be enqueued and handled in the loop,
+# OSC could launch the threading server?
+
+if __name__=='__main__':
+    run(main)

clients/midi-duet.scd examples/notepredictor/midi-duet.scdclients/midi-duet.scd renamed to examples/notepredictor/midi-duet.scd

@@ -1,12 +1,15 @@
 (
+~gui = false;
 MIDIIn.connectAll;
 b = NetAddr.new("127.0.0.1", 9999);
-// Server.default.options.inDevice_("Built-in Microph");
-// Server.default.options.outDevice_("Built-in Output");
-Server.default.options.inDevice_("mic-buds");
-Server.default.options.outDevice_("mic-buds");
+Server.default.options.inDevice_("Built-in Microph");
+Server.default.options.outDevice_("Built-in Output");
+// Server.default.options.inDevice_("mic-buds");
+// Server.default.options.outDevice_("mic-buds");
 s.boot;
-k = MIDIKeyboard.new(bounds: Rect(0, 0, 500, 100), octaves:11, startnote:0)
+~gui.if{
+    k = MIDIKeyboard.new(bounds: Rect(0, 0, 500, 100), octaves:11, startnote:0)
+};
 )
 
 (
@@ -42,7 +45,7 @@ b.sendMsg("/predictor/reset");
 MIDIdef.noteOn(\input, {
     arg val, num, chan, src;
     var t2 = Process.elapsedTime;
-    var dt = t2-t; //time since last note
+    var dt = t2-(t?t2); //time since last note
 
     // cancel any pending predictions
     SystemClock.clear;
@@ -87,15 +90,18 @@ OSCdef(\return, {
                 b.sendMsg("/predictor/reset");
                 //release the last note
                 y.release(1.0);
+                // unset time so next note will have dt=0
+                t = nil;
                 \reset.postln
             }{
-                // cancel any pending predictions (there shouldn't be any, but might
+                // cancel any pending predictions
+                // (there shouldn't be any, but might
                 // be if there was a lot of fast MIDI input)
                 SystemClock.clear;
                 // feed model its own prediction as input
                 b.sendMsg("/predictor/predict", num, dt);
                 // release the previous note
-                (dt<1e-2).if{
+                (dt<3e-2).if{
                     // if the time delay is very small, slowly release to play a chord
                     y.release(1.0)
                 }{
@@ -109,8 +115,10 @@ OSCdef(\return, {
                 // mark the time of current note
                 t = Process.elapsedTime;
                 // crudely draw note on piano GUI
-                AppClock.sched(0,{k.keyDown(num)});
-                AppClock.sched(0.2,{k.keyUp(num)});
+                ~gui.if{
+                    AppClock.sched(0,{k.keyDown(num)});
+                    AppClock.sched(0.2,{k.keyUp(num)});
+                }
             }
     })};
 

examples/notepredictor/server.py

@@ -0,0 +1,103 @@
+"""
+Authors:
+  Victor Shepardson
+  Jack Armitage
+  Intelligent Instruments Lab 2022
+"""
+# TODO: convert to iipyper
+
+# import asyncio
+# import fire
+from notepredictor import NotePredictor
+# from osc import OSC
+
+from iipyper import OSC, run
+
+# def predictor_handler(address, *args):
+#     """
+#     Handle OSC messages to Predictor
+#     """
+#     address = address.split("/")
+
+#     if(address[2] == "load"):
+#         print(f"/load {args}")
+#         global predictor
+#         predictor = NotePredictor.from_checkpoint(*args)
+#         predictor.eval()
+
+#     elif(address[2] == "predict"):
+#         print(f"/predict {args}")
+#         r = predictor.predict(*args)
+#         msg = (r['pitch'], r['time'])
+#         # print(msg)
+#         osc.send_message('/prediction', msg)
+
+#     elif(address[2] == "reset"):
+#         print(f"/reset {args}")
+#         predictor.reset(*args)
+        
+#     else:
+#         print(f"PitchPredictor: Unrecognised OSC {address} with {args}")
+
+# async def loop():
+#     """
+#     Separate async loop.
+#     """
+#     i = 0
+#     while True:
+#         i += 1
+#         # osc.send_message("/hello", i)
+#         await asyncio.sleep(1)
+
+# async def init_main():
+#     await osc.create_server(asyncio.get_event_loop())
+#     osc.add_handler("/predictor/*", predictor_handler)
+#     osc.create_client()
+    
+#     await loop()
+    
+#     osc.close_server()
+
+# def main(ip="127.0.0.1", send=57120, receive=9999, checkpoint=None):
+def main(host="127.0.0.1", port=9999, checkpoint=None):
+    # global osc, predictor
+
+    # osc = OSC(ip, send, receive)
+    osc = OSC(host, port)
+
+    predictor = None
+    if checkpoint is not None:
+        predictor = NotePredictor.from_checkpoint(checkpoint)
+        predictor.eval()
+
+    # asyncio.run(init_main())
+
+    @osc.args('/predictor/*')
+    def predictor_handler(address, *args):
+        """
+        Handle OSC messages to Predictor
+        """
+        address = address.split("/")
+        cmd = address[2]
+
+        if cmd=="load":
+            print(f"/load {args}")
+            # global predictor
+            predictor = NotePredictor.from_checkpoint(*args)
+            predictor.eval()
+
+        elif cmd=="predict":
+            print(f"/predict {args}")
+            r = predictor.predict(*args)
+            return '/prediction', r['pitch'], r['time']
+
+        elif cmd=="reset":
+            print(f"/reset {args}")
+            predictor.reset(*args)
+            
+        else:
+            print(f"PitchPredictor: Unrecognised OSC {address} with {args}")
+
+if __name__=='__main__':
+    # fire.Fire(main)
+    run(main)

iipyper/iipyper/__init__.py

@@ -0,0 +1,44 @@
+import asyncio
+
+import fire
+
+from .midi import *
+from .osc import *
+
+_loop_fns = []
+# decorator to make a function loop
+def repeat(time):
+    # close the decorator over time argument
+    def decorator(f):
+        # define the coroutine
+        async def g():
+            # call `f` every `time` seconds
+            while True:
+                f()
+                await asyncio.sleep(time)
+        # track the coroutine in a global list
+        _loop_fns.append(g)
+
+    return decorator
+
+async def _run_async():
+    # start OSC server
+    for osc in OSC.instances:
+        await osc.create_server(asyncio.get_event_loop())
+        # osc.create_client()
+    
+    # start loop tasks
+    if len(_loop_fns):
+        for f in _loop_fns:
+            asyncio.create_task(f())
+    # else:
+    while True:
+        await asyncio.sleep(1)
+
+    # clean up
+    # for osc in OSC.instances:
+    #     osc.close_server()
+
+def run(main):
+    fire.Fire(main)
+    asyncio.run(_run_async())