Move rate and RateKeeper2 back to rate_control (and remove MISC from with_notebook)

Author: mwcraig

vpython/rate_control.py

@@ -1,11 +1,15 @@
 from __future__ import division, print_function
 import time
 import platform
+import queue
+import json
 
 from ._notebook_helpers import _isnotebook
 
 if _isnotebook:
     import IPython
+    import ipykernel
+    ws_queue = queue.Queue()
 
 # Unresolved bug: rate(X) yields only about 0.8X iterations per second.
 
@@ -31,15 +35,15 @@
 
 ##Possible way to get one-millisecond accuracy in sleep on Windows:
 ##http://msdn.microsoft.com/en-us/library/windows/desktop/ms686298(v=vs.85).aspx
-##When your program starts, the Windows system's timer resolution has a 
-##seemingly random value that depends on which programs are running 
-##(and apparently, which programs were run and then exited).  
-##Common values for the resolution are 15 ms and 1 ms, but a range 
-##of values is possible (use timeGetDevCaps to determine this range).  
-##AFAICT, calling timeBeginPeriod() changes the system timer resolution 
-##for every call you make to a Win32 function with a timeout 
-##(e.g., MsgWaitForMultipleObjects() works exactly the same as Sleep() 
-##with respect to the timeout) and every call that every other application 
+##When your program starts, the Windows system's timer resolution has a
+##seemingly random value that depends on which programs are running
+##(and apparently, which programs were run and then exited).
+##Common values for the resolution are 15 ms and 1 ms, but a range
+##of values is possible (use timeGetDevCaps to determine this range).
+##AFAICT, calling timeBeginPeriod() changes the system timer resolution
+##for every call you make to a Win32 function with a timeout
+##(e.g., MsgWaitForMultipleObjects() works exactly the same as Sleep()
+##with respect to the timeout) and every call that every other application
 ##in the system makes to a Win32 function with a timeout.
 
 def _sleep(dt):
@@ -58,18 +62,18 @@ def _sleep(dt):
     tend = _clock()+dt
     while _clock() < tend:
         pass
-        
+
 class simulateDelay:
     """
-    Simulate rendering/compute times.. with an average value of delayAvg with 
+    Simulate rendering/compute times.. with an average value of delayAvg with
     a variance of something like delaySigma**2.
     """
 
     def __init__(self, delayAvg=0.001, delaySigma=0.0001):
         self.delayAvg=delayAvg
         self.delaySigma=delaySigma
         self.callTimes = []
-        
+
     def __call__(self):
         self.callTimes.append(_clock())
 
@@ -94,9 +98,9 @@ def initialize(self):
         self.whenToRender = []
         for i in range(MAX_RENDERS+2):
             self.whenToRender.append(0)
-        self.renderIndex = 0 
+        self.renderIndex = 0
         self.rateCount = 0 # counts calls to rate in a 1-second cycle (reset to 0 every second)
-        
+
     def callInteract(self):
         t = _clock()
         self.interactFunc()
@@ -148,7 +152,7 @@ def buildStrategy(self, rate):
 
         # Prepare the self.renderIndex array of indices for when to do renders:
         self.distributeRenders(M, N)
-        
+
         # M = self.rateCalls = number of calls to rate/second
         # N = number of renders/second
         # callTime = time spent in rate function (very small)
@@ -160,20 +164,20 @@ def buildStrategy(self, rate):
         self.delay = (1.0 - N*R - self.renderWaits*self.interactionPeriod)/M - self.callTime - U
 ##        print("%1.4f %i %i %i %1.6f %1.6f %1.6f %1.6f" % (_clock(), M, N, self.renderWaits,
 ##                                self.userTime, self.callTime, self.delay, self.renderTime))
-        
+
     def __call__(self, maxRate=100):
         #td.add('-------------------------')
         if not self.initialized:
             self.initialize()
             self.initialized = True
-        calledTime = _clock()            
+        calledTime = _clock()
         if maxRate < 1: raise ValueError("rate value must be greater than or equal to 1")
         self.count += 1
         if self.count == 1: # first time rate has been called
             self.callInteract()
             self.lastEndRate = _clock()
             return
-        
+
         dt = calledTime - self.lastEndRate # time spent in user code
         nr = self.whenToRender[self.renderIndex]
         if self.count == 2 or (self.count == self.lastCount + self.rateCalls):
@@ -187,7 +191,7 @@ def __call__(self, maxRate=100):
             self.lastSleep = _clock()
         elif dt < 0.2: # don't count long delays due to menu or similar operations
             self.userTime = 0.95*self.userTime + 0.05*dt
-        
+
         dt = _clock() - calledTime # approximate amount of time spent in this function
         if self.callTime == 0.0: self.callTime = dt
         elif dt < 0.2: # don't count long delays due to menu or similar operations
@@ -216,11 +220,23 @@ def __call__(self, maxRate=100):
         self.lastEndRate = _clock()
 
 
-class _RateKeeper2(RateKeeper):
+def message_send_wrapper():
+    """
+    The only purpose of this function is delay import of baseObj to eliminate
+    what would otherwise be a circular import. __init__ imports rate, and vpython imports rate,
+    and this cannot also import vpython at the same time.
+    """
+    from .vpython import baseObj
+    def message_sender(msg):
+        baseObj.glow.handle_msg(msg)
+    return message_sender
+
 
+class _RateKeeper2(RateKeeper):
     def __init__(self, interactPeriod=INTERACT_PERIOD, interactFunc=simulateDelay):
         self.rval = 30
         self.tocall = None
+        self._sender = None
         super(_RateKeeper2, self).__init__(interactPeriod=interactPeriod, interactFunc=self.sendtofrontend)
 
     def sendtofrontend(self):
@@ -229,7 +245,19 @@ def sendtofrontend(self):
 
         # Check if events to process from front end
         if _isnotebook:
-            if IPython.__version__ >= '3.0.0' :
+            if not self._sender:
+                self._sender = message_send_wrapper()
+            if ((IPython.__version__ >= '7.0.0') or
+                    (ipykernel.__version__ >= '5.0.0')):
+                while ws_queue.qsize() > 0:
+                    data = ws_queue.get()
+                    d = json.loads(data)  # update_canvas info
+                    for m in d:
+                        # Must send events one at a time to GW.handle_msg because bound events need the loop code:
+                        msg = {'content':{'data':[m]}} # message format used by notebook
+                        self._sender(msg)
+
+            elif IPython.__version__ >= '3.0.0':
                 kernel = IPython.get_ipython().kernel
                 parent = kernel._parent_header
                 ident = kernel._parent_ident
@@ -241,5 +269,6 @@ def __call__(self, N): # rate(N) calls this function
         if self.rval < 1: raise ValueError("rate value must be greater than or equal to 1")
         super(_RateKeeper2, self).__call__(self.rval) ## calls __call__ in rate_control.py
 
+
 # The rate function:
 rate = _RateKeeper2(interactFunc = simulateDelay(delayAvg = 0.001))

vpython/vpython.py

@@ -10,11 +10,10 @@
 from time import clock
 import time
 import sys
-import queue
-import json
 from . import __version__, __gs_version__
 from ._notebook_helpers import _isnotebook
-from ._vector_import_helper import vector, mag, norm, dot, adjust_up, adjust_axis, object_rotate
+from ._vector_import_helper import (vector, mag, norm, dot, adjust_up,
+                                    adjust_axis, object_rotate)
 
 # List of names that will be imported form this file with import *
 __all__ = ['Camera', 'GlowWidget', 'GSversion', 'Mouse', 'arrow', 'attach_arrow',
@@ -28,7 +27,6 @@
            'standardAttributes', 'text', 'textures', 'triangle', 'vertex',
            'wtext']
 vec = vector # synonyms in GlowScript
-ws_queue = queue.Queue()
 
 def __checkisnotebook(): # returns True if running in Jupyter notebook
     try:
@@ -210,45 +208,9 @@ def _encode_attr(D, ismethods): # ismethods is True if a list of method operatio
                 out.append(s)
     return out
 
-class _RateKeeper2(RateKeeper):
-
-    def __init__(self, interactPeriod=INTERACT_PERIOD, interactFunc=simulateDelay):
-        self.rval = 30
-        self.tocall = None
-        super(_RateKeeper2, self).__init__(interactPeriod=interactPeriod, interactFunc=self.sendtofrontend)
-
-    def sendtofrontend(self):
-        # This is called by the rate() function, through rate_control _RateKeeper callInteract().
-        # See the function commsend() for details of how the browser is updated.
-
-        # Check if events to process from front end
-        if _isnotebook:
-            if (IPython.__version__ >= '7.0.0') or (ipykernel.__version__ >= '5.0.0'):
-                while ws_queue.qsize() > 0:
-                    data = ws_queue.get()
-                    d = json.loads(data) # update_canvas info
-                    for m in d:
-                        # Must send events one at a time to GW.handle_msg because bound events need the loop code:
-                        msg = {'content':{'data':[m]}} # message format used by notebook
-                        baseObj.glow.handle_msg(msg)
-
-            elif IPython.__version__ >= '3.0.0' :
-                kernel = get_ipython().kernel
-                parent = kernel._parent_header
-                ident = kernel._parent_ident
-                kernel.do_one_iteration()
-                kernel.set_parent(ident, parent)
-
-    def __call__(self, N): # rate(N) calls this function
-        self.rval = N
-        if self.rval < 1: raise ValueError("rate value must be greater than or equal to 1")
-        super(_RateKeeper2, self).__call__(self.rval) ## calls __call__ in rate_control.py
-
 if sys.version > '3':
     long = int
 
-# The rate function:
-rate = _RateKeeper2(interactFunc = simulateDelay(delayAvg = 0.001))
 
 def list_to_vec(L):
     return vector(L[0], L[1], L[2])

vpython/with_notebook.py

@@ -5,8 +5,10 @@
 import notebook
 import IPython
 from IPython.display import display, Javascript
+import ipykernel
 
 from .vpython import GlowWidget, baseObj, canvas
+from .rate_control import ws_queue
 from . import __version__
 
 import tornado.httpserver
@@ -88,7 +90,7 @@ def find_free_port():
         if libready and dataready: break
     # Mark with the version number that the files have been transferred successfully:
     fd = open(nbdir+'/vpython_version.txt', 'w')
-    fd.write(__version__)    
+    fd.write(__version__)
     fd.close()
 
 display(Javascript("""if (typeof Jupyter !== "undefined") {require.undef("nbextensions/vpython_libraries/glow.min");}else{element.textContent = ' ';}"""))
@@ -101,30 +103,26 @@ def find_free_port():
 
 time.sleep(1)      # allow some time for javascript code above to run before attempting to setup Comm Channel
 
-baseObj.glow = GlowWidget()     # Setup Comm Channel
-
-baseObj.trigger() # start the trigger ping-pong process
-
 wsConnected = False
 
 class WSHandler(tornado.websocket.WebSocketHandler):
     def open(self):
         global wsConnected
         wsConnected = True
-      
+
     def on_message(self, message):
         ws_queue.put(message)
- 
+
     def on_close(self):
         self.stopTornado()
 
     def stop_tornado(self):
         ioloop = tornado.ioloop.IOLoop.instance()
         ioloop.add_callback(ioloop.stop)
- 
+
     def check_origin(self, origin):
         return True
- 
+
 def start_server():
     asyncio.set_event_loop(asyncio.new_event_loop())
     application = tornado.web.Application([(r'/ws', WSHandler),])
@@ -135,6 +133,7 @@ def start_server():
     Log.setLevel(level)
     tornado.ioloop.IOLoop.instance().start()
 
+
 if (ipykernel.__version__ >= '5.0.0'):
 	from threading import Thread
 	t = Thread(target=start_server, args=())
@@ -144,16 +143,27 @@ def start_server():
 		time.sleep(0.1)          # wait for websocket to connect
 else:
 	baseObj.glow = GlowWidget()     # Setup Comm Channel
-	
-scene = canvas()
-
-# This must come after creating a canvas
-class MISC(baseObj):
-    def __init__(self):
-        super(MISC, self).__init__() 
-    
-    def prnt(self, s):
-        self.addmethod('GSprint', s)
+
+baseObj.trigger()  # start the trigger ping-pong process
+
+if IPython.__version__ >= '4.0.0':
+    if (ipykernel.__version__ >= '5.0.0'):
+        async def wsperiodic():
+            while True:
+                if ws_queue.qsize() > 0:
+                    data = ws_queue.get()
+                    d = json.loads(data)
+                    # Must send events one at a time to GW.handle_msg because
+                    # bound events need the loop code
+                    for m in d:
+                        # message format used by notebook
+                        msg = {'content': {'data': [m]}}
+                        baseObj.glow.handle_msg(msg)
+
+                await asyncio.sleep(0)
+
+        loop = asyncio.get_event_loop()
+        loop.create_task(wsperiodic())
 
 # Dummy name to import...
 _ = None