cython

1
# mode: run
2

3
def empty():
4
    """
5
    >>> empty()
6
    {}
7
    """
8
    d = {}
9
    return d
10

11
def keyvalue(key, value):
12
    """
13
    >>> keyvalue(1, 2)
14
    {1: 2}
15
    """
16
    d = {key:value}
17
    return d
18

19
def keyvalues(key1, value1, key2, value2):
20
    """
21
    >>> sorted(keyvalues(1, 2, 3, 4).items())
22
    [(1, 2), (3, 4)]
23
    """
24
    d = {key1:value1, key2:value2}
25
    return d
26

27
def keyvalues2(key1, value1, key2, value2):
28
    """
29
    >>> sorted(keyvalues2(1, 2, 3, 4).items())
30
    [(1, 2), (3, 4)]
31
    """
32
    d = {key1:value1, key2:value2,}
33
    return d
34

35
def constant():
36
    """
37
    >>> len(constant())
38
    2
39
    >>> print(constant()['parrot'])
40
    resting
41
    >>> print(constant()['answer'])
42
    42
43
    """
44
    d = {u"parrot":u"resting", u"answer":42}
45
    return d
46

47
def dict_call():
48
    """
49
    >>> print(dict_call()['parrot'])
50
    resting
51
    >>> print(dict_call()['answer'])
52
    42
53
    """
54
    d = dict(parrot=u"resting", answer=42)
55
    return d
56

57
def dict_call_dict():
58
    """
59
    >>> print(dict_call_dict()['parrot'])
60
    resting
61
    >>> print(dict_call_dict()['answer'])
62
    42
63
    """
64
    d = dict(dict(parrot=u"resting", answer=42))
65
    return d
66

67
def dict_call_kwargs():
68
    """
69
    >>> print(dict_call_kwargs()['parrot1'])
70
    resting
71
    >>> print(dict_call_kwargs()['parrot2'])
72
    resting
73
    >>> print(dict_call_kwargs()['answer1'])
74
    42
75
    >>> print(dict_call_kwargs()['answer2'])
76
    42
77
    """
78
    kwargs = dict(parrot1=u"resting", answer1=42)
79
    d = dict(parrot2=u"resting", answer2=42, **kwargs)
80
    return d
81

82

83
def items_of_dict_call():
84
    """
85
    >>> items_of_dict_call()
86
    [('answer1', 42), ('answer2', 42), ('parrot1', 'resting'), ('parrot2', 'resting')]
87
    """
88
    kwargs = dict(parrot1="resting", answer1=42)
89
    items = dict(kwargs.items(), parrot2="resting", answer2=42, **kwargs).items()
90
    return sorted(items)
91

92

93
def item_creation_sideeffect(L, sideeffect, unhashable):
94
    """
95
    >>> def sideeffect(x):
96
    ...     L.append(x)
97
    ...     return x
98
    >>> def unhashable(x):
99
    ...     L.append(x)
100
    ...     return [x]
101

102
    >>> L = []
103
    >>> item_creation_sideeffect(L, sideeffect, unhashable)  # doctest: +ELLIPSIS
104
    Traceback (most recent call last):
105
    TypeError: ...unhashable...
106
    >>> L
107
    [2, 4]
108

109
    >>> L = []
110
    >>> {1:2, sideeffect(2): 3, 3: 4, unhashable(4): 5, sideeffect(5): 6}  # doctest: +ELLIPSIS
111
    Traceback (most recent call last):
112
    TypeError: ...unhashable...
113
    >>> L
114
    [2, 4, 5]
115
    """
116
    return {1:2, sideeffect(2): 3, 3: 4, unhashable(4): 5, sideeffect(5): 6}
117

118

119
def dict_unpacking_not_for_arg_create_a_copy():
120
    """
121
    >>> dict_unpacking_not_for_arg_create_a_copy()
122
    [('a', 'modified'), ('b', 'original')]
123
    [('a', 'original'), ('b', 'original')]
124
    """
125
    data = {'a': 'original', 'b': 'original'}
126

127
    func = lambda: {**data}
128

129
    call_once = func()
130
    call_once['a'] = 'modified'
131

132
    call_twice = func()
133

134
    print(sorted(call_once.items()))
135
    print(sorted(call_twice.items()))
136

137
def from_keys_bound(dict d, val):
138
    """
139
    https://github.com/cython/cython/issues/5051
140
    Optimization of bound method calls was breaking classmethods
141
    >>> sorted(from_keys_bound({}, 100).items())
142
    [('a', 100), ('b', 100)]
143
    >>> sorted(from_keys_bound({}, None).items())
144
    [('a', None), ('b', None)]
145
    """
146
    if val is not None:
147
        return d.fromkeys(("a", "b"), val)
148
    else:
149
        return d.fromkeys(("a", "b"))
150