Hello community,
here is the log from the commit of package python-dill for openSUSE:Factory
checked in at 2020-02-03 11:12:07
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Comparing /work/SRC/openSUSE:Factory/python-dill (Old)
and /work/SRC/openSUSE:Factory/.python-dill.new.26092 (New)
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Package is "python-dill"
Mon Feb 3 11:12:07 2020 rev:6 rq:768849 version:0.3.1.1
Changes:
--------
--- /work/SRC/openSUSE:Factory/python-dill/python-dill.changes 2019-07-31
14:15:11.698807518 +0200
+++ /work/SRC/openSUSE:Factory/.python-dill.new.26092/python-dill.changes
2020-02-03 11:12:20.141815133 +0100
@@ -1,0 +2,18 @@
+Thu Jan 30 17:21:16 UTC 2020 - Todd R <toddrme2...@gmail.com>
+
+- version update to 0.3.1.1
+ * Add support for pickling MappingProxyType on Python3
+ * Fix GetSetDescriptorType unpickling error in test_selected.py
+ * add python 3.x keywords to dump and load
+ * add save_socket method for socket objects
+ * add support for pickling MappingProxyType
+ * cleanup of Pickler,Unpickler; move dump to Pickler.dump
+ * don't use multiple inheritance in Pickler,Unpickler
+ * enabled to pickle __kwdefaults__ property
+ * fix pickling keyword only arguments
+ * fix typo in readline error message (#327)
+ * more handling of 3.8 SyntaxWarnings
+ * rollback register(SocketType) due to multiprocess test_pickling failure
+ * unified handling of MappingProxyType and DictProxyType
+
+-------------------------------------------------------------------
Old:
----
dill-0.3.0.tar.gz
New:
----
dill-0.3.1.1.tar.gz
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Other differences:
------------------
++++++ python-dill.spec ++++++
--- /var/tmp/diff_new_pack.g31RGV/_old 2020-02-03 11:12:21.385815761 +0100
+++ /var/tmp/diff_new_pack.g31RGV/_new 2020-02-03 11:12:21.413815776 +0100
@@ -1,7 +1,7 @@
#
# spec file for package python-dill
#
-# Copyright (c) 2019 SUSE LINUX GmbH, Nuernberg, Germany.
+# Copyright (c) 2020 SUSE LLC
#
# All modifications and additions to the file contributed by third parties
# remain the property of their copyright owners, unless otherwise agreed
@@ -18,7 +18,7 @@
%{?!python_module:%define python_module() python-%{**} python3-%{**}}
Name: python-dill
-Version: 0.3.0
+Version: 0.3.1.1
Release: 0
Summary: Module to serialize all of Python
License: BSD-3-Clause
++++++ dill-0.3.0.tar.gz -> dill-0.3.1.1.tar.gz ++++++
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/dill-0.3.0/README new/dill-0.3.1.1/README
--- old/dill-0.3.0/README 2019-06-27 01:01:34.000000000 +0200
+++ new/dill-0.3.1.1/README 2019-09-28 17:40:23.000000000 +0200
@@ -67,7 +67,7 @@
Current Release
===============
-This documentation is for version ``dill-0.3.0``.
+This documentation is for version ``dill-0.3.1.1``.
The latest released version of ``dill`` is available from:
@@ -96,8 +96,8 @@
download the tarball, unzip, and run the installer::
[download]
- $ tar -xvzf dill-0.3.0.tar.gz
- $ cd dill-0.3.0
+ $ tar -xvzf dill-0.3.1.1.tar.gz
+ $ cd dill-0.3.1.1
$ python setup py build
$ python setup py install
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/dill-0.3.0/README.md new/dill-0.3.1.1/README.md
--- old/dill-0.3.0/README.md 2019-06-27 00:53:35.000000000 +0200
+++ new/dill-0.3.1.1/README.md 2019-09-28 17:38:53.000000000 +0200
@@ -71,6 +71,7 @@
Development Version
+[](https://dill.readthedocs.io/en/latest/?badge=latest)
[](https://travis-ci.org/uqfoundation/dill)
[](https://codecov.io/gh/uqfoundation/dill)
-------------------
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/dill-0.3.0/dill/_dill.py
new/dill-0.3.1.1/dill/_dill.py
--- old/dill-0.3.0/dill/_dill.py 2019-06-27 00:53:35.000000000 +0200
+++ new/dill-0.3.1.1/dill/_dill.py 2019-09-28 17:38:53.000000000 +0200
@@ -35,10 +35,11 @@
import sys
diff = None
_use_diff = False
-PY3 = (sys.hexversion >= 0x30000f0)
+PY3 = (sys.hexversion >= 0x3000000)
# OLDER: 3.0 <= x < 3.4 *OR* x < 2.7.10 #NOTE: guessing relevant versions
-OLDER = (PY3 and sys.hexversion < 0x30400f0) or (sys.hexversion < 0x2070af0)
-PY34 = (0x30400f0 <= sys.hexversion < 0x30500f0)
+OLDER = (PY3 and sys.hexversion < 0x3040000) or (sys.hexversion < 0x2070ab1)
+OLD33 = (sys.hexversion < 0x3030000)
+PY34 = (0x3040000 <= sys.hexversion < 0x3050000)
if PY3: #XXX: get types from .objtypes ?
import builtins as __builtin__
from pickle import _Pickler as StockPickler, Unpickler as StockUnpickler
@@ -58,7 +59,10 @@
SliceType = slice
TypeType = type # 'new-style' classes #XXX: unregistered
XRangeType = range
- DictProxyType = type(object.__dict__)
+ if OLD33:
+ DictProxyType = type(object.__dict__)
+ else:
+ from types import MappingProxyType as DictProxyType
else:
import __builtin__
from pickle import Pickler as StockPickler, Unpickler as StockUnpickler
@@ -214,6 +218,12 @@
else:
from StringIO import StringIO
InputType = OutputType = None
+if not IS_PYPY:
+ from socket import socket as SocketType
+ try: #FIXME: additionally calls ForkingPickler.register several times
+ from multiprocessing.reduction import _reduce_socket as reduce_socket
+ except ImportError:
+ from multiprocessing.reduction import reduce_socket
try:
__IPYTHON__ is True # is ipython
ExitType = None # IPython.core.autocall.ExitAutocall
@@ -237,84 +247,32 @@
### Shorthands (modified from python2.5/lib/pickle.py)
def copy(obj, *args, **kwds):
"""use pickling to 'copy' an object"""
- return loads(dumps(obj, *args, **kwds))
+ ignore = kwds.pop('ignore', Unpickler.settings['ignore'])
+ return loads(dumps(obj, *args, **kwds), ignore=ignore)
-def dump(obj, file, protocol=None, byref=None, fmode=None, recurse=None):#,
strictio=None):
+def dump(obj, file, protocol=None, byref=None, fmode=None, recurse=None,
**kwds):#, strictio=None):
"""pickle an object to a file"""
from .settings import settings
- strictio = False #FIXME: strict=True needs cleanup
- if protocol is None: protocol = settings['protocol']
- if byref is None: byref = settings['byref']
- if fmode is None: fmode = settings['fmode']
- if recurse is None: recurse = settings['recurse']
- stack.clear() # clear record of 'recursion-sensitive' pickled objects
- pik = Pickler(file, protocol)
- pik._main = _main_module
- # apply kwd settings
- pik._byref = bool(byref)
- pik._strictio = bool(strictio)
- pik._fmode = fmode
- pik._recurse = bool(recurse)
- # register if the object is a numpy ufunc
- # thanks to Paul Kienzle for pointing out ufuncs didn't pickle
- if NumpyUfuncType and numpyufunc(obj):
- @register(type(obj))
- def save_numpy_ufunc(pickler, obj):
- log.info("Nu: %s" % obj)
- StockPickler.save_global(pickler, obj)
- log.info("# Nu")
- return
- # NOTE: the above 'save' performs like:
- # import copy_reg
- # def udump(f): return f.__name__
- # def uload(name): return getattr(numpy, name)
- # copy_reg.pickle(NumpyUfuncType, udump, uload)
- # register if the object is a subclassed numpy array instance
- if NumpyArrayType and ndarraysubclassinstance(obj):
- @register(type(obj))
- def save_numpy_array(pickler, obj):
- log.info("Nu: (%s, %s)" % (obj.shape,obj.dtype))
- npdict = getattr(obj, '__dict__', None)
- f, args, state = obj.__reduce__()
- pickler.save_reduce(_create_array, (f,args,state,npdict), obj=obj)
- log.info("# Nu")
- return
- # end hack
- if GENERATOR_FAIL and type(obj) == GeneratorType:
- msg = "Can't pickle %s: attribute lookup builtins.generator failed" %
GeneratorType
- raise PicklingError(msg)
- else:
- pik.dump(obj)
- stack.clear() # clear record of 'recursion-sensitive' pickled objects
+ protocol = settings['protocol'] if protocol is None else int(protocol)
+ _kwds = kwds.copy()
+ _kwds.update(dict(byref=byref, fmode=fmode, recurse=recurse))
+ Pickler(file, protocol, **_kwds).dump(obj)
return
-def dumps(obj, protocol=None, byref=None, fmode=None, recurse=None):#,
strictio=None):
+def dumps(obj, protocol=None, byref=None, fmode=None, recurse=None, **kwds):#,
strictio=None):
"""pickle an object to a string"""
file = StringIO()
- dump(obj, file, protocol, byref, fmode, recurse)#, strictio)
+ dump(obj, file, protocol, byref, fmode, recurse, **kwds)#, strictio)
return file.getvalue()
-def load(file, ignore=None):
+def load(file, ignore=None, **kwds):
"""unpickle an object from a file"""
- from .settings import settings
- if ignore is None: ignore = settings['ignore']
- pik = Unpickler(file)
- pik._main = _main_module
- # apply kwd settings
- pik._ignore = bool(ignore)
- obj = pik.load()
- if type(obj).__module__ == getattr(_main_module, '__name__', '__main__'):
- if not ignore:
- # point obj class to main
- try: obj.__class__ = getattr(pik._main, type(obj).__name__)
- except (AttributeError,TypeError): pass # defined in a file
- #_main_module.__dict__.update(obj.__dict__) #XXX: should update globals ?
- return obj
+ return Unpickler(file, ignore=ignore, **kwds).load()
-def loads(str, ignore=None):
+def loads(str, ignore=None, **kwds):
"""unpickle an object from a string"""
file = StringIO(str)
- return load(file, ignore)
+ return load(file, ignore, **kwds)
# def dumpzs(obj, protocol=None):
# """pickle an object to a compressed string"""
@@ -373,7 +331,7 @@
exec("from %s import %s" % (module, name), main_module.__dict__)
#NOTE: 06/03/15 renamed main_module to main
-def dump_session(filename='/tmp/session.pkl', main=None, byref=False):
+def dump_session(filename='/tmp/session.pkl', main=None, byref=False, **kwds):
"""pickle the current state of __main__ to a file"""
from .settings import settings
protocol = settings['protocol']
@@ -385,8 +343,8 @@
try:
if byref:
main = _stash_modules(main)
- pickler = Pickler(f, protocol)
- pickler._main = main
+ pickler = Pickler(f, protocol, **kwds)
+ pickler._main = main #FIXME: dill.settings are disabled
pickler._byref = False # disable pickling by name reference
pickler._recurse = False # disable pickling recursion for globals
pickler._session = True # is best indicator of when pickling a session
@@ -396,15 +354,15 @@
f.close()
return
-def load_session(filename='/tmp/session.pkl', main=None):
+def load_session(filename='/tmp/session.pkl', main=None, **kwds):
"""update the __main__ module with the state from the session file"""
if main is None: main = _main_module
if hasattr(filename, 'read'):
f = filename
else:
f = open(filename, 'rb')
- try:
- unpickler = Unpickler(f)
+ try: #FIXME: dill.settings are disabled
+ unpickler = Unpickler(f, **kwds)
unpickler._main = main
unpickler._session = True
module = unpickler.load()
@@ -436,33 +394,63 @@
class Pickler(StockPickler):
"""python's Pickler extended to interpreter sessions"""
dispatch = MetaCatchingDict(StockPickler.dispatch.copy())
- _main = None
_session = False
from .settings import settings
- _byref = settings['byref']
- _strictio = False
- _fmode = settings['fmode']
- _recurse = settings['recurse']
def __init__(self, *args, **kwds):
- _byref = kwds.pop('byref', Pickler._byref)
- #_strictio = kwds.pop('strictio', Pickler._strictio)
- _fmode = kwds.pop('fmode', Pickler._fmode)
- _recurse = kwds.pop('recurse', Pickler._recurse)
+ settings = Pickler.settings
+ _byref = kwds.pop('byref', None)
+ #_strictio = kwds.pop('strictio', None)
+ _fmode = kwds.pop('fmode', None)
+ _recurse = kwds.pop('recurse', None)
StockPickler.__init__(self, *args, **kwds)
self._main = _main_module
self._diff_cache = {}
- self._byref = _byref
- #self._strictio = _strictio
- self._fmode = _fmode
- self._recurse = _recurse
+ self._byref = settings['byref'] if _byref is None else _byref
+ self._strictio = False #_strictio
+ self._fmode = settings['fmode'] if _fmode is None else _fmode
+ self._recurse = settings['recurse'] if _recurse is None else _recurse
+
+ def dump(self, obj): #NOTE: if settings change, need to update attributes
+ stack.clear() # clear record of 'recursion-sensitive' pickled objects
+ # register if the object is a numpy ufunc
+ # thanks to Paul Kienzle for pointing out ufuncs didn't pickle
+ if NumpyUfuncType and numpyufunc(obj):
+ @register(type(obj))
+ def save_numpy_ufunc(pickler, obj):
+ log.info("Nu: %s" % obj)
+ StockPickler.save_global(pickler, obj)
+ log.info("# Nu")
+ return
+ # NOTE: the above 'save' performs like:
+ # import copy_reg
+ # def udump(f): return f.__name__
+ # def uload(name): return getattr(numpy, name)
+ # copy_reg.pickle(NumpyUfuncType, udump, uload)
+ # register if the object is a subclassed numpy array instance
+ if NumpyArrayType and ndarraysubclassinstance(obj):
+ @register(type(obj))
+ def save_numpy_array(pickler, obj):
+ log.info("Nu: (%s, %s)" % (obj.shape,obj.dtype))
+ npdict = getattr(obj, '__dict__', None)
+ f, args, state = obj.__reduce__()
+ pickler.save_reduce(_create_array, (f,args,state,npdict),
obj=obj)
+ log.info("# Nu")
+ return
+ # end hack
+ if GENERATOR_FAIL and type(obj) == GeneratorType:
+ msg = "Can't pickle %s: attribute lookup builtins.generator
failed" % GeneratorType
+ raise PicklingError(msg)
+ else:
+ StockPickler.dump(self, obj)
+ stack.clear() # clear record of 'recursion-sensitive' pickled objects
+ return
+ dump.__doc__ = StockPickler.dump.__doc__
pass
class Unpickler(StockUnpickler):
"""python's Unpickler extended to interpreter sessions and more types"""
from .settings import settings
- _ignore = settings['ignore']
- _main = None
_session = False
def find_class(self, module, name):
@@ -474,10 +462,22 @@
return StockUnpickler.find_class(self, module, name)
def __init__(self, *args, **kwds):
- _ignore = kwds.pop('ignore', Unpickler._ignore)
+ settings = Pickler.settings
+ _ignore = kwds.pop('ignore', None)
StockUnpickler.__init__(self, *args, **kwds)
self._main = _main_module
- self._ignore = _ignore
+ self._ignore = settings['ignore'] if _ignore is None else _ignore
+
+ def load(self): #NOTE: if settings change, need to update attributes
+ obj = StockUnpickler.load(self)
+ if type(obj).__module__ == getattr(_main_module, '__name__',
'__main__'):
+ if not self._ignore:
+ # point obj class to main
+ try: obj.__class__ = getattr(self._main, type(obj).__name__)
+ except (AttributeError,TypeError): pass # defined in a file
+ #_main_module.__dict__.update(obj.__dict__) #XXX: should update globals
?
+ return obj
+ load.__doc__ = StockUnpickler.load.__doc__
pass
'''
@@ -579,13 +579,15 @@
def _create_type(typeobj, *args):
return typeobj(*args)
-def _create_function(fcode, fglobals, fname=None, fdefaults=None, \
- fclosure=None, fdict=None):
+def _create_function(fcode, fglobals, fname=None, fdefaults=None,
+ fclosure=None, fdict=None, fkwdefaults=None):
# same as FunctionType, but enable passing __dict__ to new function,
# __dict__ is the storehouse for attributes added after function creation
if fdict is None: fdict = dict()
func = FunctionType(fcode, fglobals or dict(), fname, fdefaults, fclosure)
func.__dict__.update(fdict) #XXX: better copy? option to copy?
+ if fkwdefaults is not None:
+ func.__kwdefaults__ = fkwdefaults
return func
def _create_ftype(ftypeobj, func, args, kwds):
@@ -943,6 +945,14 @@
log.info("# RL")
return
+if not IS_PYPY:
+ #@register(SocketType) #FIXME: causes multiprocess test_pickling FAIL
+ def save_socket(pickler, obj):
+ log.info("So: %s" % obj)
+ pickler.save_reduce(*reduce_socket(obj))
+ log.info("# So")
+ return
+
@register(ItemGetterType)
def save_itemgetter(pickler, obj):
log.info("Ig: %s" % obj)
@@ -1138,22 +1148,30 @@
log.info("# Ce")
return
-# The following function is based on 'saveDictProxy' from spickle
-# Copyright (c) 2011 by science+computing ag
-# License: http://www.apache.org/licenses/LICENSE-2.0
if not IS_PYPY:
- @register(DictProxyType)
- def save_dictproxy(pickler, obj):
- log.info("Dp: %s" % obj)
- attr = obj.get('__dict__')
- #pickler.save_reduce(_create_dictproxy, (attr,'nested'), obj=obj)
- if type(attr) == GetSetDescriptorType and attr.__name__ == "__dict__" \
- and getattr(attr.__objclass__, "__dict__", None) == obj:
- pickler.save_reduce(getattr,
(attr.__objclass__,"__dict__"),obj=obj)
- log.info("# Dp")
+ if not OLD33:
+ @register(DictProxyType)
+ def save_dictproxy(pickler, obj):
+ log.info("Mp: %s" % obj)
+ pickler.save_reduce(DictProxyType, (obj.copy(),), obj=obj)
+ log.info("# Mp")
return
- # all bad below... so throw ReferenceError or TypeError
- raise ReferenceError("%s does not reference a class __dict__" % obj)
+ else:
+ # The following function is based on 'saveDictProxy' from spickle
+ # Copyright (c) 2011 by science+computing ag
+ # License: http://www.apache.org/licenses/LICENSE-2.0
+ @register(DictProxyType)
+ def save_dictproxy(pickler, obj):
+ log.info("Dp: %s" % obj)
+ attr = obj.get('__dict__')
+ #pickler.save_reduce(_create_dictproxy, (attr,'nested'), obj=obj)
+ if type(attr) == GetSetDescriptorType and attr.__name__ ==
"__dict__" \
+ and getattr(attr.__objclass__, "__dict__", None) == obj:
+ pickler.save_reduce(getattr,
(attr.__objclass__,"__dict__"),obj=obj)
+ log.info("# Dp")
+ return
+ # all bad below... so throw ReferenceError or TypeError
+ raise ReferenceError("%s does not reference a class __dict__" %
obj)
@register(SliceType)
def save_slice(pickler, obj):
@@ -1388,10 +1406,11 @@
_super = ('super' in getattr(obj.__code__,'co_names',())) and
(_byref is not None)
if _super: pickler._byref = True
if _memo: pickler._recurse = False
+ fkwdefaults = getattr(obj, '__kwdefaults__', None)
pickler.save_reduce(_create_function, (obj.__code__,
globs, obj.__name__,
obj.__defaults__, obj.__closure__,
- obj.__dict__), obj=obj)
+ obj.__dict__, fkwdefaults), obj=obj)
else:
_super = ('super' in getattr(obj.func_code,'co_names',())) and
(_byref is not None) and getattr(pickler, '_recurse', False)
if _super: pickler._byref = True
@@ -1444,7 +1463,7 @@
# == undocumented ==
# python -- the string path or executable name of the selected python
# verbose -- if True, be verbose about printing warning messages
- # all other args and kwds are passed to dill.dumps
+ # all other args and kwds are passed to dill.dumps #FIXME: ignore on load
verbose = kwds.pop('verbose', False)
python = kwds.pop('python', None)
if python is None:
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/dill-0.3.0/dill/info.py new/dill-0.3.1.1/dill/info.py
--- old/dill-0.3.0/dill/info.py 2019-06-27 01:01:34.000000000 +0200
+++ new/dill-0.3.1.1/dill/info.py 2019-09-28 17:40:23.000000000 +0200
@@ -1,6 +1,6 @@
# THIS FILE GENERATED FROM SETUP.PY
-this_version = '0.3.0'
-stable_version = '0.3.0'
+this_version = '0.3.1.1'
+stable_version = '0.3.1.1'
readme = '''-----------------------------
dill: serialize all of python
-----------------------------
@@ -70,7 +70,7 @@
Current Release
===============
-This documentation is for version ``dill-0.3.0``.
+This documentation is for version ``dill-0.3.1.1``.
The latest released version of ``dill`` is available from:
@@ -99,8 +99,8 @@
download the tarball, unzip, and run the installer::
[download]
- $ tar -xvzf dill-0.3.0.tar.gz
- $ cd dill-0.3.0
+ $ tar -xvzf dill-0.3.1.1.tar.gz
+ $ cd dill-0.3.1.1
$ python setup py build
$ python setup py install
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/dill-0.3.0/dill/source.py
new/dill-0.3.1.1/dill/source.py
--- old/dill-0.3.0/dill/source.py 2019-06-27 00:53:35.000000000 +0200
+++ new/dill-0.3.1.1/dill/source.py 2019-09-28 17:38:53.000000000 +0200
@@ -126,7 +126,7 @@
if sys.platform[:3] == 'win':
err += ", please install 'pyreadline'"
if err:
- raise IOError(msg)
+ raise IOError(err)
lbuf = readline.get_current_history_length()
lines = [readline.get_history_item(i)+'\n' for i in range(1,lbuf)]
else:
@@ -851,7 +851,7 @@
else: # we have to "hack" a bit... and maybe be lucky
encl = outermost(func)
# pattern: 'func = enclosing(fobj'
- pat = r'.*[\w\s]=\s*'+getname(encl)+'\\('+getname(fobj)
+ pat = r'.*[\w\s]=\s*'+getname(encl)+r'\('+getname(fobj)
mod = getname(getmodule(encl))
#HACK: get file containing 'outer' function; is func there?
lines,_ = findsource(encl)
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/dill-0.3.0/dill.egg-info/PKG-INFO
new/dill-0.3.1.1/dill.egg-info/PKG-INFO
--- old/dill-0.3.0/dill.egg-info/PKG-INFO 2019-06-27 01:01:35.000000000
+0200
+++ new/dill-0.3.1.1/dill.egg-info/PKG-INFO 2019-09-28 17:40:23.000000000
+0200
@@ -1,12 +1,12 @@
Metadata-Version: 1.2
Name: dill
-Version: 0.3.0
+Version: 0.3.1.1
Summary: serialize all of python
Home-page: https://pypi.org/project/dill
Author: Mike McKerns
Author-email: UNKNOWN
License: 3-clause BSD
-Download-URL:
https://github.com/uqfoundation/dill/releases/download/dill-0.3.0/dill-0.3.0.tar.gz
+Download-URL:
https://github.com/uqfoundation/dill/releases/download/dill-0.3.1.1/dill-0.3.1.1.tar.gz
Description: -----------------------------
dill: serialize all of python
-----------------------------
@@ -76,7 +76,7 @@
Current Release
===============
- This documentation is for version ``dill-0.3.0``.
+ This documentation is for version ``dill-0.3.1.1``.
The latest released version of ``dill`` is available from:
@@ -105,8 +105,8 @@
download the tarball, unzip, and run the installer::
[download]
- $ tar -xvzf dill-0.3.0.tar.gz
- $ cd dill-0.3.0
+ $ tar -xvzf dill-0.3.1.1.tar.gz
+ $ cd dill-0.3.1.1
$ python setup py build
$ python setup py install
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/dill-0.3.0/dill.egg-info/SOURCES.txt
new/dill-0.3.1.1/dill.egg-info/SOURCES.txt
--- old/dill-0.3.0/dill.egg-info/SOURCES.txt 2019-06-27 01:01:35.000000000
+0200
+++ new/dill-0.3.1.1/dill.egg-info/SOURCES.txt 2019-09-28 17:40:23.000000000
+0200
@@ -31,6 +31,7 @@
tests/test_diff.py
tests/test_extendpickle.py
tests/test_file.py
+tests/test_functions.py
tests/test_functors.py
tests/test_mixins.py
tests/test_module.py
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/dill-0.3.0/setup.py new/dill-0.3.1.1/setup.py
--- old/dill-0.3.0/setup.py 2019-06-27 00:53:35.000000000 +0200
+++ new/dill-0.3.1.1/setup.py 2019-09-28 17:39:15.000000000 +0200
@@ -9,8 +9,8 @@
import os
# set version numbers
-stable_version = '0.3.0'
-target_version = '0.3.0'
+stable_version = '0.3.1.1'
+target_version = '0.3.1.1'
is_release = stable_version == target_version
# check if easy_install is available
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/dill-0.3.0/tests/test_functions.py
new/dill-0.3.1.1/tests/test_functions.py
--- old/dill-0.3.0/tests/test_functions.py 1970-01-01 01:00:00.000000000
+0100
+++ new/dill-0.3.1.1/tests/test_functions.py 2019-09-28 17:38:53.000000000
+0200
@@ -0,0 +1,63 @@
+#!/usr/bin/env python
+
+
+import dill
+import sys
+dill.settings['recurse'] = True
+
+
+def is_py3():
+ return hex(sys.hexversion) >= '0x30000f0'
+
+
+def function_a(a):
+ return a
+
+
+def function_b(b, b1):
+ return b + b1
+
+
+def function_c(c, c1=1):
+ return c + c1
+
+
+def function_d(d, d1, d2=1):
+ return d + d1 + d2
+
+
+if is_py3():
+ exec('''
+def function_e(e, *e1, e2=1, e3=2):
+ return e + sum(e1) + e2 + e3''')
+
+
+def test_functions():
+ dumped_func_a = dill.dumps(function_a)
+ assert dill.loads(dumped_func_a)(0) == 0
+
+ dumped_func_b = dill.dumps(function_b)
+ assert dill.loads(dumped_func_b)(1,2) == 3
+
+ dumped_func_c = dill.dumps(function_c)
+ assert dill.loads(dumped_func_c)(1) == 2
+ assert dill.loads(dumped_func_c)(1, 2) == 3
+
+ dumped_func_d = dill.dumps(function_d)
+ assert dill.loads(dumped_func_d)(1, 2) == 4
+ assert dill.loads(dumped_func_d)(1, 2, 3) == 6
+ assert dill.loads(dumped_func_d)(1, 2, d2=3) == 6
+
+ if is_py3():
+ exec('''
+dumped_func_e = dill.dumps(function_e)
+assert dill.loads(dumped_func_e)(1, 2) == 6
+assert dill.loads(dumped_func_e)(1, 2, 3) == 9
+assert dill.loads(dumped_func_e)(1, 2, e2=3) == 8
+assert dill.loads(dumped_func_e)(1, 2, e2=3, e3=4) == 10
+assert dill.loads(dumped_func_e)(1, 2, 3, e2=4) == 12
+assert dill.loads(dumped_func_e)(1, 2, 3, e2=4, e3=5) == 15''')
+
+
+if __name__ == '__main__':
+ test_functions()
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/dill-0.3.0/tests/test_weakref.py
new/dill-0.3.1.1/tests/test_weakref.py
--- old/dill-0.3.0/tests/test_weakref.py 2019-06-27 00:53:35.000000000
+0200
+++ new/dill-0.3.1.1/tests/test_weakref.py 2019-09-28 17:38:53.000000000
+0200
@@ -72,6 +72,18 @@
# print ("PASS: %s" % obj)
assert not res
+def test_dictproxy():
+ from dill._dill import DictProxyType
+ try:
+ m = DictProxyType({"foo": "bar"})
+ except:
+ m = type.__dict__
+ mp = dill.copy(m)
+ assert mp.items() == m.items()
+
if __name__ == '__main__':
test_weakref()
+ from dill._dill import IS_PYPY
+ if not IS_PYPY:
+ test_dictproxy()
