aync await, callstack behavior change, pop by-label

Author: flipcoder

README.md

@@ -527,7 +527,8 @@ Here are the marker/repeat commands:
 - :N| goes back to last marker N number of times
 - :name*N| goes back to last marker 'name' N number of times
 - || return/pop to last position after marker jump
-- ||| end the song here
+- ||| return/pop to last position after marker jump by-label
+- |||| end the song here
 ``` 
 
 ## Command line parameters (use -):

test/markers.txbt

@@ -1,9 +1,5 @@
 ; marker test
 ; should play  1 2 1 2 3 4 4 5 6 6 6 7 1' (1') 2' 2' 2'
-;:|
-;|:
-;:|:
-;|||
 1
 2
 :|
@@ -15,12 +11,12 @@
 :|x:
 2'
 :x*2|
-|||
+||||
 |a:
 4
 ||
 |next:
 6
 :2|
 7
-||
+|||

textbeat/__main__.py

@@ -50,6 +50,7 @@
 from __future__ import absolute_import, unicode_literals, print_function, generators
 # try:
 from .defs import *
+import asyncio
 # except:
 #     from .defs import *
 def main():
@@ -288,7 +289,7 @@ def main():
         # log(FG.BLUE + 'New? Type help and press enter to start the tutorial.')
         log('')
 
-    player.run()
+    asyncio.run(player.run())
 
     if player.midifile:
         player.midifile.save(midifn)

textbeat/player.py

@@ -1,28 +1,36 @@
 from .defs import *
 
+from collections import deque
+from prompt_toolkit import PromptSession
+
+STACK_SIZE = 64
+
 class StackFrame(object):
     """
     Stack frames are items on the Player's call stack.
     Similar to function calls, the Player uses a stack to track markers/repeats.
     """
-    def __init__(self, row, caller, count):
+    def __init__(self, name, row, caller, count):
+        self.name = name
         self.row = row
         self.caller = caller
         self.count = count # repeat call counter
         self.markers = {} # marker name -> line
         self.returns = {} # repeat row -> number of rpts left
         # self.returns[row] = 0
+    def __str__(self):
+        return 'StackFrame' + str((self.name, self.row, self.caller, self.count, self.markers, self.returns))
 
 class Player(object):
     """
     The Player is what parses the txbt format and plays it.
-    This is the most "quick and dirty" part of textbeat, so it will probably
+    Beware! This is the most "quick and dirty" part of textbeat, so it will probably
     be rewritten eventually.
     """
 
     class Flag:
         """
-        Bitflags for Roman numeral notation, transposition, and looping
+        Bitflag options for Roman numeral notation, transposition, and looping
         """
         ROMAN = bit(0) # use roman numeral notation
         TRANSPOSE = bit(1) # allow transposition of note letters
@@ -68,10 +76,12 @@ def __init__(self):
         self.ring = False # ring: disables midi muting on program exit, letting notes ring out
         self.buf = []
         self.markers = {} # markers are for doing jumps and repeats
-        f = StackFrame(-1,-1,0)
+        f = StackFrame('',-1,-1,0)
         f.returns[''] = 0
         self.tutorial = None # Tutorial object to run (should be run inside shell, see -T)
-        self.callstack = [f] # callstack for moving around the file using markers/repeats
+        # self.callstack = [f] # callstack for moving around the file using markers/repeats
+        self.callstack = deque(maxlen=STACK_SIZE) # callstack for moving around the file using markers/repeats
+        self.callstack.append(f)
         # self.separators = [] # separators are currently not supported
         self.track_history = ['.'] * NUM_TRACKS # keep track of track history for replaying with " symbol
         self.fn = None # filename
@@ -182,7 +192,7 @@ def refresh_devices(self):
                 pass
         self.auto = 'auto' in self.devices
 
-    def set_host(self, plugins):
+    def set_plugins(self, plugins):
         self.plugins = plugins
         self.refresh_devices()
 
@@ -251,14 +261,16 @@ def write_midi_tempo(self):
                 'set_tempo', tempo=mido.bpm2tempo(self.tempo)
             ))
 
-    def run(self):
+    async def run(self):
         for ch in self.tracks:
             ch.refresh()
 
         self.header = True
         embedded_file = False
 
         self.write_midi_tempo()
+
+        prompt_session = PromptSession(history=HISTORY, vi_mode=self.vimode)
 
         while not self.quitflag:
             self.follow()
@@ -320,7 +332,7 @@ def run(self):
                                 # if bufline.endswith('.txbt'):
                                     # play file?
                                 # bufline = raw_input(cline)
-                                bufline = prompt(cline, history=HISTORY, vi_mode=self.vimode)
+                                bufline = await prompt_session.prompt_async(cline)
                                 bufline = list(filter(None, bufline.split(' ')))
                                 bufline = list(map(lambda b: b.replace(';',' '), bufline))
                             # elif self.remote:
@@ -456,7 +468,7 @@ def run(self):
                                     elif var=='R':
                                         if not 'auto' in self.devices:
                                             self.devices = ['auto'] + self.devices
-                                        self.set_host(val.split(','))
+                                        self.set_plugins(val.split(','))
                                     elif var=='V': self.version = val
                                     elif var=='D':
                                         self.devices = val.split(',')
@@ -575,24 +587,38 @@ def run(self):
                             continue
                         # marker AND repeat, continue to repeat parser section
 
-                    if self.line.startswith('|||'):
+                    if self.line.startswith('||||'):
                         self.quitflag = True
                         continue
-                    elif self.line.startswith('||'):
+                    elif self.line.startswith('|||'):
+                        p = None
+                        while True:
+                            assert self.callstack
+                            p = self.callstack.pop()
+                            if p.name != '':
+                                break
+                        self.row = p.caller + 1
+                        continue
+                    elif self.line.startswith('||'): # return/pop
+                        # print(self.callstack)
                         if len(self.callstack)>1:
                             frame = self.callstack[-1]
                             frame.count = max(0,frame.count-1)
                             if frame.count:
                                 self.row = frame.row + 1
                                 continue
                             else:
+                                # print('returning to caller', frame.caller)
                                 self.row = frame.caller + 1
-                                self.callstack = self.callstack[:-1]
+                                # self.callstack = self.callstack[:-1]
+                                self.callstack.pop()
                                 continue
                         else:
-                            self.quitflag = True
+                            # allow bypassing '||' on empty stack
+                            # self.quitflag = True
+                            self.row += 1
                             continue
-                    if self.line[0]==':' and self.line[-1] in '|:' and '|' in self.line:
+                    elif self.line[0]==':' and self.line[-1] in '|:' and '|' in self.line:
                         jumpline = self.line[1:self.line.index('|')]
                         frame = self.callstack[-1]
                         jumpline = jumpline.split('*') # *n = n repeats
@@ -622,28 +648,38 @@ def run(self):
                         # if bmrow in frame.returns:
 
                             # return to marker (no pushing)
-                            #     self.callstack.append(StackFrame(bmrow, self.row, count))
+                            #     self.callstack.append(StackFrame(bm, bmrow, self.row, count))
                         #     self.markers[jumpline[0]] = bmrow
                         #     self.row = bmrow + 1
                         #     self.last_marker = bmrow
 
+                        # print('bm', bm)
+                        # print('fm', frame.markers)
+                        # print('fm', frame.returns)
                         if bmrow==self.last_marker or bm in frame.markers: # call w/o push?
+                        # # if bm in frame.markers:
                             # ctx already passed bookmark, call w/o pushing (return to mark)
+                            # print(frame.returns, self.row)
                             if self.row in frame.returns: # have we repeated yet?
+                                # 2nd repeat (count exists)
                                 rpt = frame.returns[self.row]
                                 if rpt>0:
                                     frame.returns[self.row] = rpt - 1
                                     self.row = bmrow + 1 # repeat
                                 else:
+                                    # repeating done
+                                    # frame.returns[self.row] = rpt - 1
                                     del frame.returns[self.row] # reset
                                     self.row += 1
                             else:
                                 # start return count
-                                frame.returns[self.row] = count - 1
+                                self.callstack.append(StackFrame(bm, bmrow, self.row, count))
+                                self.callstack[-1].returns[self.row] = count - 1
                                 self.row = bmrow + 1 # repeat
                         else:
                             # mark not yet passed, do push/pop
-                            self.callstack.append(StackFrame(bmrow, self.row, count))
+                            # print(bm)
+                            self.callstack.append(StackFrame(bm, bmrow, self.row, count))
                             self.markers[bm] = bmrow
                             self.row = bmrow + 1
                             self.last_marker = bmrow
@@ -656,7 +692,7 @@ def run(self):
                         #     else:
                         #         self.row += 1
                         # else:
-                        #     self.callstack.append(StackFrame(bmrow, self.row, count))
+                        #     self.callstack.append(StackFrame(bm, bmrow, self.row, count))
                         #     self.markers[jumpline[0]] = bmrow
                         #     self.row = bmrow + 1
                         #     self.last_marker = bmrow
@@ -1855,7 +1891,7 @@ def run(self):
                     try:
                         # don't delay on ctrl lines or file header
                         if not ctrl and not self.header:
-                            self.schedule.logic(60.0 / self.tempo / self.grid)
+                            await self.schedule.logic(60.0 / self.tempo / self.grid)
                             break
                         else:
                             break

textbeat/schedule.py

@@ -1,4 +1,6 @@
 from .defs import *
+import time
+import asyncio
 
 class Event(object):
     def __init__(self, t, func, ch):
@@ -16,6 +18,8 @@ def __init__(self, ctx):
         self.clock = 0.0
         self.last_clock = 0
         self.started = False
+        # self.sleepfunc = time.sleep
+        # self.sleep = asyncio.sleep
     # all note mute and play events should be marked skippable
     def pending(self):
         return len(self.events)
@@ -27,13 +31,14 @@ def clear(self):
     def clear_channel(self, ch):
         assert False
         self.events = [ev for ev in self.events if ev.ch!=ch]
-    def logic(self, t):
+    async def logic(self, t):
         processed = 0
         self.passed = 0
 
+        # tt = time.perf_counter()
         # if self.last_clock == 0:
-        #     self.last_clock = time.clock()
-        # clock = time.clock()
+        #     self.last_clock = tt
+        # clock = tt
         # self.dontsleep = (clock - self.last_clock)
         # self.last_clock = clock
 
@@ -47,8 +52,8 @@ def logic(self, t):
         #     self.passed = 0.0
         # log(self.clock)
 
-        # pending_events_count = sum(1 for e in self.events if e.t > 0.0 and e.t < 2.0)
-        # print(pending_events_count)
+        pending_events_count = sum(1 for e in self.events if e.t > 0.0 and e.t < 2.0)
+        print(pending_events_count)
 
         try:
             self.events = sorted(self.events, key=lambda e: e.t)
@@ -60,7 +65,7 @@ def logic(self, t):
                     if ev.t >= 0.0:
                         if self.ctx.cansleep and self.ctx.startrow == -1:
                             self.ctx.t += self.ctx.speed * t * (ev.t-self.passed)
-                            time.sleep(max(0,self.ctx.speed * t * (ev.t-self.passed)))
+                            await asyncio.sleep(max(0,self.ctx.speed * t * (ev.t-self.passed)))
                         ev.func(0)
                         self.passed = ev.t # only inc if positive
                     else:
@@ -72,7 +77,7 @@ def logic(self, t):
             if slp > 0.0:
                 self.ctx.t += self.ctx.speed*slp
                 if self.ctx.cansleep and self.ctx.startrow == -1:
-                    time.sleep(max(0,self.ctx.speed*slp))
+                    await asyncio.sleep(max(0,self.ctx.speed*slp))
             self.passed = 0.0
 
             self.events = self.events[processed:]