File: kwargsdict.py

package info (click to toggle)
pypy3 7.3.19%2Bdfsg-2
  • links: PTS, VCS
  • area: main
  • in suites: trixie
  • size: 212,236 kB
  • sloc: python: 2,098,316; ansic: 540,565; sh: 21,462; asm: 14,419; cpp: 4,451; makefile: 4,209; objc: 761; xml: 530; exp: 499; javascript: 314; pascal: 244; lisp: 45; csh: 12; awk: 4
file content (198 lines) | stat: -rw-r--r-- 6,828 bytes parent folder | download | duplicates (3)
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
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
"""dict implementation specialized for keyword argument dicts.

Based on two lists containing key value pairs.
"""

from rpython.rlib import jit, rerased, objectmodel, rutf8

from pypy.objspace.std.dictmultiobject import (
    DictStrategy, EmptyDictStrategy, ObjectDictStrategy, UnicodeDictStrategy,
    create_iterator_classes, W_DictObject)


class EmptyKwargsDictStrategy(EmptyDictStrategy):
    def switch_to_unicode_strategy(self, w_dict):
        strategy = self.space.fromcache(KwargsDictStrategy)
        storage = strategy.get_empty_storage()
        w_dict.set_strategy(strategy)
        w_dict.dstorage = storage

    def copy(self, w_dict):
        dstorage = self.unerase(w_dict.dstorage)
        return W_DictObject(self.space, self, self.get_empty_storage())


class KwargsDictStrategy(DictStrategy):
    erase, unerase = rerased.new_erasing_pair("kwargsdict")
    erase = staticmethod(erase)
    unerase = staticmethod(unerase)

    def get_empty_storage(self):
        d = ([], [])
        return self.erase(d)

    def is_correct_type(self, w_obj):
        space = self.space
        return space.is_w(space.type(w_obj), space.w_text)

    def _never_equal_to(self, w_lookup_type):
        return False

    def setitem(self, w_dict, w_key, w_value):
        if self.is_correct_type(w_key):
            self.setitem_correct(w_dict, w_key, w_value)
            return
        else:
            self.switch_to_object_strategy(w_dict)
            w_dict.setitem(w_key, w_value)

    def setitem_correct(self, w_dict, w_key, w_value):
        self._setitem_correct_indirection(w_dict, w_key, w_value)

    @jit.look_inside_iff(lambda self, w_dict, w_key, w_value:
            jit.isconstant(self.length(w_dict)) and jit.isconstant(w_key))
    def _setitem_correct_indirection(self, w_dict, w_key, w_value):
        keys_w, values_w = self.unerase(w_dict.dstorage)
        for i in range(len(keys_w)):
            if keys_w[i].eq_w(w_key):
                values_w[i] = w_value
                break
        else:
            # limit the size so that the linear searches don't become too long
            if len(keys_w) >= 16:
                self.switch_to_unicode_strategy(w_dict)
                w_dict.setitem(w_key, w_value)
            else:
                keys_w.append(w_key)
                values_w.append(w_value)

    def setdefault(self, w_dict, w_key, w_default):
        if self.is_correct_type(w_key):
            w_result = self.getitem_correct(w_dict, w_key)
            if w_result is not None:
                return w_result
            self.setitem_correct(w_dict, w_key, w_default)
            return w_default
        else:
            self.switch_to_object_strategy(w_dict)
            return w_dict.setdefault(w_key, w_default)

    def delitem(self, w_dict, w_key):
        # XXX could do better, but is it worth it?
        self.switch_to_object_strategy(w_dict)
        return w_dict.delitem(w_key)

    def length(self, w_dict):
        return len(self.unerase(w_dict.dstorage)[0])

    def getitem_correct(self, w_dict, w_key):
        return self._getitem_correct_indirection(w_dict, w_key)

    @jit.look_inside_iff(lambda self, w_dict, w_key:
            jit.isconstant(self.length(w_dict)) and jit.isconstant(w_key))
    def _getitem_correct_indirection(self, w_dict, w_key):
        keys_w, values_w = self.unerase(w_dict.dstorage)
        for i in range(len(keys_w)):
            if keys_w[i].eq_w(w_key):
                return values_w[i]
        return None

    def getitem(self, w_dict, w_key):
        space = self.space
        if self.is_correct_type(w_key):
            return self.getitem_correct(w_dict, w_key)
        elif self._never_equal_to(space.type(w_key)):
            return None
        else:
            self.switch_to_object_strategy(w_dict)
            return w_dict.getitem(w_key)

    def w_keys(self, w_dict):
        l = self.unerase(w_dict.dstorage)[0]
        return self.space.newlist(l[:])

    def values(self, w_dict):
        return self.unerase(w_dict.dstorage)[1][:] # to make non-resizable

    def items(self, w_dict):
        space = self.space
        keys_w, values_w = self.unerase(w_dict.dstorage)
        return [space.newtuple2(keys_w[i], values_w[i])
                for i in range(len(keys_w))]

    def popitem(self, w_dict):
        keys_w, values_w = self.unerase(w_dict.dstorage)
        if not keys_w:
            raise KeyError
        w_key = keys_w.pop()
        w_value = values_w.pop()
        return w_key, w_value

    def clear(self, w_dict):
        w_dict.dstorage = self.get_empty_storage()

    def switch_to_object_strategy(self, w_dict):
        strategy = self.space.fromcache(ObjectDictStrategy)
        keys_w, values_w = self.unerase(w_dict.dstorage)
        d_new = strategy.unerase(strategy.get_empty_storage())
        for i in range(len(keys_w)):
            d_new[keys_w[i]] = values_w[i]
        w_dict.set_strategy(strategy)
        w_dict.dstorage = strategy.erase(d_new)

    def switch_to_unicode_strategy(self, w_dict):
        strategy = self.space.fromcache(UnicodeDictStrategy)
        keys_w, values_w = self.unerase(w_dict.dstorage)
        storage = strategy.get_empty_storage()
        w_dict.set_strategy(strategy)
        w_dict.dstorage = storage
        for i in range(len(keys_w)):
            # NB: this can turn the dict into an object strategy, if a key is
            # not ASCII!
            w_dict.setitem(keys_w[i], values_w[i])

    def view_as_kwargs(self, w_dict):
        keys_w, values_w = self.unerase(w_dict.dstorage)
        return keys_w[:], values_w[:] # copy to make non-resizable

    def getiterkeys(self, w_dict):
        return iter(self.unerase(w_dict.dstorage)[0])

    def getitervalues(self, w_dict):
        return iter(self.unerase(w_dict.dstorage)[1])

    def getiteritems_with_hash(self, w_dict):
        keys_w, values_w = self.unerase(w_dict.dstorage)
        return ZipItemsWithHash(keys_w, values_w)

    def copy(self, w_dict):
        dstorage = self.unerase(w_dict.dstorage)
        return W_DictObject(self.space, self,
                self.erase((dstorage[0][:], dstorage[1][:])))

    def getiterreversed(self, w_dict):
        l = self.unerase(w_dict.dstorage)[0]
        l = l[:] # inefficient, but who cares
        l.reverse()
        return iter(l)


class ZipItemsWithHash(object):
    def __init__(self, list1, list2):
        assert len(list1) == len(list2)
        self.list1 = list1
        self.list2 = list2
        self.i = 0

    def __iter__(self):
        return self

    def next(self):
        i = self.i
        if i >= len(self.list1):
            raise StopIteration
        self.i = i + 1
        w_key = self.list1[i]
        return (w_key, self.list2[i], w_key.hash_w())

create_iterator_classes(KwargsDictStrategy)