← Back to branch summary

~ubuntu-branches/debian/stretch/electrum/stretch

« back to all changes in this revision

Viewing changes to gui/kivy/tools/.buildozer/android/platform/python-for-android/dist/kivy/python-install/lib/python2.7/copy_reg.py

  • Committer: Package Import Robot
  • Author(s): Tristan Seligmann
  • Date: 2016-04-04 03:02:39 UTC
  • mfrom: (1.1.10)
  • Revision ID: package-import@ubuntu.com-20160404030239-0szgkio8yryjv7c9
Tags: 2.6.3-1
http://bugs.debian.org/819517
* New upstream release.
  - Drop backported install-wizard-connect.patch.
* Add Suggests: python-zbar and update the installation hint to suggest
  apt-get instead of pip (closes: #819517).
* Bump Standards-Version to 3.9.7 (no changes).
* Update Vcs-* links.

Show diffs side-by-side

added added

removed removed

Lines of Context:
gui/kivy/tools/.buildozer/android/platform/python-for-android/dist/kivy/python-install/lib/python2.7/copy_reg.py
 
1
"""Helper to provide extensibility for pickle/cPickle.
 
2
 
 
3
This is only useful to add pickle support for extension types defined in
 
4
C, not for instances of user-defined classes.
 
5
"""
 
6
 
 
7
from types import ClassType as _ClassType
 
8
 
 
9
__all__ = ["pickle", "constructor",
 
10
           "add_extension", "remove_extension", "clear_extension_cache"]
 
11
 
 
12
dispatch_table = {}
 
13
 
 
14
def pickle(ob_type, pickle_function, constructor_ob=None):
 
15
    if type(ob_type) is _ClassType:
 
16
        raise TypeError("copy_reg is not intended for use with classes")
 
17
 
 
18
    if not hasattr(pickle_function, '__call__'):
 
19
        raise TypeError("reduction functions must be callable")
 
20
    dispatch_table[ob_type] = pickle_function
 
21
 
 
22
    # The constructor_ob function is a vestige of safe for unpickling.
 
23
    # There is no reason for the caller to pass it anymore.
 
24
    if constructor_ob is not None:
 
25
        constructor(constructor_ob)
 
26
 
 
27
def constructor(object):
 
28
    if not hasattr(object, '__call__'):
 
29
        raise TypeError("constructors must be callable")
 
30
 
 
31
# Example: provide pickling support for complex numbers.
 
32
 
 
33
try:
 
34
    complex
 
35
except NameError:
 
36
    pass
 
37
else:
 
38
 
 
39
    def pickle_complex(c):
 
40
        return complex, (c.real, c.imag)
 
41
 
 
42
    pickle(complex, pickle_complex, complex)
 
43
 
 
44
# Support for pickling new-style objects
 
45
 
 
46
def _reconstructor(cls, base, state):
 
47
    if base is object:
 
48
        obj = object.__new__(cls)
 
49
    else:
 
50
        obj = base.__new__(cls, state)
 
51
        if base.__init__ != object.__init__:
 
52
            base.__init__(obj, state)
 
53
    return obj
 
54
 
 
55
_HEAPTYPE = 1<<9
 
56
 
 
57
# Python code for object.__reduce_ex__ for protocols 0 and 1
 
58
 
 
59
def _reduce_ex(self, proto):
 
60
    assert proto < 2
 
61
    for base in self.__class__.__mro__:
 
62
        if hasattr(base, '__flags__') and not base.__flags__ & _HEAPTYPE:
 
63
            break
 
64
    else:
 
65
        base = object # not really reachable
 
66
    if base is object:
 
67
        state = None
 
68
    else:
 
69
        if base is self.__class__:
 
70
            raise TypeError, "can't pickle %s objects" % base.__name__
 
71
        state = base(self)
 
72
    args = (self.__class__, base, state)
 
73
    try:
 
74
        getstate = self.__getstate__
 
75
    except AttributeError:
 
76
        if getattr(self, "__slots__", None):
 
77
            raise TypeError("a class that defines __slots__ without "
 
78
                            "defining __getstate__ cannot be pickled")
 
79
        try:
 
80
            dict = self.__dict__
 
81
        except AttributeError:
 
82
            dict = None
 
83
    else:
 
84
        dict = getstate()
 
85
    if dict:
 
86
        return _reconstructor, args, dict
 
87
    else:
 
88
        return _reconstructor, args
 
89
 
 
90
# Helper for __reduce_ex__ protocol 2
 
91
 
 
92
def __newobj__(cls, *args):
 
93
    return cls.__new__(cls, *args)
 
94
 
 
95
def _slotnames(cls):
 
96
    """Return a list of slot names for a given class.
 
97
 
 
98
    This needs to find slots defined by the class and its bases, so we
 
99
    can't simply return the __slots__ attribute.  We must walk down
 
100
    the Method Resolution Order and concatenate the __slots__ of each
 
101
    class found there.  (This assumes classes don't modify their
 
102
    __slots__ attribute to misrepresent their slots after the class is
 
103
    defined.)
 
104
    """
 
105
 
 
106
    # Get the value from a cache in the class if possible
 
107
    names = cls.__dict__.get("__slotnames__")
 
108
    if names is not None:
 
109
        return names
 
110
 
 
111
    # Not cached -- calculate the value
 
112
    names = []
 
113
    if not hasattr(cls, "__slots__"):
 
114
        # This class has no slots
 
115
        pass
 
116
    else:
 
117
        # Slots found -- gather slot names from all base classes
 
118
        for c in cls.__mro__:
 
119
            if "__slots__" in c.__dict__:
 
120
                slots = c.__dict__['__slots__']
 
121
                # if class has a single slot, it can be given as a string
 
122
                if isinstance(slots, basestring):
 
123
                    slots = (slots,)
 
124
                for name in slots:
 
125
                    # special descriptors
 
126
                    if name in ("__dict__", "__weakref__"):
 
127
                        continue
 
128
                    # mangled names
 
129
                    elif name.startswith('__') and not name.endswith('__'):
 
130
                        names.append('_%s%s' % (c.__name__, name))
 
131
                    else:
 
132
                        names.append(name)
 
133
 
 
134
    # Cache the outcome in the class if at all possible
 
135
    try:
 
136
        cls.__slotnames__ = names
 
137
    except:
 
138
        pass # But don't die if we can't
 
139
 
 
140
    return names
 
141
 
 
142
# A registry of extension codes.  This is an ad-hoc compression
 
143
# mechanism.  Whenever a global reference to <module>, <name> is about
 
144
# to be pickled, the (<module>, <name>) tuple is looked up here to see
 
145
# if it is a registered extension code for it.  Extension codes are
 
146
# universal, so that the meaning of a pickle does not depend on
 
147
# context.  (There are also some codes reserved for local use that
 
148
# don't have this restriction.)  Codes are positive ints; 0 is
 
149
# reserved.
 
150
 
 
151
_extension_registry = {}                # key -> code
 
152
_inverted_registry = {}                 # code -> key
 
153
_extension_cache = {}                   # code -> object
 
154
# Don't ever rebind those names:  cPickle grabs a reference to them when
 
155
# it's initialized, and won't see a rebinding.
 
156
 
 
157
def add_extension(module, name, code):
 
158
    """Register an extension code."""
 
159
    code = int(code)
 
160
    if not 1 <= code <= 0x7fffffff:
 
161
        raise ValueError, "code out of range"
 
162
    key = (module, name)
 
163
    if (_extension_registry.get(key) == code and
 
164
        _inverted_registry.get(code) == key):
 
165
        return # Redundant registrations are benign
 
166
    if key in _extension_registry:
 
167
        raise ValueError("key %s is already registered with code %s" %
 
168
                         (key, _extension_registry[key]))
 
169
    if code in _inverted_registry:
 
170
        raise ValueError("code %s is already in use for key %s" %
 
171
                         (code, _inverted_registry[code]))
 
172
    _extension_registry[key] = code
 
173
    _inverted_registry[code] = key
 
174
 
 
175
def remove_extension(module, name, code):
 
176
    """Unregister an extension code.  For testing only."""
 
177
    key = (module, name)
 
178
    if (_extension_registry.get(key) != code or
 
179
        _inverted_registry.get(code) != key):
 
180
        raise ValueError("key %s is not registered with code %s" %
 
181
                         (key, code))
 
182
    del _extension_registry[key]
 
183
    del _inverted_registry[code]
 
184
    if code in _extension_cache:
 
185
        del _extension_cache[code]
 
186
 
 
187
def clear_extension_cache():
 
188
    _extension_cache.clear()
 
189
 
 
190
# Standard extension code assignments
 
191
 
 
192
# Reserved ranges
 
193
 
 
194
# First  Last Count  Purpose
 
195
#     1   127   127  Reserved for Python standard library
 
196
#   128   191    64  Reserved for Zope
 
197
#   192   239    48  Reserved for 3rd parties
 
198
#   240   255    16  Reserved for private use (will never be assigned)
 
199
#   256   Inf   Inf  Reserved for future assignment
 
200
 
 
201
# Extension codes are assigned by the Python Software Foundation.