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

Kivy_examples-2.3.1.dev0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: bdist_wheel (0.44.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

Kivy_examples-2.3.1.dev0.dist-info/dependency_links.txt

@@ -0,0 +1 @@
+https://github.com/kivy-garden/garden/archive/master.zip

Kivy_examples-2.3.1.dev0.dist-info/top_level.txt

@@ -0,0 +1 @@
+kivy

kivy/__init__.py

@@ -0,0 +1,519 @@
+'''
+Kivy framework
+==============
+
+Kivy is an open source library for developing multi-touch applications. It is
+cross-platform (Linux/OSX/Windows/Android/iOS) and released under
+the terms of the `MIT License <https://en.wikipedia.org/wiki/MIT_License>`_.
+
+It comes with native support for many multi-touch input devices, a growing
+library of multi-touch aware widgets and hardware accelerated OpenGL drawing.
+Kivy is designed to let you focus on building custom and highly interactive
+applications as quickly and easily as possible.
+
+With Kivy, you can take full advantage of the dynamic nature of Python. There
+are thousands of high-quality, free libraries that can be integrated in your
+application. At the same time, performance-critical parts are implemented
+using `Cython <http://cython.org/>`_.
+
+See http://kivy.org for more information.
+'''
+
+__all__ = (
+    'require', 'parse_kivy_version',
+    'kivy_configure', 'kivy_register_post_configuration',
+    'kivy_options', 'kivy_base_dir',
+    'kivy_modules_dir', 'kivy_data_dir', 'kivy_shader_dir',
+    'kivy_icons_dir', 'kivy_home_dir',
+    'kivy_config_fn', 'kivy_usermodules_dir', 'kivy_examples_dir'
+)
+
+import sys
+import shutil
+from getopt import getopt, GetoptError
+import os
+from os import environ, mkdir
+from os.path import dirname, join, basename, exists, expanduser
+import pkgutil
+import re
+import importlib
+from kivy.logger import Logger, LOG_LEVELS
+from kivy.utils import platform
+from kivy._version import __version__, RELEASE as _KIVY_RELEASE, \
+    _kivy_git_hash, _kivy_build_date
+
+# internals for post-configuration
+__kivy_post_configuration = []
+
+
+if platform == 'macosx' and sys.maxsize < 9223372036854775807:
+    r = '''Unsupported Python version detected!:
+    Kivy requires a 64 bit version of Python to run on OS X. We strongly
+    advise you to use the version of Python that is provided by Apple
+    (don't use ports, fink or homebrew unless you know what you're
+    doing).
+    See http://kivy.org/docs/installation/installation-macosx.html for
+    details.
+    '''
+    Logger.critical(r)
+
+if sys.version_info[0] == 2:
+    Logger.critical(
+        'Unsupported Python version detected!: Kivy 2.0.0 and higher does not '
+        'support Python 2. Please upgrade to Python 3, or downgrade Kivy to '
+        '1.11.0 - the last Kivy release that still supports Python 2.')
+
+
+def parse_kivy_version(version):
+    """Parses the kivy version as described in :func:`require` into a 3-tuple
+    of ([x, y, z], 'rc|a|b|dev|post', 'N') where N is the tag revision. The
+    last two elements may be None.
+    """
+    m = re.match(
+        '^([0-9]+)\\.([0-9]+)\\.([0-9]+?)(rc|a|b|\\.dev|\\.post)?([0-9]+)?$',
+        version)
+    if m is None:
+        raise Exception('Revision format must be X.Y.Z[-tag]')
+
+    major, minor, micro, tag, tagrev = m.groups()
+    if tag == '.dev':
+        tag = 'dev'
+    if tag == '.post':
+        tag = 'post'
+    return [int(major), int(minor), int(micro)], tag, tagrev
+
+
+def require(version):
+    '''Require can be used to check the minimum version required to run a Kivy
+    application. For example, you can start your application code like this::
+
+        import kivy
+        kivy.require('1.0.1')
+
+    If a user attempts to run your application with a version of Kivy that is
+    older than the specified version, an Exception is raised.
+
+    The Kivy version string is built like this::
+
+        X.Y.Z[tag[tagrevision]]
+
+        X is the major version
+        Y is the minor version
+        Z is the bugfixes revision
+
+    The tag is optional, but may be one of '.dev', '.post', 'a', 'b', or 'rc'.
+    The tagrevision is the revision number of the tag.
+
+    .. warning::
+
+        You must not ask for a version with a tag, except -dev. Asking for a
+        'dev' version will just warn the user if the current Kivy
+        version is not a -dev, but it will never raise an exception.
+        You must not ask for a version with a tagrevision.
+
+    '''
+
+    # user version
+    revision, tag, tagrev = parse_kivy_version(version)
+    # current version
+    sysrevision, systag, systagrev = parse_kivy_version(__version__)
+
+    if tag and not systag:
+        Logger.warning('Application requested a dev version of Kivy. '
+                       '(You have %s, but the application requires %s)' % (
+                           __version__, version))
+    # not tag rev (-alpha-1, -beta-x) allowed.
+    if tagrev is not None:
+        raise Exception('Revision format must not contain any tagrevision')
+
+    # finally, checking revision
+    if sysrevision < revision:
+        raise Exception('The version of Kivy installed on this system '
+                        'is too old. '
+                        '(You have %s, but the application requires %s)' % (
+                            __version__, version))
+
+
+def kivy_configure():
+    '''Call post-configuration of Kivy.
+    This function must be called if you create the window yourself.
+    '''
+    for callback in __kivy_post_configuration:
+        callback()
+
+
+def get_includes():
+    '''Retrieves the directories containing includes needed to build new Cython
+    modules with Kivy as a dependency. Currently returns the location of the
+    kivy.graphics module.
+
+    .. versionadded:: 1.9.1
+    '''
+    root_dir = dirname(__file__)
+    return [join(root_dir, 'graphics'), join(root_dir, 'tools', 'gles_compat'),
+            join(root_dir, 'include')]
+
+
+def kivy_register_post_configuration(callback):
+    '''Register a function to be called when kivy_configure() is called.
+
+    .. warning::
+        Internal use only.
+    '''
+    __kivy_post_configuration.append(callback)
+
+
+def kivy_usage():
+    '''Kivy Usage: %s [KIVY OPTION...] [-- PROGRAM OPTIONS]::
+
+            Options placed after a '-- ' separator, will not be touched by kivy,
+            and instead passed to your program.
+
+            Set KIVY_NO_ARGS=1 in your environment or before you import Kivy to
+            disable Kivy's argument parser.
+
+        -h, --help
+            Prints this help message.
+        -d, --debug
+            Shows debug log.
+        -a, --auto-fullscreen
+            Force 'auto' fullscreen mode (no resolution change).
+            Uses your display's resolution. This is most likely what you want.
+        -c, --config section:key[:value]
+            Set a custom [section] key=value in the configuration object.
+        -f, --fullscreen
+            Force running in fullscreen mode.
+        -k, --fake-fullscreen
+            Force 'fake' fullscreen mode (no window border/decoration).
+            Uses the resolution specified by width and height in your config.
+        -w, --windowed
+            Force running in a window.
+        -p, --provider id:provider[,options]
+            Add an input provider (eg: ccvtable1:tuio,192.168.0.1:3333).
+        -m mod, --module=mod
+            Activate a module (use "list" to get a list of available modules).
+        -r, --rotation
+            Rotate the window's contents (0, 90, 180, 270).
+        -s, --save
+            Save current Kivy configuration.
+        --size=640x480
+            Size of window geometry.
+        --dpi=96
+            Manually overload the Window DPI (for testing only.)
+    '''
+    print(kivy_usage.__doc__ % (basename(sys.argv[0])))
+
+
+#: Global settings options for kivy
+kivy_options = {
+    'window': ('egl_rpi', 'sdl2', 'pygame', 'sdl', 'x11'),
+    'text': ('pil', 'sdl2', 'pygame', 'sdlttf'),
+    'video': (
+        'gstplayer', 'ffmpeg', 'ffpyplayer', 'null'),
+    'audio': (
+        'gstplayer', 'pygame', 'ffpyplayer', 'sdl2',
+        'avplayer'),
+    'image': ('tex', 'imageio', 'dds', 'sdl2', 'pygame', 'pil', 'ffpy', 'gif'),
+    'camera': ('opencv', 'gi', 'avfoundation',
+               'android', 'picamera'),
+    'spelling': ('enchant', 'osxappkit', ),
+    'clipboard': (
+        'android', 'winctypes', 'xsel', 'xclip', 'dbusklipper', 'nspaste',
+        'sdl2', 'pygame', 'dummy', 'gtk3', )}
+
+# Read environment
+for option in kivy_options:
+    key = 'KIVY_%s' % option.upper()
+    if key in environ:
+        try:
+            if type(kivy_options[option]) in (list, tuple):
+                kivy_options[option] = environ[key].split(',')
+            else:
+                kivy_options[option] = environ[key].lower() in \
+                    ('true', '1', 'yes')
+        except Exception:
+            Logger.warning('Core: Wrong value for %s environment key' % key)
+            Logger.exception('')
+
+# Extract all needed path in kivy
+#: Kivy directory
+kivy_base_dir = dirname(sys.modules[__name__].__file__)
+#: Kivy modules directory
+
+kivy_modules_dir = environ.get('KIVY_MODULES_DIR',
+                               join(kivy_base_dir, 'modules'))
+#: Kivy data directory
+kivy_data_dir = environ.get('KIVY_DATA_DIR',
+                            join(kivy_base_dir, 'data'))
+#: Kivy binary deps directory
+kivy_binary_deps_dir = environ.get('KIVY_BINARY_DEPS',
+                                   join(kivy_base_dir, 'binary_deps'))
+#: Kivy glsl shader directory
+kivy_shader_dir = join(kivy_data_dir, 'glsl')
+#: Kivy icons config path (don't remove the last '')
+kivy_icons_dir = join(kivy_data_dir, 'icons', '')
+#: Kivy user-home storage directory
+kivy_home_dir = ''
+#: Kivy configuration filename
+kivy_config_fn = ''
+#: Kivy user modules directory
+kivy_usermodules_dir = ''
+#: Kivy examples directory
+kivy_examples_dir = ''
+for examples_dir in (
+        join(dirname(dirname(__file__)), 'examples'),
+        join(sys.exec_prefix, 'share', 'kivy-examples'),
+        join(sys.prefix, 'share', 'kivy-examples'),
+        '/usr/share/kivy-examples', '/usr/local/share/kivy-examples',
+        expanduser('~/.local/share/kivy-examples')):
+    if exists(examples_dir):
+        kivy_examples_dir = examples_dir
+        break
+
+
+def _patch_mod_deps_win(dep_mod, mod_name):
+    import site
+    dep_bins = []
+
+    for d in [sys.prefix, site.USER_BASE]:
+        p = join(d, 'share', mod_name, 'bin')
+        if os.path.isdir(p):
+            os.environ["PATH"] = p + os.pathsep + os.environ["PATH"]
+            if hasattr(os, 'add_dll_directory'):
+                os.add_dll_directory(p)
+            dep_bins.append(p)
+
+    dep_mod.dep_bins = dep_bins
+
+
+# if there are deps, import them so they can do their magic.
+_packages = []
+try:
+    from kivy import deps as old_deps
+    for importer, modname, ispkg in pkgutil.iter_modules(old_deps.__path__):
+        if not ispkg:
+            continue
+        if modname.startswith('gst'):
+            _packages.insert(0, (importer, modname, 'kivy.deps'))
+        else:
+            _packages.append((importer, modname, 'kivy.deps'))
+except ImportError:
+    pass
+
+try:
+    import kivy_deps
+    for importer, modname, ispkg in pkgutil.iter_modules(kivy_deps.__path__):
+        if not ispkg:
+            continue
+        if modname.startswith('gst'):
+            _packages.insert(0, (importer, modname, 'kivy_deps'))
+        else:
+            _packages.append((importer, modname, 'kivy_deps'))
+except ImportError:
+    pass
+
+_logging_msgs = []
+for importer, modname, package in _packages:
+    try:
+        module_spec = importer.find_spec(modname)
+        mod = importlib.util.module_from_spec(module_spec)
+        module_spec.loader.exec_module(mod)
+
+        version = ''
+        if hasattr(mod, '__version__'):
+            version = ' {}'.format(mod.__version__)
+        _logging_msgs.append(
+            'deps: Successfully imported "{}.{}"{}'.
+            format(package, modname, version))
+
+        if modname.startswith('gst') and version == '0.3.3':
+            _patch_mod_deps_win(mod, modname)
+
+    except ImportError as e:
+        Logger.warning(
+            'deps: Error importing dependency "{}.{}": {}'.
+            format(package, modname, str(e)))
+
+# Don't go further if we generate documentation
+if any(name in sys.argv[0] for name in (
+        'sphinx-build', 'autobuild.py', 'sphinx'
+)):
+    environ['KIVY_DOC'] = '1'
+if 'sphinx-build' in sys.argv[0]:
+    environ['KIVY_DOC_INCLUDE'] = '1'
+if any('pytest' in arg for arg in sys.argv):
+    environ['KIVY_UNITTEST'] = '1'
+if any('pyinstaller' in arg.lower() for arg in sys.argv):
+    environ['KIVY_PACKAGING'] = '1'
+
+if not environ.get('KIVY_DOC_INCLUDE'):
+    # Configuration management
+    if 'KIVY_HOME' in environ:
+        kivy_home_dir = expanduser(environ['KIVY_HOME'])
+    else:
+        user_home_dir = expanduser('~')
+        if platform == 'android':
+            user_home_dir = environ['ANDROID_APP_PATH']
+        elif platform == 'ios':
+            user_home_dir = join(expanduser('~'), 'Documents')
+        kivy_home_dir = join(user_home_dir, '.kivy')
+
+    kivy_config_fn = join(kivy_home_dir, 'config.ini')
+    kivy_usermodules_dir = join(kivy_home_dir, 'mods')
+    icon_dir = join(kivy_home_dir, 'icon')
+
+    if 'KIVY_NO_CONFIG' not in environ:
+        if not exists(kivy_home_dir):
+            mkdir(kivy_home_dir)
+        if not exists(kivy_usermodules_dir):
+            mkdir(kivy_usermodules_dir)
+        if not exists(icon_dir):
+            try:
+                shutil.copytree(join(kivy_data_dir, 'logo'), icon_dir)
+            except:
+                Logger.exception('Error when copying logo directory')
+
+    # configuration
+    from kivy.config import Config
+
+    # Set level of logger
+    level = LOG_LEVELS.get(Config.get('kivy', 'log_level'))
+    Logger.setLevel(level=level)
+
+    # Can be overridden in command line
+    if ('KIVY_UNITTEST' not in environ and
+            'KIVY_PACKAGING' not in environ and
+            environ.get('KIVY_NO_ARGS', "false") not in ('true', '1', 'yes')):
+        # save sys argv, otherwise, gstreamer use it and display help..
+        sys_argv = sys.argv
+        sys.argv = sys.argv[:1]
+
+        try:
+            opts, args = getopt(sys_argv[1:], 'hp:fkawFem:sr:dc:', [
+                'help', 'fullscreen', 'windowed', 'fps', 'event',
+                'module=', 'save', 'fake-fullscreen', 'auto-fullscreen',
+                'multiprocessing-fork', 'display=', 'size=', 'rotate=',
+                'config=', 'debug', 'dpi='])
+
+        except GetoptError as err:
+            Logger.error('Core: %s' % str(err))
+            kivy_usage()
+            sys.exit(2)
+
+        mp_fork = None
+        try:
+            for opt, arg in opts:
+                if opt == '--multiprocessing-fork':
+                    mp_fork = True
+                    break
+        except:
+            pass
+
+        # set argv to the non-read args
+        sys.argv = sys_argv[0:1] + args
+        if mp_fork is not None:
+            # Needs to be first opt for support_freeze to work
+            sys.argv.insert(1, '--multiprocessing-fork')
+
+    else:
+        opts = []
+        args = []
+
+    need_save = False
+    for opt, arg in opts:
+        if opt in ('-h', '--help'):
+            kivy_usage()
+            sys.exit(0)
+        elif opt in ('-p', '--provider'):
+            try:
+                pid, args = arg.split(':', 1)
+                Config.set('input', pid, args)
+            except ValueError:
+                # when we are doing an executable on macosx with
+                # pyinstaller, they are passing information with -p. so
+                # it will conflict with our current -p option. since the
+                # format is not the same, just avoid it.
+                pass
+        elif opt in ('-a', '--auto-fullscreen'):
+            Config.set('graphics', 'fullscreen', 'auto')
+        elif opt in ('-c', '--config'):
+            ol = arg.split(':', 2)
+            if len(ol) == 2:
+                Config.set(ol[0], ol[1], '')
+            elif len(ol) == 3:
+                Config.set(ol[0], ol[1], ol[2])
+            else:
+                raise Exception('Invalid --config value')
+            if ol[0] == 'kivy' and ol[1] == 'log_level':
+                level = LOG_LEVELS.get(Config.get('kivy', 'log_level'))
+                Logger.setLevel(level=level)
+        elif opt in ('-k', '--fake-fullscreen'):
+            Config.set('graphics', 'fullscreen', 'fake')
+        elif opt in ('-f', '--fullscreen'):
+            Config.set('graphics', 'fullscreen', '1')
+        elif opt in ('-w', '--windowed'):
+            Config.set('graphics', 'fullscreen', '0')
+        elif opt in ('--size', ):
+            w, h = str(arg).split('x')
+            Config.set('graphics', 'width', w)
+            Config.set('graphics', 'height', h)
+        elif opt in ('--display', ):
+            Config.set('graphics', 'display', str(arg))
+        elif opt in ('-m', '--module'):
+            if str(arg) == 'list':
+                from kivy.modules import Modules
+                Modules.usage_list()
+                sys.exit(0)
+            args = arg.split(':', 1)
+            if len(args) == 1:
+                args += ['']
+            Config.set('modules', args[0], args[1])
+        elif opt in ('-s', '--save'):
+            need_save = True
+        elif opt in ('-r', '--rotation'):
+            Config.set('graphics', 'rotation', arg)
+        elif opt in ('-d', '--debug'):
+            level = LOG_LEVELS.get('debug')
+            Logger.setLevel(level=level)
+        elif opt == '--dpi':
+            environ['KIVY_DPI'] = arg
+
+    if need_save and 'KIVY_NO_CONFIG' not in environ:
+        try:
+            Config.filename = kivy_config_fn
+            Config.write()
+        except Exception as e:
+            Logger.exception('Core: error while saving default'
+                             'configuration file:', str(e))
+        Logger.info('Core: Kivy configuration saved.')
+        sys.exit(0)
+
+    # configure all activated modules
+    from kivy.modules import Modules
+    Modules.configure()
+
+    # android hooks: force fullscreen and add android touch input provider
+    if platform in ('android', 'ios'):
+        from kivy.config import Config
+        Config.set('graphics', 'fullscreen', 'auto')
+        Config.remove_section('input')
+        Config.add_section('input')
+
+    if platform == 'android':
+        Config.set('input', 'androidtouch', 'android')
+
+for msg in _logging_msgs:
+    Logger.info(msg)
+
+if not _KIVY_RELEASE and _kivy_git_hash and _kivy_build_date:
+    Logger.info('Kivy: v%s, git-%s, %s' % (
+        __version__, _kivy_git_hash[:7], _kivy_build_date))
+else:
+    Logger.info('Kivy: v%s' % __version__)
+Logger.info('Kivy: Installed at "{}"'.format(__file__))
+Logger.info('Python: v{}'.format(sys.version))
+Logger.info('Python: Interpreter at "{}"'.format(sys.executable))
+
+from kivy.logger import file_log_handler
+if file_log_handler is not None:
+    file_log_handler.purge_logs()

kivy/_version.py

@@ -0,0 +1,18 @@
+# This file is imported from __init__.py and exec'd from setup.py
+
+MAJOR = 2
+MINOR = 3
+MICRO = 1
+RELEASE = False
+
+__version__ = '%d.%d.%d' % (MAJOR, MINOR, MICRO)
+
+if not RELEASE:
+    # if it's a rcx release, it's not proceeded by a period. If it is a
+    # devx release, it must start with a period
+    __version__ += '.dev0'
+
+
+_kivy_git_hash = '41416f130d8a41adc048ac8a6d6dfdb380078eb1'
+_kivy_build_date = '20241130'
+