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

kivy/core/image/img_dds.py

@@ -0,0 +1,40 @@
+'''
+DDS: DDS image loader
+'''
+
+__all__ = ('ImageLoaderDDS', )
+
+from kivy.lib.ddsfile import DDSFile
+from kivy.logger import Logger
+from kivy.core.image import ImageLoaderBase, ImageData, ImageLoader
+
+
+class ImageLoaderDDS(ImageLoaderBase):
+
+    @staticmethod
+    def extensions():
+        return ('dds', )
+
+    def load(self, filename):
+        try:
+            dds = DDSFile(filename=filename)
+        except:
+            Logger.warning('Image: Unable to load image <%s>' % filename)
+            raise
+
+        self.filename = filename
+        width, height = dds.size
+        im = ImageData(width, height, dds.dxt, dds.images[0], source=filename,
+                       flip_vertical=False)
+        if len(dds.images) > 1:
+            images = dds.images
+            images_size = dds.images_size
+            for index in range(1, len(dds.images)):
+                w, h = images_size[index]
+                data = images[index]
+                im.add_mipmap(index, w, h, data)
+        return [im]
+
+
+# register
+ImageLoader.register(ImageLoaderDDS)

kivy/core/image/img_ffpyplayer.py

@@ -0,0 +1,87 @@
+'''
+FFPyPlayer: FFmpeg based image loader
+'''
+
+__all__ = ('ImageLoaderFFPy', )
+
+import ffpyplayer
+from ffpyplayer.pic import ImageLoader as ffImageLoader, SWScale
+from ffpyplayer.tools import set_log_callback, get_log_callback
+
+from kivy.logger import Logger
+from kivy.core.image import ImageLoaderBase, ImageData, ImageLoader
+
+
+Logger.info('ImageLoaderFFPy: Using ffpyplayer {}'.format(ffpyplayer.version))
+
+
+logger_func = {'quiet': Logger.critical, 'panic': Logger.critical,
+               'fatal': Logger.critical, 'error': Logger.error,
+               'warning': Logger.warning, 'info': Logger.info,
+               'verbose': Logger.debug, 'debug': Logger.debug}
+
+
+def _log_callback(message, level):
+    message = message.strip()
+    if message:
+        logger_func[level]('ffpyplayer: {}'.format(message))
+
+
+if not get_log_callback():
+    set_log_callback(_log_callback)
+
+
+class ImageLoaderFFPy(ImageLoaderBase):
+    '''Image loader based on the ffpyplayer library.
+
+    .. versionadded:: 1.9.0
+
+    .. note:
+        This provider may support more formats than what is listed in
+        :meth:`extensions`.
+    '''
+
+    @staticmethod
+    def extensions():
+        '''Return accepted extensions for this loader'''
+        # See https://www.ffmpeg.org/general.html#Image-Formats
+        return ('bmp', 'dpx', 'exr', 'gif', 'ico', 'jpeg', 'jpg2000', 'jpg',
+                'jls', 'pam', 'pbm', 'pcx', 'pgm', 'pgmyuv', 'pic', 'png',
+                'ppm', 'ptx', 'sgi', 'ras', 'tga', 'tiff', 'webp', 'xbm',
+                'xface', 'xwd')
+
+    def load(self, filename):
+        try:
+            loader = ffImageLoader(filename)
+        except:
+            Logger.warning('Image: Unable to load image <%s>' % filename)
+            raise
+
+        # update internals
+        self.filename = filename
+        images = []
+
+        while True:
+            frame, t = loader.next_frame()
+            if frame is None:
+                break
+            images.append(frame)
+        if not len(images):
+            raise Exception('No image found in {}'.format(filename))
+
+        w, h = images[0].get_size()
+        ifmt = images[0].get_pixel_format()
+        if ifmt != 'rgba' and ifmt != 'rgb24':
+            fmt = 'rgba'
+            sws = SWScale(w, h, ifmt, ofmt=fmt)
+            for i, image in enumerate(images):
+                images[i] = sws.scale(image)
+        else:
+            fmt = ifmt if ifmt == 'rgba' else 'rgb'
+
+        return [ImageData(w, h, fmt, img.to_memoryview()[0], source_image=img)
+                for img in images]
+
+
+# register
+ImageLoader.register(ImageLoaderFFPy)

kivy/core/image/img_pil.py

@@ -0,0 +1,123 @@
+'''
+PIL: PIL image loader
+'''
+
+__all__ = ('ImageLoaderPIL', )
+
+try:
+    import Image as PILImage
+except ImportError:
+    # for python3
+    from PIL import Image as PILImage
+
+from kivy.logger import Logger
+from kivy.core.image import ImageLoaderBase, ImageData, ImageLoader
+
+try:
+    # Pillow
+    PILImage.frombytes
+    PILImage.Image.tobytes
+except AttributeError:
+    # PIL
+    # monkey patch frombytes and tobytes methods, refs:
+    # https://github.com/kivy/kivy/issues/5460
+    PILImage.frombytes = PILImage.frombuffer
+    PILImage.Image.tobytes = PILImage.Image.tostring
+
+
+class ImageLoaderPIL(ImageLoaderBase):
+    '''Image loader based on the PIL library.
+
+    .. versionadded:: 1.0.8
+
+    Support for GIF animation added.
+
+    Gif animation has a lot of issues(transparency/color depths... etc).
+    In order to keep it simple, what is implemented here is what is
+    natively supported by the PIL library.
+
+    As a general rule, try to use gifs that have no transparency.
+    Gif's with transparency will work but be prepared for some
+    artifacts until transparency support is improved.
+
+    '''
+
+    @staticmethod
+    def can_save(fmt, is_bytesio):
+        if is_bytesio:
+            return False
+        return fmt in ImageLoaderPIL.extensions()
+
+    @staticmethod
+    def can_load_memory():
+        return True
+
+    @staticmethod
+    def extensions():
+        '''Return accepted extensions for this loader'''
+        PILImage.init()
+        return tuple((ext_with_dot[1:] for ext_with_dot in PILImage.EXTENSION))
+
+    def _img_correct(self, _img_tmp):
+        '''Convert image to the correct format and orientation.
+        '''
+        # image loader work only with rgb/rgba image
+        if _img_tmp.mode.lower() not in ('rgb', 'rgba'):
+            try:
+                imc = _img_tmp.convert('RGBA')
+            except:
+                Logger.warning(
+                    'Image: Unable to convert image to rgba (was %s)' %
+                    (_img_tmp.mode.lower()))
+                raise
+            _img_tmp = imc
+
+        return _img_tmp
+
+    def _img_read(self, im):
+        '''Read images from an animated file.
+        '''
+        im.seek(0)
+
+        # Read all images inside
+        try:
+            img_ol = None
+            while True:
+                img_tmp = im
+                img_tmp = self._img_correct(img_tmp)
+                if img_ol and (hasattr(im, 'dispose') and not im.dispose):
+                    # paste new frame over old so as to handle
+                    # transparency properly
+                    img_ol.paste(img_tmp, (0, 0), img_tmp)
+                    img_tmp = img_ol
+                img_ol = img_tmp
+                yield ImageData(img_tmp.size[0], img_tmp.size[1],
+                                img_tmp.mode.lower(), img_tmp.tobytes())
+                im.seek(im.tell() + 1)
+        except EOFError:
+            pass
+
+    def load(self, filename):
+        try:
+            im = PILImage.open(filename)
+        except:
+            Logger.warning('Image: Unable to load image <%s>' % filename)
+            raise
+        # update internals
+        if not self._inline:
+            self.filename = filename
+        # returns an array of type ImageData len 1 if not a sequence image
+        return list(self._img_read(im))
+
+    @staticmethod
+    def save(filename, width, height, pixelfmt, pixels, flipped=False,
+             imagefmt=None):
+        image = PILImage.frombytes(pixelfmt.upper(), (width, height), pixels)
+        if flipped:
+            image = image.transpose(PILImage.FLIP_TOP_BOTTOM)
+        image.save(filename)
+        return True
+
+
+# register
+ImageLoader.register(ImageLoaderPIL)

kivy/core/image/img_pygame.py

@@ -0,0 +1,119 @@
+'''
+Pygame: Pygame image loader
+
+.. warning::
+
+    Pygame has been deprecated and will be removed in the release after Kivy
+    1.11.0.
+'''
+
+__all__ = ('ImageLoaderPygame', )
+
+from kivy.logger import Logger
+from kivy.core.image import ImageLoaderBase, ImageData, ImageLoader
+from os.path import isfile
+from kivy.utils import deprecated
+
+try:
+    import pygame
+except:
+    raise
+
+
+class ImageLoaderPygame(ImageLoaderBase):
+    '''Image loader based on the PIL library'''
+
+    @deprecated(
+        msg='Pygame has been deprecated and will be removed after 1.11.0')
+    def __init__(self, *largs, **kwargs):
+        super(ImageLoaderPygame, self).__init__(*largs, **kwargs)
+
+    @staticmethod
+    def extensions():
+        '''Return accepted extensions for this loader'''
+        # under OS X, i got with "pygame.error: File is not a Windows BMP
+        # file". documentation said: The image module is a required dependency
+        # of Pygame, but it only optionally supports any extended file formats.
+        # By default it can only load uncompressed BMP image
+        if pygame.image.get_extended() == 0:
+            return ('bmp', )
+        return ('jpg', 'jpeg', 'jpe', 'png', 'bmp', 'pcx', 'tga', 'tiff',
+                'tif', 'lbm', 'pbm', 'ppm', 'xpm')
+
+    @staticmethod
+    def can_save(fmt, is_bytesio):
+        if is_bytesio:
+            return False
+        return fmt in ('png', 'jpg')
+
+    @staticmethod
+    def can_load_memory():
+        return True
+
+    def load(self, filename):
+        if not filename:
+            import traceback
+            traceback.print_stack()
+            return
+        try:
+            im = None
+            if self._inline:
+                im = pygame.image.load(filename, 'x.{}'.format(self._ext))
+            elif isfile(filename):
+                with open(filename, 'rb') as fd:
+                    im = pygame.image.load(fd)
+            elif isinstance(filename, bytes):
+                try:
+                    fname = filename.decode()
+                    if isfile(fname):
+                        with open(fname, 'rb') as fd:
+                            im = pygame.image.load(fd)
+                except UnicodeDecodeError:
+                    pass
+            if im is None:
+                im = pygame.image.load(filename)
+        except:
+            # Logger.warning(type(filename)('Image: Unable to load image <%s>')
+            #               % filename)
+            raise
+
+        fmt = ''
+        if im.get_bytesize() == 3 and not im.get_colorkey():
+            fmt = 'rgb'
+        elif im.get_bytesize() == 4:
+            fmt = 'rgba'
+
+        # image loader work only with rgb/rgba image
+        if fmt not in ('rgb', 'rgba'):
+            try:
+                imc = im.convert(32)
+                fmt = 'rgba'
+            except:
+                try:
+                    imc = im.convert_alpha()
+                    fmt = 'rgba'
+                except:
+                    Logger.warning(
+                        'Image: Unable to convert image %r to rgba (was %r)' %
+                        (filename, im.fmt))
+                    raise
+            im = imc
+
+        # update internals
+        if not self._inline:
+            self.filename = filename
+        data = pygame.image.tostring(im, fmt.upper())
+        return [ImageData(im.get_width(), im.get_height(),
+                fmt, data, source=filename)]
+
+    @staticmethod
+    def save(filename, width, height, pixelfmt, pixels, flipped,
+             imagefmt=None):
+        surface = pygame.image.fromstring(
+            pixels, (width, height), pixelfmt.upper(), flipped)
+        pygame.image.save(surface, filename)
+        return True
+
+
+# register
+ImageLoader.register(ImageLoaderPygame)

kivy/core/image/img_sdl2.py

@@ -0,0 +1,66 @@
+'''
+SDL2 image loader
+=================
+'''
+
+__all__ = ('ImageLoaderSDL2', )
+
+from kivy.logger import Logger
+from kivy.core.image import ImageLoaderBase, ImageData, ImageLoader
+try:
+    from kivy.core.image import _img_sdl2
+except ImportError:
+    from kivy.core import handle_win_lib_import_error
+    handle_win_lib_import_error(
+        'image', 'sdl2', 'kivy.core.image._img_sdl2')
+    raise
+
+
+class ImageLoaderSDL2(ImageLoaderBase):
+    '''Image loader based on SDL2_image'''
+
+    def _ensure_ext(self):
+        _img_sdl2.init()
+
+    @staticmethod
+    def extensions():
+        '''Return accepted extensions for this loader'''
+        return ('bmp', 'jpg', 'jpeg', 'jpe', 'lbm', 'pcx', 'png', 'pnm',
+                'tga', 'tiff', 'webp', 'xcf', 'xpm', 'xv')
+
+    @staticmethod
+    def can_save(fmt, is_bytesio):
+        return fmt in ('jpg', 'png')
+
+    @staticmethod
+    def can_load_memory():
+        return True
+
+    def load(self, filename):
+        if self._inline:
+            data = filename.read()
+            info = _img_sdl2.load_from_memory(data)
+        else:
+            info = _img_sdl2.load_from_filename(filename)
+        if not info:
+            Logger.warning('Image: Unable to load image <%s>' % filename)
+            raise Exception('SDL2: Unable to load image')
+
+        w, h, fmt, pixels, rowlength = info
+
+        # update internals
+        if not self._inline:
+            self.filename = filename
+        return [ImageData(
+            w, h, fmt, pixels, source=filename,
+            rowlength=rowlength)]
+
+    @staticmethod
+    def save(filename, width, height, pixelfmt, pixels, flipped, imagefmt):
+        _img_sdl2.save(filename, width, height, pixelfmt, pixels, flipped,
+                       imagefmt)
+        return True
+
+
+# register
+ImageLoader.register(ImageLoaderSDL2)

kivy/core/image/img_tex.py

@@ -0,0 +1,58 @@
+'''
+Tex: Compressed texture
+'''
+
+__all__ = ('ImageLoaderTex', )
+
+import json
+from struct import unpack
+from kivy.logger import Logger
+from kivy.core.image import ImageLoaderBase, ImageData, ImageLoader
+
+
+class ImageLoaderTex(ImageLoaderBase):
+
+    @staticmethod
+    def extensions():
+        return ('tex', )
+
+    def load(self, filename):
+        try:
+            fd = open(filename, 'rb')
+            if fd.read(4) != 'KTEX':
+                raise Exception('Invalid tex identifier')
+
+            headersize = unpack('I', fd.read(4))[0]
+            header = fd.read(headersize)
+            if len(header) != headersize:
+                raise Exception('Truncated tex header')
+
+            info = json.loads(header)
+            data = fd.read()
+            if len(data) != info['datalen']:
+                raise Exception('Truncated tex data')
+
+        except:
+            Logger.warning('Image: Image <%s> is corrupted' % filename)
+            raise
+
+        width, height = info['image_size']
+        tw, th = info['texture_size']
+
+        images = [data]
+        im = ImageData(width, height, str(info['format']), images[0],
+                       source=filename)
+        '''
+        if len(dds.images) > 1:
+            images = dds.images
+            images_size = dds.images_size
+            for index in range(1, len(dds.images)):
+                w, h = images_size[index]
+                data = images[index]
+                im.add_mipmap(index, w, h, data)
+        '''
+        return [im]
+
+
+# register
+ImageLoader.register(ImageLoaderTex)

kivy/core/spelling/__init__.py

@@ -0,0 +1,135 @@
+'''
+Spelling
+========
+
+Provides abstracted access to a range of spellchecking backends as well as
+word suggestions. The API is inspired by enchant but other backends can be
+added that implement the same API.
+
+Spelling currently requires `python-enchant` for all platforms except
+OSX, where a native implementation exists.
+
+::
+
+    >>> from kivy.core.spelling import Spelling
+    >>> s = Spelling()
+    >>> s.list_languages()
+    ['en', 'en_CA', 'en_GB', 'en_US']
+    >>> s.select_language('en_US')
+    >>> s.suggest('helo')
+    [u'hole', u'help', u'helot', u'hello', u'halo', u'hero', u'hell', u'held',
+     u'helm', u'he-lo']
+
+'''
+
+__all__ = ('Spelling', 'SpellingBase', 'NoSuchLangError',
+           'NoLanguageSelectedError')
+
+import sys
+from kivy.core import core_select_lib
+
+
+class NoSuchLangError(Exception):
+    '''
+    Exception to be raised when a specific language could not be found.
+    '''
+    pass
+
+
+class NoLanguageSelectedError(Exception):
+    '''
+    Exception to be raised when a language-using method is called but no
+    language was selected prior to the call.
+    '''
+    pass
+
+
+class SpellingBase(object):
+    '''
+    Base class for all spelling providers.
+    Supports some abstract methods for checking words and getting suggestions.
+    '''
+
+    def __init__(self, language=None):
+        '''
+        If a `language` identifier (such as 'en_US') is provided and a matching
+        language exists, it is selected. If an identifier is provided and no
+        matching language exists, a NoSuchLangError exception is raised by
+        self.select_language().
+        If no `language` identifier is provided, we just fall back to the first
+        one that is available.
+
+        :Parameters:
+            `language`: str, defaults to None
+                If provided, indicates the language to be used. This needs
+                to be a language identifier understood by select_language(),
+                i.e. one of the options returned by list_languages().
+                If nothing is provided, the first available language is used.
+                If no language is available, NoLanguageSelectedError is raised.
+        '''
+        langs = self.list_languages()
+        try:
+            # If no language was specified, we just use the first one
+            # that is available.
+            fallback_lang = langs[0]
+        except IndexError:
+            raise NoLanguageSelectedError("No languages available!")
+        self.select_language(language or fallback_lang)
+
+    def select_language(self, language):
+        '''
+        From the set of registered languages, select the first language
+        for `language`.
+
+        :Parameters:
+            `language`: str
+                Language identifier. Needs to be one of the options returned by
+                list_languages(). Sets the language used for spell checking and
+                word suggestions.
+        '''
+        raise NotImplementedError('select_language() method not implemented '
+                                  'by abstract spelling base class!')
+
+    def list_languages(self):
+        '''
+        Return a list of all supported languages.
+        E.g. ['en', 'en_GB', 'en_US', 'de', ...]
+        '''
+        raise NotImplementedError('list_languages() is not implemented '
+                                  'by abstract spelling base class!')
+
+    def check(self, word):
+        '''
+        If `word` is a valid word in `self._language` (the currently active
+        language), returns True. If the word shouldn't be checked, returns
+        None (e.g. for ''). If it is not a valid word in `self._language`,
+        return False.
+
+        :Parameters:
+            `word`: str
+                The word to check.
+        '''
+        raise NotImplementedError('check() not implemented by abstract ' +
+                                  'spelling base class!')
+
+    def suggest(self, fragment):
+        '''
+        For a given `fragment` (i.e. part of a word or a word by itself),
+        provide corrections (`fragment` may be misspelled) or completions
+        as a list of strings.
+
+        :Parameters:
+            `fragment`: str
+                The word fragment to get suggestions/corrections for.
+                E.g. 'foo' might become 'of', 'food' or 'foot'.
+
+        '''
+        raise NotImplementedError('suggest() not implemented by abstract ' +
+                                  'spelling base class!')
+
+
+_libs = (('enchant', 'spelling_enchant', 'SpellingEnchant'), )
+if sys.platform == 'darwin':
+    _libs += (('osxappkit', 'spelling_osxappkit', 'SpellingOSXAppKit'), )
+
+Spelling = core_select_lib('spelling', _libs)

kivy/core/spelling/spelling_enchant.py

@@ -0,0 +1,50 @@
+'''
+Enchant Spelling
+================
+
+Implementation spelling backend based on enchant.
+
+.. warning:: pyenchant doesn't have dedicated build anymore for Windows/x64.
+             See https://github.com/kivy/kivy/issues/5816 for more information
+'''
+
+
+import enchant
+
+from kivy.core.spelling import SpellingBase, NoSuchLangError
+from kivy.compat import PY2
+
+
+class SpellingEnchant(SpellingBase):
+    '''
+    Spelling backend based on the enchant library.
+    '''
+
+    def __init__(self, language=None):
+        self._language = None
+        super(SpellingEnchant, self).__init__(language)
+
+    def select_language(self, language):
+        try:
+            self._language = enchant.Dict(language)
+        except enchant.DictNotFoundError:
+            err = 'Enchant Backend: No language for "%s"' % (language, )
+            raise NoSuchLangError(err)
+
+    def list_languages(self):
+        # Note: We do NOT return enchant.list_dicts because that also returns
+        #       the enchant dict objects and not only the language identifiers.
+        return enchant.list_languages()
+
+    def check(self, word):
+        if not word:
+            return None
+        return self._language.check(word)
+
+    def suggest(self, fragment):
+        suggestions = self._language.suggest(fragment)
+        # Don't show suggestions that are invalid
+        suggestions = [s for s in suggestions if self.check(s)]
+        if PY2:
+            suggestions = [s.decode('utf-8') for s in suggestions]
+        return suggestions