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

kivy/tests/test_weakmethod.py

@@ -0,0 +1,44 @@
+import gc
+
+
+def test_weak_method_on_obj():
+    from kivy.weakmethod import WeakMethod
+
+    class SomeClass:
+
+        def do_something(self):
+            pass
+
+    obj = SomeClass()
+    weak_method = WeakMethod(obj.do_something)
+
+    assert not weak_method.is_dead()
+    assert weak_method() == obj.do_something
+    assert weak_method == WeakMethod(obj.do_something)
+    assert weak_method != WeakMethod(SomeClass().do_something)
+
+    del obj
+    gc.collect()
+
+    assert weak_method.is_dead()
+    assert weak_method() is None
+    assert weak_method != WeakMethod(SomeClass().do_something)
+
+
+def test_weak_method_func():
+    from kivy.weakmethod import WeakMethod
+
+    def do_something():
+        pass
+
+    weak_method = WeakMethod(do_something)
+
+    assert not weak_method.is_dead()
+    assert weak_method() == do_something
+    assert weak_method == WeakMethod(do_something)
+
+    del do_something
+    gc.collect()
+
+    assert not weak_method.is_dead()
+    assert weak_method() is not None

kivy/tests/test_widget.py

@@ -0,0 +1,127 @@
+import unittest
+from tempfile import mkdtemp
+from shutil import rmtree
+
+
+class WidgetTestCase(unittest.TestCase):
+
+    def setUp(self):
+        from kivy.uix.widget import Widget
+        self.cls = Widget
+        self.root = Widget()
+
+    def test_add_remove_widget(self):
+        root = self.root
+        self.assertEqual(root.children, [])
+        c1 = self.cls()
+        root.add_widget(c1)
+        self.assertEqual(root.children, [c1])
+        root.remove_widget(c1)
+        self.assertEqual(root.children, [])
+
+    def test_invalid_add_widget(self):
+        from kivy.uix.widget import WidgetException
+        try:
+            # None of them should work
+            self.root.add_widget(None)
+            self.root.add_widget(WidgetException)
+            self.root.add_widget(self.cls)
+            self.fail()
+        except WidgetException:
+            pass
+
+    def test_clear_widgets(self):
+        root = self.root
+        self.assertEqual(root.children, [])
+
+        c1 = self.cls()
+        c2 = self.cls()
+        c3 = self.cls()
+        root.add_widget(c1, index=0)
+        root.add_widget(c2, index=1)
+        root.add_widget(c3, index=2)
+        self.assertEqual(root.children, [c1, c2, c3])
+
+        root.clear_widgets([c2])
+        self.assertEqual(root.children, [c1, c3])
+
+        root.clear_widgets([])
+        self.assertEqual(root.children, [c1, c3])
+
+        root.clear_widgets()
+        self.assertEqual(root.children, [])
+
+    def test_clear_widgets_children(self):
+        root = self.root
+        for _ in range(10):
+            root.add_widget(self.cls())
+        self.assertEqual(len(root.children), 10)
+
+        root.clear_widgets(root.children)
+        self.assertEqual(root.children, [])
+
+    def test_position(self):
+        wid = self.root
+        wid.x = 50
+        self.assertEqual(wid.x, 50)
+        self.assertEqual(wid.pos, [50, 0])
+        wid.y = 60
+        self.assertEqual(wid.y, 60)
+        self.assertEqual(wid.pos, [50, 60])
+        wid.pos = (0, 0)
+        self.assertEqual(wid.pos, [0, 0])
+        self.assertEqual(wid.x, 0)
+        self.assertEqual(wid.y, 0)
+
+    def test_size(self):
+        wid = self.root
+        wid.width = 50
+        self.assertEqual(wid.width, 50)
+        self.assertEqual(wid.size, [50, 100])
+        wid.height = 60
+        self.assertEqual(wid.height, 60)
+        self.assertEqual(wid.size, [50, 60])
+        wid.size = (100, 100)
+        self.assertEqual(wid.size, [100, 100])
+        self.assertEqual(wid.width, 100)
+        self.assertEqual(wid.height, 100)
+
+    def test_collision(self):
+        wid = self.root
+        self.assertEqual(wid.pos, [0, 0])
+        self.assertEqual(wid.size, [100, 100])
+        self.assertEqual(wid.collide_point(-1, -1), False)
+        self.assertEqual(wid.collide_point(0, 0), True)
+        self.assertEqual(wid.collide_point(50, 50), True)
+        self.assertEqual(wid.collide_point(100, 100), True)
+        self.assertEqual(wid.collide_point(200, 0), False)
+        self.assertEqual(wid.collide_point(500, 500), False)
+
+    # Currently rejected with a Shader didn't link, but work alone.
+    @unittest.skip("Doesn't work with testsuite, but work alone")
+    def test_export_to_png(self):
+        from kivy.core.image import Image as CoreImage
+        from kivy.uix.button import Button
+        from os.path import join
+
+        wid = Button(text='test', size=(200, 100), size_hint=(None, None))
+        self.root.add_widget(wid)
+
+        tmp = mkdtemp()
+        wid.export_to_png(join(tmp, 'a.png'))
+        wid.export_to_png(join(tmp, 'b.png'), scale=.5)
+        wid.export_to_png(join(tmp, 'c.png'), scale=2)
+
+        self.assertEqual(CoreImage(join(tmp, 'a.png')).size, (200, 100))
+        self.assertEqual(CoreImage(join(tmp, 'b.png')).size, (100, 50))
+        self.assertEqual(CoreImage(join(tmp, 'c.png')).size, (400, 200))
+        rmtree(tmp)
+
+        self.root.remove_widget(wid)
+
+    def test_disabled(self):
+        from kivy.uix.widget import Widget
+        w = Widget(disabled=None)
+        w.disabled = False
+        w.disabled = True
+        self.assertEqual(w.disabled, True)

kivy/tests/test_widget_walk.py

@@ -0,0 +1,70 @@
+import unittest
+
+
+class FileWidgetWalk(unittest.TestCase):
+
+    def test_walk_large_tree(self):
+        from kivy.uix.boxlayout import BoxLayout
+        from kivy.uix.label import Label
+        ''' the tree
+        BoxLayout
+            BoxLayout
+            Label
+                10 labels
+            BoxLayout
+                10 labels
+            BoxLayout
+                Label
+            Label
+        '''
+
+        root = BoxLayout()
+        tree = [root]
+
+        box = BoxLayout()
+        tree.append(box)
+        root.add_widget(box)
+
+        label = Label()
+        tree.append(label)
+        root.add_widget(label)
+        for i in range(10):
+            tree.append(Label())
+            label.add_widget(tree[-1])
+
+        box = BoxLayout()
+        tree.append(box)
+        root.add_widget(box)
+        for i in range(10):
+            tree.append(Label())
+            box.add_widget(tree[-1])
+
+        box = BoxLayout()
+        tree.append(box)
+        root.add_widget(box)
+        tree.append(Label())
+        box.add_widget(tree[-1])
+
+        label = Label()
+        tree.append(label)
+        root.add_widget(label)
+
+        def rotate(l, n):
+            return l[n:] + l[:n]
+
+        for i in range(len(tree)):
+            rotated = rotate(tree, i)   # shift list to start at i
+            # walk starting with i
+            walked = [n for n in tree[i].walk(loopback=True)]
+            walked_reversed = [n for n in tree[i].walk_reverse(loopback=True)]
+
+            self.assertListEqual(rotated, walked)
+            self.assertListEqual(walked, list(reversed(walked_reversed)))
+
+    def test_walk_single(self):
+        from kivy.uix.label import Label
+
+        label = Label()
+        self.assertListEqual([n for n in label.walk(loopback=True)], [label])
+        self.assertListEqual([n for n in label.walk_reverse(loopback=True)],
+                             [label])

kivy/tests/test_window_base.py

@@ -0,0 +1,60 @@
+from itertools import product
+
+from kivy.tests import GraphicUnitTest
+from kivy.logger import LoggerHistory
+
+
+class WindowBaseTest(GraphicUnitTest):
+
+    def test_to_normalized_pos(self):
+        win = self.Window
+        old_system_size = win.system_size[:]
+        win.system_size = w, h = type(old_system_size)((320, 240))
+        try:
+            for x, y in product([0, 319, 50, 51], [0, 239, 50, 51]):
+                expected_sx = x / (w - 1.0)
+                expected_sy = y / (h - 1.0)
+                result_sx, result_sy = win.to_normalized_pos(x, y)
+                assert result_sx == expected_sx
+                assert result_sy == expected_sy
+        finally:
+            win.system_size = old_system_size
+
+
+class WindowOpacityTest(GraphicUnitTest):
+
+    def setUp(self):
+        super().setUp()
+        self._prev_window_opacity = self.Window.opacity
+        self._prev_history = LoggerHistory.history[:]
+
+    def tearDown(self):
+        self.Window.opacity = self._prev_window_opacity
+        LoggerHistory.history[:] = self._prev_history
+        super().tearDown()
+
+    def get_new_opacity_value(self):
+        opacity = self.Window.opacity
+        opacity = opacity - 0.1 if opacity >= 0.9 else opacity + 0.1
+        return round(opacity, 2)
+
+    def check_opacity_support(self):
+        LoggerHistory.clear_history()
+        self.Window.opacity = self.get_new_opacity_value()
+        return not LoggerHistory.history
+
+    def test_window_opacity_property(self):
+        if self.check_opacity_support():
+            opacity = self.get_new_opacity_value()
+            self.Window.opacity = opacity
+            self.assertEqual(self.Window.opacity, opacity)
+
+    def test_window_opacity_clamping_positive(self):
+        if self.check_opacity_support():
+            self.Window.opacity = 1.5
+            self.assertEqual(self.Window.opacity, 1.0)
+
+    def test_window_opacity_clamping_negative(self):
+        if self.check_opacity_support():
+            self.Window.opacity = -1.5
+            self.assertEqual(self.Window.opacity, 0.0)

kivy/tests/test_window_info.py

@@ -0,0 +1,29 @@
+from kivy.tests.common import GraphicUnitTest
+from kivy import setupconfig
+
+
+class WindowInfoTest(GraphicUnitTest):
+    def test_window_info_nonzero(self):
+        from kivy.core.window import Window
+        window_info = Window.get_window_info()
+        if window_info is None:
+            return
+
+        if setupconfig.USE_X11:
+            from kivy.core.window.window_info import WindowInfoX11
+            if isinstance(window_info, WindowInfoX11):
+                self.assertNotEqual(window_info.display, 0)
+                self.assertNotEqual(window_info.window, 0)
+
+        if setupconfig.USE_WAYLAND:
+            from kivy.core.window.window_info import WindowInfoWayland
+            if isinstance(window_info, WindowInfoWayland):
+                self.assertNotEqual(window_info.display, 0)
+                self.assertNotEqual(window_info.surface, 0)
+                self.assertNotEqual(window_info.shell_surface, 0)
+
+        if setupconfig.PLATFORM == 'win32':
+            from kivy.core.window.window_info import WindowInfoWindows
+            if isinstance(window_info, WindowInfoWindows):
+                self.assertNotEqual(window_info.window, 0)
+                self.assertNotEqual(window_info.hdc, 0)

kivy/tests/visual_test_label.py

@@ -0,0 +1,291 @@
+from kivy.app import runTouchApp
+from kivy.uix.gridlayout import GridLayout
+from kivy.properties import StringProperty
+from kivy.lang import Builder
+from kivy.utils import get_hex_from_color, get_random_color
+import timeit
+import re
+import random
+from functools import partial
+
+
+def layout_perf(label, repeat):
+    if repeat:
+        repeat = int(repeat)
+    else:
+        return 'None'
+    return str(timeit.Timer(label._label.render).repeat(1, repeat))
+
+
+def layout_real_perf(label, repeat):
+    if repeat:
+        repeat = int(repeat)
+    else:
+        return 'None'
+    old_text = label._label.texture
+    label._label.texture = label._label.texture_1px
+    res = str(timeit.Timer(partial(label._label.render, True)).repeat(1,
+                                                                      repeat))
+    label._label.texture = old_text
+    return res
+
+
+kv = '''
+#:import tlp visual_test_label.layout_perf
+#:import tlrp visual_test_label.layout_real_perf
+
+<TSliderButton@ToggleButton>:
+    size_hint: None, None
+    size: 100, 50
+    group: 'slider'
+    on_press: self.parent.slider.name = self.text if self.state =='down' else\
+    'dummy'
+
+<TSpinner@Spinner>:
+    size_hint: None, None
+    size: 100, 50
+    name: ''
+    on_text: setattr(self.parent.label, self.name, self.text)
+
+<TBoolButton@ToggleButton>:
+    size_hint: None, None
+    size: 100, 50
+    on_state: setattr(self.parent.label, self.text, self.state == 'down')
+
+<TLabel@Label>:
+    size_hint: None, None
+    size: 100, 50
+
+
+<LabelTest>:
+    cols: 1
+    spacing: 10
+    padding: 20
+    TabbedPanel:
+        do_default_tab: False
+        tab_width: self.width / 11 * 3
+        TabbedPanelItem:
+            text: 'Label'
+            BoxLayout:
+                ScrollView:
+                    id: scrollview
+                    Label:
+                        size_hint: None, None
+                        size: self.texture_size
+                        id: label
+                        text: record.text
+                        dummy: 0
+                        canvas:
+                            Color:
+                                rgba: 0, 1, 0, 0.5
+                            Rectangle:
+                                pos: self.pos
+                                size: self.width, self.padding_y
+                            Rectangle:
+                                pos: self.x, self.y + self.height -\
+                                self.padding_y
+                                size: self.width, self.padding_y
+                            Color:
+                                rgba: 0, 0, 1, 0.5
+                            Rectangle:
+                                pos: self.pos
+                                size: self.padding_x, self.height
+                            Rectangle:
+                                pos: self.x + self.width - self.padding_x,\
+                                self.y
+                                size: self.padding_x, self.height
+                Splitter:
+                    sizable_from: 'left'
+                    TextInput:
+                        id: record
+                        text: label.text
+                        text: root.text
+        TabbedPanelItem:
+            text: 'Test performance'
+            BoxLayout:
+                orientation: 'vertical'
+                Label:
+                    text: 'Test timeit performance with current label settings'
+                BoxLayout:
+                    size_hint_y: None
+                    height: 40
+                    padding: [20, 0]
+                    Label:
+                        text: 'Repeat count: '
+                    TextInput:
+                        id: repeat
+                        text: '1000'
+                    Button:
+                        text: 'Go (render - layout)'
+                        on_press: results.text = tlp(label, repeat.text)
+                    Button:
+                        text: 'Go (render_real)'
+                        on_press: results.text = tlrp(label, repeat.text)
+                Label:
+                    id: results
+                    text: 'Results:'
+
+    StackLayout:
+        id: slider_ctrl
+        size_hint_y: None
+        height: self.minimum_height
+        slider: slider
+        label: label
+        TLabel:
+            text: 'halign: '
+        TSpinner:
+            name: 'halign'
+            values: ['left', 'center', 'right', 'justify']
+            text: 'left'
+        TLabel:
+            text: 'valign: '
+        TSpinner:
+            name: 'valign'
+            values: ['top', 'middle', 'center', 'bottom']
+            text: 'bottom'
+        TBoolButton:
+            text: 'markup'
+        TBoolButton:
+            text: 'shorten'
+        TextInput:
+            size_hint: None, None
+            size: 100, 50
+            hint_text: 'split_str'
+            on_text_validate: label.split_str = self.text
+            multiline: False
+        TLabel:
+            text: 'shorten_from: '
+        TSpinner:
+            name: 'shorten_from'
+            values: ['left', 'center', 'right']
+            text: 'right'
+        TBoolButton:
+            text: 'strip'
+            state: 'down'
+        ToggleButton:
+            size_hint: None, None
+            size: 100, 50
+            text: 'random size'
+            on_state: label.text = root.sized_text if self.state == 'down'\
+            else root.text
+        TLabel:
+            text: 'Slider control:'
+        TSliderButton:
+            text: 'font_size'
+        TSliderButton:
+            text: 'line_height'
+        TSliderButton:
+            text: 'max_lines'
+        TSliderButton:
+            text: 'padding_x'
+        TSliderButton:
+            text: 'padding_y'
+        TextInput:
+            size_hint: None, None
+            size: 100, 50
+            hint_text: 'text_size[0]'
+            on_text_validate: label.text_size = (int(self.text) if self.text\
+            else None), label.text_size[1]
+            multiline: False
+        TextInput:
+            size_hint: None, None
+            size: 100, 50
+            hint_text: 'text_size[1]'
+            on_text_validate: label.text_size = label.text_size[0],\
+            (int(self.text) if self.text else None)
+            multiline: False
+        TLabel:
+            text: '<-- w/ validate'
+    Label:
+        size_hint_y: None
+        height: 40
+        color: [0, 1, 0, 1]
+        text_size: self.size
+        text: 'scrollview size: {}, label size: {}, text_size: {}, '\
+        'texture_size: {}, padding: {}'.format(scrollview.size, label.size,\
+        label.text_size, label.texture_size, label.padding)
+
+    BoxLayout:
+        size_hint_y: None
+        height: 40
+        Slider:
+            id: slider
+            range: -10, 200
+            value: 15
+            name: 'dummy'
+            on_value: setattr(label, self.name, self.value)
+        Label:
+            size_hint_x: None
+            width: 50
+            text: str(int(slider.value))
+
+'''
+
+
+text = '''
+Because it would spare your Majesty all fear of future \
+annoyance. If the lady loves her husband, she does not love your \
+Majesty. If she does not love your Majesty, there is no reason \
+why she should interfere with your Majesty's plan.
+
+"It is true. And yet--Well! I wish she had been of my own \
+station! What a queen she would have made!" He relapsed into a \
+moody silence, which was not broken until we drew up in \
+Serpentine Avenue.
+
+The door of Briony Lodge was open, and an elderly woman stood \
+upon the steps. She watched us with a sardonic eye as we stepped \
+from the brougham.
+
+Mr. Sherlock Holmes, I believe?" said she.
+
+I am Mr. Holmes," answered my companion, looking at her with a \
+questioning and rather startled gaze.
+
+Indeed! My mistress told me that you were likely to call. She \
+left this morning with her husband by the 5:15 train from Charing \
+Cross for the Continent."
+
+"What!" Sherlock Holmes staggered back, white with chagrin and \
+surprise. "Do you mean that she has left England?"
+
+Never to return.
+
+"And the papers?" asked the King hoarsely. "All is lost."
+'''
+
+words = re.split('( +|\\n+)', text)
+
+
+def annotate(pre, post, callable, words):
+    state = False
+    i = random.randint(0, 4)
+    while i < len(words):
+        if ' ' in words[i] or '\n' in words[i]:  # skip spaces
+            i += 1
+            continue
+        if not state:
+            words[i] = pre.format(callable(), words[i])
+        else:
+            words[i] = post.format(words[i])
+        state = not state
+        i += random.randint(1, 7)
+
+
+annotate('[size={0}]{1}', '{0}[/size]', partial(random.randint, 8, 24), words)
+annotate('[b]{1}', '{0}[/b]', str, words)
+annotate('[i]{1}', '{0}[/i]', str, words)
+annotate('[color={0}]{1}', '{0}[/color]',
+         lambda: get_hex_from_color(get_random_color()), words)
+annotated_text = ''.join(words)
+
+
+class LabelTest(GridLayout):
+
+    text = StringProperty(text)
+    sized_text = StringProperty(annotated_text)
+
+
+if __name__ in ('__main__', ):
+    Builder.load_string(kv)
+    runTouchApp(LabelTest())

kivy/tools/__init__.py

@@ -0,0 +1,44 @@
+"""
+Tools
+=====
+
+The tools module provides various utility scripts, modules and examples.
+
+Scripts
+-------
+
+Some useful scripts include:
+
+* :file:`kviewer.py`: for viewing kv files with automatic updating
+* :file:`benchmark.py`: provides detailed OpenGL hardware information as well
+  as some benchmarks measuring kivy specific performance
+* :file:`reports.py`: provides a comprehensive report covering your systems
+  providers, libraries, configuration, environment, input devices and options
+* :file:`texturecompress.py`: a command line utility for compressing images
+  into PVRTC or ETC1 formats
+* :file:`generate-icons.py`: generates set of icons suitable for the various
+  store and package formats
+* :file:`gles_compat/subset_gles.py`: examines compatibility between GLEXT and
+  GLES2 headers for finding compatible subsets
+
+Modules
+-------
+
+Tool modules provide various resources for:
+
+* :mod:`~kivy.tools.packaging`
+* :mod:`text editor highlighting <kivy.tools.highlight>`
+
+
+Other
+-----
+
+Other miscellaneous resources include
+
+* :file:`pep8checker`: pep8 checking scripts and git hook
+* :file:`theming`: demonstrates an alternative theme for kivy
+* :file:`travis`: travis continuous integration
+
+This help document is a work-in-progress and currently under construction.
+
+"""