File: app_defaultdict.py

package info (click to toggle)
pypy3 7.0.0%2Bdfsg-3
  • links: PTS, VCS
  • area: main
  • in suites: buster
  • size: 111,848 kB
  • sloc: python: 1,291,746; ansic: 74,281; asm: 5,187; cpp: 3,017; sh: 2,533; makefile: 544; xml: 243; lisp: 45; csh: 21; awk: 4
file content (63 lines) | stat: -rw-r--r-- 2,041 bytes parent folder | download
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
# NOT_RPYTHON

# For now this is here, living at app-level.
#
# The issue is that for now we don't support writing interp-level
# subclasses of W_Root that inherit at app-level from a type like
# 'dict'.  But what we can do is write individual methods at
# interp-level.

import _collections


class defaultdict(dict):
    __slots__ = ['default_factory']
    __module__ = 'collections'

    def __init__(self, *args, **kwds):
        if len(args) > 0:
            default_factory = args[0]
            args = args[1:]
            if not callable(default_factory) and default_factory is not None:
                raise TypeError("first argument must be callable")
        else:
            default_factory = None
        defaultdict.default_factory.__set__(self, default_factory)
        super(defaultdict, self).__init__(*args, **kwds)

    def __missing__(self, key):
        pass    # this method is written at interp-level
    __missing__.__code__ = _collections.__missing__.__code__

    def __repr__(self, recurse=set()):
        # XXX not thread-safe, but good enough
        dictrepr = super(defaultdict, self).__repr__()
        if id(self) in recurse:
            factoryrepr = "..."
        else:
            try:
                recurse.add(id(self))
                factoryrepr = repr(self.default_factory)
            finally:
                recurse.remove(id(self))
        return "defaultdict(%s, %s)" % (factoryrepr, dictrepr)

    def copy(self):
        return type(self)(self.default_factory, self)

    __copy__ = copy

    def __reduce__(self):
        """
        __reduce__ must return a 5-tuple as follows:

           - factory function
           - tuple of args for the factory function
           - additional state (here None)
           - sequence iterator (here None)
           - dictionary iterator (yielding successive (key, value) pairs

           This API is used by pickle.py and copy.py.
        """
        return (type(self), (self.default_factory,), None, None,
                iter(self.items()))