Hello community,

here is the log from the commit of package python-python-mpv for 
openSUSE:Leap:15.2 checked in at 2020-03-02 13:21:36
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Comparing /work/SRC/openSUSE:Leap:15.2/python-python-mpv (Old)
 and      /work/SRC/openSUSE:Leap:15.2/.python-python-mpv.new.26092 (New)
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

Package is "python-python-mpv"

Mon Mar  2 13:21:36 2020 rev:13 rq:777047 version:0.4.4

Changes:
--------
--- /work/SRC/openSUSE:Leap:15.2/python-python-mpv/python-python-mpv.changes    
2020-01-15 15:52:24.467562290 +0100
+++ 
/work/SRC/openSUSE:Leap:15.2/.python-python-mpv.new.26092/python-python-mpv.changes
 2020-03-02 13:21:37.270191240 +0100
@@ -1,0 +2,33 @@
+Wed Dec  4 08:40:49 UTC 2019 - Luigi Baldoni <[email protected]>
+
+- Update to version 0.4.4.
+  * Allow mpv-1.dll to be placed in python script directory (#96)
+  * tests: Silence libmpv during unittests
+  * Fix Python 3.5 compatibility 
+
+-------------------------------------------------------------------
+Mon Dec  2 08:22:36 UTC 2019 - Luigi Baldoni <[email protected]>
+
+- Update to version 0.4.1
+  * Add stream protocol handling
+
+-------------------------------------------------------------------
+Tue Nov 26 12:42:09 UTC 2019 - Luigi Baldoni <[email protected]>
+
+- Update to version 0.4.0
+  * key bindings: Introduce key char parameter
+  * README - vo "opengl" doesn't exist anymore 
+
+-------------------------------------------------------------------
+Sun Nov 10 16:05:24 UTC 2019 - Luigi Baldoni <[email protected]>
+
+
+- Update to version 0.3.10
+  * Use stride//4 rather than the returned image w
+  * README: Add cosven's QT/OpenGL example
+  * fix: getProcAddr function should return a function or 0
+  * Readme: Add PyGtk embedding example 
+
+- Spec cleanup
+
+-------------------------------------------------------------------

Old:
----
  python-mpv-0.3.9.tar.gz

New:
----
  python-mpv-0.4.4.tar.gz

++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

Other differences:
------------------
++++++ python-python-mpv.spec ++++++
--- /var/tmp/diff_new_pack.msOLJ9/_old  2020-03-02 13:21:37.574191845 +0100
+++ /var/tmp/diff_new_pack.msOLJ9/_new  2020-03-02 13:21:37.574191845 +0100
@@ -1,7 +1,7 @@
 #
 # spec file for package python-python-mpv
 #
-# Copyright (c) 2018 SUSE LINUX GmbH, Nuernberg, Germany.
+# Copyright (c) 2019 SUSE LLC
 #
 # All modifications and additions to the file contributed by third parties
 # remain the property of their copyright owners, unless otherwise agreed
@@ -16,14 +16,12 @@
 #
 
 
-%{?!python_module:%define python_module() python-%{**} python3-%{**}}
 Name:           python-python-mpv
-Version:        0.3.9
+Version:        0.4.4
 Release:        0
 Summary:        Python interface to the mpv media player
 License:        AGPL-3.0-or-later
-Group:          Development/Languages/Python
-Url:            https://github.com/jaseg/python-mpv
+URL:            https://github.com/jaseg/python-mpv
 Source0:        
https://files.pythonhosted.org/packages/source/p/python-mpv/python-mpv-%{version}.tar.gz
 Source99:       %{name}-rpmlintrc
 BuildRequires:  %{python_module setuptools}

++++++ python-mpv-0.3.9.tar.gz -> python-mpv-0.4.4.tar.gz ++++++
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' 
'--exclude=.svnignore' old/python-mpv-0.3.9/PKG-INFO 
new/python-mpv-0.4.4/PKG-INFO
--- old/python-mpv-0.3.9/PKG-INFO       2018-07-25 12:08:50.000000000 +0200
+++ new/python-mpv-0.4.4/PKG-INFO       2019-12-04 09:14:17.000000000 +0100
@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: python-mpv
-Version: 0.3.9
+Version: 0.4.4
 Summary: A python interface to the mpv media player
 Home-page: https://github.com/jaseg/python-mpv
 Author: jaseg
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' 
'--exclude=.svnignore' old/python-mpv-0.3.9/README.rst 
new/python-mpv-0.4.4/README.rst
--- old/python-mpv-0.3.9/README.rst     2017-12-25 13:32:27.000000000 +0100
+++ new/python-mpv-0.4.4/README.rst     2019-12-04 00:05:11.000000000 +0100
@@ -19,16 +19,21 @@
 Requirements
 ~~~~~~~~~~~~
 
-libmpv (no kidding!)
-....................
+libmpv
+......
 ``libmpv.so`` either locally (in your current working directory) or somewhere 
in your system library search path. This
 module is somewhat lenient as far as ``libmpv`` versions are concerned but 
since ``libmpv`` is changing quite frequently
 you'll only get all the newest features when using an up-to-date version of 
this module. The unit tests for this module
 do some basic automatic version compatibility checks. If you discover anything 
missing here, please open an `issue`_ or
 submit a `pull request`_ on github.
 
-Python 2.7, 3.5 or 3.6 (officially)
-...................................
+On Windows you can place libmpv anywhere in your ``%PATH%`` (e.g. next to 
``python.exe``) or next to this module's
+``mpv.py``.  Before falling back to looking in the mpv module's directory, 
python-mpv uses the DLL search order built
+into ctypes, which is different to the one Windows uses internally. Consult 
`this stackoverflow post
+<https://stackoverflow.com/a/23805306>`__ for details.
+
+Python >= 3.5 (officially)
+..........................
 The ``master`` branch officially only supports recent python releases (3.5 
onwards), but there is the somewhat outdated
 but functional `py2compat branch`_ providing Python 2 compatibility.
 
@@ -98,7 +103,7 @@
     player.fullscreen = True
     player.loop_playlist = 'inf'
     # Option access, in general these require the core to reinitialize
-    player['vo'] = 'opengl'
+    player['vo'] = 'gpu'
 
     @player.on_key_press('q')
     def my_q_binding():
@@ -135,6 +140,24 @@
         print(player.playlist)
         player.wait_for_playback()
 
+Directly feeding mpv data from python
+.....................................
+
+.. code:: python
+
+    #!/usr/bin/env python3
+    import mpv
+
+    player = mpv.MPV()
+    @player.python_stream('foo')
+    def reader():
+        with open('test.webm', 'rb') as f:
+            while True:
+                yield f.read(1024*1024)
+
+    player.play('python://foo')
+    player.wait_for_playback()
+
 PyQT embedding
 ..............
 
@@ -170,6 +193,50 @@
     win.show()
     sys.exit(app.exec_())
 
+PyGtk embedding
+..............
+
+.. code:: python
+    
+    #!/usr/bin/env python3
+    import gi
+
+    import mpv
+
+    gi.require_version('Gtk', '3.0')
+    from gi.repository import Gtk
+
+
+    class MainClass(Gtk.Window):
+
+        def __init__(self):
+            super(MainClass, self).__init__()
+            self.set_default_size(600, 400)
+            self.connect("destroy", self.on_destroy)
+
+            widget = Gtk.Frame()
+            self.add(widget)
+            self.show_all()
+
+            # Must be created >after< the widget is shown, else property 
'window' will be None
+            self.mpv = 
mpv.MPV(wid=str(widget.get_property("window").get_xid()))
+            self.mpv.play("test.webm")
+
+        def on_destroy(self, widget, data=None):
+            self.mpv.terminate()
+            Gtk.main_quit()
+
+
+    if __name__ == '__main__':
+        application = MainClass()
+        Gtk.main()
+
+Using OpenGL from PyQT
+......................
+
+Github user cosven_ has managed to `make mpv render into a Qt widget using 
OpenGL
+<https://gist.github.com/cosven/b313de2acce1b7e15afda263779c0afc>`__ through 
this python API.
+
 Coding Conventions
 ------------------
 
@@ -179,3 +246,4 @@
 
 .. _`PEP 8`: https://www.python.org/dev/peps/pep-0008/
 .. _`mpv.py`: https://raw.githubusercontent.com/jaseg/python-mpv/master/mpv.py
+.. _cosven: https://github.com/cosven
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' 
'--exclude=.svnignore' old/python-mpv-0.3.9/mpv.py new/python-mpv-0.4.4/mpv.py
--- old/python-mpv-0.3.9/mpv.py 2018-07-25 12:02:23.000000000 +0200
+++ new/python-mpv-0.4.4/mpv.py 2019-12-04 00:14:14.000000000 +0100
@@ -28,7 +28,10 @@
 import traceback
 
 if os.name == 'nt':
-    backend = CDLL('mpv-1.dll')
+    try:
+        backend = CDLL('mpv-1.dll')
+    except FileNotFoundError:
+        backend = 
CDLL(os.path.join(os.path.dirname(os.path.abspath(__file__)), 'mpv-1.dll'))
     fs_enc = 'utf-8'
 else:
     import locale
@@ -72,6 +75,14 @@
     PROPERTY_UNAVAILABLE    = -10
     PROPERTY_ERROR          = -11
     COMMAND                 = -12
+    LOADING_FAILED          = -13
+    AO_INIT_FAILED          = -14
+    VO_INIT_FAILED          = -15
+    NOTHING_TO_PLAY         = -16
+    UNKNOWN_FORMAT          = -17
+    UNSUPPORTED             = -18
+    NOT_IMPLEMENTED         = -19
+    GENERIC                 = -20
 
     EXCEPTION_DICT = {
              0:     None,
@@ -88,7 +99,17 @@
             -9:     lambda *a: TypeError('Tried to get/set mpv property using 
wrong format, or passed invalid value', *a),
             -10:    lambda *a: PropertyUnavailableError('mpv property is not 
available', *a),
             -11:    lambda *a: RuntimeError('Generic error getting or setting 
mpv property', *a),
-            -12:    lambda *a: SystemError('Error running mpv command', *a) }
+            -12:    lambda *a: SystemError('Error running mpv command', *a),
+            -14:    lambda *a: RuntimeError('Initializing the audio output 
failed', *a),
+            -15:    lambda *a: RuntimeError('Initializing the video output 
failed'),
+            -16:    lambda *a: RuntimeError('There was no audio or video data 
to play. This also happens if the file '
+                                            'was recognized, but did not 
contain any audio or video streams, or no '
+                                            'streams were selected.'),
+            -17:    lambda *a: RuntimeError('When trying to load the file, the 
file format could not be determined, '
+                                            'or the file was too broken to 
open it'),
+            -18:    lambda *a: ValueError('Generic error for signaling that 
certain system requirements are not fulfilled'),
+            -19:    lambda *a: NotImplementedError('The API function which was 
called is a stub only'),
+            -20:    lambda *a: RuntimeError('Unspecified error') }
 
     @staticmethod
     def default_error_handler(ec, *args):
@@ -282,14 +303,24 @@
                  'level':  self.level.decode('utf-8'),
                  'text':   decoder(self.text).rstrip() }
 
-class MpvEventEndFile(c_int):
-    EOF_OR_INIT_FAILURE = 0
+class MpvEventEndFile(Structure):
+    _fields_ = [('reason', c_int),
+                ('error', c_int)]
+
+    EOF                 = 0
     RESTARTED           = 1
     ABORTED             = 2
     QUIT                = 3
+    ERROR               = 4
+    REDIRECT            = 5
+
+    # For backwards-compatibility
+    @property
+    def value(self):
+        return self.reason
 
     def as_dict(self, decoder=identity_decoder):
-        return {'reason': self.value}
+        return {'reason': self.reason, 'error': self.error}
 
 class MpvEventScriptInputDispatch(Structure):
     _fields_ = [('arg0', c_int),
@@ -305,10 +336,26 @@
     def as_dict(self, decoder=identity_decoder):
         return { 'args': [ self.args[i].decode('utf-8') for i in 
range(self.num_args) ] }
 
+StreamReadFn = CFUNCTYPE(c_int64, c_void_p, POINTER(c_char), c_uint64)
+StreamSeekFn = CFUNCTYPE(c_int64, c_void_p, c_int64)
+StreamSizeFn = CFUNCTYPE(c_int64, c_void_p)
+StreamCloseFn = CFUNCTYPE(None, c_void_p)
+StreamCancelFn = CFUNCTYPE(None, c_void_p)
+
+class StreamCallbackInfo(Structure):
+    _fields_ = [('cookie', c_void_p),
+                ('read', StreamReadFn),
+                ('seek', StreamSeekFn),
+                ('size', StreamSizeFn),
+                ('close', StreamCloseFn), ]
+#                ('cancel', StreamCancelFn)]
+
+StreamOpenFn = CFUNCTYPE(c_int, c_void_p, c_char_p, 
POINTER(StreamCallbackInfo))
+
 WakeupCallback = CFUNCTYPE(None, c_void_p)
 
 OpenGlCbUpdateFn = CFUNCTYPE(None, c_void_p)
-OpenGlCbGetProcAddrFn = CFUNCTYPE(None, c_void_p, c_char_p)
+OpenGlCbGetProcAddrFn = CFUNCTYPE(c_void_p, c_void_p, c_char_p)
 
 def _handle_func(name, args, restype, errcheck, ctx=MpvHandle):
     func = getattr(backend, name)
@@ -387,6 +434,8 @@
 _handle_func('mpv_set_wakeup_callback',     [WakeupCallback, c_void_p],        
         None, errcheck=None)
 _handle_func('mpv_get_wakeup_pipe',         [],                                
         c_int, errcheck=None)
 
+_handle_func('mpv_stream_cb_add_ro',        [c_char_p, c_void_p, 
StreamOpenFn],         c_int, ec_errcheck)
+
 _handle_func('mpv_get_sub_api',             [MpvSubApi],                       
         c_void_p, notnull_errcheck)
 
 _handle_gl_func('mpv_opengl_cb_set_update_callback',    [OpenGlCbUpdateFn, 
c_void_p])
@@ -517,6 +566,40 @@
     def __setattr__(self, name, value):
         setattr(self.mpv, _py_to_mpv(name), value)
 
+class GeneratorStream:
+    """Transform a python generator into an mpv-compatible stream object. This 
only supports size() and read(), and
+    does not support seek(), close() or cancel().
+    """
+
+    def __init__(self, generator_fun, size=None):
+        self._generator_fun = generator_fun
+        self.size = size
+
+    def seek(self, offset):
+        self._read_iter = iter(self._generator_fun())
+        self._read_chunk = b''
+        return 0 # We only support seeking to the first byte atm
+        # implementation in case seeking to arbitrary offsets would be 
necessary
+        # while offset > 0:
+        #     offset -= len(self.read(offset))
+        # return offset
+
+    def read(self, size):
+        if not self._read_chunk:
+            try:
+                self._read_chunk += next(self._read_iter)
+            except StopIteration:
+                return b''
+        rv, self._read_chunk = self._read_chunk[:size], self._read_chunk[size:]
+        return rv
+
+    def close(self):
+        self._read_iter = iter([]) # make next read() call return EOF
+
+    def cancel(self):
+        self._read_iter = iter([]) # make next read() call return EOF
+        # TODO?
+
 class MPV(object):
     """See man mpv(1) for the details of the implemented commands. All mpv 
properties can be accessed as
     ``my_mpv.some_property`` and all mpv options can be accessed as 
``my_mpv['some-option']``.
@@ -565,6 +648,11 @@
         self._event_handle = _mpv_create_client(self.handle, 
b'py_event_handler')
         self._loop = partial(_event_loop, self._event_handle, 
self._playback_cond, self._event_callbacks,
                 self._message_handlers, self._property_handlers, log_handler)
+        self._stream_protocol_cbs = {}
+        self._stream_protocol_frontends = collections.defaultdict(lambda: {})
+        self.register_stream_protocol('python', self._python_stream_open)
+        self._python_streams = {}
+        self._python_stream_catchall = None
         if loglevel is not None or log_handler is not None:
             self.set_loglevel(loglevel or 'terminal-default')
         if start_event_thread:
@@ -683,7 +771,7 @@
         if res['format'] != 'bgr0':
             raise ValueError('Screenshot in unknown format "{}". Currently, 
only bgr0 is supported.'
                     .format(res['format']))
-        img = Image.frombytes('RGBA', (res['w'], res['h']), res['data'])
+        img = Image.frombytes('RGBA', (res['stride']//4, res['h']), 
res['data'])
         b,g,r,a = img.split()
         return Image.merge('RGB', (r,g,b))
 
@@ -950,7 +1038,7 @@
         def register(fun):
             @self.key_binding(keydef, mode)
             @wraps(fun)
-            def wrapper(state='p-', name=None):
+            def wrapper(state='p-', name=None, char=None):
                 if state[0] in ('d', 'p'):
                     fun()
             return wrapper
@@ -969,7 +1057,7 @@
 
             player = mpv.MPV()
             @player.key_binding('Q')
-            def binding(state, name):
+            def binding(state, name, char):
                 print('blep')
 
             binding.unregister_mpv_key_bindings()
@@ -1015,8 +1103,8 @@
             raise TypeError('register_key_binding expects either an str with 
an mpv command or a python callable.')
         self.command('enable-section', binding_name, 
'allow-hide-cursor+allow-vo-dragging')
 
-    def _handle_key_binding_message(self, binding_name, key_state, 
key_name=None):
-        self._key_binding_handlers[binding_name](key_state, key_name)
+    def _handle_key_binding_message(self, binding_name, key_state, 
key_name=None, key_char=None):
+        self._key_binding_handlers[binding_name](key_state, key_name, key_char)
 
     def unregister_key_binding(self, keydef):
         """Unregister a key binding by keydef."""
@@ -1028,6 +1116,87 @@
             if not self._key_binding_handlers:
                 self.unregister_message_handler('key-binding')
 
+    def register_stream_protocol(self, proto, open_fn=None):
+        """ Register a custom stream protocol as documented in 
libmpv/stream_cb.h:
+            https://github.com/mpv-player/mpv/blob/master/libmpv/stream_cb.h
+
+            proto is the protocol scheme, e.g. "foo" for "foo://" urls.
+
+            This function can either be used with two parameters or it can be 
used as a decorator on the target
+            function.
+
+            open_fn is a function taking an URI string and returning an mpv 
stream object.
+            open_fn may raise a ValueError to signal libmpv the URI could not 
be opened.
+
+            The mpv stream protocol is as follows:
+            class Stream:
+                @property
+                def size(self):
+                    return None # unknown size
+                    return size # int with size in bytes
+
+                def read(self, size):
+                    ...
+                    return read # non-empty bytes object with input
+                    return b'' # empty byte object signals permanent EOF
+
+                def seek(self, pos):
+                    return new_offset # integer with new byte offset. The new 
offset may be before the requested offset
+                    in case an exact seek is inconvenient.
+
+                def close(self):
+                    ...
+
+                # def cancel(self): (future API versions only)
+                #     Abort a running read() or seek() operation
+                #     ...
+
+        """
+
+        def decorator(open_fn):
+            @StreamOpenFn
+            def open_backend(_userdata, uri, cb_info):
+                try:
+                    frontend = open_fn(uri.decode('utf-8'))
+                except ValueError:
+                    return ErrorCode.LOADING_FAILED
+
+                def read_backend(_userdata, buf, bufsize):
+                    data = frontend.read(bufsize)
+                    for i in range(len(data)):
+                        buf[i] = data[i]
+                    return len(data)
+
+                cb_info.contents.cookie = None
+                read = cb_info.contents.read = StreamReadFn(read_backend)
+                close = cb_info.contents.close = StreamCloseFn(lambda 
_userdata: frontend.close())
+
+                seek, size, cancel = None, None, None
+                if hasattr(frontend, 'seek'):
+                    seek = cb_info.contents.seek = StreamSeekFn(lambda 
_userdata, offx: frontend.seek(offx))
+                if hasattr(frontend, 'size') and frontend.size is not None:
+                    size = cb_info.contents.size = StreamSizeFn(lambda 
_userdata: frontend.size)
+
+                # Future API versions only
+                # if hasattr(frontend, 'cancel'):
+                #     cb_info.contents.cancel = StreamCancelFn(lambda 
_userdata: frontend.cancel())
+
+                # keep frontend and callbacks in memory forever (TODO)
+                frontend._registered_callbacks = [read, close, seek, size, 
cancel]
+                self._stream_protocol_frontends[proto][uri] = frontend
+                return 0
+
+            if proto in self._stream_protocol_cbs:
+                raise KeyError('Stream protocol already registered')
+            self._stream_protocol_cbs[proto] = [open_backend]
+            _mpv_stream_cb_add_ro(self.handle, proto.encode('utf-8'), 
c_void_p(), open_backend)
+
+            return open_fn
+
+        if open_fn is not None:
+            decorator(open_fn)
+        return decorator
+
     # Convenience functions
     def play(self, filename):
         """Play a path or URL (requires ``ytdl`` option to be set)."""
@@ -1043,6 +1212,97 @@
         ``MPV.loadfile(filename, 'append-play')``."""
         self.loadfile(filename, 'append', **options)
 
+    # "Python stream" logic. This is some porcelain for directly playing data 
from python generators.
+
+    def _python_stream_open(self, uri):
+        """Internal handler for python:// protocol streams registered through 
@python_stream(...) and
+        @python_stream_catchall
+        """
+        name, = re.fullmatch('python://(.*)', uri).groups()
+
+        if name in self._python_streams:
+            generator_fun, size = self._python_streams[name]
+        else:
+            if self._python_stream_catchall is not None:
+                generator_fun, size = self._python_stream_catchall(name)
+            else:
+                raise ValueError('Python stream name not found and no 
catch-all defined')
+
+        return GeneratorStream(generator_fun, size)
+
+    def python_stream(self, name=None, size=None):
+        """Register a generator for the python stream with the given name.
+
+        name is the name, i.e. the part after the "python://" in the URI, that 
this generator is registered as.
+        size is the total number of bytes in the stream (if known).
+
+        Any given name can only be registered once. The catch-all can also 
only be registered once. To unregister a
+        stream, call the .unregister function set on the callback.
+
+        The generator signals EOF by returning, manually raising StopIteration 
or by yielding b'', an empty bytes
+        object.
+
+        The generator may be called multiple times if libmpv seeks or loops.
+
+        See also: @mpv.python_stream_catchall
+
+        @mpv.python_stream('foobar')
+        def reader():
+            for chunk in chunks:
+                yield chunk
+        mpv.play('python://foobar')
+        mpv.wait_for_playback()
+        reader.unregister()
+        """
+        def register(cb):
+            if name in self._python_streams:
+                raise KeyError('Python stream name "{}" is already 
registered'.format(name))
+            self._python_streams[name] = (cb, size)
+            def unregister():
+                if name not in self._python_streams or\
+                        self._python_streams[name][0] is not cb: # This is 
just a basic sanity check
+                    raise RuntimeError('Python stream has already been 
unregistered')
+                del self._python_streams[name]
+            cb.unregister = unregister
+            return cb
+        return register
+
+    def python_stream_catchall(self, cb):
+        """ Register a catch-all python stream to be called when no name 
matches can be found. Use this decorator on a
+        function that takes a name argument and returns a (generator, size) 
tuple (with size being None if unknown).
+
+        An invalid URI can be signalled to libmpv by raising a ValueError 
inside the callback.
+
+        See also: @mpv.python_stream(name, size)
+
+        @mpv.python_stream_catchall
+        def catchall(name):
+            if not name.startswith('foo'):
+                raise ValueError('Unknown Name')
+
+            def foo_reader():
+                with open(name, 'rb') as f:
+                    while True:
+                        chunk = f.read(1024)
+                        if not chunk:
+                            break
+                        yield chunk
+            return foo_reader, None
+        mpv.play('python://foo23')
+        mpv.wait_for_playback()
+        catchall.unregister()
+        """
+        if self._python_stream_catchall is not None:
+            raise KeyError('A catch-all python stream is already registered')
+
+        self._python_stream_catchall = cb
+        def unregister():
+            if self._python_stream_catchall is not cb:
+                    raise RuntimeError('This catch-all python stream has 
already been unregistered')
+            self._python_stream_catchall = None
+        cb.unregister = unregister
+        return cb
+
     # Property accessors
     def _get_property(self, name, decoder=strict_decoder, fmt=MpvFormat.NODE):
         out = create_string_buffer(sizeof(MpvNode))
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' 
'--exclude=.svnignore' old/python-mpv-0.3.9/python_mpv.egg-info/PKG-INFO 
new/python-mpv-0.4.4/python_mpv.egg-info/PKG-INFO
--- old/python-mpv-0.3.9/python_mpv.egg-info/PKG-INFO   2018-07-25 
12:08:50.000000000 +0200
+++ new/python-mpv-0.4.4/python_mpv.egg-info/PKG-INFO   2019-12-04 
09:14:17.000000000 +0100
@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: python-mpv
-Version: 0.3.9
+Version: 0.4.4
 Summary: A python interface to the mpv media player
 Home-page: https://github.com/jaseg/python-mpv
 Author: jaseg
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' 
'--exclude=.svnignore' old/python-mpv-0.3.9/setup.py 
new/python-mpv-0.4.4/setup.py
--- old/python-mpv-0.3.9/setup.py       2018-07-25 12:07:26.000000000 +0200
+++ new/python-mpv-0.4.4/setup.py       2019-12-04 00:14:14.000000000 +0100
@@ -3,7 +3,7 @@
 from setuptools import setup
 setup(
     name = 'python-mpv',
-    version = '0.3.9',
+    version = '0.4.4',
     py_modules = ['mpv'],
     description = 'A python interface to the mpv media player',
     url = 'https://github.com/jaseg/python-mpv',


Reply via email to