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

kivy/context.py

@@ -0,0 +1,102 @@
+'''
+Context
+=======
+
+.. versionadded:: 1.8.0
+
+.. warning::
+
+    This is experimental and subject to change as long as this warning notice
+    is present.
+
+Kivy has a few "global" instances that are used directly by many pieces of the
+framework: `Cache`, `Builder`, `Clock`.
+
+TODO: document this module.
+
+'''
+
+__all__ = ('Context', 'ProxyContext', 'register_context',
+           'get_current_context')
+
+_contexts = {}
+_default_context = None
+_context_stack = []
+
+
+class ProxyContext(object):
+
+    __slots__ = ['_obj']
+
+    def __init__(self, obj):
+        object.__init__(self)
+        object.__setattr__(self, '_obj', obj)
+
+    def __getattribute__(self, name):
+        return getattr(object.__getattribute__(self, '_obj'), name)
+
+    def __delattr__(self, name):
+        delattr(object.__getattribute__(self, '_obj'), name)
+
+    def __setattr__(self, name, value):
+        setattr(object.__getattribute__(self, '_obj'), name, value)
+
+    def __bool__(self):
+        return bool(object.__getattribute__(self, '_obj'))
+
+    def __str__(self):
+        return str(object.__getattribute__(self, '_obj'))
+
+    def __repr__(self):
+        return repr(object.__getattribute__(self, '_obj'))
+
+
+class Context(dict):
+
+    def __init__(self, init=False):
+        dict.__init__(self)
+        self.sandbox = None
+        if not init:
+            return
+
+        for name in _contexts:
+            context = _contexts[name]
+            instance = context['cls'](*context['args'], **context['kwargs'])
+            self[name] = instance
+
+    def push(self):
+        _context_stack.append(self)
+        for name, instance in self.items():
+            object.__setattr__(_contexts[name]['proxy'], '_obj', instance)
+
+    def pop(self):
+        # After popping context from stack. Update proxy's _obj with
+        # instances in current context
+        _context_stack.pop(-1)
+        for name, instance in get_current_context().items():
+            object.__setattr__(_contexts[name]['proxy'], '_obj', instance)
+
+
+def register_context(name, cls, *args, **kwargs):
+    '''Register a new context.
+    '''
+    instance = cls(*args, **kwargs)
+    proxy = ProxyContext(instance)
+    _contexts[name] = {
+        'cls': cls,
+        'args': args,
+        'kwargs': kwargs,
+        'proxy': proxy}
+    _default_context[name] = instance
+    return proxy
+
+
+def get_current_context():
+    '''Return the current context.
+    '''
+    if not _context_stack:
+        return _default_context
+    return _context_stack[-1]
+
+
+_default_context = Context(init=False)

kivy/core/__init__.py

@@ -0,0 +1,247 @@
+'''
+Core Abstraction
+================
+
+This module defines the abstraction layers for our core providers and their
+implementations. For further information, please refer to
+:ref:`architecture` and the :ref:`providers` section of the documentation.
+
+In most cases, you shouldn't directly use a library that's already covered
+by the core abstraction. Always try to use our providers first.
+In case we are missing a feature or method, please let us know by
+opening a new Bug report instead of relying on your library.
+
+.. warning::
+    These are **not** widgets! These are just abstractions of the respective
+    functionality. For example, you cannot add a core image to your window.
+    You have to use the image **widget** class instead. If you're really
+    looking for widgets, please refer to :mod:`kivy.uix` instead.
+'''
+
+
+import os
+import sysconfig
+import sys
+import traceback
+import tempfile
+import subprocess
+import importlib
+import kivy
+from kivy.logger import Logger
+
+
+class CoreCriticalException(Exception):
+    pass
+
+
+def core_select_lib(category, llist, create_instance=False,
+                    base='kivy.core', basemodule=None):
+    if 'KIVY_DOC' in os.environ:
+        return
+    category = category.lower()
+    basemodule = basemodule or category
+    libs_ignored = []
+    errs = []
+    for option, modulename, classname in llist:
+        try:
+            # module activated in config ?
+            try:
+                if option not in kivy.kivy_options[category]:
+                    libs_ignored.append(modulename)
+                    Logger.debug(
+                        '{0}: Provider <{1}> ignored by config'.format(
+                            category.capitalize(), option))
+                    continue
+            except KeyError:
+                pass
+
+            # import module
+            mod = importlib.__import__(name='{2}.{0}.{1}'.format(
+                basemodule, modulename, base),
+                globals=globals(),
+                locals=locals(),
+                fromlist=[modulename], level=0)
+            cls = mod.__getattribute__(classname)
+
+            # ok !
+            Logger.info('{0}: Provider: {1}{2}'.format(
+                category.capitalize(), option,
+                '({0} ignored)'.format(libs_ignored) if libs_ignored else ''))
+            if create_instance:
+                cls = cls()
+            return cls
+
+        except ImportError as e:
+            errs.append((option, e, sys.exc_info()[2]))
+            libs_ignored.append(modulename)
+            Logger.debug('{0}: Ignored <{1}> (import error)'.format(
+                category.capitalize(), option))
+            Logger.trace('', exc_info=e)
+
+        except CoreCriticalException as e:
+            errs.append((option, e, sys.exc_info()[2]))
+            Logger.error('{0}: Unable to use {1}'.format(
+                category.capitalize(), option))
+            Logger.error(
+                '{0}: The module raised an important error: {1!r}'.format(
+                    category.capitalize(), e.message))
+            raise
+
+        except Exception as e:
+            errs.append((option, e, sys.exc_info()[2]))
+            libs_ignored.append(modulename)
+            Logger.trace('{0}: Unable to use {1}'.format(
+                category.capitalize(), option))
+            Logger.trace('', exc_info=e)
+
+    err = '\n'.join(['{} - {}: {}\n{}'.format(opt, e.__class__.__name__, e,
+                   ''.join(traceback.format_tb(tb))) for opt, e, tb in errs])
+    Logger.critical(
+        '{0}: Unable to find any valuable {0} provider. Please enable '
+        'debug logging (e.g. add -d if running from the command line, or '
+        'change the log level in the config) and re-run your app to '
+        'identify potential causes\n{1}'.format(category.capitalize(), err))
+
+
+def core_register_libs(category, libs, base='kivy.core'):
+    if 'KIVY_DOC' in os.environ:
+        return
+    category = category.lower()
+    kivy_options = kivy.kivy_options[category]
+    libs_loadable = {}
+    libs_ignored = []
+
+    for option, lib in libs:
+        # module activated in config ?
+        if option not in kivy_options:
+            Logger.debug('{0}: option <{1}> ignored by config'.format(
+                category.capitalize(), option))
+            libs_ignored.append(lib)
+            continue
+        libs_loadable[option] = lib
+
+    libs_loaded = []
+    for item in kivy_options:
+        try:
+            # import module
+            try:
+                lib = libs_loadable[item]
+            except KeyError:
+                continue
+            importlib.__import__(name='{2}.{0}.{1}'.format(category, lib, base),
+                       globals=globals(),
+                       locals=locals(),
+                       fromlist=[lib],
+                       level=0)
+
+            libs_loaded.append(lib)
+
+        except Exception as e:
+            Logger.trace('{0}: Unable to use <{1}> as loader!'.format(
+                category.capitalize(), option))
+            Logger.trace('', exc_info=e)
+            libs_ignored.append(lib)
+
+    Logger.info('{0}: Providers: {1} {2}'.format(
+        category.capitalize(),
+        ', '.join(libs_loaded),
+        '({0} ignored)'.format(
+            ', '.join(libs_ignored)) if libs_ignored else ''))
+    return libs_loaded
+
+
+def handle_win_lib_import_error(category, provider, mod_name):
+    if sys.platform != 'win32':
+        return
+
+    assert mod_name.startswith('kivy.')
+    kivy_root = os.path.dirname(kivy.__file__)
+    dirs = mod_name[5:].split('.')
+    mod_path = os.path.join(kivy_root, *dirs)
+
+    # get the full expected path to the compiled pyd file
+    # filename is <debug>.cp<major><minor>-<platform>.pyd
+    # https://github.com/python/cpython/blob/master/Doc/whatsnew/3.5.rst
+    if hasattr(sys, 'gettotalrefcount'):  # debug
+        mod_path += '._d'
+    mod_path += '.cp{}{}-{}.pyd'.format(
+        sys.version_info.major, sys.version_info.minor,
+        sysconfig.get_platform().replace('-', '_'))
+
+    # does the compiled pyd exist at all?
+    if not os.path.exists(mod_path):
+        Logger.debug(
+            '{}: Failed trying to import "{}" for provider {}. Compiled file '
+            'does not exist. Have you perhaps forgotten to compile Kivy, or '
+            'did not install all required dependencies?'.format(
+                category, provider, mod_path))
+        return
+
+    # tell user to provide dependency walker
+    env_var = 'KIVY_{}_DEPENDENCY_WALKER'.format(provider.upper())
+    if env_var not in os.environ:
+        Logger.debug(
+            '{0}: Failed trying to import the "{1}" provider from "{2}". '
+            'This error is often encountered when a dependency is missing,'
+            ' or if there are multiple copies of the same dependency dll on '
+            'the Windows PATH and they are incompatible with each other. '
+            'This can occur if you are mixing installations (such as different'
+            ' python installations, like anaconda python and a system python) '
+            'or if another unrelated program added its directory to the PATH. '
+            'Please examine your PATH and python installation for potential '
+            'issues. To further troubleshoot a "DLL load failed" error, '
+            'please download '
+            '"Dependency Walker" (64 or 32 bit version - matching your python '
+            'bitness) from dependencywalker.com and set the environment '
+            'variable {3} to the full path of the downloaded depends.exe file '
+            'and rerun your application to generate an error report'.
+            format(category, provider, mod_path, env_var))
+        return
+
+    depends_bin = os.environ[env_var]
+    if not os.path.exists(depends_bin):
+        raise ValueError('"{}" provided in {} does not exist'.format(
+            depends_bin, env_var))
+
+    # make file for the resultant log
+    fd, temp_file = tempfile.mkstemp(
+        suffix='.dwi', prefix='kivy_depends_{}_log_'.format(provider),
+        dir=os.path.expanduser('~/'))
+    os.close(fd)
+
+    Logger.info(
+        '{}: Running dependency walker "{}" on "{}" to generate '
+        'troubleshooting log. Please wait for it to complete'.format(
+            category, depends_bin, mod_path))
+    Logger.debug(
+        '{}: Dependency walker command is "{}"'.format(
+            category,
+            [depends_bin, '/c', '/od:{}'.format(temp_file), mod_path]))
+
+    try:
+        subprocess.check_output([
+            depends_bin, '/c', '/od:{}'.format(temp_file), mod_path])
+    except subprocess.CalledProcessError as exc:
+        if exc.returncode >= 0x00010000:
+            Logger.error(
+                '{}: Dependency walker failed with error code "{}". No '
+                'error report was generated'.
+                format(category, exc.returncode))
+            return
+
+    Logger.info(
+        '{}: dependency walker generated "{}" containing troubleshooting '
+        'information about provider {} and its failing file "{} ({})". You '
+        'can open the file in dependency walker to view any potential issues '
+        'and troubleshoot it yourself. '
+        'To share the file with the Kivy developers and request support, '
+        'please contact us at our support channels '
+        'https://kivy.org/doc/master/contact.html (not on github, unless '
+        'it\'s truly a bug). Make sure to provide the generated file as well '
+        'as the *complete* Kivy log being printed here. Keep in mind the '
+        'generated dependency walker log file contains paths to dlls on your '
+        'system used by kivy or its dependencies to help troubleshoot them, '
+        'and these paths may include your name in them. Please view the '
+        'log file in dependency walker before sharing to ensure you are not '
+        'sharing sensitive paths'.format(
+            category, temp_file, provider, mod_name, mod_path))

kivy/core/audio/__init__.py

@@ -0,0 +1,223 @@
+'''
+Audio
+=====
+
+Load an audio sound and play it with::
+
+    from kivy.core.audio import SoundLoader
+
+    sound = SoundLoader.load('mytest.wav')
+    if sound:
+        print("Sound found at %s" % sound.source)
+        print("Sound is %.3f seconds" % sound.length)
+        sound.play()
+
+You should not use the Sound class directly. The class returned by
+:func:`SoundLoader.load` will be the best sound provider for that particular
+file type, so it might return different Sound classes depending the file type.
+
+Event dispatching and state changes
+-----------------------------------
+
+Audio is often processed in parallel to your code. This means you often need to
+enter the Kivy :func:`eventloop <kivy.base.EventLoopBase>` in order to allow
+events and state changes to be dispatched correctly.
+
+You seldom need to worry about this as Kivy apps typically always
+require this event loop for the GUI to remain responsive, but it is good to
+keep this in mind when debugging or running in a
+`REPL <https://en.wikipedia.org/wiki/Read%E2%80%93eval%E2%80%93print_loop>`_
+(Read-eval-print loop).
+
+.. versionchanged:: 1.10.0
+    The pygst and gi providers have been removed.
+
+.. versionchanged:: 1.8.0
+    There are now 2 distinct Gstreamer implementations: one using Gi/Gst
+    working for both Python 2+3 with Gstreamer 1.0, and one using PyGST
+    working only for Python 2 + Gstreamer 0.10.
+
+.. note::
+
+    The core audio library does not support recording audio. If you require
+    this functionality, please refer to the
+    `audiostream <https://github.com/kivy/audiostream>`_ extension.
+
+'''
+
+__all__ = ('Sound', 'SoundLoader')
+
+from kivy.logger import Logger
+from kivy.event import EventDispatcher
+from kivy.core import core_register_libs
+from kivy.resources import resource_find
+from kivy.properties import StringProperty, NumericProperty, OptionProperty, \
+    AliasProperty, BooleanProperty, BoundedNumericProperty
+from kivy.utils import platform
+from kivy.setupconfig import USE_SDL2
+
+from sys import float_info
+
+
+class SoundLoader:
+    '''Load a sound, using the best loader for the given file type.
+    '''
+
+    _classes = []
+
+    @staticmethod
+    def register(classobj):
+        '''Register a new class to load the sound.'''
+        Logger.debug('Audio: register %s' % classobj.__name__)
+        SoundLoader._classes.append(classobj)
+
+    @staticmethod
+    def load(filename):
+        '''Load a sound, and return a Sound() instance.'''
+        rfn = resource_find(filename)
+        if rfn is not None:
+            filename = rfn
+        ext = filename.split('.')[-1].lower()
+        if '?' in ext:
+            ext = ext.split('?')[0]
+        for classobj in SoundLoader._classes:
+            if ext in classobj.extensions():
+                return classobj(source=filename)
+        Logger.warning('Audio: Unable to find a loader for <%s>' %
+                       filename)
+        return None
+
+
+class Sound(EventDispatcher):
+    '''Represents a sound to play. This class is abstract, and cannot be used
+    directly.
+
+    Use SoundLoader to load a sound.
+
+    :Events:
+        `on_play`: None
+            Fired when the sound is played.
+        `on_stop`: None
+            Fired when the sound is stopped.
+    '''
+
+    source = StringProperty(None)
+    '''Filename / source of your audio file.
+
+    .. versionadded:: 1.3.0
+
+    :attr:`source` is a :class:`~kivy.properties.StringProperty` that defaults
+    to None and is read-only. Use the :meth:`SoundLoader.load` for loading
+    audio.
+    '''
+
+    volume = NumericProperty(1.)
+    '''Volume, in the range 0-1. 1 means full volume, 0 means mute.
+
+    .. versionadded:: 1.3.0
+
+    :attr:`volume` is a :class:`~kivy.properties.NumericProperty` and defaults
+    to 1.
+    '''
+
+    pitch = BoundedNumericProperty(1., min=float_info.epsilon)
+    '''Pitch of a sound. 2 is an octave higher, .5 one below. This is only
+    implemented for SDL2 audio provider yet.
+
+    .. versionadded:: 1.10.0
+
+    :attr:`pitch` is a :class:`~kivy.properties.NumericProperty` and defaults
+    to 1.
+    '''
+
+    state = OptionProperty('stop', options=('stop', 'play'))
+    '''State of the sound, one of 'stop' or 'play'.
+
+    .. versionadded:: 1.3.0
+
+    :attr:`state` is a read-only :class:`~kivy.properties.OptionProperty`.'''
+
+    loop = BooleanProperty(False)
+    '''Set to True if the sound should automatically loop when it finishes.
+
+    .. versionadded:: 1.8.0
+
+    :attr:`loop` is a :class:`~kivy.properties.BooleanProperty` and defaults to
+    False.'''
+
+    __events__ = ('on_play', 'on_stop')
+
+    def on_source(self, instance, filename):
+        self.unload()
+        if filename is None:
+            return
+        self.load()
+
+    def get_pos(self):
+        '''
+        Returns the current position of the audio file.
+        Returns 0 if not playing.
+
+        .. versionadded:: 1.4.1
+        '''
+        return 0
+
+    def _get_length(self):
+        return 0
+
+    length = property(lambda self: self._get_length(),
+                      doc='Get length of the sound (in seconds).')
+
+    def load(self):
+        '''Load the file into memory.'''
+        pass
+
+    def unload(self):
+        '''Unload the file from memory.'''
+        pass
+
+    def play(self):
+        '''Play the file.'''
+        self.state = 'play'
+        self.dispatch('on_play')
+
+    def stop(self):
+        '''Stop playback.'''
+        self.state = 'stop'
+        self.dispatch('on_stop')
+
+    def seek(self, position):
+        '''Go to the <position> (in seconds).
+
+        .. note::
+            Most sound providers cannot seek when the audio is stopped.
+            Play then seek.
+        '''
+        pass
+
+    def on_play(self):
+        pass
+
+    def on_stop(self):
+        pass
+
+
+# Little trick here, don't activate gstreamer on window
+# seem to have lot of crackle or something...
+audio_libs = []
+if platform == 'android':
+    audio_libs += [('android', 'audio_android')]
+elif platform in ('macosx', 'ios'):
+    audio_libs += [('avplayer', 'audio_avplayer')]
+try:
+    from kivy.lib.gstplayer import GstPlayer  # NOQA
+    audio_libs += [('gstplayer', 'audio_gstplayer')]
+except ImportError:
+    pass
+audio_libs += [('ffpyplayer', 'audio_ffpyplayer')]
+if USE_SDL2:
+    audio_libs += [('sdl2', 'audio_sdl2')]
+else:
+    audio_libs += [('pygame', 'audio_pygame')]
+
+libs_loaded = core_register_libs('audio', audio_libs)

kivy/core/audio/audio_android.py

@@ -0,0 +1,104 @@
+"""
+AudioAndroid: Kivy audio implementation for Android using native API
+"""
+
+__all__ = ("SoundAndroidPlayer", )
+
+from jnius import autoclass, java_method, PythonJavaClass
+from android import api_version
+from kivy.core.audio import Sound, SoundLoader
+
+
+MediaPlayer = autoclass("android.media.MediaPlayer")
+AudioManager = autoclass("android.media.AudioManager")
+if api_version >= 21:
+    AudioAttributesBuilder = autoclass("android.media.AudioAttributes$Builder")
+
+
+class OnCompletionListener(PythonJavaClass):
+    __javainterfaces__ = ["android/media/MediaPlayer$OnCompletionListener"]
+    __javacontext__ = "app"
+
+    def __init__(self, callback, **kwargs):
+        super(OnCompletionListener, self).__init__(**kwargs)
+        self.callback = callback
+
+    @java_method("(Landroid/media/MediaPlayer;)V")
+    def onCompletion(self, mp):
+        self.callback()
+
+
+class SoundAndroidPlayer(Sound):
+    @staticmethod
+    def extensions():
+        return ("mp3", "mp4", "aac", "3gp", "flac", "mkv", "wav", "ogg", "m4a",
+                "gsm", "mid", "xmf", "mxmf", "rtttl", "rtx", "ota", "imy")
+
+    def __init__(self, **kwargs):
+        self._mediaplayer = None
+        self._completion_listener = None
+        super(SoundAndroidPlayer, self).__init__(**kwargs)
+
+    def load(self):
+        self.unload()
+        self._mediaplayer = MediaPlayer()
+        if api_version >= 21:
+            self._mediaplayer.setAudioAttributes(
+                AudioAttributesBuilder()
+                .setLegacyStreamType(AudioManager.STREAM_MUSIC)
+                .build())
+        else:
+            self._mediaplayer.setAudioStreamType(AudioManager.STREAM_MUSIC)
+        self._mediaplayer.setDataSource(self.source)
+        self._completion_listener = OnCompletionListener(
+            self._completion_callback
+        )
+        self._mediaplayer.setOnCompletionListener(self._completion_listener)
+        self._mediaplayer.prepare()
+
+    def unload(self):
+        if self._mediaplayer:
+            self._mediaplayer.release()
+            self._mediaplayer = None
+
+    def play(self):
+        if not self._mediaplayer:
+            return
+        self._mediaplayer.start()
+        super(SoundAndroidPlayer, self).play()
+
+    def stop(self):
+        if not self._mediaplayer:
+            return
+        self._mediaplayer.stop()
+        self._mediaplayer.prepare()
+
+    def seek(self, position):
+        if not self._mediaplayer:
+            return
+        self._mediaplayer.seekTo(float(position) * 1000)
+
+    def get_pos(self):
+        if self._mediaplayer:
+            return self._mediaplayer.getCurrentPosition() / 1000.
+        return super(SoundAndroidPlayer, self).get_pos()
+
+    def on_volume(self, instance, volume):
+        if self._mediaplayer:
+            volume = float(volume)
+            self._mediaplayer.setVolume(volume, volume)
+
+    def _completion_callback(self):
+        super(SoundAndroidPlayer, self).stop()
+
+    def _get_length(self):
+        if self._mediaplayer:
+            return self._mediaplayer.getDuration() / 1000.
+        return super(SoundAndroidPlayer, self)._get_length()
+
+    def on_loop(self, instance, loop):
+        if self._mediaplayer:
+            self._mediaplayer.setLooping(loop)
+
+
+SoundLoader.register(SoundAndroidPlayer)