Script 'mail_helper' called by obssrc Hello community, here is the log from the commit of package python-immutables for openSUSE:Factory checked in at 2021-04-26 16:38:48 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Comparing /work/SRC/openSUSE:Factory/python-immutables (Old) and /work/SRC/openSUSE:Factory/.python-immutables.new.12324 (New) ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Package is "python-immutables" Mon Apr 26 16:38:48 2021 rev:6 rq:887885 version:0.15 Changes: -------- --- /work/SRC/openSUSE:Factory/python-immutables/python-immutables.changes 2020-12-12 20:31:25.049792765 +0100 +++ /work/SRC/openSUSE:Factory/.python-immutables.new.12324/python-immutables.changes 2021-04-26 16:39:01.082017731 +0200 @@ -1,0 +2,6 @@ +Thu Apr 22 20:28:33 UTC 2021 - Dirk M??ller <[email protected]> + +- update to 0.15 + * python 3.9 support + +------------------------------------------------------------------- Old: ---- immutables-0.14.tar.gz New: ---- immutables-0.15.tar.gz ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Other differences: ------------------ ++++++ python-immutables.spec ++++++ --- /var/tmp/diff_new_pack.P9HIXt/_old 2021-04-26 16:39:01.618018584 +0200 +++ /var/tmp/diff_new_pack.P9HIXt/_new 2021-04-26 16:39:01.622018590 +0200 @@ -1,7 +1,7 @@ # # spec file for package python-immutables # -# Copyright (c) 2020 SUSE LLC +# Copyright (c) 2021 SUSE LLC # # All modifications and additions to the file contributed by third parties # remain the property of their copyright owners, unless otherwise agreed @@ -19,7 +19,7 @@ %{?!python_module:%define python_module() python-%{**} python3-%{**}} %define skip_python2 1 Name: python-immutables -Version: 0.14 +Version: 0.15 Release: 0 Summary: Immutable collections for Python License: Apache-2.0 ++++++ immutables-0.14.tar.gz -> immutables-0.15.tar.gz ++++++ diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/immutables-0.14/PKG-INFO new/immutables-0.15/PKG-INFO --- old/immutables-0.14/PKG-INFO 2020-05-18 06:37:31.000000000 +0200 +++ new/immutables-0.15/PKG-INFO 2021-02-10 05:54:14.000000000 +0100 @@ -1,6 +1,6 @@ -Metadata-Version: 1.2 +Metadata-Version: 2.1 Name: immutables -Version: 0.14 +Version: 0.15 Summary: Immutable Collections Home-page: https://github.com/MagicStack/immutables Author: MagicStack Inc @@ -20,7 +20,8 @@ The underlying datastructure is a Hash Array Mapped Trie (HAMT) used in Clojure, Scala, Haskell, and other functional languages. This implementation is used in CPython 3.7 in the ``contextvars`` - module (see PEP 550 and PEP 567 for more details). + module (see `PEP 550 <https://www.python.org/dev/peps/pep-0550/>`_ and + `PEP 567 <https://www.python.org/dev/peps/pep-0567/>`_ for more details). Immutable mappings based on HAMT have O(log N) performance for both ``set()`` and ``get()`` operations, which is essentially O(1) for @@ -137,8 +138,10 @@ Classifier: Programming Language :: Python :: 3.6 Classifier: Programming Language :: Python :: 3.7 Classifier: Programming Language :: Python :: 3.8 +Classifier: Programming Language :: Python :: 3.9 Classifier: Operating System :: POSIX Classifier: Operating System :: MacOS :: MacOS X Classifier: Operating System :: Microsoft :: Windows Provides: immutables Requires-Python: >=3.5 +Provides-Extra: test diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/immutables-0.14/README.rst new/immutables-0.15/README.rst --- old/immutables-0.14/README.rst 2020-05-18 06:37:20.000000000 +0200 +++ new/immutables-0.15/README.rst 2021-02-10 05:54:11.000000000 +0100 @@ -12,7 +12,8 @@ The underlying datastructure is a Hash Array Mapped Trie (HAMT) used in Clojure, Scala, Haskell, and other functional languages. This implementation is used in CPython 3.7 in the ``contextvars`` -module (see PEP 550 and PEP 567 for more details). +module (see `PEP 550 <https://www.python.org/dev/peps/pep-0550/>`_ and +`PEP 567 <https://www.python.org/dev/peps/pep-0567/>`_ for more details). Immutable mappings based on HAMT have O(log N) performance for both ``set()`` and ``get()`` operations, which is essentially O(1) for diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/immutables-0.14/immutables/_map.c new/immutables-0.15/immutables/_map.c --- old/immutables-0.14/immutables/_map.c 2020-05-18 06:37:20.000000000 +0200 +++ new/immutables-0.15/immutables/_map.c 2021-02-10 05:54:11.000000000 +0100 @@ -1,4 +1,5 @@ #include <stddef.h> /* For offsetof */ +#include "pythoncapi_compat.h" #include "_map.h" @@ -571,7 +572,7 @@ return NULL; } - Py_SIZE(node) = size; + Py_SET_SIZE(node, size); for (i = 0; i < size; i++) { node->b_array[i] = NULL; @@ -1356,7 +1357,7 @@ node->c_array[i] = NULL; } - Py_SIZE(node) = size; + Py_SET_SIZE(node, size); node->c_hash = hash; node->c_mutid = mutid; @@ -3193,14 +3194,14 @@ if (MapMutation_Check(m)) { if (_PyUnicodeWriter_WriteASCIIString( - &writer, "<immutables.MapMutation({", 25) < 0) + &writer, "immutables.MapMutation({", 24) < 0) { goto error; } } else { if (_PyUnicodeWriter_WriteASCIIString( - &writer, "<immutables.Map({", 17) < 0) + &writer, "immutables.Map({", 16) < 0) { goto error; } @@ -3254,16 +3255,6 @@ goto error; } - PyObject *addr = PyUnicode_FromFormat(" at %p>", m); - if (addr == NULL) { - goto error; - } - if (_PyUnicodeWriter_WriteStr(&writer, addr) < 0) { - Py_DECREF(addr); - goto error; - } - Py_DECREF(addr); - Py_ReprLeave((PyObject *)m); return _PyUnicodeWriter_Finish(&writer); diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/immutables-0.14/immutables/_version.py new/immutables-0.15/immutables/_version.py --- old/immutables-0.14/immutables/_version.py 2020-05-18 06:37:20.000000000 +0200 +++ new/immutables-0.15/immutables/_version.py 2021-02-10 05:54:11.000000000 +0100 @@ -10,4 +10,4 @@ # supported platforms, publish the packages on PyPI, merge the PR # to the target branch, create a Git tag pointing to the commit. -__version__ = '0.14' +__version__ = '0.15' diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/immutables-0.14/immutables/map.py new/immutables-0.15/immutables/map.py --- old/immutables-0.14/immutables/map.py 2020-05-18 06:37:20.000000000 +0200 +++ new/immutables-0.15/immutables/map.py 2021-02-10 05:54:11.000000000 +0100 @@ -46,10 +46,12 @@ W_EMPTY, W_NEWNODE, W_NOT_FOUND = range(3) void = object() + class _Unhashable: __slots__ = () __hash__ = None + _NULL = _Unhashable() del _Unhashable @@ -649,8 +651,7 @@ items = [] for key, val in self.items(): items.append("{!r}: {!r}".format(key, val)) - return '<immutables.Map({{{}}}) at 0x{:0x}>'.format( - ', '.join(items), id(self)) + return 'immutables.Map({{{}}})'.format(', '.join(items)) def __dump__(self): # pragma: no cover buf = [] @@ -818,8 +819,7 @@ items = [] for key, val in self.__root.items(): items.append("{!r}: {!r}".format(key, val)) - return '<immutables.MapMutation({{{}}}) at 0x{:0x}>'.format( - ', '.join(items), id(self)) + return 'immutables.MapMutation({{{}}})'.format(', '.join(items)) def __len__(self): return self.__count diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/immutables-0.14/immutables/pythoncapi_compat.h new/immutables-0.15/immutables/pythoncapi_compat.h --- old/immutables-0.14/immutables/pythoncapi_compat.h 1970-01-01 01:00:00.000000000 +0100 +++ new/immutables-0.15/immutables/pythoncapi_compat.h 2021-02-10 05:54:11.000000000 +0100 @@ -0,0 +1,278 @@ +// Header file providing new functions of the Python C API to old Python +// versions. +// +// File distributed under the MIT license. +// +// Homepage: +// https://github.com/pythoncapi/pythoncapi_compat +// +// Latest version: +// https://raw.githubusercontent.com/pythoncapi/pythoncapi_compat/master/pythoncapi_compat.h + +#ifndef PYTHONCAPI_COMPAT +#define PYTHONCAPI_COMPAT + +#ifdef __cplusplus +extern "C" { +#endif + +#include <Python.h> +#include "frameobject.h" // PyFrameObject, PyFrame_GetBack() + + +// Cast argument to PyObject* type. +#ifndef _PyObject_CAST +# define _PyObject_CAST(op) ((PyObject*)(op)) +#endif + + +// bpo-42262 added Py_NewRef() to Python 3.10.0a3 +#if PY_VERSION_HEX < 0x030a00A3 && !defined(Py_NewRef) +static inline PyObject* _Py_NewRef(PyObject *obj) +{ + Py_INCREF(obj); + return obj; +} +#define Py_NewRef(obj) _Py_NewRef(_PyObject_CAST(obj)) +#endif + + +// bpo-42262 added Py_XNewRef() to Python 3.10.0a3 +#if PY_VERSION_HEX < 0x030a00A3 && !defined(Py_XNewRef) +static inline PyObject* _Py_XNewRef(PyObject *obj) +{ + Py_XINCREF(obj); + return obj; +} +#define Py_XNewRef(obj) _Py_XNewRef(_PyObject_CAST(obj)) +#endif + + +// bpo-39573 added Py_SET_REFCNT() to Python 3.9.0a4 +#if PY_VERSION_HEX < 0x030900A4 && !defined(Py_SET_REFCNT) +static inline void _Py_SET_REFCNT(PyObject *ob, Py_ssize_t refcnt) +{ + ob->ob_refcnt = refcnt; +} +#define Py_SET_REFCNT(ob, refcnt) _Py_SET_REFCNT((PyObject*)(ob), refcnt) +#endif + + +// bpo-39573 added Py_SET_TYPE() to Python 3.9.0a4 +#if PY_VERSION_HEX < 0x030900A4 && !defined(Py_SET_TYPE) +static inline void +_Py_SET_TYPE(PyObject *ob, PyTypeObject *type) +{ + ob->ob_type = type; +} +#define Py_SET_TYPE(ob, type) _Py_SET_TYPE((PyObject*)(ob), type) +#endif + + +// bpo-39573 added Py_SET_SIZE() to Python 3.9.0a4 +#if PY_VERSION_HEX < 0x030900A4 && !defined(Py_SET_SIZE) +static inline void +_Py_SET_SIZE(PyVarObject *ob, Py_ssize_t size) +{ + ob->ob_size = size; +} +#define Py_SET_SIZE(ob, size) _Py_SET_SIZE((PyVarObject*)(ob), size) +#endif + + +// bpo-40421 added PyFrame_GetCode() to Python 3.9.0b1 +#if PY_VERSION_HEX < 0x030900B1 +static inline PyCodeObject* +PyFrame_GetCode(PyFrameObject *frame) +{ + PyCodeObject *code; + assert(frame != NULL); + code = frame->f_code; + assert(code != NULL); + Py_INCREF(code); + return code; +} +#endif + +static inline PyCodeObject* +_PyFrame_GetCodeBorrow(PyFrameObject *frame) +{ + PyCodeObject *code = PyFrame_GetCode(frame); + Py_DECREF(code); + return code; // borrowed reference +} + + +// bpo-40421 added PyFrame_GetCode() to Python 3.9.0b1 +#if PY_VERSION_HEX < 0x030900B1 +static inline PyFrameObject* +PyFrame_GetBack(PyFrameObject *frame) +{ + PyFrameObject *back; + assert(frame != NULL); + back = frame->f_back; + Py_XINCREF(back); + return back; +} +#endif + +static inline PyFrameObject* +_PyFrame_GetBackBorrow(PyFrameObject *frame) +{ + PyFrameObject *back = PyFrame_GetBack(frame); + Py_XDECREF(back); + return back; // borrowed reference +} + + +// bpo-39947 added PyThreadState_GetInterpreter() to Python 3.9.0a5 +#if PY_VERSION_HEX < 0x030900A5 +static inline PyInterpreterState * +PyThreadState_GetInterpreter(PyThreadState *tstate) +{ + assert(tstate != NULL); + return tstate->interp; +} +#endif + + +// bpo-40429 added PyThreadState_GetFrame() to Python 3.9.0b1 +#if PY_VERSION_HEX < 0x030900B1 +static inline PyFrameObject* +PyThreadState_GetFrame(PyThreadState *tstate) +{ + PyFrameObject *frame; + assert(tstate != NULL); + frame = tstate->frame; + Py_XINCREF(frame); + return frame; +} +#endif + +static inline PyFrameObject* +_PyThreadState_GetFrameBorrow(PyThreadState *tstate) +{ + PyFrameObject *frame = PyThreadState_GetFrame(tstate); + Py_XDECREF(frame); + return frame; // borrowed reference +} + + +// bpo-39947 added PyInterpreterState_Get() to Python 3.9.0a5 +#if PY_VERSION_HEX < 0x030900A5 +static inline PyInterpreterState * +PyInterpreterState_Get(void) +{ + PyThreadState *tstate; + PyInterpreterState *interp; + + tstate = PyThreadState_GET(); + if (tstate == NULL) { + Py_FatalError("GIL released (tstate is NULL)"); + } + interp = tstate->interp; + if (interp == NULL) { + Py_FatalError("no current interpreter"); + } + return interp; +} +#endif + + +// bpo-39947 added PyInterpreterState_Get() to Python 3.9.0a6 +#if 0x030700A1 <= PY_VERSION_HEX && PY_VERSION_HEX < 0x030900A6 +static inline uint64_t +PyThreadState_GetID(PyThreadState *tstate) +{ + assert(tstate != NULL); + return tstate->id; +} +#endif + + +// bpo-37194 added PyObject_CallNoArgs() to Python 3.9.0a1 +#if PY_VERSION_HEX < 0x030900A1 +static inline PyObject* +PyObject_CallNoArgs(PyObject *func) +{ + return PyObject_CallFunctionObjArgs(func, NULL); +} +#endif + + +// bpo-39245 made PyObject_CallOneArg() public (previously called +// _PyObject_CallOneArg) in Python 3.9.0a4 +#if PY_VERSION_HEX < 0x030900A4 +static inline PyObject* +PyObject_CallOneArg(PyObject *func, PyObject *arg) +{ + return PyObject_CallFunctionObjArgs(func, arg, NULL); +} +#endif + + +// bpo-40024 added PyModule_AddType() to Python 3.9.0a5 +#if PY_VERSION_HEX < 0x030900A5 +static inline int +PyModule_AddType(PyObject *module, PyTypeObject *type) +{ + const char *name, *dot; + + if (PyType_Ready(type) < 0) { + return -1; + } + + // inline _PyType_Name() + name = type->tp_name; + assert(name != NULL); + dot = strrchr(name, '.'); + if (dot != NULL) { + name = dot + 1; + } + + Py_INCREF(type); + if (PyModule_AddObject(module, name, (PyObject *)type) < 0) { + Py_DECREF(type); + return -1; + } + + return 0; +} +#endif + + +// bpo-40241 added PyObject_GC_IsTracked() to Python 3.9.0a6. +// bpo-4688 added _PyObject_GC_IS_TRACKED() to Python 2.7.0a2. +#if PY_VERSION_HEX < 0x030900A6 +static inline int +PyObject_GC_IsTracked(PyObject* obj) +{ + return (PyObject_IS_GC(obj) && _PyObject_GC_IS_TRACKED(obj)); +} +#endif + +// bpo-40241 added PyObject_GC_IsFinalized() to Python 3.9.0a6. +// bpo-18112 added _PyGCHead_FINALIZED() to Python 3.4.0 final. +#if PY_VERSION_HEX < 0x030900A6 && PY_VERSION_HEX >= 0x030400F0 +static inline int +PyObject_GC_IsFinalized(PyObject *obj) +{ + return (PyObject_IS_GC(obj) && _PyGCHead_FINALIZED((PyGC_Head *)(obj)-1)); +} +#endif + + +// bpo-39573 added Py_IS_TYPE() to Python 3.9.0a4 +#if PY_VERSION_HEX < 0x030900A4 && !defined(Py_IS_TYPE) +static inline int +_Py_IS_TYPE(const PyObject *ob, const PyTypeObject *type) { + return ob->ob_type == type; +} +#define Py_IS_TYPE(ob, type) _Py_IS_TYPE((const PyObject*)(ob), type) +#endif + + +#ifdef __cplusplus +} +#endif +#endif // PYTHONCAPI_COMPAT diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/immutables-0.14/immutables.egg-info/PKG-INFO new/immutables-0.15/immutables.egg-info/PKG-INFO --- old/immutables-0.14/immutables.egg-info/PKG-INFO 2020-05-18 06:37:30.000000000 +0200 +++ new/immutables-0.15/immutables.egg-info/PKG-INFO 2021-02-10 05:54:14.000000000 +0100 @@ -1,6 +1,6 @@ -Metadata-Version: 1.2 +Metadata-Version: 2.1 Name: immutables -Version: 0.14 +Version: 0.15 Summary: Immutable Collections Home-page: https://github.com/MagicStack/immutables Author: MagicStack Inc @@ -20,7 +20,8 @@ The underlying datastructure is a Hash Array Mapped Trie (HAMT) used in Clojure, Scala, Haskell, and other functional languages. This implementation is used in CPython 3.7 in the ``contextvars`` - module (see PEP 550 and PEP 567 for more details). + module (see `PEP 550 <https://www.python.org/dev/peps/pep-0550/>`_ and + `PEP 567 <https://www.python.org/dev/peps/pep-0567/>`_ for more details). Immutable mappings based on HAMT have O(log N) performance for both ``set()`` and ``get()`` operations, which is essentially O(1) for @@ -137,8 +138,10 @@ Classifier: Programming Language :: Python :: 3.6 Classifier: Programming Language :: Python :: 3.7 Classifier: Programming Language :: Python :: 3.8 +Classifier: Programming Language :: Python :: 3.9 Classifier: Operating System :: POSIX Classifier: Operating System :: MacOS :: MacOS X Classifier: Operating System :: Microsoft :: Windows Provides: immutables Requires-Python: >=3.5 +Provides-Extra: test diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/immutables-0.14/immutables.egg-info/SOURCES.txt new/immutables-0.15/immutables.egg-info/SOURCES.txt --- old/immutables-0.14/immutables.egg-info/SOURCES.txt 2020-05-18 06:37:31.000000000 +0200 +++ new/immutables-0.15/immutables.egg-info/SOURCES.txt 2021-02-10 05:54:14.000000000 +0100 @@ -10,9 +10,11 @@ immutables/_version.py immutables/map.py immutables/py.typed +immutables/pythoncapi_compat.h immutables.egg-info/PKG-INFO immutables.egg-info/SOURCES.txt immutables.egg-info/dependency_links.txt +immutables.egg-info/requires.txt immutables.egg-info/top_level.txt tests/__init__.py tests/test_issue24.py diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/immutables-0.14/immutables.egg-info/requires.txt new/immutables-0.15/immutables.egg-info/requires.txt --- old/immutables-0.14/immutables.egg-info/requires.txt 1970-01-01 01:00:00.000000000 +0100 +++ new/immutables-0.15/immutables.egg-info/requires.txt 2021-02-10 05:54:14.000000000 +0100 @@ -0,0 +1,4 @@ + +[test] +flake8~=3.8.4 +pycodestyle~=2.6.0 diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/immutables-0.14/setup.py new/immutables-0.15/setup.py --- old/immutables-0.14/setup.py 2020-05-18 06:37:20.000000000 +0200 +++ new/immutables-0.15/setup.py 2021-02-10 05:54:11.000000000 +0100 @@ -3,6 +3,19 @@ import setuptools +# Minimal dependencies required to test immutables. +TEST_DEPENDENCIES = [ + # pycodestyle is a dependency of flake8, but it must be frozen because + # their combination breaks too often + # (example breakage: https://gitlab.com/pycqa/flake8/issues/427) + 'flake8~=3.8.4', + 'pycodestyle~=2.6.0', +] + +EXTRA_DEPENDENCIES = { + 'test': TEST_DEPENDENCIES, +} + CFLAGS = ['-O2'] if platform.uname().system != 'Windows': CFLAGS.extend(['-std=c99', '-fsigned-char', '-Wall', @@ -59,6 +72,7 @@ 'Programming Language :: Python :: 3.6', 'Programming Language :: Python :: 3.7', 'Programming Language :: Python :: 3.8', + 'Programming Language :: Python :: 3.9', 'Operating System :: POSIX', 'Operating System :: MacOS :: MacOS X', 'Operating System :: Microsoft :: Windows', @@ -72,5 +86,5 @@ provides=['immutables'], include_package_data=True, ext_modules=ext_modules, - test_suite='tests.suite', + extras_require=EXTRA_DEPENDENCIES, ) diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/immutables-0.14/tests/test_issue24.py new/immutables-0.15/tests/test_issue24.py --- old/immutables-0.14/tests/test_issue24.py 2020-05-18 06:37:20.000000000 +0200 +++ new/immutables-0.15/tests/test_issue24.py 2021-02-10 05:54:11.000000000 +0100 @@ -51,7 +51,7 @@ d = m.__dump__().splitlines() self.assertTrue(d) if d[0].startswith('HAMT'): - header = d[1] # skip _map.Map.__dump__() header + header = d[1] # skip _map.Map.__dump__() header else: header = d[0] self.dump_check_bitmap_node_count(header, 7) @@ -66,7 +66,7 @@ d = m2.__dump__().splitlines() self.assertTrue(d) if d[0].startswith('HAMT'): - header = d[1] # skip _map.Map.__dump__() header + header = d[1] # skip _map.Map.__dump__() header else: header = d[0] self.dump_check_bitmap_node_count(header, 4) @@ -79,7 +79,7 @@ self.assertTrue(len(d) > 3) # get node headers if d[0].startswith('HAMT'): - h1, h2 = d[1], d[3] # skip _map.Map.__dump__() header + h1, h2 = d[1], d[3] # skip _map.Map.__dump__() header else: h1, h2 = d[0], d[2] self.dump_check_node_kind(h1, 'Bitmap') @@ -96,12 +96,13 @@ self.assertTrue(len(d) > 3) # get node headers if d[0].startswith('HAMT'): - h1, h2 = d[1], d[3] # skip _map.Map.__dump__() header + h1, h2 = d[1], d[3] # skip _map.Map.__dump__() header else: h1, h2 = d[0], d[2] self.dump_check_node_kind(h1, 'Bitmap') self.dump_check_collision_node_count(h2, 4) + try: from immutables._map import Map as CMap except ImportError: diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/immutables-0.14/tests/test_map.py new/immutables-0.15/tests/test_map.py --- old/immutables-0.14/tests/test_map.py 2020-05-18 06:37:20.000000000 +0200 +++ new/immutables-0.15/tests/test_map.py 2021-02-10 05:54:11.000000000 +0100 @@ -7,7 +7,12 @@ import weakref from immutables.map import Map as PyMap -from immutables._testutils import * # NoQA +from immutables._testutils import EqError +from immutables._testutils import HashKey +from immutables._testutils import HashKeyCrasher +from immutables._testutils import HashingError +from immutables._testutils import KeyStr +from immutables._testutils import ReprError class BaseMapTest: @@ -159,8 +164,6 @@ # <Key name:E hash:362244>: 'e' # <Key name:B hash:101>: 'b' - - def test_map_stress_01(self): COLLECTION_SIZE = 7000 TEST_ITERS_EVERY = 647 @@ -845,11 +848,10 @@ def test_repr_1(self): h = self.Map() - self.assertTrue(repr(h).startswith('<immutables.Map({}) at 0x')) + self.assertEqual(repr(h), 'immutables.Map({})') h = h.set(1, 2).set(2, 3).set(3, 4) - self.assertTrue(repr(h).startswith( - '<immutables.Map({1: 2, 2: 3, 3: 4}) at 0x')) + self.assertEqual(repr(h), 'immutables.Map({1: 2, 2: 3, 3: 4})') def test_repr_2(self): h = self.Map() @@ -879,8 +881,7 @@ h = h.set(k, 1) k.val = h - self.assertTrue(repr(h).startswith( - '<immutables.Map({{...}: 1}) at 0x')) + self.assertEqual(repr(h), 'immutables.Map({{...}: 1})') def test_hash_1(self): h = self.Map() @@ -964,8 +965,7 @@ h = h.set('a', 1) hm1 = h.mutate() - self.assertTrue(repr(hm1).startswith( - "<immutables.MapMutation({'a': 1})")) + self.assertEqual(repr(hm1), "immutables.MapMutation({'a': 1})") with self.assertRaisesRegex(TypeError, 'unhashable type'): hash(hm1) @@ -1238,7 +1238,6 @@ # node to be converted into an array node h = h.set(HashKey(i, i), i) - h = h.set(HashKey(18, '18-collision'), 18) with h.mutate() as m: @@ -1351,7 +1350,9 @@ with self.assertRaisesRegex(TypeError, "can('t|not) pickle"): pickle.dumps(h.mutate()) - @unittest.skipIf(sys.version_info < (3, 7, 0), "__class_getitem__ is not available") + @unittest.skipIf( + sys.version_info < (3, 7, 0), "__class_getitem__ is not available" + ) def test_map_is_subscriptable(self): self.assertIs(self.Map[int, str], self.Map) diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/immutables-0.14/tests/test_none_keys.py new/immutables-0.15/tests/test_none_keys.py --- old/immutables-0.14/tests/test_none_keys.py 2020-05-18 06:37:20.000000000 +0200 +++ new/immutables-0.15/tests/test_none_keys.py 2021-02-10 05:54:11.000000000 +0100 @@ -1,7 +1,7 @@ import unittest from immutables.map import map_hash, map_mask, Map as PyMap -from immutables._testutils import * # NoQA +from immutables._testutils import HashKey none_hash = map_hash(None) @@ -61,7 +61,7 @@ self.assertEqual(len(m), 1) self.assertTrue(None in m) self.assertEqual(m[None], 1) - self.assertTrue(repr(m).startswith('<immutables.Map({None: 1}) at 0x')) + self.assertEqual(repr(m), 'immutables.Map({None: 1})') for level in range(7): key = NoneCollision('a', level) @@ -72,7 +72,7 @@ m = m.delete(None) self.assertEqual(len(m), 0) self.assertFalse(None in m) - self.assertTrue(repr(m).startswith('<immutables.Map({}) at 0x')) + self.assertEqual(repr(m), 'immutables.Map({})') self.assertEqual(m, self.Map()) @@ -125,7 +125,7 @@ self.assertFalse(None in m3) self.assertFalse(key in m3) self.assertEqual(m3, self.Map()) - self.assertTrue(repr(m3).startswith('<immutables.Map({}) at 0x')) + self.assertEqual(repr(m3), 'immutables.Map({})') with self.assertRaises(KeyError): m3.delete(None) with self.assertRaises(KeyError): @@ -144,7 +144,7 @@ self.assertFalse(None in m4) self.assertFalse(key in m4) self.assertEqual(m4, self.Map()) - self.assertTrue(repr(m4).startswith('<immutables.Map({}) at 0x')) + self.assertEqual(repr(m4), 'immutables.Map({})') with self.assertRaises(KeyError): m4.delete(None) with self.assertRaises(KeyError): @@ -342,7 +342,7 @@ self.assertTrue(key4 in m3) self.assertEqual(m3[key2], 2) self.assertEqual(m3[key4], 4) - self.assertFalse(None in m3) + self.assertFalse(None in m3) with self.assertRaises(KeyError): m3.delete(None) @@ -352,7 +352,7 @@ self.assertTrue(key4 in m3) self.assertEqual(m3[None], 9) self.assertEqual(m3[key4], 4) - self.assertFalse(key2 in m3) + self.assertFalse(key2 in m3) with self.assertRaises(KeyError): m3.delete(key2) @@ -362,7 +362,7 @@ self.assertTrue(key2 in m3) self.assertEqual(m3[None], 9) self.assertEqual(m3[key2], 2) - self.assertFalse(key4 in m3) + self.assertFalse(key4 in m3) with self.assertRaises(KeyError): m3.delete(key4) ++++++ skip_32bit_tests.patch ++++++ --- /var/tmp/diff_new_pack.P9HIXt/_old 2021-04-26 16:39:01.706018724 +0200 +++ /var/tmp/diff_new_pack.P9HIXt/_new 2021-04-26 16:39:01.710018730 +0200 @@ -1,12 +1,13 @@ ---- a/tests/test_none_keys.py -+++ b/tests/test_none_keys.py +Index: immutables-0.15/tests/test_none_keys.py +=================================================================== +--- immutables-0.15.orig/tests/test_none_keys.py ++++ immutables-0.15/tests/test_none_keys.py @@ -1,8 +1,10 @@ -+import sys import unittest ++import sys from immutables.map import map_hash, map_mask, Map as PyMap --from immutables._testutils import * # NoQA -+from immutables._testutils import HashKey # NoQA + from immutables._testutils import HashKey +is_32bits = sys.maxsize <= 2**32 # 32bit-dness
