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

kivy/tools/benchmark.py

@@ -0,0 +1,286 @@
+'''
+Benchmark
+=========
+
+This script performs and displays the results of a set of benchmarks. These
+provide a set of metrics mainly aimed at gauging the OpenGL performance of your
+system.
+
+It also provides more specs regarding your graphics card setup together with
+more comprehensive system information.
+'''
+
+from __future__ import print_function
+
+benchmark_version = '1'
+
+import os
+import sys
+import json
+import kivy
+import gc
+from time import clock, time, ctime
+from random import randint
+
+from kivy.uix.label import Label
+from kivy.uix.button import Button
+from kivy.uix.widget import Widget
+from kivy.graphics import RenderContext
+from kivy.input.motionevent import MotionEvent
+from kivy.cache import Cache
+from kivy.clock import Clock
+from kivy.compat import PY2
+
+if not PY2:
+    xrange = range
+
+clockfn = time
+if sys.platform == 'win32':
+    clockfn = clock
+
+
+class FakeMotionEvent(MotionEvent):
+    pass
+
+
+class bench_widget_creation:
+    '''Widget: creation (10000 Widget)'''
+
+    def run(self):
+        o = []
+        for x in range(10000):
+            o.append(Widget())
+
+
+class bench_widget_creation_with_root:
+    '''Widget: creation (10000 Widget + 1 root)'''
+
+    def run(self):
+        o = Widget()
+        for x in range(10000):
+            o.add_widget(Widget())
+
+
+class bench_widget_draw:
+    '''Widget: empty drawing (10000 Widget + 1 root)'''
+
+    def __init__(self):
+        self.ctx = RenderContext()
+        self.root = root = Widget()
+        for x in range(10000):
+            root.add_widget(Widget())
+        self.ctx.add(self.root.canvas)
+
+    def run(self):
+        self.ctx.draw()
+
+
+class bench_widget_dispatch:
+    '''Widget: event dispatch (1000 on_update in 10*1000 Widget)'''
+
+    def __init__(self):
+        root = Widget()
+        for x in range(10):
+            parent = Widget()
+            for y in range(1000):
+                parent.add_widget(Widget())
+            root.add_widget(parent)
+        self.root = root
+
+    def run(self):
+        touch = FakeMotionEvent('fake', 1, [])
+        self.root.dispatch('on_touch_down', touch)
+        self.root.dispatch('on_touch_move', touch)
+        self.root.dispatch('on_touch_up', touch)
+
+
+class bench_label_creation:
+    '''Core: label creation (10000 * 10 a-z)'''
+
+    def __init__(self):
+        labels = []
+        for x in range(10000):
+            label = [chr(randint(ord('a'), ord('z'))) for x in range(10)]
+            labels.append(''.join(label))
+        self.labels = labels
+
+    def run(self):
+        o = []
+        for x in self.labels:
+            o.append(Label(text=x))
+
+
+class bench_button_creation:
+    '''Core: button creation (10000 * 10 a-z)'''
+
+    def __init__(self):
+        labels = []
+        for x in xrange(10000):
+            button = map(lambda x: chr(randint(ord('a'), ord('z'))),
+                         xrange(10))
+            labels.append(''.join(button))
+        self.labels = labels
+
+    def run(self):
+        o = []
+        for x in self.labels:
+            o.append(Button(text=x))
+
+
+class bench_label_creation_with_tick:
+    '''Core: label creation (10000 * 10 a-z), with Clock.tick'''
+
+    def __init__(self):
+        labels = []
+        for x in range(10000):
+            label = [chr(randint(ord('a'), ord('z'))) for x in range(10)]
+            labels.append(''.join(label))
+        self.labels = labels
+
+    def run(self):
+        o = []
+        for x in self.labels:
+            o.append(Label(text=x))
+        # tick for texture creation
+        Clock.tick()
+
+
+class bench_button_creation_with_tick:
+    '''Core: button creation (10000 * 10 a-z), with Clock.tick'''
+
+    def __init__(self):
+        labels = []
+        for x in xrange(10000):
+            button = map(lambda x: chr(randint(ord('a'), ord('z'))),
+                         xrange(10))
+            labels.append(''.join(button))
+        self.labels = labels
+
+    def run(self):
+        o = []
+        for x in self.labels:
+            o.append(Button(text=x))
+        # tick for texture creation
+        Clock.tick()
+
+
+if __name__ == '__main__':
+
+    report = []
+    report_newline = True
+    Clock.start_clock()
+
+    def log(s, newline=True):
+        global report_newline
+        if not report_newline:
+            report[-1] = '%s %s' % (report[-1], s)
+        else:
+            report.append(s)
+        if newline:
+            print(s)
+            report_newline = True
+        else:
+            print(s, end=' ')
+            report_newline = False
+        sys.stdout.flush()
+
+    clock_total = 0
+    benchs = list(globals().keys())
+    benchs.sort()
+    benchs = [globals()[x] for x in benchs if x.startswith('bench_')]
+
+    log('')
+    log('=' * 70)
+    log('Kivy Benchmark v%s' % benchmark_version)
+    log('=' * 70)
+    log('')
+    log('System information')
+    log('-------------------')
+
+    log('OS platform     : %s' % sys.platform)
+    log('Python EXE      : %s' % sys.executable)
+    log('Python Version  : %s' % sys.version)
+    log('Python API      : %s' % sys.api_version)
+    log('Kivy Version    : %s' % kivy.__version__)
+    log('Install path    : %s' % os.path.dirname(kivy.__file__))
+    log('Install date    : %s' % ctime(os.path.getctime(kivy.__file__)))
+
+    log('')
+    log('OpenGL information')
+    log('-------------------')
+
+    from kivy.core.gl import glGetString, GL_VENDOR, GL_RENDERER, GL_VERSION
+    log('GL Vendor: %s' % glGetString(GL_VENDOR))
+    log('GL Renderer: %s' % glGetString(GL_RENDERER))
+    log('GL Version: %s' % glGetString(GL_VERSION))
+    log('')
+
+    log('Benchmark')
+    log('---------')
+
+    for x in benchs:
+        # clean cache to prevent weird case
+        for cat in Cache._categories:
+            Cache.remove(cat)
+
+        # force gc before next test
+        gc.collect()
+
+        log('%2d/%-2d %-60s' % (benchs.index(x) + 1,
+            len(benchs), x.__doc__), False)
+        try:
+            sys.stderr.write('.')
+            test = x()
+        except Exception as e:
+            log('failed %s' % str(e))
+            import traceback
+            traceback.print_exc()
+            continue
+
+        clock_start = clockfn()
+
+        try:
+            sys.stderr.write('.')
+            test.run()
+            clock_end = clockfn() - clock_start
+            log('%.6f' % clock_end)
+        except Exception as e:
+            log('failed %s' % str(e))
+            continue
+
+        clock_total += clock_end
+
+    log('')
+    log('Result: %.6f' % clock_total)
+    log('')
+    Clock.stop_clock()
+
+try:
+    reply = input(
+        'Do you want to send benchmark to gist.github.com (Y/n) : ')
+except EOFError:
+    sys.exit(0)
+
+if reply.lower().strip() in ('', 'y'):
+    print('Please wait while sending the benchmark...')
+
+    try:
+        import requests
+    except ImportError:
+        print("`requests` module not found, no benchmark posted.")
+        sys.exit(1)
+
+    payload = {
+        'public': True, 'files': {
+            'benchmark.txt': {
+                'content': '\n'.join(report)}}}
+
+    r = requests.post('https://api.github.com/gists', data=json.dumps(payload))
+
+    print()
+    print()
+    print('REPORT posted at {0}'.format(r.json['html_url']))
+    print()
+    print()
+else:
+    print('No benchmark posted.')

kivy/tools/changelog_parser.py

@@ -0,0 +1,120 @@
+"""
+Changelog parser
+================
+
+This generates a changelog from a json file of the PRs of a given milestone,
+dumped to json, using the [GitHub CLI](https://github.com/cli/cli).
+
+First, in the command line, create the following alias::
+
+    gh alias set --shell viewMilestone "gh api graphql -F owner='kivy' \
+-F name='kivy' -F number=\\$1 -f query='
+        query GetMilestones(\\$name: String!, \\$owner: String!, \\$number: \
+Int!) {
+            repository(owner: \\$owner, name: \\$name) {
+                milestone(number: \\$number) {
+                    pullRequests(states: MERGED, first: 1000) {
+                        nodes {
+                            number
+                            title
+                            labels (first: 25) {
+                                nodes {
+                                    name
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    '"
+
+Then, log in using ``gh`` and run::
+
+    gh viewMilestone 26 > prs.json
+
+This will generate ``prs.json``. Then, to generate the changelog, run::
+
+    python -m kivy.tools.changelog_parser prs.json changelog.md
+
+to generate a markdown changelog at ``changelog.md``. Then, edit as desired
+and paste into the
+[changelog here](https://github.com/kivy/kivy/blob/master/doc/sources\
+/changelog.rst).
+"""
+from os.path import exists
+import sys
+from collections import defaultdict
+import json
+
+__all__ = ('process_changelog', )
+
+
+def write_special_section(fh, items, header):
+    items = sorted(items, key=lambda x: x[0])
+    if items:
+        fh.write(f'{header}\n{"-" * len(header)}\n\n')
+        for n, title in items:
+            fh.write(f'- [:repo:`{n}`]: {title}\n')
+        fh.write('\n')
+
+
+def process_changelog(filename_in, filename_out):
+    if exists(filename_out):
+        raise ValueError(
+            '{} already exists and would be overwritten'.format(filename_out))
+
+    with open(filename_in, 'r') as fh:
+        data = json.load(fh)
+    prs = data["data"]["repository"]["milestone"]["pullRequests"]["nodes"]
+
+    bad_pr = False
+    grouped = defaultdict(list)
+    highlighted = []
+    api_breaks = []
+    deprecates = []
+    for item in prs:
+        n = item['number']
+        title = item['title']
+        labels = [label['name'] for label in item['labels']['nodes']]
+        api_break = 'Notes: API-break' in labels
+        highlight = 'Notes: Release-highlight' in labels
+        deprecated = 'Notes: API-deprecation' in labels
+        component_str = 'Component: '
+        components = [
+            label[len(component_str):]
+            for label in labels if label.startswith(component_str)
+        ]
+
+        if not components:
+            print(f'Found no component label for #{n}')
+            bad_pr = True
+            continue
+        if len(components) > 1:
+            print(f'Found more than one component label for #{n}')
+            bad_pr = True
+            continue
+
+        grouped[components[0]].append((n, title))
+        if highlight:
+            highlighted.append((n, title))
+        if api_break:
+            api_breaks.append((n, title))
+        if deprecated:
+            deprecates.append((n, title))
+
+    if bad_pr:
+        raise ValueError(
+            'One or more PRs have no, or more than one component label')
+
+    with open(filename_out, 'w') as fh:
+        write_special_section(fh, highlighted, 'Highlights')
+        write_special_section(fh, deprecates, 'Deprecated')
+        write_special_section(fh, api_breaks, 'Breaking changes')
+
+        for group, items in sorted(grouped.items(), key=lambda x: x[0]):
+            write_special_section(fh, items, group.capitalize())
+
+
+if __name__ == '__main__':
+    process_changelog(*sys.argv[1:])

kivy/tools/coverage.py

@@ -0,0 +1,135 @@
+"""Kivy coverage plugin
+=======================
+
+This provides a coverage plugin to measure code execution in kv files. To use,
+create and add::
+
+    [run]
+    plugins =
+        kivy.tools.coverage
+
+to the ``.coveragerc`` file in the root of your project. Or::
+
+    [coverage:run]
+    plugins =
+        kivy.tools.coverage
+
+in ``setup.cfg``.
+
+Then you can test your project with e.g. ``pip install coverage`` followed by
+``coverage run --source=./ kivy_app.py`` and ``coverage report``.
+
+Or to use with pytest, ``pip install pytest-cov`` followed by something like
+``pytest --cov=./ .``
+
+TODO: Expand kv statements measured.
+
+Currently, it ignores rules such as Widget creation or graphics object
+creation from being measured. Similarly for import statements.
+
+KV code created as strings within a python file is also not measured. To
+support the above, deeper changes will be required.
+"""
+
+import os
+import coverage
+from kivy.lang.parser import Parser
+
+
+class CoverageKVParser(Parser):
+
+    def execute_directives(self):
+        # don't actually execute anything
+        pass
+
+    def get_coverage_lines(self):
+        lines = set()
+        for parser_prop in walk_parser(self):
+            for line_num, line in enumerate(
+                    parser_prop.value.splitlines(),
+                    start=parser_prop.line + 1):
+                if line.strip():
+                    lines.add(line_num)
+
+        return lines
+
+
+def walk_parser_rules(parser_rule):
+    yield parser_rule
+
+    for child in parser_rule.children:
+        for rule in walk_parser_rules(child):
+            yield rule
+
+    if parser_rule.canvas_before is not None:
+        for rule in walk_parser_rules(parser_rule.canvas_before):
+            yield rule
+        yield parser_rule.canvas_before
+    if parser_rule.canvas_root is not None:
+        for rule in walk_parser_rules(parser_rule.canvas_root):
+            yield rule
+    if parser_rule.canvas_after is not None:
+        for rule in walk_parser_rules(parser_rule.canvas_after):
+            yield rule
+
+
+def walk_parser_rules_properties(parser_rule):
+    for rule in parser_rule.properties.values():
+        yield rule
+    for rule in parser_rule.handlers:
+        yield rule
+
+
+def walk_parser(parser):
+    if parser.root is not None:
+        for rule in walk_parser_rules(parser.root):
+            for prop in walk_parser_rules_properties(rule):
+                yield prop
+
+    for _, cls_rule in parser.rules:
+        for rule in walk_parser_rules(cls_rule):
+            for prop in walk_parser_rules_properties(rule):
+                yield prop
+
+
+class KivyCoveragePlugin(coverage.plugin.CoveragePlugin):
+
+    def file_tracer(self, filename):
+        if filename.endswith('.kv'):
+            return KivyFileTracer(filename=filename)
+        return None
+
+    def file_reporter(self, filename):
+        return KivyFileReporter(filename=filename)
+
+    def find_executable_files(self, src_dir):
+        for (dirpath, dirnames, filenames) in os.walk(src_dir):
+            for filename in filenames:
+                if filename.endswith('.kv'):
+                    yield os.path.join(dirpath, filename)
+
+
+class KivyFileTracer(coverage.plugin.FileTracer):
+
+    filename = ''
+
+    def __init__(self, filename, **kwargs):
+        super(KivyFileTracer, self).__init__(**kwargs)
+        self.filename = filename
+
+    def source_filename(self):
+        return self.filename
+
+
+class KivyFileReporter(coverage.plugin.FileReporter):
+
+    def lines(self):
+        with open(self.filename) as fh:
+            source = fh.read()
+
+        parser = CoverageKVParser(content=source, filename=self.filename)
+        return parser.get_coverage_lines()
+
+
+def coverage_init(reg, options):
+    reg.add_file_tracer(KivyCoveragePlugin())