U P’“e (ã@s„dZdZddlZddlmZmZddlmZddlm Z ddl m Z ddl m Z d d „Zd d „ZGd d„deƒZGdd„deƒZdS)a Interactive launcher ==================== .. versionadded:: 1.3.0 .. deprecated:: 1.10.0 The interactive launcher has been deprecated. The :class:`InteractiveLauncher` provides a user-friendly python shell interface to an :class:`App` so that it can be prototyped and debugged interactively. .. note:: The Kivy API intends for some functions to only be run once or before the main EventLoop has started. Methods that can normally be called during the course of an application will work as intended, but specifically overriding methods such as :meth:`on_touch` dynamically leads to trouble. Creating an InteractiveLauncher ------------------------------- Take your existing subclass of :class:`App` (this can be production code) and pass an instance to the :class:`InteractiveLauncher` constructor. :: from kivy.interactive import InteractiveLauncher from kivy.app import App from kivy.uix.button import Button class MyApp(App): def build(self): return Button(text='Hello Shell') launcher = InteractiveLauncher(MyApp()) launcher.run() After pressing *enter*, the script will return. This allows the interpreter to continue running. Inspection or modification of the :class:`App` can be done safely through the InteractiveLauncher instance or the provided :class:`SafeMembrane` class instances. .. note:: If you want to test this example, start Python without any file to have already an interpreter, and copy/paste all the lines. You'll still have the interpreter at the end + the kivy application running. Interactive Development ----------------------- IPython provides a fast way to learn the Kivy API. The :class:`App` instance and all of its attributes, including methods and the entire widget tree, can be quickly listed by using the '.' operator and pressing 'tab'. Try this code in an Ipython shell. :: from kivy.interactive import InteractiveLauncher from kivy.app import App from kivy.uix.widget import Widget from kivy.graphics import Color, Ellipse class MyPaintWidget(Widget): def on_touch_down(self, touch): with self.canvas: Color(1, 1, 0) d = 30. Ellipse(pos=(touch.x - d/2, touch.y - d/2), size=(d, d)) class TestApp(App): def build(self): return Widget() i = InteractiveLauncher(TestApp()) i.run() i. # press 'tab' to list attributes of the app i.root. # press 'tab' to list attributes of the root widget # App is boring. Attach a new widget! i.root.add_widget(MyPaintWidget()) i.safeIn() # The application is now blocked. # Click on the screen several times. i.safeOut() # The clicks will show up now # Erase artwork and start over i.root.canvas.clear() .. note:: All of the proxies used in the module store their referent in the :attr:`_ref` attribute, which can be accessed directly if needed, such as for getting doc strings. :func:`help` and :func:`type` will access the proxy, not its referent. Directly Pausing the Application -------------------------------- Both the :class:`InteractiveLauncher` and :class:`SafeMembrane` hold internal references to the :class:`EventLoop`'s 'safe' and 'confirmed' :class:`threading.Event` objects. You can use their safing methods to control the application manually. :meth:`SafeMembrane.safeIn` will cause the application to pause and :meth:`SafeMembrane.safeOut` will allow a paused application to continue running. This is potentially useful for scripting actions into functions that need the screen to update etc. .. note:: The pausing is implemented via the :class:`Clocks' ` :meth:`~kivy.clock.ClockBase.schedule_once` method and occurs before the start of each frame. Adding Attributes Dynamically ----------------------------- .. note:: This module uses threading and object proxies to encapsulate the running :class:`App`. Deadlocks and memory corruption can occur if making direct references inside the thread without going through the provided proxy(s). The :class:`InteractiveLauncher` can have attributes added to it exactly like a normal object and if these were created from outside the membrane, they will not be threadsafe because the external references to them in the python interpreter do not go through InteractiveLauncher's membrane behavior, inherited from :class:`SafeMembrane`. To threadsafe these external references, simply assign them to :class:`SafeMembrane` instances of themselves like so:: from kivy.interactive import SafeMembrane interactiveLauncher.attribute = myNewObject # myNewObject is unsafe myNewObject = SafeMembrane(myNewObject) # myNewObject is now safe. Call at will. myNewObject.method() TODO ==== Unit tests, examples, and a better explanation of which methods are safe in a running application would be nice. All three would be excellent. Could be re-written with a context-manager style i.e. :: with safe: foo() Any use cases besides compacting code? )Ú SafeMembraneÚInteractiveLauncheréN)ÚThreadÚEvent)ÚApp)Ú EventLoop)ÚClock)Ú deprecatedcCs"tj ¡tj ¡tj ¡dS©N)rÚ confirmedÚsetÚsafeÚwaitÚclear)Údt©rú4/tmp/pip-unpacked-wheel-xzebddm3/kivy/interactive.pyÚsafeWait«s  rcCst|ƒtkr|j}q|Sr )ÚtyperÚ_ref)ÚobrrrÚunwrap±s rc@sÄeZdZdZdZdd„Zdd„Zdd„Zd d „Zd d „Z d d„Z e j fdd„Z e j fdd„Z e jfdd„Ze jfdd„Zdd„Zdd„Zdd„Zdd„Zdd „Zd!d"„Zd#d$„Zd%d&„Zd'd(„Zd)S)*ra` This help is for a proxy object. Did you want help on the proxy's referent instead? Try using help(._ref) The SafeMembrane is a threadsafe proxy that also returns attributes as new thread-safe objects and makes thread-safe method calls, preventing thread-unsafe objects from leaking into the user's environment. )rr r cOstj|_tj|_||_dSr )rr r r)ÚselfrÚargsÚkwargsrrrÚ__init__ÄszSafeMembrane.__init__cCs$|j ¡t td¡|j ¡dS)z=Provides a thread-safe entry point for interactive launching.éÿÿÿÿN)r rrZ schedule_oncerr r©rrrrÚsafeInÉs  zSafeMembrane.safeIncCs|j ¡dS)zr6rrrÚ __setitem__ s zSafeMembrane.__setitem__cCs| ¡|j|=| ¡dSr ©rrrr=rrrÚ __delitem__szSafeMembrane.__delitem__cCst|j||…ƒSr r<©rÚiÚjrrrÚ __getslice__szSafeMembrane.__getslice__cCs*| ¡t|ƒ}||j||…<| ¡dSr r@)rrErFr6rrrÚ __setslice__szSafeMembrane.__setslice__cCs | ¡|j||…=| ¡dSr rBrDrrrÚ __delslice__s zSafeMembrane.__delslice__cOs| ¡|jj||ŽdSr )rrÚ __enter__©rrrrrrrJ"szSafeMembrane.__enter__cOs|jj||Ž| ¡dSr )rÚ__exit__rrKrrrrL&szSafeMembrane.__exit__N)Ú__name__Ú __module__Ú __qualname__Ú__doc__Ú __slots__rrrr#r$r+Úobjectr2r3r7r9r;r?rArCrGrHrIrJrLrrrrr·s*   rc@s:eZdZdZdZed dd„ƒZdd„Zdd „Zd d „Z dS) rz’ Proxy to an application instance that launches it in a thread and then returns and acts as a proxy to the application in the thread. )rr r ÚthreadÚappNcOsb|dkrtƒ}tƒt_tj|_|j ¡tƒt_tj|_||_|fdd„}t|d|i|—Ž|_dS)Nc_s|j||ŽdSr )Úrun)rTrrrrrÚstartApp>sz.InteractiveLauncher.__init__..startAppÚtarget) rrrr r r rTrrS)rrTrrrVrrrr3s  zInteractiveLauncher.__init__cCs|j ¡|j|_dSr )rSÚstartrTrrrrrrUCs zInteractiveLauncher.runcCsdt_|j ¡dS)NT)rÚquitrSÚjoinrrrrÚstopIszInteractiveLauncher.stopcCs |j ¡Sr )rTr$rrrrr$NszInteractiveLauncher.__repr__)N) rMrNrOrPrQr rrUr[r$rrrrr+s r)rPÚ__all__r Ú threadingrrZkivy.apprZ kivy.baserZ kivy.clockrZ kivy.utilsr rrrRrrrrrrÚs     t