[Python-Dev] [Python-checkins] cpython: Add reference implementation for PEP 443

Brett Cannon brett at python.org
Wed Jun 5 16:31:04 CEST 2013
Previous message: [Python-Dev] PyPI upload error
Next message: [Python-Dev] [Python-checkins] cpython: Add reference implementation for PEP 443
Messages sorted by: [ date ] [ thread ] [ subject ] [ author ]
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 at python.org>wrote:

> http://hg.python.org/cpython/rev/dfcb64f51f7b
> changeset:   84039:dfcb64f51f7b
> user:        Łukasz Langa <lukasz at langa.pl>
> date:        Wed Jun 05 12:20:24 2013 +0200
> summary:
>   Add reference implementation for PEP 443
>
> PEP 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 at blueyonder.co.uk>
>  .. moduleauthor:: Raymond Hettinger <python at rcn.com>
>  .. moduleauthor:: Nick Coghlan <ncoghlan at gmail.com>
> +.. moduleauthor:: Łukasz Langa <lukasz at langa.pl>
>  .. sectionauthor:: Peter Harris <scav at 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
> + at 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 at python.org
> http://mail.python.org/mailman/listinfo/python-checkins
>
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://mail.python.org/pipermail/python-dev/attachments/20130605/a0c2b1ac/attachment-0001.html>
Previous message: [Python-Dev] PyPI upload error
Next message: [Python-Dev] [Python-checkins] cpython: Add reference implementation for PEP 443
Messages sorted by: [ date ] [ thread ] [ subject ] [ author ]
More information about the Python-Dev mailing list