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
|
# itypes
[](https://travis-ci.org/PavanTatikonda/itypes)
Basic immutable container types for Python.
A simple implementation that's designed for simplicity over performance.
Use these in circumstances where it may result in more comprehensible code,
or when you want to create custom types with restricted, immutable interfaces.
For an alternative implementation designed for performance,
please see [pyrsistent](https://github.com/tobgu/pyrsistent).
### Installation
Install using `pip`:
pip install itypes
### Instantiating dictionaries and lists.
>>> import itypes
>>> d = itypes.Dict({'a': 1, 'b': 2, 'c': 3})
>>> l = itypes.List(['a', 'b', 'c'])
### On instantiation, nested types are coerced to immutables.
>>> d = itypes.Dict({'a': 123, 'b': ['a', 'b', 'c']})
>>> d['b']
List(['a', 'b', 'c'])
### Assignments and deletions return new copies.
Methods: `set(key, value)`, `delete(key)`
>>> d2 = d.set('c', 456)
>>> d2
Dict({'a': 123, 'b': ['a', 'b', 'c'], 'c': 456})
>>> d3 = d2.delete('a')
>>> d3
Dict({'b': ['a', 'b', 'c'], 'c': 456})
### Standard assignments and deletions fail.
>>> d['z'] = 123
TypeError: 'Dict' object doesn't support item assignment
>>> del(d['c'])
TypeError: 'Dict' object doesn't support item deletion
### Nested lookups.
Method: `get_in(keys, default=None)`
>>> d['b'][-1]
'c'
>>> d['b'][5]
IndexError: list index out of range
>>> d.get_in(['b', -1])
'c'
>>> d.get_in(['b', 5])
None
### Nested assignments and deletions.
Methods: `set_in(keys, value)`, `delete_in(keys)`
>>> d2 = d.set_in(['b', 1], 'xxx')
>>> d2
Dict({'a': 123, 'b': ['a', 'xxx', 'c']})
>>> d3 = d2.delete_in(['b', 0])
>>> d3
Dict({'a': 123, 'b': ['xxx', 'c']})
### Equality works against standard types.
>>> d = itypes.Dict({'a': 1, 'b': 2, 'c': 3})
>>> d == {'a': 1, 'b': 2, 'c': 3}
True
### Objects are hashable.
>>> hash(d)
277752239
### Shortcuts for switching between mutable and immutable types.
Functions: `to_mutable(instance)`, `to_immutable(value)`
>>> value = itypes.to_mutable(d)
>>> value
{'a': 123, 'b': ['a', 'b', 'c']}
>>> itypes.to_immutable(value)
Dict({'a': 123, 'b': ['a', 'b', 'c']})
### Subclassing.
Only private attribute names may be set on instances. Use `@property` for attribute access.
Define a `.clone(self, data)` method if objects have additional state.
Example:
class Configuration(itypes.Dict):
def __init__(self, title, *args, **kwargs):
self._title = title
super(Configuration, self).__init__(*args, **kwargs)
@property
def title(self):
return self._title
def clone(self, data):
return Configuration(self._title, data)
Using the custom class:
>>> config = Configuration('worker-process', {'hostname': 'example.com', 'dynos': 4})
>>> config.title
'worker-process'
>>> new = config.set('dynos', 2)
>>> new
Configuration({'dynos': 2, 'hostname': 'example.com'})
>>> new.title
'worker-process'
### Custom immutable objects.
Subclass `itypes.Object` for an object that prevents setting public attributes.
>>> class Custom(itypes.Object):
... pass
Only private attribute names may be set on instances. Use `@property` for attribute access.
>>> class Document(itypes.Object):
... def __init__(self, title, content):
... self._title = title
... self._content = title
... @property
... def title(self):
... return self._title
... @property
... def content(self):
... return self._content
Using immutable objects:
>>> doc = Document(title='Immutability', content='For simplicity')
>>> doc.title
'Immutability'
>>> doc.title = 'Changed'
TypeError: 'Document' object doesn't support property assignment.
|
