Mailman 3 June 2013 - Python-Dev

doctest and pickle
by Ethan Furman June 9, 2013

June 9, 2013

Is there a doctest mailing list? I couldn't find it. I'm try to use doctest to verify my docs (imagine that!) but I'm having trouble with the one that uses pickle (imagine that!). Any advice on how to make it work? Here's the excerpt: =============================================================================== Pickling -------- Enumerations can be pickled and unpickled:: >>> from enum import Enum >>> class Fruit(Enum): ... tomato = 1 ... … [View More]

11 23

Unicode minus sign in numeric conversions
by Łukasz Langa June 9, 2013

June 9, 2013

Expected behaviour: >>> float('\N{MINUS SIGN}12.34') -12.34 Current behaviour: Traceback (most recent call last): ... ValueError: could not convert string to float: '−12.34' Please note: '\N{MINUS SIGN}' == '\u2212' -- Best regards, Łukasz Langa WWW: http://lukasz.langa.pl/ Twitter: @llanga IRC: ambv on #python-dev

4 3

Obsoleted RFCs
by Serhiy Storchaka June 8, 2013

June 8, 2013

Here is attached a list of obsoleted RFCs referred in the *.rst, *.txt, *.py, *.c and *.h files. I think it would be worthwhile to update the source code and documentation for more modern RFCs. For example for updating RFC3548 to RFC4648 there is an issue #16995.

6 8

Re: [Python-Dev] [Python-checkins] cpython: Add reference implementation for PEP 443
by Thomas Wouters June 8, 2013

June 8, 2013

On Wed, Jun 5, 2013 at 3:20 AM, lukasz.langa <python-checkins(a)python.org>wrote: > +from weakref import WeakKeyDictionary > FYI, this change exposes a bug in the atexit module involving subinterpreters, causing the refleaks reported by Antoine's daily report: interpreter startup now always imports weakref, which imports atexit and registers a classmethod. Unfortunately the atexit module doesn't seem to know subinterpreters from subtitles and so doesn't unregister this classmethod … [View More]

4 5

Summary of Python tracker Issues
by Python tracker June 7, 2013

June 7, 2013

ACTIVITY SUMMARY (2013-05-31 - 2013-06-07) Python tracker at http://bugs.python.org/ To view or respond to any of the issues listed below, click on the issue. Do NOT respond to this message. Issues counts and deltas: open 4024 (+27) closed 25905 (+21) total 29929 (+48) Open issues with patches: 1793 Issues opened (41) ================== #8902: add datetime.time.now() for consistency http://bugs.python.org/issue8902 reopened by belopolsky #17206: Py_XDECREF() expands its … [View More]

1 0

Re: [Python-Dev] [Python-checkins] cpython: Issue #17931: Resolve confusion on Windows between pids and process handles.
by Brett Cannon June 7, 2013

June 7, 2013

I think this CL introduced a memory leak. The daily leak report went from 0 to not 0 between June 4 and June 5 and this is the only CL that touched C code. On Wed, Jun 5, 2013 at 6:31 PM, richard.oudkerk <python-checkins(a)python.org>wrote: > http://hg.python.org/cpython/rev/0410bf251e10 > changeset: 84045:0410bf251e10 > user: Richard Oudkerk <shibturn(a)gmail.com> > date: Wed Jun 05 23:29:30 2013 +0100 > summary: > Issue #17931: Resolve … [View More]confusion on Windows between pids and process > handles. > > files: > Include/longobject.h | 13 +++++++++++++ > Misc/NEWS | 5 ++--- > Modules/posixmodule.c | 25 +++++++++---------------- > PC/msvcrtmodule.c | 5 +++-- > PC/pyconfig.h | 4 ++-- > 5 files changed, 29 insertions(+), 23 deletions(-) > > > diff --git a/Include/longobject.h b/Include/longobject.h > --- a/Include/longobject.h > +++ b/Include/longobject.h > @@ -52,6 +52,19 @@ > #error "sizeof(pid_t) is neither sizeof(int), sizeof(long) or sizeof(long > long)" > #endif /* SIZEOF_PID_T */ > > +#if SIZEOF_VOID_P == SIZEOF_INT > +# define _Py_PARSE_INTPTR "i" > +# define _Py_PARSE_UINTPTR "I" > +#elif SIZEOF_VOID_P == SIZEOF_LONG > +# define _Py_PARSE_INTPTR "l" > +# define _Py_PARSE_UINTPTR "k" > +#elif defined(SIZEOF_LONG_LONG) && SIZEOF_VOID_P == SIZEOF_LONG_LONG > +# define _Py_PARSE_INTPTR "L" > +# define _Py_PARSE_UINTPTR "K" > +#else > +# error "void* different in size from int, long and long long" > +#endif /* SIZEOF_VOID_P */ > + > /* Used by Python/mystrtoul.c. */ > #ifndef Py_LIMITED_API > PyAPI_DATA(unsigned char) _PyLong_DigitValue[256]; > diff --git a/Misc/NEWS b/Misc/NEWS > --- a/Misc/NEWS > +++ b/Misc/NEWS > @@ -10,9 +10,8 @@ > Core and Builtins > ----------------- > > -- Issue #17931: Fix PyLong_FromPid() on Windows 64-bit: processes are > - identified by their HANDLE which is a pointer (and not a long, which is > - smaller). > +- Issue #17931: Resolve confusion on Windows between pids and process > + handles. > > - Tweak the exception message when the magic number or size value in a > bytecode > file is truncated. > diff --git a/Modules/posixmodule.c b/Modules/posixmodule.c > --- a/Modules/posixmodule.c > +++ b/Modules/posixmodule.c > @@ -5014,11 +5014,7 @@ > if (spawnval == -1) > return posix_error(); > else > -#if SIZEOF_LONG == SIZEOF_VOID_P > - return Py_BuildValue("l", (long) spawnval); > -#else > - return Py_BuildValue("L", (PY_LONG_LONG) spawnval); > -#endif > + return Py_BuildValue(_Py_PARSE_INTPTR, spawnval); > } > > > @@ -5104,11 +5100,7 @@ > if (spawnval == -1) > (void) posix_error(); > else > -#if SIZEOF_LONG == SIZEOF_VOID_P > - res = Py_BuildValue("l", (long) spawnval); > -#else > - res = Py_BuildValue("L", (PY_LONG_LONG) spawnval); > -#endif > + res = Py_BuildValue(_Py_PARSE_INTPTR, spawnval); > > while (--envc >= 0) > PyMem_DEL(envlist[envc]); > @@ -6178,16 +6170,17 @@ > win32_kill(PyObject *self, PyObject *args) > { > PyObject *result; > - DWORD pid, sig, err; > + pid_t pid; > + DWORD sig, err; > HANDLE handle; > > - if (!PyArg_ParseTuple(args, "kk:kill", &pid, &sig)) > + if (!PyArg_ParseTuple(args, _Py_PARSE_PID "k:kill", &pid, &sig)) > return NULL; > > /* Console processes which share a common console can be sent CTRL+C > or > CTRL+BREAK events, provided they handle said events. */ > if (sig == CTRL_C_EVENT || sig == CTRL_BREAK_EVENT) { > - if (GenerateConsoleCtrlEvent(sig, pid) == 0) { > + if (GenerateConsoleCtrlEvent(sig, (DWORD)pid) == 0) { > err = GetLastError(); > PyErr_SetFromWindowsErr(err); > } > @@ -6197,7 +6190,7 @@ > > /* If the signal is outside of what GenerateConsoleCtrlEvent can use, > attempt to open and terminate the process. */ > - handle = OpenProcess(PROCESS_ALL_ACCESS, FALSE, pid); > + handle = OpenProcess(PROCESS_ALL_ACCESS, FALSE, (DWORD)pid); > if (handle == NULL) { > err = GetLastError(); > return PyErr_SetFromWindowsErr(err); > @@ -6603,7 +6596,7 @@ > Py_intptr_t pid; > int status, options; > > - if (!PyArg_ParseTuple(args, _Py_PARSE_PID "i:waitpid", &pid, > &options)) > + if (!PyArg_ParseTuple(args, _Py_PARSE_INTPTR "i:waitpid", &pid, > &options)) > return NULL; > Py_BEGIN_ALLOW_THREADS > pid = _cwait(&status, pid, options); > @@ -6612,7 +6605,7 @@ > return posix_error(); > > /* shift the status left a byte so this is more like the POSIX > waitpid */ > - return Py_BuildValue("Ni", PyLong_FromPid(pid), status << 8); > + return Py_BuildValue(_Py_PARSE_INTPTR "i", pid, status << 8); > } > #endif /* HAVE_WAITPID || HAVE_CWAIT */ > > diff --git a/PC/msvcrtmodule.c b/PC/msvcrtmodule.c > --- a/PC/msvcrtmodule.c > +++ b/PC/msvcrtmodule.c > @@ -113,11 +113,12 @@ > static PyObject * > msvcrt_open_osfhandle(PyObject *self, PyObject *args) > { > - long handle; > + Py_intptr_t handle; > int flags; > int fd; > > - if (!PyArg_ParseTuple(args, "li:open_osfhandle", &handle, &flags)) > + if (!PyArg_ParseTuple(args, _Py_PARSE_INTPTR "i:open_osfhandle", > + &handle, &flags)) > return NULL; > > fd = _open_osfhandle(handle, flags); > diff --git a/PC/pyconfig.h b/PC/pyconfig.h > --- a/PC/pyconfig.h > +++ b/PC/pyconfig.h > @@ -723,8 +723,8 @@ > /* The size of `wchar_t', as computed by sizeof. */ > #define SIZEOF_WCHAR_T 2 > > -/* The size of `pid_t' (HANDLE). */ > -#define SIZEOF_PID_T SIZEOF_VOID_P > +/* The size of `pid_t', as computed by sizeof. */ > +#define SIZEOF_PID_T SIZEOF_INT > > /* Define if you have the dl library (-ldl). */ > /* #undef HAVE_LIBDL */ > > -- > Repository URL: http://hg.python.org/cpython > > _______________________________________________ > Python-checkins mailing list > Python-checkins(a)python.org > http://mail.python.org/mailman/listinfo/python-checkins > > [View Less]

2 1

html documentation and table-of-contents
by Ethan Furman June 7, 2013

June 7, 2013

I just used the build system on the 3.4.0 docs, and some of the library modules (haven't checked the others) have the TOC showing up at the bottom of the page instead of the top. Am I doing something wrong? -- ~Ethan~

1 0

Compiling Python with Python
by Jussi Pakkanen June 5, 2013

June 5, 2013

Hello all I'd like to start this email by saying this is not a proposal to change Python's build system. This is just the results of some experimentation you might be interested it. I have been working on a cross-platform build system called Meson, which is implemented in Python 3. For symmetry I wanted to see if it could be used to build Python itself. After about an evening worth of work, I got the basic C parts (that is, the build targets in the main Makefile such as core Python, pgen etc) … [View More]

3 4

Re: [Python-Dev] HAVE_FSTAT?
by Hossein June 5, 2013

June 5, 2013

Hi. My 2 cents about this: (well I'm only a noob) I had this problem; I don't know about other people's environment, but my environment's problem was that it was actually not POSIX-compliant: it didn't have other file functions as well, but anyway the `fstat` error is the FIRST error you get when you compile in such environments, so people as unaware as me think the problem is with fstat only. Anyway I think if you are going to remove anything, you should think in terms of POSIX-… [View More]

1 0

Re: [Python-Dev] [Python-checkins] cpython: Add reference implementation for PEP 443
by Brett Cannon June 5, 2013

June 5, 2013

Any chance you could move your definitions for "generic function" and "single dispatch" to the glossary and just link to them here? On Wed, Jun 5, 2013 at 6:20 AM, lukasz.langa <python-checkins(a)python.org>wrote: > http://hg.python.org/cpython/rev/dfcb64f51f7b > changeset: 84039:dfcb64f51f7b > user: Łukasz Langa <lukasz(a)langa.pl> > date: Wed Jun 05 12:20:24 2013 +0200 > summary: > Add reference implementation for PEP 443 > > PEP … [View More]accepted: > http://mail.python.org/pipermail/python-dev/2013-June/126734.html > > files: > Doc/library/functools.rst | 110 +++++++ > Lib/functools.py | 128 ++++++++- > Lib/pkgutil.py | 52 +--- > Lib/test/test_functools.py | 374 ++++++++++++++++++++++++- > Misc/NEWS | 3 + > Modules/Setup.dist | 2 +- > 6 files changed, 614 insertions(+), 55 deletions(-) > > > diff --git a/Doc/library/functools.rst b/Doc/library/functools.rst > --- a/Doc/library/functools.rst > +++ b/Doc/library/functools.rst > @@ -6,6 +6,7 @@ > .. moduleauthor:: Peter Harris <scav(a)blueyonder.co.uk> > .. moduleauthor:: Raymond Hettinger <python(a)rcn.com> > .. moduleauthor:: Nick Coghlan <ncoghlan(a)gmail.com> > +.. moduleauthor:: Łukasz Langa <lukasz(a)langa.pl> > .. sectionauthor:: Peter Harris <scav(a)blueyonder.co.uk> > > **Source code:** :source:`Lib/functools.py` > @@ -186,6 +187,115 @@ > *sequence* contains only one item, the first item is returned. > > > +.. decorator:: singledispatch(default) > + > + Transforms a function into a single-dispatch generic function. A > **generic > + function** is composed of multiple functions implementing the same > operation > + for different types. Which implementation should be used during a call > is > + determined by the dispatch algorithm. When the implementation is > chosen > + based on the type of a single argument, this is known as **single > + dispatch**. > + > + To define a generic function, decorate it with the ``@singledispatch`` > + decorator. Note that the dispatch happens on the type of the first > argument, > + create your function accordingly:: > + > + >>> from functools import singledispatch > + >>> @singledispatch > + ... def fun(arg, verbose=False): > + ... if verbose: > + ... print("Let me just say,", end=" ") > + ... print(arg) > + > + To add overloaded implementations to the function, use the > :func:`register` > + attribute of the generic function. It is a decorator, taking a type > + parameter and decorating a function implementing the operation for that > + type:: > + > + >>> @fun.register(int) > + ... def _(arg, verbose=False): > + ... if verbose: > + ... print("Strength in numbers, eh?", end=" ") > + ... print(arg) > + ... > + >>> @fun.register(list) > + ... def _(arg, verbose=False): > + ... if verbose: > + ... print("Enumerate this:") > + ... for i, elem in enumerate(arg): > + ... print(i, elem) > + > + To enable registering lambdas and pre-existing functions, the > + :func:`register` attribute can be used in a functional form:: > + > + >>> def nothing(arg, verbose=False): > + ... print("Nothing.") > + ... > + >>> fun.register(type(None), nothing) > + > + The :func:`register` attribute returns the undecorated function which > + enables decorator stacking, pickling, as well as creating unit tests > for > + each variant independently:: > + > + >>> @fun.register(float) > + ... @fun.register(Decimal) > + ... def fun_num(arg, verbose=False): > + ... if verbose: > + ... print("Half of your number:", end=" ") > + ... print(arg / 2) > + ... > + >>> fun_num is fun > + False > + > + When called, the generic function dispatches on the type of the first > + argument:: > + > + >>> fun("Hello, world.") > + Hello, world. > + >>> fun("test.", verbose=True) > + Let me just say, test. > + >>> fun(42, verbose=True) > + Strength in numbers, eh? 42 > + >>> fun(['spam', 'spam', 'eggs', 'spam'], verbose=True) > + Enumerate this: > + 0 spam > + 1 spam > + 2 eggs > + 3 spam > + >>> fun(None) > + Nothing. > + >>> fun(1.23) > + 0.615 > + > + Where there is no registered implementation for a specific type, its > + method resolution order is used to find a more generic implementation. > + The original function decorated with ``@singledispatch`` is registered > + for the base ``object`` type, which means it is used if no better > + implementation is found. > + > + To check which implementation will the generic function choose for > + a given type, use the ``dispatch()`` attribute:: > + > + >>> fun.dispatch(float) > + <function fun_num at 0x1035a2840> > + >>> fun.dispatch(dict) # note: default implementation > + <function fun at 0x103fe0000> > + > + To access all registered implementations, use the read-only > ``registry`` > + attribute:: > + > + >>> fun.registry.keys() > + dict_keys([<class 'NoneType'>, <class 'int'>, <class 'object'>, > + <class 'decimal.Decimal'>, <class 'list'>, > + <class 'float'>]) > + >>> fun.registry[float] > + <function fun_num at 0x1035a2840> > + >>> fun.registry[object] > + <function fun at 0x103fe0000> > + > + .. versionadded:: 3.4 > + > + > .. function:: update_wrapper(wrapper, wrapped, > assigned=WRAPPER_ASSIGNMENTS, updated=WRAPPER_UPDATES) > > Update a *wrapper* function to look like the *wrapped* function. The > optional > diff --git a/Lib/functools.py b/Lib/functools.py > --- a/Lib/functools.py > +++ b/Lib/functools.py > @@ -3,19 +3,24 @@ > # Python module wrapper for _functools C module > # to allow utilities written in Python to be added > # to the functools module. > -# Written by Nick Coghlan <ncoghlan at gmail.com> > -# and Raymond Hettinger <python at rcn.com> > -# Copyright (C) 2006-2010 Python Software Foundation. > +# Written by Nick Coghlan <ncoghlan at gmail.com>, > +# Raymond Hettinger <python at rcn.com>, > +# and Łukasz Langa <lukasz at langa.pl>. > +# Copyright (C) 2006-2013 Python Software Foundation. > # See C source code for _functools credits/copyright > > __all__ = ['update_wrapper', 'wraps', 'WRAPPER_ASSIGNMENTS', > 'WRAPPER_UPDATES', > - 'total_ordering', 'cmp_to_key', 'lru_cache', 'reduce', > 'partial'] > + 'total_ordering', 'cmp_to_key', 'lru_cache', 'reduce', > 'partial', > + 'singledispatch'] > > try: > from _functools import reduce > except ImportError: > pass > +from abc import get_cache_token > from collections import namedtuple > +from types import MappingProxyType > +from weakref import WeakKeyDictionary > try: > from _thread import RLock > except: > @@ -354,3 +359,118 @@ > return update_wrapper(wrapper, user_function) > > return decorating_function > + > + > > +################################################################################ > +### singledispatch() - single-dispatch generic function decorator > > +################################################################################ > + > +def _compose_mro(cls, haystack): > + """Calculates the MRO for a given class `cls`, including relevant > abstract > + base classes from `haystack`. > + > + """ > + bases = set(cls.__mro__) > + mro = list(cls.__mro__) > + for needle in haystack: > + if (needle in bases or not hasattr(needle, '__mro__') > + or not issubclass(cls, needle)): > + continue # either present in the __mro__ already or > unrelated > + for index, base in enumerate(mro): > + if not issubclass(base, needle): > + break > + if base in bases and not issubclass(needle, base): > + # Conflict resolution: put classes present in __mro__ and > their > + # subclasses first. See test_mro_conflicts() in > test_functools.py > + # for examples. > + index += 1 > + mro.insert(index, needle) > + return mro > + > +def _find_impl(cls, registry): > + """Returns the best matching implementation for the given class `cls` > in > + `registry`. Where there is no registered implementation for a specific > + type, its method resolution order is used to find a more generic > + implementation. > + > + Note: if `registry` does not contain an implementation for the base > + `object` type, this function may return None. > + > + """ > + mro = _compose_mro(cls, registry.keys()) > + match = None > + for t in mro: > + if match is not None: > + # If `match` is an ABC but there is another unrelated, equally > + # matching ABC. Refuse the temptation to guess. > + if (t in registry and not issubclass(match, t) > + and match not in cls.__mro__): > + raise RuntimeError("Ambiguous dispatch: {} or {}".format( > + match, t)) > + break > + if t in registry: > + match = t > + return registry.get(match) > + > +def singledispatch(func): > + """Single-dispatch generic function decorator. > + > + Transforms a function into a generic function, which can have > different > + behaviours depending upon the type of its first argument. The > decorated > + function acts as the default implementation, and additional > + implementations can be registered using the 'register()' attribute of > + the generic function. > + > + """ > + registry = {} > + dispatch_cache = WeakKeyDictionary() > + cache_token = None > + > + def dispatch(typ): > + """generic_func.dispatch(type) -> <function implementation> > + > + Runs the dispatch algorithm to return the best available > implementation > + for the given `type` registered on `generic_func`. > + > + """ > + nonlocal cache_token > + if cache_token is not None: > + current_token = get_cache_token() > + if cache_token != current_token: > + dispatch_cache.clear() > + cache_token = current_token > + try: > + impl = dispatch_cache[typ] > + except KeyError: > + try: > + impl = registry[typ] > + except KeyError: > + impl = _find_impl(typ, registry) > + dispatch_cache[typ] = impl > + return impl > + > + def register(typ, func=None): > + """generic_func.register(type, func) -> func > + > + Registers a new implementation for the given `type` on a > `generic_func`. > + > + """ > + nonlocal cache_token > + if func is None: > + return lambda f: register(typ, f) > + registry[typ] = func > + if cache_token is None and hasattr(typ, '__abstractmethods__'): > + cache_token = get_cache_token() > + dispatch_cache.clear() > + return func > + > + def wrapper(*args, **kw): > + return dispatch(args[0].__class__)(*args, **kw) > + > + registry[object] = func > + wrapper.register = register > + wrapper.dispatch = dispatch > + wrapper.registry = MappingProxyType(registry) > + wrapper._clear_cache = dispatch_cache.clear > + update_wrapper(wrapper, func) > + return wrapper > diff --git a/Lib/pkgutil.py b/Lib/pkgutil.py > --- a/Lib/pkgutil.py > +++ b/Lib/pkgutil.py > @@ -1,12 +1,13 @@ > """Utilities to support packages.""" > > +from functools import singledispatch as simplegeneric > +import imp > +import importlib > import os > +import os.path > import sys > -import importlib > -import imp > -import os.path > +from types import ModuleType > from warnings import warn > -from types import ModuleType > > __all__ = [ > 'get_importer', 'iter_importers', 'get_loader', 'find_loader', > @@ -27,46 +28,6 @@ > return marshal.load(stream) > > > -def simplegeneric(func): > - """Make a trivial single-dispatch generic function""" > - registry = {} > - def wrapper(*args, **kw): > - ob = args[0] > - try: > - cls = ob.__class__ > - except AttributeError: > - cls = type(ob) > - try: > - mro = cls.__mro__ > - except AttributeError: > - try: > - class cls(cls, object): > - pass > - mro = cls.__mro__[1:] > - except TypeError: > - mro = object, # must be an ExtensionClass or some such > :( > - for t in mro: > - if t in registry: > - return registry[t](*args, **kw) > - else: > - return func(*args, **kw) > - try: > - wrapper.__name__ = func.__name__ > - except (TypeError, AttributeError): > - pass # Python 2.3 doesn't allow functions to be renamed > - > - def register(typ, func=None): > - if func is None: > - return lambda f: register(typ, f) > - registry[typ] = func > - return func > - > - wrapper.__dict__ = func.__dict__ > - wrapper.__doc__ = func.__doc__ > - wrapper.register = register > - return wrapper > - > - > def walk_packages(path=None, prefix='', onerror=None): > """Yields (module_loader, name, ispkg) for all modules recursively > on path, or, if path is None, all accessible modules. > @@ -148,13 +109,12 @@ > yield i, name, ispkg > > > -#@simplegeneric > +@simplegeneric > def iter_importer_modules(importer, prefix=''): > if not hasattr(importer, 'iter_modules'): > return [] > return importer.iter_modules(prefix) > > -iter_importer_modules = simplegeneric(iter_importer_modules) > > # Implement a file walker for the normal importlib path hook > def _iter_file_finder_modules(importer, prefix=''): > diff --git a/Lib/test/test_functools.py b/Lib/test/test_functools.py > --- a/Lib/test/test_functools.py > +++ b/Lib/test/test_functools.py > @@ -1,24 +1,30 @@ > import collections > -import sys > -import unittest > -from test import support > -from weakref import proxy > +from itertools import permutations > import pickle > from random import choice > +import sys > +from test import support > +import unittest > +from weakref import proxy > > import functools > > py_functools = support.import_fresh_module('functools', > blocked=['_functools']) > c_functools = support.import_fresh_module('functools', > fresh=['_functools']) > > +decimal = support.import_fresh_module('decimal', fresh=['_decimal']) > + > + > def capture(*args, **kw): > """capture all positional and keyword arguments""" > return args, kw > > + > def signature(part): > """ return the signature of a partial object """ > return (part.func, part.args, part.keywords, part.__dict__) > > + > class TestPartial: > > def test_basic_examples(self): > @@ -138,6 +144,7 @@ > join = self.partial(''.join) > self.assertEqual(join(data), '0123456789') > > + > @unittest.skipUnless(c_functools, 'requires the C _functools module') > class TestPartialC(TestPartial, unittest.TestCase): > if c_functools: > @@ -194,18 +201,22 @@ > "new style getargs format but argument is not a tuple", > f.__setstate__, BadSequence()) > > + > class TestPartialPy(TestPartial, unittest.TestCase): > partial = staticmethod(py_functools.partial) > > + > if c_functools: > class PartialSubclass(c_functools.partial): > pass > > + > @unittest.skipUnless(c_functools, 'requires the C _functools module') > class TestPartialCSubclass(TestPartialC): > if c_functools: > partial = PartialSubclass > > + > class TestUpdateWrapper(unittest.TestCase): > > def check_wrapper(self, wrapper, wrapped, > @@ -312,6 +323,7 @@ > self.assertTrue(wrapper.__doc__.startswith('max(')) > self.assertEqual(wrapper.__annotations__, {}) > > + > class TestWraps(TestUpdateWrapper): > > def _default_update(self): > @@ -372,6 +384,7 @@ > self.assertEqual(wrapper.attr, 'This is a different test') > self.assertEqual(wrapper.dict_attr, f.dict_attr) > > + > class TestReduce(unittest.TestCase): > func = functools.reduce > > @@ -452,6 +465,7 @@ > d = {"one": 1, "two": 2, "three": 3} > self.assertEqual(self.func(add, d), "".join(d.keys())) > > + > class TestCmpToKey: > > def test_cmp_to_key(self): > @@ -534,14 +548,17 @@ > self.assertRaises(TypeError, hash, k) > self.assertNotIsInstance(k, collections.Hashable) > > + > @unittest.skipUnless(c_functools, 'requires the C _functools module') > class TestCmpToKeyC(TestCmpToKey, unittest.TestCase): > if c_functools: > cmp_to_key = c_functools.cmp_to_key > > + > class TestCmpToKeyPy(TestCmpToKey, unittest.TestCase): > cmp_to_key = staticmethod(py_functools.cmp_to_key) > > + > class TestTotalOrdering(unittest.TestCase): > > def test_total_ordering_lt(self): > @@ -642,6 +659,7 @@ > with self.assertRaises(TypeError): > TestTO(8) <= () > > + > class TestLRU(unittest.TestCase): > > def test_lru(self): > @@ -834,6 +852,353 @@ > DoubleEq(2)) # Verify the correct > return value > > > +class TestSingleDispatch(unittest.TestCase): > + def test_simple_overloads(self): > + @functools.singledispatch > + def g(obj): > + return "base" > + def g_int(i): > + return "integer" > + g.register(int, g_int) > + self.assertEqual(g("str"), "base") > + self.assertEqual(g(1), "integer") > + self.assertEqual(g([1,2,3]), "base") > + > + def test_mro(self): > + @functools.singledispatch > + def g(obj): > + return "base" > + class C: > + pass > + class D(C): > + pass > + def g_C(c): > + return "C" > + g.register(C, g_C) > + self.assertEqual(g(C()), "C") > + self.assertEqual(g(D()), "C") > + > + def test_classic_classes(self): > + @functools.singledispatch > + def g(obj): > + return "base" > + class C: > + pass > + class D(C): > + pass > + def g_C(c): > + return "C" > + g.register(C, g_C) > + self.assertEqual(g(C()), "C") > + self.assertEqual(g(D()), "C") > + > + def test_register_decorator(self): > + @functools.singledispatch > + def g(obj): > + return "base" > + @g.register(int) > + def g_int(i): > + return "int %s" % (i,) > + self.assertEqual(g(""), "base") > + self.assertEqual(g(12), "int 12") > + self.assertIs(g.dispatch(int), g_int) > + self.assertIs(g.dispatch(object), g.dispatch(str)) > + # Note: in the assert above this is not g. > + # @singledispatch returns the wrapper. > + > + def test_wrapping_attributes(self): > + @functools.singledispatch > + def g(obj): > + "Simple test" > + return "Test" > + self.assertEqual(g.__name__, "g") > + self.assertEqual(g.__doc__, "Simple test") > + > + @unittest.skipUnless(decimal, 'requires _decimal') > + @support.cpython_only > + def test_c_classes(self): > + @functools.singledispatch > + def g(obj): > + return "base" > + @g.register(decimal.DecimalException) > + def _(obj): > + return obj.args > + subn = decimal.Subnormal("Exponent < Emin") > + rnd = decimal.Rounded("Number got rounded") > + self.assertEqual(g(subn), ("Exponent < Emin",)) > + self.assertEqual(g(rnd), ("Number got rounded",)) > + @g.register(decimal.Subnormal) > + def _(obj): > + return "Too small to care." > + self.assertEqual(g(subn), "Too small to care.") > + self.assertEqual(g(rnd), ("Number got rounded",)) > + > + def test_compose_mro(self): > + c = collections > + mro = functools._compose_mro > + bases = [c.Sequence, c.MutableMapping, c.Mapping, c.Set] > + for haystack in permutations(bases): > + m = mro(dict, haystack) > + self.assertEqual(m, [dict, c.MutableMapping, c.Mapping, > object]) > + bases = [c.Container, c.Mapping, c.MutableMapping, c.OrderedDict] > + for haystack in permutations(bases): > + m = mro(c.ChainMap, haystack) > + self.assertEqual(m, [c.ChainMap, c.MutableMapping, c.Mapping, > + c.Sized, c.Iterable, c.Container, > object]) > + # Note: The MRO order below depends on haystack ordering. > + m = mro(c.defaultdict, [c.Sized, c.Container, str]) > + self.assertEqual(m, [c.defaultdict, dict, c.Container, c.Sized, > object]) > + m = mro(c.defaultdict, [c.Container, c.Sized, str]) > + self.assertEqual(m, [c.defaultdict, dict, c.Sized, c.Container, > object]) > + > + def test_register_abc(self): > + c = collections > + d = {"a": "b"} > + l = [1, 2, 3] > + s = {object(), None} > + f = frozenset(s) > + t = (1, 2, 3) > + @functools.singledispatch > + def g(obj): > + return "base" > + self.assertEqual(g(d), "base") > + self.assertEqual(g(l), "base") > + self.assertEqual(g(s), "base") > + self.assertEqual(g(f), "base") > + self.assertEqual(g(t), "base") > + g.register(c.Sized, lambda obj: "sized") > + self.assertEqual(g(d), "sized") > + self.assertEqual(g(l), "sized") > + self.assertEqual(g(s), "sized") > + self.assertEqual(g(f), "sized") > + self.assertEqual(g(t), "sized") > + g.register(c.MutableMapping, lambda obj: "mutablemapping") > + self.assertEqual(g(d), "mutablemapping") > + self.assertEqual(g(l), "sized") > + self.assertEqual(g(s), "sized") > + self.assertEqual(g(f), "sized") > + self.assertEqual(g(t), "sized") > + g.register(c.ChainMap, lambda obj: "chainmap") > + self.assertEqual(g(d), "mutablemapping") # irrelevant ABCs > registered > + self.assertEqual(g(l), "sized") > + self.assertEqual(g(s), "sized") > + self.assertEqual(g(f), "sized") > + self.assertEqual(g(t), "sized") > + g.register(c.MutableSequence, lambda obj: "mutablesequence") > + self.assertEqual(g(d), "mutablemapping") > + self.assertEqual(g(l), "mutablesequence") > + self.assertEqual(g(s), "sized") > + self.assertEqual(g(f), "sized") > + self.assertEqual(g(t), "sized") > + g.register(c.MutableSet, lambda obj: "mutableset") > + self.assertEqual(g(d), "mutablemapping") > + self.assertEqual(g(l), "mutablesequence") > + self.assertEqual(g(s), "mutableset") > + self.assertEqual(g(f), "sized") > + self.assertEqual(g(t), "sized") > + g.register(c.Mapping, lambda obj: "mapping") > + self.assertEqual(g(d), "mutablemapping") # not specific enough > + self.assertEqual(g(l), "mutablesequence") > + self.assertEqual(g(s), "mutableset") > + self.assertEqual(g(f), "sized") > + self.assertEqual(g(t), "sized") > + g.register(c.Sequence, lambda obj: "sequence") > + self.assertEqual(g(d), "mutablemapping") > + self.assertEqual(g(l), "mutablesequence") > + self.assertEqual(g(s), "mutableset") > + self.assertEqual(g(f), "sized") > + self.assertEqual(g(t), "sequence") > + g.register(c.Set, lambda obj: "set") > + self.assertEqual(g(d), "mutablemapping") > + self.assertEqual(g(l), "mutablesequence") > + self.assertEqual(g(s), "mutableset") > + self.assertEqual(g(f), "set") > + self.assertEqual(g(t), "sequence") > + g.register(dict, lambda obj: "dict") > + self.assertEqual(g(d), "dict") > + self.assertEqual(g(l), "mutablesequence") > + self.assertEqual(g(s), "mutableset") > + self.assertEqual(g(f), "set") > + self.assertEqual(g(t), "sequence") > + g.register(list, lambda obj: "list") > + self.assertEqual(g(d), "dict") > + self.assertEqual(g(l), "list") > + self.assertEqual(g(s), "mutableset") > + self.assertEqual(g(f), "set") > + self.assertEqual(g(t), "sequence") > + g.register(set, lambda obj: "concrete-set") > + self.assertEqual(g(d), "dict") > + self.assertEqual(g(l), "list") > + self.assertEqual(g(s), "concrete-set") > + self.assertEqual(g(f), "set") > + self.assertEqual(g(t), "sequence") > + g.register(frozenset, lambda obj: "frozen-set") > + self.assertEqual(g(d), "dict") > + self.assertEqual(g(l), "list") > + self.assertEqual(g(s), "concrete-set") > + self.assertEqual(g(f), "frozen-set") > + self.assertEqual(g(t), "sequence") > + g.register(tuple, lambda obj: "tuple") > + self.assertEqual(g(d), "dict") > + self.assertEqual(g(l), "list") > + self.assertEqual(g(s), "concrete-set") > + self.assertEqual(g(f), "frozen-set") > + self.assertEqual(g(t), "tuple") > + > + def test_mro_conflicts(self): > + c = collections > + > + @functools.singledispatch > + def g(arg): > + return "base" > + > + class O(c.Sized): > + def __len__(self): > + return 0 > + > + o = O() > + self.assertEqual(g(o), "base") > + g.register(c.Iterable, lambda arg: "iterable") > + g.register(c.Container, lambda arg: "container") > + g.register(c.Sized, lambda arg: "sized") > + g.register(c.Set, lambda arg: "set") > + self.assertEqual(g(o), "sized") > + c.Iterable.register(O) > + self.assertEqual(g(o), "sized") # because it's explicitly in > __mro__ > + c.Container.register(O) > + self.assertEqual(g(o), "sized") # see above: Sized is in __mro__ > + > + class P: > + pass > + > + p = P() > + self.assertEqual(g(p), "base") > + c.Iterable.register(P) > + self.assertEqual(g(p), "iterable") > + c.Container.register(P) > + with self.assertRaises(RuntimeError) as re: > + g(p) > + self.assertEqual( > + str(re), > + ("Ambiguous dispatch: <class 'collections.abc.Container'> > " > + "or <class 'collections.abc.Iterable'>"), > + ) > + > + class Q(c.Sized): > + def __len__(self): > + return 0 > + > + q = Q() > + self.assertEqual(g(q), "sized") > + c.Iterable.register(Q) > + self.assertEqual(g(q), "sized") # because it's explicitly in > __mro__ > + c.Set.register(Q) > + self.assertEqual(g(q), "set") # because c.Set is a subclass of > + # c.Sized which is explicitly in > + # __mro__ > + > + def test_cache_invalidation(self): > + from collections import UserDict > + class TracingDict(UserDict): > + def __init__(self, *args, **kwargs): > + super(TracingDict, self).__init__(*args, **kwargs) > + self.set_ops = [] > + self.get_ops = [] > + def __getitem__(self, key): > + result = self.data[key] > + self.get_ops.append(key) > + return result > + def __setitem__(self, key, value): > + self.set_ops.append(key) > + self.data[key] = value > + def clear(self): > + self.data.clear() > + _orig_wkd = functools.WeakKeyDictionary > + td = TracingDict() > + functools.WeakKeyDictionary = lambda: td > + c = collections > + @functools.singledispatch > + def g(arg): > + return "base" > + d = {} > + l = [] > + self.assertEqual(len(td), 0) > + self.assertEqual(g(d), "base") > + self.assertEqual(len(td), 1) > + self.assertEqual(td.get_ops, []) > + self.assertEqual(td.set_ops, [dict]) > + self.assertEqual(td.data[dict], g.registry[object]) > + self.assertEqual(g(l), "base") > + self.assertEqual(len(td), 2) > + self.assertEqual(td.get_ops, []) > + self.assertEqual(td.set_ops, [dict, list]) > + self.assertEqual(td.data[dict], g.registry[object]) > + self.assertEqual(td.data[list], g.registry[object]) > + self.assertEqual(td.data[dict], td.data[list]) > + self.assertEqual(g(l), "base") > + self.assertEqual(g(d), "base") > + self.assertEqual(td.get_ops, [list, dict]) > + self.assertEqual(td.set_ops, [dict, list]) > + g.register(list, lambda arg: "list") > + self.assertEqual(td.get_ops, [list, dict]) > + self.assertEqual(len(td), 0) > + self.assertEqual(g(d), "base") > + self.assertEqual(len(td), 1) > + self.assertEqual(td.get_ops, [list, dict]) > + self.assertEqual(td.set_ops, [dict, list, dict]) > + self.assertEqual(td.data[dict], > + functools._find_impl(dict, g.registry)) > + self.assertEqual(g(l), "list") > + self.assertEqual(len(td), 2) > + self.assertEqual(td.get_ops, [list, dict]) > + self.assertEqual(td.set_ops, [dict, list, dict, list]) > + self.assertEqual(td.data[list], > + functools._find_impl(list, g.registry)) > + class X: > + pass > + c.MutableMapping.register(X) # Will not invalidate the cache, > + # not using ABCs yet. > + self.assertEqual(g(d), "base") > + self.assertEqual(g(l), "list") > + self.assertEqual(td.get_ops, [list, dict, dict, list]) > + self.assertEqual(td.set_ops, [dict, list, dict, list]) > + g.register(c.Sized, lambda arg: "sized") > + self.assertEqual(len(td), 0) > + self.assertEqual(g(d), "sized") > + self.assertEqual(len(td), 1) > + self.assertEqual(td.get_ops, [list, dict, dict, list]) > + self.assertEqual(td.set_ops, [dict, list, dict, list, dict]) > + self.assertEqual(g(l), "list") > + self.assertEqual(len(td), 2) > + self.assertEqual(td.get_ops, [list, dict, dict, list]) > + self.assertEqual(td.set_ops, [dict, list, dict, list, dict, list]) > + self.assertEqual(g(l), "list") > + self.assertEqual(g(d), "sized") > + self.assertEqual(td.get_ops, [list, dict, dict, list, list, dict]) > + self.assertEqual(td.set_ops, [dict, list, dict, list, dict, list]) > + g.dispatch(list) > + g.dispatch(dict) > + self.assertEqual(td.get_ops, [list, dict, dict, list, list, dict, > + list, dict]) > + self.assertEqual(td.set_ops, [dict, list, dict, list, dict, list]) > + c.MutableSet.register(X) # Will invalidate the cache. > + self.assertEqual(len(td), 2) # Stale cache. > + self.assertEqual(g(l), "list") > + self.assertEqual(len(td), 1) > + g.register(c.MutableMapping, lambda arg: "mutablemapping") > + self.assertEqual(len(td), 0) > + self.assertEqual(g(d), "mutablemapping") > + self.assertEqual(len(td), 1) > + self.assertEqual(g(l), "list") > + self.assertEqual(len(td), 2) > + g.register(dict, lambda arg: "dict") > + self.assertEqual(g(d), "dict") > + self.assertEqual(g(l), "list") > + g._clear_cache() > + self.assertEqual(len(td), 0) > + functools.WeakKeyDictionary = _orig_wkd > + > + > def test_main(verbose=None): > test_classes = ( > TestPartialC, > @@ -846,6 +1211,7 @@ > TestWraps, > TestReduce, > TestLRU, > + TestSingleDispatch, > ) > support.run_unittest(*test_classes) > > diff --git a/Misc/NEWS b/Misc/NEWS > --- a/Misc/NEWS > +++ b/Misc/NEWS > @@ -344,6 +344,9 @@ > the default for linking if LDSHARED is not also overriden. This > restores > Distutils behavior introduced in 3.2.3 and inadvertently dropped in > 3.3.0. > > +- Implement PEP 443 "Single-dispatch generic functions". > + > + > Tests > ----- > > diff --git a/Modules/Setup.dist b/Modules/Setup.dist > --- a/Modules/Setup.dist > +++ b/Modules/Setup.dist > @@ -116,6 +116,7 @@ > _operator _operator.c # operator.add() and similar goodies > _collections _collectionsmodule.c # Container types > itertools itertoolsmodule.c # Functions creating iterators for > efficient looping > +atexit atexitmodule.c # Register functions to be run at > interpreter-shutdown > > # access to ISO C locale support > _locale _localemodule.c # -lintl > @@ -170,7 +171,6 @@ > #_weakref _weakref.c # basic weak reference support > #_testcapi _testcapimodule.c # Python C API test module > #_random _randommodule.c # Random number generator > -#atexit atexitmodule.c # Register functions to be run at > interpreter-shutdown > #_elementtree -I$(srcdir)/Modules/expat -DHAVE_EXPAT_CONFIG_H > -DUSE_PYEXPAT_CAPI _elementtree.c # elementtree accelerator > #_pickle _pickle.c # pickle accelerator > #_datetime _datetimemodule.c # datetime accelerator > > -- > Repository URL: http://hg.python.org/cpython > > _______________________________________________ > Python-checkins mailing list > Python-checkins(a)python.org > http://mail.python.org/mailman/listinfo/python-checkins > > [View Less]

2 1