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

kivy/tests/fixtures.py

@@ -0,0 +1,169 @@
+import pytest
+import gc
+import weakref
+import time
+import os.path
+
+__all__ = ('kivy_clock', 'kivy_metrics', 'kivy_exception_manager', 'kivy_app')
+
+
+@pytest.fixture()
+def kivy_clock():
+    from kivy.context import Context
+    from kivy.clock import ClockBase
+
+    context = Context(init=False)
+    context['Clock'] = ClockBase()
+    context.push()
+
+    from kivy.clock import Clock
+    Clock._max_fps = 0
+
+    try:
+        Clock.start_clock()
+        yield Clock
+        Clock.stop_clock()
+    finally:
+        context.pop()
+
+
+@pytest.fixture()
+def kivy_metrics():
+    from kivy.context import Context
+    from kivy.metrics import MetricsBase, Metrics
+    from kivy._metrics import dispatch_pixel_scale
+
+    context = Context(init=False)
+    context['Metrics'] = MetricsBase()
+    context.push()
+    # need to do it to reset the global value
+    dispatch_pixel_scale()
+
+    try:
+        yield Metrics
+    finally:
+        context.pop()
+        Metrics._set_cached_scaling()
+
+
+@pytest.fixture()
+def kivy_exception_manager():
+    from kivy.context import Context
+    from kivy.base import ExceptionManagerBase, ExceptionManager
+
+    context = Context(init=False)
+    context['ExceptionManager'] = ExceptionManagerBase()
+    context.push()
+
+    try:
+        yield ExceptionManager
+    finally:
+        context.pop()
+
+
+# keep track of all the kivy app fixtures so that we can check that it
+# properly dies
+apps = []
+
+
+@pytest.fixture()
+async def kivy_app(request, nursery):
+    gc.collect()
+    if apps:
+        last_app, last_request = apps.pop()
+        assert last_app() is None, \
+            'Memory leak: failed to release app for test ' + repr(last_request)
+
+    from os import environ
+    environ['KIVY_USE_DEFAULTCONFIG'] = '1'
+
+    # force window size + remove all inputs
+    from kivy.config import Config
+    Config.set('graphics', 'width', '320')
+    Config.set('graphics', 'height', '240')
+    for items in Config.items('input'):
+        Config.remove_option('input', items[0])
+
+    from kivy.core.window import Window
+    from kivy.context import Context
+    from kivy.clock import ClockBase
+    from kivy.factory import FactoryBase, Factory
+    from kivy.app import App
+    from kivy.lang.builder import BuilderBase, Builder
+    from kivy.base import stopTouchApp
+    from kivy import kivy_data_dir
+    from kivy.logger import LoggerHistory
+
+    kivy_eventloop = environ.get('KIVY_EVENTLOOP', 'asyncio')
+    if kivy_eventloop == 'asyncio':
+        pytest.importorskip(
+            'pytest_asyncio',
+            reason='KIVY_EVENTLOOP == "asyncio" but '
+                   '"pytest_asyncio" is not installed')
+        async_lib = 'asyncio'
+    elif kivy_eventloop == 'trio':
+        pytest.importorskip(
+            'pytest_trio',
+            reason='KIVY_EVENTLOOP == "trio" but '
+                   '"pytest_trio" is not installed')
+        async_lib = 'trio'
+    else:
+        pytest.skip(
+            'KIVY_EVENTLOOP must be set to either of "asyncio" or '
+            '"trio" to run async tests')
+
+    context = Context(init=False)
+    context['Clock'] = ClockBase(async_lib=async_lib)
+
+    # have to make sure all global kv files are loaded before this because
+    # globally read kv files (e.g. on module import) will not be loaded again
+    # in the new builder, except if manually loaded, which we don't do
+    context['Factory'] = FactoryBase.create_from(Factory)
+    context['Builder'] = BuilderBase.create_from(Builder)
+    context.push()
+
+    Window.create_window()
+    Window.register()
+    Window.initialized = True
+    Window.canvas.clear()
+
+    app = request.param[0]()
+    app.set_async_lib(async_lib)
+
+    if async_lib == 'asyncio':
+        import asyncio
+        loop = asyncio.get_event_loop()
+        loop.create_task(app.async_run())
+    else:
+        nursery.start_soon(app.async_run)
+    from kivy.clock import Clock
+    Clock._max_fps = 0
+
+    ts = time.perf_counter()
+    while not app.app_has_started:
+        await app.async_sleep(.1)
+        if time.perf_counter() - ts >= 10:
+            raise TimeoutError()
+
+    await app.wait_clock_frames(5)
+
+    yield app
+
+    stopTouchApp()
+
+    ts = time.perf_counter()
+    while not app.app_has_stopped:
+        await app.async_sleep(.1)
+        if time.perf_counter() - ts >= 10:
+            raise TimeoutError()
+
+    for child in Window.children[:]:
+        Window.remove_widget(child)
+    context.pop()
+
+    # release all the resources
+    del context
+    LoggerHistory.clear_history()
+    apps.append((weakref.ref(app), request))
+    del app
+    gc.collect()

kivy/tests/perf_test_textinput.py

@@ -0,0 +1,195 @@
+from kivy.app import App
+from kivy.uix.floatlayout import FloatLayout
+from kivy.lang import Builder
+from kivy.resources import resource_find
+from kivy.clock import Clock
+
+import timeit
+
+Builder.load_string('''
+<PerfApp>:
+    value: 0
+    but: but.__self__
+    slider: slider
+    text_input: text_input
+    BoxLayout:
+        orientation: 'vertical'
+        TextInput:
+            id: text_input
+        BoxLayout:
+            orientation: 'vertical'
+            size_hint: 1, .2
+            BoxLayout:
+                Button:
+                    id: but
+                    text: 'Start Test'
+                    on_release: root.start_test() if self.text == 'Start Test'\
+                    else ''
+            Slider:
+                id: slider
+                min: 0
+                max: 100
+                value: root.value
+''')
+
+
+class PerfApp(App, FloatLayout):
+
+    def build(self):
+        return self
+
+    def __init__(self, **kwargs):
+        super(PerfApp, self).__init__(**kwargs)
+        self.tests = []
+        tests = (self.load_large_text, self.stress_insert,
+            self.stress_del, self.stress_selection)
+        for test in tests:
+            but = type(self.but)(text=test.__name__)
+            self.but.parent.add_widget(but)
+            but.test = test
+            self.tests.append(but)
+        self.test_done = True
+
+    def load_large_text(self, *largs):
+        print('loading uix/textinput.py....')
+        self.test_done = False
+        fd = open(resource_find('uix/textinput.py'), 'r')
+        print('putting text in textinput')
+
+        def load_text(*l):
+            self.text_input.text = fd.read()
+
+        t = timeit.Timer(load_text)
+        ttk = t.timeit(1)
+        fd.close()
+        import resource
+        print('mem usage after test')
+        print(resource.getrusage(resource.RUSAGE_SELF).ru_maxrss / 1024, 'MB')
+        print('------------------------------------------')
+        print('Loaded', len(self.text_input._lines), 'lines', ttk, 'secs')
+        print('------------------------------------------')
+        self.test_done = True
+
+    def stress_del(self, *largs):
+        self.test_done = False
+        text_input = self.text_input
+        self.lt = len_text = len(text_input.text)
+        target = len_text - (210 * 9)
+        self.tot_time = 0
+        ev = None
+
+        def dlt(*l):
+            if len(text_input.text) <= target:
+                ev.cancel()
+                print('Done!')
+                m_len = len(text_input._lines)
+                print('deleted 210 characters 9 times')
+                import resource
+                print('mem usage after test')
+                print(resource.getrusage(resource.RUSAGE_SELF).ru_maxrss /
+                    1024, 'MB')
+                print('total lines in text input:', m_len)
+                print('--------------------------------------')
+                print('total time elapsed:', self.tot_time)
+                print('--------------------------------------')
+                self.test_done = True
+                return
+            text_input.select_text(self.lt - 220, self.lt - 10)
+            text_input.delete_selection()
+            self.lt -= 210
+            text_input.scroll_y -= 100
+            self.tot_time += l[0]
+            ev()
+        ev = Clock.create_trigger(dlt)
+        ev()
+
+    def stress_insert(self, *largs):
+        self.test_done = False
+        text_input = self.text_input
+        text_input.select_all()
+        text_input.copy(text_input.selection_text)
+        text_input.cursor = text_input.get_cursor_from_index(
+            text_input.selection_to)
+        len_text = len(text_input._lines)
+        self.tot_time = 0
+        ev = None
+
+        def pste(*l):
+            if len(text_input._lines) >= (len_text) * 9:
+                ev.cancel()
+                print('Done!')
+                m_len = len(text_input._lines)
+                print('pasted', len_text, 'lines',
+                    round((m_len - len_text) / len_text), 'times')
+                import resource
+                print('mem usage after test')
+                print(resource.getrusage(resource.RUSAGE_SELF).ru_maxrss /
+                    1024, 'MB')
+                print('total lines in text input:', m_len)
+                print('--------------------------------------')
+                print('total time elapsed:', self.tot_time)
+                print('--------------------------------------')
+                self.test_done = True
+                return
+            self.tot_time += l[0]
+            text_input.paste()
+            ev()
+        ev = Clock.create_trigger(pste)
+        ev()
+
+    def stress_selection(self, *largs):
+        self.test_done = False
+        text_input = self.text_input
+        self.tot_time = 0
+        old_selection_from = text_input.selection_from - 210
+        ev = None
+
+        def pste(*l):
+            if text_input.selection_from >= old_selection_from:
+                ev.cancel()
+                print('Done!')
+                import resource
+                print('mem usage after test')
+                print(resource.getrusage(resource.RUSAGE_SELF).ru_maxrss /
+                    1024, 'MB')
+                print('--------------------------------------')
+                print('total time elapsed:', self.tot_time)
+                print('--------------------------------------')
+                self.test_done = True
+                return
+            text_input.select_text(text_input.selection_from - 1,
+                text_input.selection_to)
+            ev()
+        ev = Clock.create_trigger(pste)
+        ev()
+
+    def start_test(self, *largs):
+        self.but.text = 'test started'
+        self.slider.max = len(self.tests)
+        ev = None
+
+        def test(*l):
+            if self.test_done:
+                try:
+                    but = self.tests[int(self.slider.value)]
+                    self.slider.value += 1
+                    but.state = 'down'
+                    print('=====================')
+                    print('Test:', but.text)
+                    print('=====================')
+                    but.test(but)
+                except IndexError:
+                    for but in self.tests:
+                        but.state = 'normal'
+                    self.but.text = 'Start Test'
+                    self.slider.value = 0
+                    print('===================')
+                    print('All Tests Completed')
+                    print('===================')
+                    ev.cancel()
+
+        ev = Clock.schedule_interval(test, 1)
+
+
+if __name__ in ('__main__', ):
+    PerfApp().run()

kivy/tests/pyinstaller/simple_widget/main.py

@@ -0,0 +1,12 @@
+
+
+from project.widget import MyWidget
+
+if __name__ == '__main__':
+    w = MyWidget()
+
+    assert w.x == w.y
+    w.y = 868
+    assert w.x == 868
+    w.y = 370
+    assert w.x == 370

kivy/tests/pyinstaller/simple_widget/project/widget.py

@@ -0,0 +1,12 @@
+from kivy.uix.widget import Widget
+
+
+class MyWidget(Widget):
+
+    def __init__(self, **kwargs):
+        super(MyWidget, self).__init__(**kwargs)
+
+        def callback(*l):
+            self.x = self.y
+        self.fbind('y', callback)
+        callback()

kivy/tests/pyinstaller/test_pyinstaller.py

@@ -0,0 +1,115 @@
+import pytest
+import os
+import subprocess
+import sys
+import shutil
+
+if sys.platform != 'win32':
+    pytestmark = pytest.mark.skip(
+        "PyInstaller is currently only tested on Windows")
+else:
+    try:
+        import PyInstaller
+    except ImportError:
+        pytestmark = pytest.mark.skip("PyInstaller is not available")
+
+
+@pytest.mark.incremental
+class PyinstallerBase(object):
+
+    pinstall_path = ''
+
+    env = None
+
+    @classmethod
+    def setup_class(cls):
+        cls.env = cls.get_env()
+
+    @classmethod
+    def get_env(cls):
+        env = os.environ.copy()
+        env['__KIVY_PYINSTALLER_DIR'] = cls.pinstall_path
+
+        if 'PYTHONPATH' not in env:
+            env['PYTHONPATH'] = cls.pinstall_path
+        else:
+            env['PYTHONPATH'] = cls.pinstall_path + os.sep + env['PYTHONPATH']
+        return env
+
+    @classmethod
+    def get_run_env(cls):
+        return os.environ.copy()
+
+    def test_project(self):
+        try:
+            # check that the project works normally before packaging
+            subprocess.check_output(
+                [sys.executable or 'python',
+                 os.path.join(self.pinstall_path, 'main.py')],
+                stderr=subprocess.STDOUT, env=self.env)
+        except subprocess.CalledProcessError as e:
+            print(e.output.decode('utf8'))
+            raise
+
+    def test_packaging(self):
+        dist = os.path.join(self.pinstall_path, 'dist')
+        build = os.path.join(self.pinstall_path, 'build')
+        try:
+            # create pyinstaller package
+            subprocess.check_output(
+                [sys.executable or 'python', '-m', 'PyInstaller',
+                 os.path.join(self.pinstall_path, 'main.spec'),
+                 '--distpath', dist, '--workpath', build],
+                stderr=subprocess.STDOUT, env=self.env)
+        except subprocess.CalledProcessError as e:
+            print(e.output.decode('utf8'))
+            raise
+
+    def test_packaged_project(self):
+        try:
+            # test package
+            subprocess.check_output(
+                os.path.join(self.pinstall_path, 'dist', 'main', 'main'),
+                stderr=subprocess.STDOUT, env=self.get_run_env())
+        except subprocess.CalledProcessError as e:
+            print(e.output.decode('utf8'))
+            raise
+
+    @classmethod
+    def teardown_class(cls):
+        shutil.rmtree(
+            os.path.join(cls.pinstall_path, '__pycache__'),
+            ignore_errors=True)
+        shutil.rmtree(
+            os.path.join(cls.pinstall_path, 'build'), ignore_errors=True)
+        shutil.rmtree(
+            os.path.join(cls.pinstall_path, 'dist'), ignore_errors=True)
+        shutil.rmtree(
+            os.path.join(cls.pinstall_path, 'project', '__pycache__'),
+            ignore_errors=True)
+
+
+class TestSimpleWidget(PyinstallerBase):
+
+    pinstall_path = os.path.join(os.path.dirname(__file__), 'simple_widget')
+
+
+class TestVideoWidget(PyinstallerBase):
+
+    pinstall_path = os.path.join(os.path.dirname(__file__), 'video_widget')
+
+    @classmethod
+    def get_env(cls):
+        env = super(TestVideoWidget, cls).get_env()
+        import kivy
+        env['__KIVY_VIDEO_TEST_FNAME'] = os.path.abspath(os.path.join(
+            kivy.kivy_examples_dir, "widgets", "cityCC0.mpg"))
+        return env
+
+    @classmethod
+    def get_run_env(cls):
+        env = super(TestVideoWidget, cls).get_run_env()
+        import kivy
+        env['__KIVY_VIDEO_TEST_FNAME'] = os.path.abspath(os.path.join(
+            kivy.kivy_examples_dir, "widgets", "cityCC0.mpg"))
+        return env

kivy/tests/pyinstaller/video_widget/main.py

@@ -0,0 +1,6 @@
+from project import VideoApp
+
+if __name__ == '__main__':
+    from kivy.core.video import Video
+    assert Video is not None
+    VideoApp().run()

kivy/tests/pyinstaller/video_widget/project/__init__.py

@@ -0,0 +1,38 @@
+from kivy.app import App
+from kivy.uix.videoplayer import VideoPlayer
+from kivy.clock import Clock
+import os
+import time
+
+
+class VideoApp(App):
+
+    player = None
+
+    start_t = None
+
+    def build(self):
+        self.player = player = VideoPlayer(
+            source=os.environ['__KIVY_VIDEO_TEST_FNAME'], volume=0)
+
+        self.player.fbind('position', self.check_position)
+        Clock.schedule_once(self.start_player, 0)
+        Clock.schedule_interval(self.stop_player, 1)
+        return player
+
+    def start_player(self, *args):
+        self.player.state = 'play'
+        self.start_t = time.perf_counter()
+
+    def check_position(self, *args):
+        if self.player.position > 0.1:
+            self.stop_player()
+
+    def stop_player(self, *args):
+        if time.perf_counter() - self.start_t > 20:
+            assert self.player.duration > 0
+            assert self.player.position > 0
+            self.stop()
+        else:
+            if self.player.position > 0 and self.player.duration > 0:
+                self.stop()