Kivy-examples 2.3.1.dev0__py3-none-any.whl

Kivy_examples-2.3.1.dev0.data/data/share/kivy-examples/application/app_suite.py

@@ -0,0 +1,152 @@
+'''
+Suite of Application Builders
+=============================
+
+This explores different methods of starting an application. If you run
+this without a command line parameter, you should see a menu in your terminal.
+You can also run this with a 'r' parameter to pick a random method.
+There are lots of logging options to make this easier to debug: the execution
+order may not be obvious. Each time you run the command, only one kivy
+application is created.
+
+This uses the file testkvfile.kv and the file app_suite_data/testkvdir.kv.
+
+'''
+
+from __future__ import print_function
+import sys
+import re
+from random import choice
+
+import kivy
+kivy.require('1.8.0')  # 1.8 is when kv_directory became part of app.
+from kivy.app import App
+from kivy.uix.button import Button
+from kivy.lang import Builder
+
+from kivy.uix.floatlayout import FloatLayout
+# Note that importing FloatLayout causes Kivy to execute, including
+# starting up the Logger and some other messages.
+print("** In main program, done with imports")
+
+
+class TestBuildApp(App):
+    """ Use build() function to return a widget. """
+    def build(self):
+        """   Build called by kivy when an App is started.
+              Called after trying to load a .kv file.
+              Returns a new Button as a root widget.
+              """
+        print("** inside build()")
+        return Button(text='hello from TestBuildApp')
+
+
+class TestKVFileApp(App):
+    """
+    Empty class, but name used to find .kv file. The filename is the lowercase
+    version of the class, i.e. 'testkvfileapp.kv'. If not found, it strips
+    off the final 'app', i.e. 'testkvfile.kv'. If not file is found, and no
+    other method sets the self.root, the program will run with an empty screen.
+    """
+    pass
+
+
+class TestKVDirApp(App):
+    """
+    Empty class except for setting class variable kv_directory.
+    This directory sets the directory in which to search for the .kv file.
+    The name of the kv file is still governed by the class name and the .kv
+    file should still have one root widget.
+    """
+    kv_directory = 'app_suite_data'
+
+
+class TestKVStringApp(App):
+    """
+    Use a build() function and use the kivy.lang.Builder function to parse up a
+    Kivy language string.
+    """
+    def build(self):
+        """   Called by kivy run().  """
+        print("** inside build()")
+        widget = Builder.load_string(
+            "Button:\n  text: 'hello from TestKVStringApp'")
+        print("** widget built")
+        return widget
+
+
+class TestPrebuiltApp(App):
+    """ Use the Builder to create a top level widget at the beginning
+    of the Python program, then use a dummy class for that widget.
+    This costs a bit more in start-up time. """
+    kv = "<Prebuilt>\n  Button:\n    text:'hello from TestPrebuiltApp'"
+    Builder.load_string(kv)
+    print("** in TestPrebuiltApp, class initialization built <Prebuilt>")
+
+    class Prebuilt(FloatLayout):
+        """ Empty class to cause setting root to <Prebuilt> tag and
+        set inheritance """
+        pass
+
+    def build(self):
+        """ called, returns instance matching tag . """
+        return self.Prebuilt()
+
+
+def print_class(class_name):
+    """ Read this file and print the section with the class name specified.)"""
+    filename = sys.argv[0]
+    with open(filename) as f:
+        data = f.read()
+        regex = "^(class " + class_name + "\\b.*?)^\\S"
+        match = re.search(regex, data, flags=re.MULTILINE | re.DOTALL)
+        if match:
+            print(match.group(1))
+
+
+# the __name__ idiom executes when run from command line but not from import.
+if __name__ == '__main__':
+    dash = "-" * 40
+
+    arg = sys.argv[1][0].lower() if len(sys.argv) > 1 else "h"
+    print(dash)
+
+    if arg == 'r':
+        arg = choice('bfds')
+
+    if arg == 'b':
+        print_class("TestBuildApp")
+        TestBuildApp().run()
+    elif arg == 'f':
+        print_class("TestKVFileApp")
+        TestKVFileApp().run()
+    elif arg == 'd':
+        print_class("TestKVDirApp")
+        TestKVDirApp().run()
+    elif arg == 's':
+        print_class("TestKVStringApp")
+        TestKVStringApp().run()
+    elif arg == 'p':
+        print_class("TestPrebuiltApp")
+        TestPrebuiltApp().run()
+    else:   # help
+        print("""
+This demo runs different application windows based on a command line argument.
+
+Try using one of these:
+   b - Use build() method to return a widget
+   d - Use a kv file from a different directory
+   f - Use a kv file with the widget object
+   p - Use prebuilt widget inside a layout
+   s - Use a kivy language string to create the widget
+   r - pick one of the options at random.
+
+   h - show this help message.
+
+   After closing the application window, this program will exit.
+   While the run() method does return, kivy cannot run another
+   application window after one has been closed.
+ """)
+
+    print(dash)
+    print("This program is gratified to be of use.")

Kivy_examples-2.3.1.dev0.data/data/share/kivy-examples/application/app_suite_data/testkvdir.kv

@@ -0,0 +1,4 @@
+#:kivy 1.0
+
+Button:
+    text: 'Hello from app_suite_data/testkvdir.kv'

Kivy_examples-2.3.1.dev0.data/data/share/kivy-examples/application/app_with_build.py

@@ -0,0 +1,24 @@
+'''
+Application example using build() + return
+==========================================
+
+An application can be built if you return a widget on build(), or if you set
+self.root.
+'''
+
+import kivy
+kivy.require('1.0.7')
+
+from kivy.app import App
+from kivy.uix.button import Button
+
+
+class TestApp(App):
+
+    def build(self):
+        # return a Button() as a root widget
+        return Button(text='hello world')
+
+
+if __name__ == '__main__':
+    TestApp().run()

Kivy_examples-2.3.1.dev0.data/data/share/kivy-examples/application/app_with_config.py

@@ -0,0 +1,49 @@
+from kivy.app import App
+from kivy.lang import Builder
+from kivy.properties import ConfigParserProperty
+
+KV = '''
+FloatLayout:
+    BoxLayout:
+        size_hint: .5, .5
+        pos_hint: {'center': (.5, .5)}
+
+        orientation: 'vertical'
+
+        TextInput:
+            text: app.text
+            on_text: app.text = self.text
+
+        Slider:
+            min: 0
+            max: 100
+            value: app.number
+            on_value: app.number = self.value
+'''
+
+
+class ConfigApp(App):
+    number = ConfigParserProperty(
+        0, 'general', 'number',
+        'app', val_type=float
+    )
+    text = ConfigParserProperty(
+        '', 'general', 'text',
+        'app', val_type=str
+    )
+
+    def build_config(self, config):
+        config.setdefaults(
+            'general',
+            {
+                'number': 0,
+                'text': 'test'
+            }
+        )
+
+    def build(self):
+        return Builder.load_string(KV)
+
+
+if __name__ == '__main__':
+    ConfigApp().run()

Kivy_examples-2.3.1.dev0.data/data/share/kivy-examples/application/app_with_kv.py

@@ -0,0 +1,25 @@
+'''
+Application built from a  .kv file
+==================================
+
+This shows how to implicitly use a .kv file for your application. You
+should see a full screen button labelled "Hello from test.kv".
+
+After Kivy instantiates a subclass of App, it implicitly searches for a .kv
+file. The file test.kv is selected because the name of the subclass of App is
+TestApp, which implies that kivy should try to load "test.kv". That file
+contains a root Widget.
+'''
+
+import kivy
+kivy.require('1.0.7')
+
+from kivy.app import App
+
+
+class TestApp(App):
+    pass
+
+
+if __name__ == '__main__':
+    TestApp().run()

Kivy_examples-2.3.1.dev0.data/data/share/kivy-examples/application/app_with_kv_in_template1.py

@@ -0,0 +1,27 @@
+'''
+Application from a .kv in a Template Directory
+==============================================
+
+This example shows how you can change the directory for the .kv file. You
+should see "Hello from template1/test.ky" as a button.
+
+As kivy instantiates the TestApp subclass of App, the variable kv_directory
+is set. Kivy then implicitly searches for a .kv file matching the name
+of the subclass in that directory, finding the file template1/test.kv. That
+file contains the root widget.
+
+
+'''
+
+import kivy
+kivy.require('1.0.7')
+
+from kivy.app import App
+
+
+class TestApp(App):
+    kv_directory = 'template1'
+
+
+if __name__ == '__main__':
+    TestApp().run()

Kivy_examples-2.3.1.dev0.data/data/share/kivy-examples/application/template1/test.kv

@@ -0,0 +1,4 @@
+#:kivy 1.0
+
+Button:
+    text: 'Hello from template1/test.kv'

Kivy_examples-2.3.1.dev0.data/data/share/kivy-examples/application/test.kv

@@ -0,0 +1,4 @@
+#:kivy 1.0
+
+Button:
+    text: 'Hello from test.kv'

Kivy_examples-2.3.1.dev0.data/data/share/kivy-examples/application/testkvfile.kv

@@ -0,0 +1,4 @@
+#:kivy 1.0
+
+Button:
+    text: 'Hello from testkvfile.kv'

Kivy_examples-2.3.1.dev0.data/data/share/kivy-examples/async/asyncio_advanced.py

@@ -0,0 +1,90 @@
+'''Example shows the recommended way of how to run Kivy with the Python built
+in asyncio event loop as just another async coroutine.
+'''
+import asyncio
+
+from kivy.app import App
+from kivy.lang.builder import Builder
+
+kv = '''
+BoxLayout:
+    orientation: 'vertical'
+    BoxLayout:
+        ToggleButton:
+            id: btn1
+            group: 'a'
+            text: 'Sleeping'
+            allow_no_selection: False
+            on_state: if self.state == 'down': label.status = self.text
+        ToggleButton:
+            id: btn2
+            group: 'a'
+            text: 'Swimming'
+            allow_no_selection: False
+            on_state: if self.state == 'down': label.status = self.text
+        ToggleButton:
+            id: btn3
+            group: 'a'
+            text: 'Reading'
+            allow_no_selection: False
+            state: 'down'
+            on_state: if self.state == 'down': label.status = self.text
+    Label:
+        id: label
+        status: 'Reading'
+        text: 'Beach status is "{}"'.format(self.status)
+'''
+
+
+class AsyncApp(App):
+
+    other_task = None
+
+    def build(self):
+        return Builder.load_string(kv)
+
+    def app_func(self):
+        '''This will run both methods asynchronously and then block until they
+        are finished
+        '''
+        self.other_task = asyncio.ensure_future(self.waste_time_freely())
+
+        async def run_wrapper():
+            # we don't actually need to set asyncio as the lib because it is
+            # the default, but it doesn't hurt to be explicit
+            await self.async_run(async_lib='asyncio')
+            print('App done')
+            self.other_task.cancel()
+
+        return asyncio.gather(run_wrapper(), self.other_task)
+
+    async def waste_time_freely(self):
+        '''This method is also run by the asyncio loop and periodically prints
+        something.
+        '''
+        try:
+            i = 0
+            while True:
+                if self.root is not None:
+                    status = self.root.ids.label.status
+                    print('{} on the beach'.format(status))
+
+                    # get some sleep
+                    if self.root.ids.btn1.state != 'down' and i >= 2:
+                        i = 0
+                        print('Yawn, getting tired. Going to sleep')
+                        self.root.ids.btn1.trigger_action()
+
+                i += 1
+                await asyncio.sleep(2)
+        except asyncio.CancelledError as e:
+            print('Wasting time was canceled', e)
+        finally:
+            # when canceled, print that it finished
+            print('Done wasting time')
+
+
+if __name__ == '__main__':
+    loop = asyncio.get_event_loop()
+    loop.run_until_complete(AsyncApp().app_func())
+    loop.close()

Kivy_examples-2.3.1.dev0.data/data/share/kivy-examples/async/asyncio_basic.py

@@ -0,0 +1,59 @@
+'''Example shows the recommended way of how to run Kivy with the Python built
+in asyncio event loop as just another async coroutine.
+'''
+import asyncio
+
+from kivy.app import async_runTouchApp
+from kivy.lang.builder import Builder
+
+kv = '''
+BoxLayout:
+    orientation: 'vertical'
+    Button:
+        id: btn
+        text: 'Press me'
+    BoxLayout:
+        Label:
+            id: label
+            text: 'Button is "{}"'.format(btn.state)
+'''
+
+
+async def run_app_happily(root, other_task):
+    '''This method, which runs Kivy, is run by the asyncio loop as one of the
+    coroutines.
+    '''
+    # we don't actually need to set asyncio as the lib because it is the
+    # default, but it doesn't hurt to be explicit
+    await async_runTouchApp(root, async_lib='asyncio')  # run Kivy
+    print('App done')
+    # now cancel all the other tasks that may be running
+    other_task.cancel()
+
+
+async def waste_time_freely():
+    '''This method is also run by the asyncio loop and periodically prints
+    something.
+    '''
+    try:
+        while True:
+            print('Sitting on the beach')
+            await asyncio.sleep(2)
+    except asyncio.CancelledError as e:
+        print('Wasting time was canceled', e)
+    finally:
+        # when canceled, print that it finished
+        print('Done wasting time')
+
+if __name__ == '__main__':
+    def root_func():
+        '''This will run both methods asynchronously and then block until they
+        are finished
+        '''
+        root = Builder.load_string(kv)  # root widget
+        other_task = asyncio.ensure_future(waste_time_freely())
+        return asyncio.gather(run_app_happily(root, other_task), other_task)
+
+    loop = asyncio.get_event_loop()
+    loop.run_until_complete(root_func())
+    loop.close()

Kivy_examples-2.3.1.dev0.data/data/share/kivy-examples/async/trio_advanced.py

@@ -0,0 +1,93 @@
+'''Example shows the recommended way of how to run Kivy with a trio
+event loop as just another async coroutine.
+'''
+import trio
+
+from kivy.app import App
+from kivy.lang.builder import Builder
+
+kv = '''
+BoxLayout:
+    orientation: 'vertical'
+    BoxLayout:
+        ToggleButton:
+            id: btn1
+            group: 'a'
+            text: 'Sleeping'
+            allow_no_selection: False
+            on_state: if self.state == 'down': label.status = self.text
+        ToggleButton:
+            id: btn2
+            group: 'a'
+            text: 'Swimming'
+            allow_no_selection: False
+            on_state: if self.state == 'down': label.status = self.text
+        ToggleButton:
+            id: btn3
+            group: 'a'
+            text: 'Reading'
+            allow_no_selection: False
+            state: 'down'
+            on_state: if self.state == 'down': label.status = self.text
+    Label:
+        id: label
+        status: 'Reading'
+        text: 'Beach status is "{}"'.format(self.status)
+'''
+
+
+class AsyncApp(App):
+
+    nursery = None
+
+    def build(self):
+        return Builder.load_string(kv)
+
+    async def app_func(self):
+        '''trio needs to run a function, so this is it. '''
+
+        async with trio.open_nursery() as nursery:
+            '''In trio you create a nursery, in which you schedule async
+            functions to be run by the nursery simultaneously as tasks.
+
+            This will run all two methods starting in random order
+            asynchronously and then block until they are finished or canceled
+            at the `with` level. '''
+            self.nursery = nursery
+
+            async def run_wrapper():
+                # trio needs to be set so that it'll be used for the event loop
+                await self.async_run(async_lib='trio')
+                print('App done')
+                nursery.cancel_scope.cancel()
+
+            nursery.start_soon(run_wrapper)
+            nursery.start_soon(self.waste_time_freely)
+
+    async def waste_time_freely(self):
+        '''This method is also run by trio and periodically prints something.
+        '''
+        try:
+            i = 0
+            while True:
+                if self.root is not None:
+                    status = self.root.ids.label.status
+                    print('{} on the beach'.format(status))
+
+                    # get some sleep
+                    if self.root.ids.btn1.state != 'down' and i >= 2:
+                        i = 0
+                        print('Yawn, getting tired. Going to sleep')
+                        self.root.ids.btn1.trigger_action()
+
+                i += 1
+                await trio.sleep(2)
+        except trio.Cancelled as e:
+            print('Wasting time was canceled', e)
+        finally:
+            # when canceled, print that it finished
+            print('Done wasting time')
+
+
+if __name__ == '__main__':
+    trio.run(AsyncApp().app_func)

Kivy_examples-2.3.1.dev0.data/data/share/kivy-examples/async/trio_basic.py

@@ -0,0 +1,58 @@
+'''Example shows the recommended way of how to run Kivy with a trio
+event loop as just another async coroutine.
+'''
+import trio
+from kivy.app import async_runTouchApp
+from kivy.lang.builder import Builder
+
+kv = '''
+BoxLayout:
+    orientation: 'vertical'
+    Button:
+        id: btn
+        text: 'Press me'
+    BoxLayout:
+        Label:
+            id: label
+            text: 'Button is "{}"'.format(btn.state)
+'''
+
+
+async def run_app_happily(root, nursery):
+    '''This method, which runs Kivy, is run by trio as one of the coroutines.
+    '''
+    # trio needs to be set so that it'll be used for the event loop
+    await async_runTouchApp(root, async_lib='trio')  # run Kivy
+    print('App done')
+    # now cancel all the other tasks that may be running
+    nursery.cancel_scope.cancel()
+
+
+async def waste_time_freely():
+    '''This method is also run by trio and periodically prints something.'''
+    try:
+        while True:
+            print('Sitting on the beach')
+            await trio.sleep(2)
+    except trio.Cancelled as e:
+        print('Wasting time was canceled', e)
+    finally:
+        # when canceled, print that it finished
+        print('Done wasting time')
+
+if __name__ == '__main__':
+    async def root_func():
+        '''trio needs to run a function, so this is it. '''
+
+        root = Builder.load_string(kv)  # root widget
+        async with trio.open_nursery() as nursery:
+            '''In trio you create a nursery, in which you schedule async
+            functions to be run by the nursery simultaneously as tasks.
+
+            This will run all two methods starting in random order
+            asynchronously and then block until they are finished or canceled
+            at the `with` level. '''
+            nursery.start_soon(run_app_happily, root, nursery)
+            nursery.start_soon(waste_time_freely)
+
+    trio.run(root_func)