odict.html @ a462c6a

gh-pages

Last change on this file since a462c6a was a462c6a, checked in by ajj, 9 years ago
Rebuild to fix index and modules docs
Property mode set to `100644`
File size: 160.1 KB

Line
1	<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
2	"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
3
4
5	<html xmlns="http://www.w3.org/1999/xhtml">
6	<head>
7	<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
8
9	<title>sas.data_util.odict — SasView 3.0.0 documentation</title>
10
11	<link rel="stylesheet" href="../../../_static/default.css" type="text/css" />
12	<link rel="stylesheet" href="../../../_static/pygments.css" type="text/css" />
13
14	<script type="text/javascript">
15	var DOCUMENTATION_OPTIONS = {
16	URL_ROOT: '../../../',
17	VERSION: '3.0.0',
18	COLLAPSE_INDEX: false,
19	FILE_SUFFIX: '.html',
20	HAS_SOURCE: true
21	};
22	</script>
23	<script type="text/javascript" src="../../../_static/jquery.js"></script>
24	<script type="text/javascript" src="../../../_static/underscore.js"></script>
25	<script type="text/javascript" src="../../../_static/doctools.js"></script>
26	<script type="text/javascript" src="http://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-AMS-MML_HTMLorMML"></script>
27	<link rel="top" title="SasView 3.0.0 documentation" href="../../../index.html" />
28	<link rel="up" title="Module code" href="../../index.html" />
29	</head>
30	<body>
31	<div class="related">
32	<h3>Navigation</h3>
33	<ul>
34	<li class="right" style="margin-right: 10px">
35	<a href="../../../genindex.html" title="General Index"
36	accesskey="I">index</a></li>
37	<li class="right" >
38	<a href="../../../py-modindex.html" title="Python Module Index"
39	>modules</a> \|</li>
40	<li><a href="../../../index.html">SasView 3.0.0 documentation</a> »</li>
41	<li><a href="../../index.html" accesskey="U">Module code</a> »</li>
42	</ul>
43	</div>
44
45	<div class="document">
46	<div class="documentwrapper">
47	<div class="bodywrapper">
48	<div class="body">
49
50	<h1>Source code for sas.data_util.odict</h1><div class="highlight"><pre>
51	<span class="c"># odict.py</span>
52	<span class="c"># An Ordered Dictionary object</span>
53	<span class="c"># Copyright (C) 2005 Nicola Larosa, Michael Foord</span>
54	<span class="c"># E-mail: nico AT tekNico DOT net, fuzzyman AT voidspace DOT org DOT uk</span>
55
56	<span class="c"># This software is licensed under the terms of the BSD license.</span>
57	<span class="c"># http://www.voidspace.org.uk/python/license.shtml</span>
58	<span class="c"># Basically you're free to copy, modify, distribute and relicense it,</span>
59	<span class="c"># So long as you keep a copy of the license with it.</span>
60
61	<span class="c"># Documentation at http://www.voidspace.org.uk/python/odict.html</span>
62	<span class="c"># For information about bugfixes, updates and support, please join the</span>
63	<span class="c"># Pythonutils mailing list:</span>
64	<span class="c"># http://groups.google.com/group/pythonutils/</span>
65	<span class="c"># Comments, suggestions and bug reports welcome.</span>
66
67	<span class="sd">"""A dict that keeps keys in insertion order"""</span>
68	<span class="kn">from</span> <span class="nn">__future__</span> <span class="kn">import</span> <span class="n">generators</span>
69
70	<span class="n">__author__</span> <span class="o">=</span> <span class="p">(</span><span class="s">'Nicola Larosa <nico-NoSp@m-tekNico.net>,'</span>
71	<span class="s">'Michael Foord <fuzzyman AT voidspace DOT org DOT uk>'</span><span class="p">)</span>
72
73	<span class="n">__docformat__</span> <span class="o">=</span> <span class="s">"restructuredtext en"</span>
74
75	<span class="n">__revision__</span> <span class="o">=</span> <span class="s">'$Id: odict.py 58 2008-09-02 14:09:54Z farrowch $'</span>
76
77	<span class="n">__version__</span> <span class="o">=</span> <span class="s">'0.2.2'</span>
78
79	<span class="n">__all__</span> <span class="o">=</span> <span class="p">[</span><span class="s">'OrderedDict'</span><span class="p">,</span> <span class="s">'SequenceOrderedDict'</span><span class="p">]</span>
80
81	<span class="kn">import</span> <span class="nn">sys</span>
82	<span class="n">INTP_VER</span> <span class="o">=</span> <span class="n">sys</span><span class="o">.</span><span class="n">version_info</span><span class="p">[:</span><span class="mi">2</span><span class="p">]</span>
83	<span class="k">if</span> <span class="n">INTP_VER</span> <span class="o"><</span> <span class="p">(</span><span class="mi">2</span><span class="p">,</span> <span class="mi">2</span><span class="p">):</span>
84	<span class="k">raise</span> <span class="ne">RuntimeError</span><span class="p">(</span><span class="s">"Python v.2.2 or later required"</span><span class="p">)</span>
85
86	<span class="kn">import</span> <span class="nn">types</span><span class="o">,</span> <span class="nn">warnings</span>
87
88	<div class="viewcode-block" id="OrderedDict"><a class="viewcode-back" href="../../../dev/api/sas.data_util.html#sas.data_util.odict.OrderedDict">[docs]</a><span class="k">class</span> <span class="nc">OrderedDict</span><span class="p">(</span><span class="nb">dict</span><span class="p">):</span>
89	<span class="sd">"""</span>
90	<span class="sd"> A class of dictionary that keeps the insertion order of keys.</span>
91	<span class="sd"> </span>
92	<span class="sd"> All appropriate methods return keys, items, or values in an ordered way.</span>
93	<span class="sd"> </span>
94	<span class="sd"> All normal dictionary methods are available. Update and comparison is</span>
95	<span class="sd"> restricted to other OrderedDict objects.</span>
96	<span class="sd"> </span>
97	<span class="sd"> Various sequence methods are available, including the ability to explicitly</span>
98	<span class="sd"> mutate the key ordering.</span>
99	<span class="sd"> </span>
100	<span class="sd"> __contains__ tests:</span>
101	<span class="sd"> </span>
102	<span class="sd"> >>> d = OrderedDict(((1, 3),))</span>
103	<span class="sd"> >>> 1 in d</span>
104	<span class="sd"> 1</span>
105	<span class="sd"> >>> 4 in d</span>
106	<span class="sd"> 0</span>
107	<span class="sd"> </span>
108	<span class="sd"> __getitem__ tests:</span>
109	<span class="sd"> </span>
110	<span class="sd"> >>> OrderedDict(((1, 3), (3, 2), (2, 1)))[2]</span>
111	<span class="sd"> 1</span>
112	<span class="sd"> >>> OrderedDict(((1, 3), (3, 2), (2, 1)))[4]</span>
113	<span class="sd"> Traceback (most recent call last):</span>
114	<span class="sd"> KeyError: 4</span>
115	<span class="sd"> </span>
116	<span class="sd"> __len__ tests:</span>
117	<span class="sd"> </span>
118	<span class="sd"> >>> len(OrderedDict())</span>
119	<span class="sd"> 0</span>
120	<span class="sd"> >>> len(OrderedDict(((1, 3), (3, 2), (2, 1))))</span>
121	<span class="sd"> 3</span>
122	<span class="sd"> </span>
123	<span class="sd"> get tests:</span>
124	<span class="sd"> </span>
125	<span class="sd"> >>> d = OrderedDict(((1, 3), (3, 2), (2, 1)))</span>
126	<span class="sd"> >>> d.get(1)</span>
127	<span class="sd"> 3</span>
128	<span class="sd"> >>> d.get(4) is None</span>
129	<span class="sd"> 1</span>
130	<span class="sd"> >>> d.get(4, 5)</span>
131	<span class="sd"> 5</span>
132	<span class="sd"> >>> d</span>
133	<span class="sd"> OrderedDict([(1, 3), (3, 2), (2, 1)])</span>
134	<span class="sd"> </span>
135	<span class="sd"> has_key tests:</span>
136	<span class="sd"> </span>
137	<span class="sd"> >>> d = OrderedDict(((1, 3), (3, 2), (2, 1)))</span>
138	<span class="sd"> >>> d.has_key(1)</span>
139	<span class="sd"> 1</span>
140	<span class="sd"> >>> d.has_key(4)</span>
141	<span class="sd"> 0</span>
142	<span class="sd"> """</span>
143
144	<span class="k">def</span> <span class="nf">__init__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">init_val</span><span class="o">=</span><span class="p">(),</span> <span class="n">strict</span><span class="o">=</span><span class="bp">False</span><span class="p">):</span>
145	<span class="sd">"""</span>
146	<span class="sd"> Create a new ordered dictionary. Cannot init from a normal dict,</span>
147	<span class="sd"> nor from kwargs, since items order is undefined in those cases.</span>
148	<span class="sd"> </span>
149	<span class="sd"> If the ``strict`` keyword argument is ``True`` (``False`` is the</span>
150	<span class="sd"> default) then when doing slice assignment - the ``OrderedDict`` you are</span>
151	<span class="sd"> assigning from must not contain any keys in the remaining dict.</span>
152	<span class="sd"> </span>
153	<span class="sd"> >>> OrderedDict()</span>
154	<span class="sd"> OrderedDict([])</span>
155	<span class="sd"> >>> OrderedDict({1: 1})</span>
156	<span class="sd"> Traceback (most recent call last):</span>
157	<span class="sd"> TypeError: undefined order, cannot get items from dict</span>
158	<span class="sd"> >>> OrderedDict({1: 1}.items())</span>
159	<span class="sd"> OrderedDict([(1, 1)])</span>
160	<span class="sd"> >>> d = OrderedDict(((1, 3), (3, 2), (2, 1)))</span>
161	<span class="sd"> >>> d</span>
162	<span class="sd"> OrderedDict([(1, 3), (3, 2), (2, 1)])</span>
163	<span class="sd"> >>> OrderedDict(d)</span>
164	<span class="sd"> OrderedDict([(1, 3), (3, 2), (2, 1)])</span>
165	<span class="sd"> """</span>
166	<span class="bp">self</span><span class="o">.</span><span class="n">strict</span> <span class="o">=</span> <span class="n">strict</span>
167	<span class="nb">dict</span><span class="o">.</span><span class="n">__init__</span><span class="p">(</span><span class="bp">self</span><span class="p">)</span>
168	<span class="k">if</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">init_val</span><span class="p">,</span> <span class="n">OrderedDict</span><span class="p">):</span>
169	<span class="bp">self</span><span class="o">.</span><span class="n">_sequence</span> <span class="o">=</span> <span class="n">init_val</span><span class="o">.</span><span class="n">keys</span><span class="p">()</span>
170	<span class="nb">dict</span><span class="o">.</span><span class="n">update</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">init_val</span><span class="p">)</span>
171	<span class="k">elif</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">init_val</span><span class="p">,</span> <span class="nb">dict</span><span class="p">):</span>
172	<span class="c"># we lose compatibility with other ordered dict types this way</span>
173	<span class="k">raise</span> <span class="ne">TypeError</span><span class="p">(</span><span class="s">'undefined order, cannot get items from dict'</span><span class="p">)</span>
174	<span class="k">else</span><span class="p">:</span>
175	<span class="bp">self</span><span class="o">.</span><span class="n">_sequence</span> <span class="o">=</span> <span class="p">[]</span>
176	<span class="bp">self</span><span class="o">.</span><span class="n">update</span><span class="p">(</span><span class="n">init_val</span><span class="p">)</span>
177
178	<span class="c">### Special methods ###</span>
179
180	<span class="k">def</span> <span class="nf">__delitem__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">key</span><span class="p">):</span>
181	<span class="sd">"""</span>
182	<span class="sd"> >>> d = OrderedDict(((1, 3), (3, 2), (2, 1)))</span>
183	<span class="sd"> >>> del d[3]</span>
184	<span class="sd"> >>> d</span>
185	<span class="sd"> OrderedDict([(1, 3), (2, 1)])</span>
186	<span class="sd"> >>> del d[3]</span>
187	<span class="sd"> Traceback (most recent call last):</span>
188	<span class="sd"> KeyError: 3</span>
189	<span class="sd"> >>> d[3] = 2</span>
190	<span class="sd"> >>> d</span>
191	<span class="sd"> OrderedDict([(1, 3), (2, 1), (3, 2)])</span>
192	<span class="sd"> >>> del d[0:1]</span>
193	<span class="sd"> >>> d</span>
194	<span class="sd"> OrderedDict([(2, 1), (3, 2)])</span>
195	<span class="sd"> """</span>
196	<span class="k">if</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">key</span><span class="p">,</span> <span class="n">types</span><span class="o">.</span><span class="n">SliceType</span><span class="p">):</span>
197	<span class="c"># FIXME: efficiency?</span>
198	<span class="n">keys</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="n">_sequence</span><span class="p">[</span><span class="n">key</span><span class="p">]</span>
199	<span class="k">for</span> <span class="n">entry</span> <span class="ow">in</span> <span class="n">keys</span><span class="p">:</span>
200	<span class="nb">dict</span><span class="o">.</span><span class="n">__delitem__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">entry</span><span class="p">)</span>
201	<span class="k">del</span> <span class="bp">self</span><span class="o">.</span><span class="n">_sequence</span><span class="p">[</span><span class="n">key</span><span class="p">]</span>
202	<span class="k">else</span><span class="p">:</span>
203	<span class="c"># do the dict.__delitem__ first as it raises</span>
204	<span class="c"># the more appropriate error</span>
205	<span class="nb">dict</span><span class="o">.</span><span class="n">__delitem__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">key</span><span class="p">)</span>
206	<span class="bp">self</span><span class="o">.</span><span class="n">_sequence</span><span class="o">.</span><span class="n">remove</span><span class="p">(</span><span class="n">key</span><span class="p">)</span>
207
208	<span class="k">def</span> <span class="nf">__eq__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">other</span><span class="p">):</span>
209	<span class="sd">"""</span>
210	<span class="sd"> >>> d = OrderedDict(((1, 3), (3, 2), (2, 1)))</span>
211	<span class="sd"> >>> d == OrderedDict(d)</span>
212	<span class="sd"> True</span>
213	<span class="sd"> >>> d == OrderedDict(((1, 3), (2, 1), (3, 2)))</span>
214	<span class="sd"> False</span>
215	<span class="sd"> >>> d == OrderedDict(((1, 0), (3, 2), (2, 1)))</span>
216	<span class="sd"> False</span>
217	<span class="sd"> >>> d == OrderedDict(((0, 3), (3, 2), (2, 1)))</span>
218	<span class="sd"> False</span>
219	<span class="sd"> >>> d == dict(d)</span>
220	<span class="sd"> False</span>
221	<span class="sd"> >>> d == False</span>
222	<span class="sd"> False</span>
223	<span class="sd"> """</span>
224	<span class="k">if</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">other</span><span class="p">,</span> <span class="n">OrderedDict</span><span class="p">):</span>
225	<span class="c"># FIXME: efficiency?</span>
226	<span class="c"># Generate both item lists for each compare</span>
227	<span class="k">return</span> <span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">items</span><span class="p">()</span> <span class="o">==</span> <span class="n">other</span><span class="o">.</span><span class="n">items</span><span class="p">())</span>
228	<span class="k">else</span><span class="p">:</span>
229	<span class="k">return</span> <span class="bp">False</span>
230
231	<span class="k">def</span> <span class="nf">__lt__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">other</span><span class="p">):</span>
232	<span class="sd">"""</span>
233	<span class="sd"> >>> d = OrderedDict(((1, 3), (3, 2), (2, 1)))</span>
234	<span class="sd"> >>> c = OrderedDict(((0, 3), (3, 2), (2, 1)))</span>
235	<span class="sd"> >>> c < d</span>
236	<span class="sd"> True</span>
237	<span class="sd"> >>> d < c</span>
238	<span class="sd"> False</span>
239	<span class="sd"> >>> d < dict(c)</span>
240	<span class="sd"> Traceback (most recent call last):</span>
241	<span class="sd"> TypeError: Can only compare with other OrderedDicts</span>
242	<span class="sd"> """</span>
243	<span class="k">if</span> <span class="ow">not</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">other</span><span class="p">,</span> <span class="n">OrderedDict</span><span class="p">):</span>
244	<span class="k">raise</span> <span class="ne">TypeError</span><span class="p">(</span><span class="s">'Can only compare with other OrderedDicts'</span><span class="p">)</span>
245	<span class="c"># FIXME: efficiency?</span>
246	<span class="c"># Generate both item lists for each compare</span>
247	<span class="k">return</span> <span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">items</span><span class="p">()</span> <span class="o"><</span> <span class="n">other</span><span class="o">.</span><span class="n">items</span><span class="p">())</span>
248
249	<span class="k">def</span> <span class="nf">__le__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">other</span><span class="p">):</span>
250	<span class="sd">"""</span>
251	<span class="sd"> >>> d = OrderedDict(((1, 3), (3, 2), (2, 1)))</span>
252	<span class="sd"> >>> c = OrderedDict(((0, 3), (3, 2), (2, 1)))</span>
253	<span class="sd"> >>> e = OrderedDict(d)</span>
254	<span class="sd"> >>> c <= d</span>
255	<span class="sd"> True</span>
256	<span class="sd"> >>> d <= c</span>
257	<span class="sd"> False</span>
258	<span class="sd"> >>> d <= dict(c)</span>
259	<span class="sd"> Traceback (most recent call last):</span>
260	<span class="sd"> TypeError: Can only compare with other OrderedDicts</span>
261	<span class="sd"> >>> d <= e</span>
262	<span class="sd"> True</span>
263	<span class="sd"> """</span>
264	<span class="k">if</span> <span class="ow">not</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">other</span><span class="p">,</span> <span class="n">OrderedDict</span><span class="p">):</span>
265	<span class="k">raise</span> <span class="ne">TypeError</span><span class="p">(</span><span class="s">'Can only compare with other OrderedDicts'</span><span class="p">)</span>
266	<span class="c"># FIXME: efficiency?</span>
267	<span class="c"># Generate both item lists for each compare</span>
268	<span class="k">return</span> <span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">items</span><span class="p">()</span> <span class="o"><=</span> <span class="n">other</span><span class="o">.</span><span class="n">items</span><span class="p">())</span>
269
270	<span class="k">def</span> <span class="nf">__ne__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">other</span><span class="p">):</span>
271	<span class="sd">"""</span>
272	<span class="sd"> >>> d = OrderedDict(((1, 3), (3, 2), (2, 1)))</span>
273	<span class="sd"> >>> d != OrderedDict(d)</span>
274	<span class="sd"> False</span>
275	<span class="sd"> >>> d != OrderedDict(((1, 3), (2, 1), (3, 2)))</span>
276	<span class="sd"> True</span>
277	<span class="sd"> >>> d != OrderedDict(((1, 0), (3, 2), (2, 1)))</span>
278	<span class="sd"> True</span>
279	<span class="sd"> >>> d == OrderedDict(((0, 3), (3, 2), (2, 1)))</span>
280	<span class="sd"> False</span>
281	<span class="sd"> >>> d != dict(d)</span>
282	<span class="sd"> True</span>
283	<span class="sd"> >>> d != False</span>
284	<span class="sd"> True</span>
285	<span class="sd"> """</span>
286	<span class="k">if</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">other</span><span class="p">,</span> <span class="n">OrderedDict</span><span class="p">):</span>
287	<span class="c"># FIXME: efficiency?</span>
288	<span class="c"># Generate both item lists for each compare</span>
289	<span class="k">return</span> <span class="ow">not</span> <span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">items</span><span class="p">()</span> <span class="o">==</span> <span class="n">other</span><span class="o">.</span><span class="n">items</span><span class="p">())</span>
290	<span class="k">else</span><span class="p">:</span>
291	<span class="k">return</span> <span class="bp">True</span>
292
293	<span class="k">def</span> <span class="nf">__gt__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">other</span><span class="p">):</span>
294	<span class="sd">"""</span>
295	<span class="sd"> >>> d = OrderedDict(((1, 3), (3, 2), (2, 1)))</span>
296	<span class="sd"> >>> c = OrderedDict(((0, 3), (3, 2), (2, 1)))</span>
297	<span class="sd"> >>> d > c</span>
298	<span class="sd"> True</span>
299	<span class="sd"> >>> c > d</span>
300	<span class="sd"> False</span>
301	<span class="sd"> >>> d > dict(c)</span>
302	<span class="sd"> Traceback (most recent call last):</span>
303	<span class="sd"> TypeError: Can only compare with other OrderedDicts</span>
304	<span class="sd"> """</span>
305	<span class="k">if</span> <span class="ow">not</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">other</span><span class="p">,</span> <span class="n">OrderedDict</span><span class="p">):</span>
306	<span class="k">raise</span> <span class="ne">TypeError</span><span class="p">(</span><span class="s">'Can only compare with other OrderedDicts'</span><span class="p">)</span>
307	<span class="c"># FIXME: efficiency?</span>
308	<span class="c"># Generate both item lists for each compare</span>
309	<span class="k">return</span> <span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">items</span><span class="p">()</span> <span class="o">></span> <span class="n">other</span><span class="o">.</span><span class="n">items</span><span class="p">())</span>
310
311	<span class="k">def</span> <span class="nf">__ge__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">other</span><span class="p">):</span>
312	<span class="sd">"""</span>
313	<span class="sd"> >>> d = OrderedDict(((1, 3), (3, 2), (2, 1)))</span>
314	<span class="sd"> >>> c = OrderedDict(((0, 3), (3, 2), (2, 1)))</span>
315	<span class="sd"> >>> e = OrderedDict(d)</span>
316	<span class="sd"> >>> c >= d</span>
317	<span class="sd"> False</span>
318	<span class="sd"> >>> d >= c</span>
319	<span class="sd"> True</span>
320	<span class="sd"> >>> d >= dict(c)</span>
321	<span class="sd"> Traceback (most recent call last):</span>
322	<span class="sd"> TypeError: Can only compare with other OrderedDicts</span>
323	<span class="sd"> >>> e >= d</span>
324	<span class="sd"> True</span>
325	<span class="sd"> """</span>
326	<span class="k">if</span> <span class="ow">not</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">other</span><span class="p">,</span> <span class="n">OrderedDict</span><span class="p">):</span>
327	<span class="k">raise</span> <span class="ne">TypeError</span><span class="p">(</span><span class="s">'Can only compare with other OrderedDicts'</span><span class="p">)</span>
328	<span class="c"># FIXME: efficiency?</span>
329	<span class="c"># Generate both item lists for each compare</span>
330	<span class="k">return</span> <span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">items</span><span class="p">()</span> <span class="o">>=</span> <span class="n">other</span><span class="o">.</span><span class="n">items</span><span class="p">())</span>
331
332	<span class="k">def</span> <span class="nf">__repr__</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
333	<span class="sd">"""</span>
334	<span class="sd"> Used for __repr__ and __str__</span>
335	<span class="sd"> </span>
336	<span class="sd"> >>> r1 = repr(OrderedDict((('a', 'b'), ('c', 'd'), ('e', 'f'))))</span>
337	<span class="sd"> >>> r1</span>
338	<span class="sd"> "OrderedDict([('a', 'b'), ('c', 'd'), ('e', 'f')])"</span>
339	<span class="sd"> >>> r2 = repr(OrderedDict((('a', 'b'), ('e', 'f'), ('c', 'd'))))</span>
340	<span class="sd"> >>> r2</span>
341	<span class="sd"> "OrderedDict([('a', 'b'), ('e', 'f'), ('c', 'd')])"</span>
342	<span class="sd"> >>> r1 == str(OrderedDict((('a', 'b'), ('c', 'd'), ('e', 'f'))))</span>
343	<span class="sd"> True</span>
344	<span class="sd"> >>> r2 == str(OrderedDict((('a', 'b'), ('e', 'f'), ('c', 'd'))))</span>
345	<span class="sd"> True</span>
346	<span class="sd"> """</span>
347	<span class="k">return</span> <span class="s">'</span><span class="si">%s</span><span class="s">([</span><span class="si">%s</span><span class="s">])'</span> <span class="o">%</span> <span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">__class__</span><span class="o">.</span><span class="n">__name__</span><span class="p">,</span> <span class="s">', '</span><span class="o">.</span><span class="n">join</span><span class="p">(</span>
348	<span class="p">[</span><span class="s">'(</span><span class="si">%r</span><span class="s">, </span><span class="si">%r</span><span class="s">)'</span> <span class="o">%</span> <span class="p">(</span><span class="n">key</span><span class="p">,</span> <span class="bp">self</span><span class="p">[</span><span class="n">key</span><span class="p">])</span> <span class="k">for</span> <span class="n">key</span> <span class="ow">in</span> <span class="bp">self</span><span class="o">.</span><span class="n">_sequence</span><span class="p">]))</span>
349
350	<span class="k">def</span> <span class="nf">__setitem__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">key</span><span class="p">,</span> <span class="n">val</span><span class="p">):</span>
351	<span class="sd">"""</span>
352	<span class="sd"> Allows slice assignment, so long as the slice is an OrderedDict</span>
353	<span class="sd"> >>> d = OrderedDict()</span>
354	<span class="sd"> >>> d['a'] = 'b'</span>
355	<span class="sd"> >>> d['b'] = 'a'</span>
356	<span class="sd"> >>> d[3] = 12</span>
357	<span class="sd"> >>> d</span>
358	<span class="sd"> OrderedDict([('a', 'b'), ('b', 'a'), (3, 12)])</span>
359	<span class="sd"> >>> d[:] = OrderedDict(((1, 2), (2, 3), (3, 4)))</span>
360	<span class="sd"> >>> d</span>
361	<span class="sd"> OrderedDict([(1, 2), (2, 3), (3, 4)])</span>
362	<span class="sd"> >>> d[::2] = OrderedDict(((7, 8), (9, 10)))</span>
363	<span class="sd"> >>> d</span>
364	<span class="sd"> OrderedDict([(7, 8), (2, 3), (9, 10)])</span>
365	<span class="sd"> >>> d = OrderedDict(((0, 1), (1, 2), (2, 3), (3, 4)))</span>
366	<span class="sd"> >>> d[1:3] = OrderedDict(((1, 2), (5, 6), (7, 8)))</span>
367	<span class="sd"> >>> d</span>
368	<span class="sd"> OrderedDict([(0, 1), (1, 2), (5, 6), (7, 8), (3, 4)])</span>
369	<span class="sd"> >>> d = OrderedDict(((0, 1), (1, 2), (2, 3), (3, 4)), strict=True)</span>
370	<span class="sd"> >>> d[1:3] = OrderedDict(((1, 2), (5, 6), (7, 8)))</span>
371	<span class="sd"> >>> d</span>
372	<span class="sd"> OrderedDict([(0, 1), (1, 2), (5, 6), (7, 8), (3, 4)])</span>
373	<span class="sd"> </span>
374	<span class="sd"> >>> a = OrderedDict(((0, 1), (1, 2), (2, 3)), strict=True)</span>
375	<span class="sd"> >>> a[3] = 4</span>
376	<span class="sd"> >>> a</span>
377	<span class="sd"> OrderedDict([(0, 1), (1, 2), (2, 3), (3, 4)])</span>
378	<span class="sd"> >>> a[::1] = OrderedDict([(0, 1), (1, 2), (2, 3), (3, 4)])</span>
379	<span class="sd"> >>> a</span>
380	<span class="sd"> OrderedDict([(0, 1), (1, 2), (2, 3), (3, 4)])</span>
381	<span class="sd"> >>> a[:2] = OrderedDict([(0, 1), (1, 2), (2, 3), (3, 4), (4, 5)])</span>
382	<span class="sd"> Traceback (most recent call last):</span>
383	<span class="sd"> ValueError: slice assignment must be from unique keys</span>
384	<span class="sd"> >>> a = OrderedDict(((0, 1), (1, 2), (2, 3)))</span>
385	<span class="sd"> >>> a[3] = 4</span>
386	<span class="sd"> >>> a</span>
387	<span class="sd"> OrderedDict([(0, 1), (1, 2), (2, 3), (3, 4)])</span>
388	<span class="sd"> >>> a[::1] = OrderedDict([(0, 1), (1, 2), (2, 3), (3, 4)])</span>
389	<span class="sd"> >>> a</span>
390	<span class="sd"> OrderedDict([(0, 1), (1, 2), (2, 3), (3, 4)])</span>
391	<span class="sd"> >>> a[:2] = OrderedDict([(0, 1), (1, 2), (2, 3), (3, 4)])</span>
392	<span class="sd"> >>> a</span>
393	<span class="sd"> OrderedDict([(0, 1), (1, 2), (2, 3), (3, 4)])</span>
394	<span class="sd"> >>> a[::-1] = OrderedDict([(0, 1), (1, 2), (2, 3), (3, 4)])</span>
395	<span class="sd"> >>> a</span>
396	<span class="sd"> OrderedDict([(3, 4), (2, 3), (1, 2), (0, 1)])</span>
397	<span class="sd"> </span>
398	<span class="sd"> >>> d = OrderedDict([(0, 1), (1, 2), (2, 3), (3, 4)])</span>
399	<span class="sd"> >>> d[:1] = 3</span>
400	<span class="sd"> Traceback (most recent call last):</span>
401	<span class="sd"> TypeError: slice assignment requires an OrderedDict</span>
402	<span class="sd"> </span>
403	<span class="sd"> >>> d = OrderedDict([(0, 1), (1, 2), (2, 3), (3, 4)])</span>
404	<span class="sd"> >>> d[:1] = OrderedDict([(9, 8)])</span>
405	<span class="sd"> >>> d</span>
406	<span class="sd"> OrderedDict([(9, 8), (1, 2), (2, 3), (3, 4)])</span>
407	<span class="sd"> """</span>
408	<span class="k">if</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">key</span><span class="p">,</span> <span class="n">types</span><span class="o">.</span><span class="n">SliceType</span><span class="p">):</span>
409	<span class="k">if</span> <span class="ow">not</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">val</span><span class="p">,</span> <span class="n">OrderedDict</span><span class="p">):</span>
410	<span class="c"># FIXME: allow a list of tuples?</span>
411	<span class="k">raise</span> <span class="ne">TypeError</span><span class="p">(</span><span class="s">'slice assignment requires an OrderedDict'</span><span class="p">)</span>
412	<span class="n">keys</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="n">_sequence</span><span class="p">[</span><span class="n">key</span><span class="p">]</span>
413	<span class="c"># NOTE: Could use ``range(*key.indices(len(self._sequence)))``</span>
414	<span class="n">indexes</span> <span class="o">=</span> <span class="nb">range</span><span class="p">(</span><span class="nb">len</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">_sequence</span><span class="p">))[</span><span class="n">key</span><span class="p">]</span>
415	<span class="k">if</span> <span class="n">key</span><span class="o">.</span><span class="n">step</span> <span class="ow">is</span> <span class="bp">None</span><span class="p">:</span>
416	<span class="c"># NOTE: new slice may not be the same size as the one being</span>
417	<span class="c"># overwritten !</span>
418	<span class="c"># NOTE: What is the algorithm for an impossible slice?</span>
419	<span class="c"># e.g. d[5:3]</span>
420	<span class="n">pos</span> <span class="o">=</span> <span class="n">key</span><span class="o">.</span><span class="n">start</span> <span class="ow">or</span> <span class="mi">0</span>
421	<span class="k">del</span> <span class="bp">self</span><span class="p">[</span><span class="n">key</span><span class="p">]</span>
422	<span class="n">newkeys</span> <span class="o">=</span> <span class="n">val</span><span class="o">.</span><span class="n">keys</span><span class="p">()</span>
423	<span class="k">for</span> <span class="n">k</span> <span class="ow">in</span> <span class="n">newkeys</span><span class="p">:</span>
424	<span class="k">if</span> <span class="n">k</span> <span class="ow">in</span> <span class="bp">self</span><span class="p">:</span>
425	<span class="k">if</span> <span class="bp">self</span><span class="o">.</span><span class="n">strict</span><span class="p">:</span>
426	<span class="k">raise</span> <span class="ne">ValueError</span><span class="p">(</span><span class="s">'slice assignment must be from '</span>
427	<span class="s">'unique keys'</span><span class="p">)</span>
428	<span class="k">else</span><span class="p">:</span>
429	<span class="c"># NOTE: This removes duplicate keys first</span>
430	<span class="c"># so start position might have changed?</span>
431	<span class="k">del</span> <span class="bp">self</span><span class="p">[</span><span class="n">k</span><span class="p">]</span>
432	<span class="bp">self</span><span class="o">.</span><span class="n">_sequence</span> <span class="o">=</span> <span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">_sequence</span><span class="p">[:</span><span class="n">pos</span><span class="p">]</span> <span class="o">+</span> <span class="n">newkeys</span> <span class="o">+</span>
433	<span class="bp">self</span><span class="o">.</span><span class="n">_sequence</span><span class="p">[</span><span class="n">pos</span><span class="p">:])</span>
434	<span class="nb">dict</span><span class="o">.</span><span class="n">update</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">val</span><span class="p">)</span>
435	<span class="k">else</span><span class="p">:</span>
436	<span class="c"># extended slice - length of new slice must be the same</span>
437	<span class="c"># as the one being replaced</span>
438	<span class="k">if</span> <span class="nb">len</span><span class="p">(</span><span class="n">keys</span><span class="p">)</span> <span class="o">!=</span> <span class="nb">len</span><span class="p">(</span><span class="n">val</span><span class="p">):</span>
439	<span class="k">raise</span> <span class="ne">ValueError</span><span class="p">(</span><span class="s">'attempt to assign sequence of size </span><span class="si">%s</span><span class="s"> '</span>
440	<span class="s">'to extended slice of size </span><span class="si">%s</span><span class="s">'</span> <span class="o">%</span> <span class="p">(</span><span class="nb">len</span><span class="p">(</span><span class="n">val</span><span class="p">),</span> <span class="nb">len</span><span class="p">(</span><span class="n">keys</span><span class="p">)))</span>
441	<span class="c"># FIXME: efficiency?</span>
442	<span class="k">del</span> <span class="bp">self</span><span class="p">[</span><span class="n">key</span><span class="p">]</span>
443	<span class="n">item_list</span> <span class="o">=</span> <span class="nb">zip</span><span class="p">(</span><span class="n">indexes</span><span class="p">,</span> <span class="n">val</span><span class="o">.</span><span class="n">items</span><span class="p">())</span>
444	<span class="c"># smallest indexes first - higher indexes not guaranteed to</span>
445	<span class="c"># exist</span>
446	<span class="n">item_list</span><span class="o">.</span><span class="n">sort</span><span class="p">()</span>
447	<span class="k">for</span> <span class="n">pos</span><span class="p">,</span> <span class="p">(</span><span class="n">newkey</span><span class="p">,</span> <span class="n">newval</span><span class="p">)</span> <span class="ow">in</span> <span class="n">item_list</span><span class="p">:</span>
448	<span class="k">if</span> <span class="bp">self</span><span class="o">.</span><span class="n">strict</span> <span class="ow">and</span> <span class="n">newkey</span> <span class="ow">in</span> <span class="bp">self</span><span class="p">:</span>
449	<span class="k">raise</span> <span class="ne">ValueError</span><span class="p">(</span><span class="s">'slice assignment must be from unique'</span>
450	<span class="s">' keys'</span><span class="p">)</span>
451	<span class="bp">self</span><span class="o">.</span><span class="n">insert</span><span class="p">(</span><span class="n">pos</span><span class="p">,</span> <span class="n">newkey</span><span class="p">,</span> <span class="n">newval</span><span class="p">)</span>
452	<span class="k">else</span><span class="p">:</span>
453	<span class="k">if</span> <span class="n">key</span> <span class="ow">not</span> <span class="ow">in</span> <span class="bp">self</span><span class="p">:</span>
454	<span class="bp">self</span><span class="o">.</span><span class="n">_sequence</span><span class="o">.</span><span class="n">append</span><span class="p">(</span><span class="n">key</span><span class="p">)</span>
455	<span class="nb">dict</span><span class="o">.</span><span class="n">__setitem__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">key</span><span class="p">,</span> <span class="n">val</span><span class="p">)</span>
456
457	<span class="k">def</span> <span class="nf">__getitem__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">key</span><span class="p">):</span>
458	<span class="sd">"""</span>
459	<span class="sd"> Allows slicing. Returns an OrderedDict if you slice.</span>
460	<span class="sd"> >>> b = OrderedDict([(7, 0), (6, 1), (5, 2), (4, 3), (3, 4), (2, 5), (1, 6)])</span>
461	<span class="sd"> >>> b[::-1]</span>
462	<span class="sd"> OrderedDict([(1, 6), (2, 5), (3, 4), (4, 3), (5, 2), (6, 1), (7, 0)])</span>
463	<span class="sd"> >>> b[2:5]</span>
464	<span class="sd"> OrderedDict([(5, 2), (4, 3), (3, 4)])</span>
465	<span class="sd"> >>> type(b[2:4])</span>
466	<span class="sd"> <class '__main__.OrderedDict'></span>
467	<span class="sd"> """</span>
468	<span class="k">if</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">key</span><span class="p">,</span> <span class="n">types</span><span class="o">.</span><span class="n">SliceType</span><span class="p">):</span>
469	<span class="c"># FIXME: does this raise the error we want?</span>
470	<span class="n">keys</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="n">_sequence</span><span class="p">[</span><span class="n">key</span><span class="p">]</span>
471	<span class="c"># FIXME: efficiency?</span>
472	<span class="k">return</span> <span class="n">OrderedDict</span><span class="p">([(</span><span class="n">entry</span><span class="p">,</span> <span class="bp">self</span><span class="p">[</span><span class="n">entry</span><span class="p">])</span> <span class="k">for</span> <span class="n">entry</span> <span class="ow">in</span> <span class="n">keys</span><span class="p">])</span>
473	<span class="k">else</span><span class="p">:</span>
474	<span class="k">return</span> <span class="nb">dict</span><span class="o">.</span><span class="n">__getitem__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">key</span><span class="p">)</span>
475
476	<span class="n">__str__</span> <span class="o">=</span> <span class="n">__repr__</span>
477
478	<span class="k">def</span> <span class="nf">__setattr__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">name</span><span class="p">,</span> <span class="n">value</span><span class="p">):</span>
479	<span class="sd">"""</span>
480	<span class="sd"> Implemented so that accesses to ``sequence`` raise a warning and are</span>
481	<span class="sd"> diverted to the new ``setkeys`` method.</span>
482	<span class="sd"> """</span>
483	<span class="k">if</span> <span class="n">name</span> <span class="o">==</span> <span class="s">'sequence'</span><span class="p">:</span>
484	<span class="n">warnings</span><span class="o">.</span><span class="n">warn</span><span class="p">(</span><span class="s">'Use of the sequence attribute is deprecated.'</span>
485	<span class="s">' Use the keys method instead.'</span><span class="p">,</span> <span class="ne">DeprecationWarning</span><span class="p">)</span>
486	<span class="c"># NOTE: doesn't return anything</span>
487	<span class="bp">self</span><span class="o">.</span><span class="n">setkeys</span><span class="p">(</span><span class="n">value</span><span class="p">)</span>
488	<span class="k">else</span><span class="p">:</span>
489	<span class="c"># FIXME: do we want to allow arbitrary setting of attributes?</span>
490	<span class="c"># Or do we want to manage it?</span>
491	<span class="nb">object</span><span class="o">.</span><span class="n">__setattr__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">name</span><span class="p">,</span> <span class="n">value</span><span class="p">)</span>
492
493	<span class="k">def</span> <span class="nf">__getattr__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">name</span><span class="p">):</span>
494	<span class="sd">"""</span>
495	<span class="sd"> Implemented so that access to ``sequence`` raises a warning.</span>
496	<span class="sd"> </span>
497	<span class="sd"> >>> d = OrderedDict()</span>
498	<span class="sd"> >>> d.sequence</span>
499	<span class="sd"> []</span>
500	<span class="sd"> """</span>
501	<span class="k">if</span> <span class="n">name</span> <span class="o">==</span> <span class="s">'sequence'</span><span class="p">:</span>
502	<span class="n">warnings</span><span class="o">.</span><span class="n">warn</span><span class="p">(</span><span class="s">'Use of the sequence attribute is deprecated.'</span>
503	<span class="s">' Use the keys method instead.'</span><span class="p">,</span> <span class="ne">DeprecationWarning</span><span class="p">)</span>
504	<span class="c"># NOTE: Still (currently) returns a direct reference. Need to</span>
505	<span class="c"># because code that uses sequence will expect to be able to</span>
506	<span class="c"># mutate it in place.</span>
507	<span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="n">_sequence</span>
508	<span class="k">else</span><span class="p">:</span>
509	<span class="c"># raise the appropriate error</span>
510	<span class="k">raise</span> <span class="ne">AttributeError</span><span class="p">(</span><span class="s">"OrderedDict has no '</span><span class="si">%s</span><span class="s">' attribute"</span> <span class="o">%</span> <span class="n">name</span><span class="p">)</span>
511
512	<span class="k">def</span> <span class="nf">__deepcopy__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">memo</span><span class="p">):</span>
513	<span class="sd">"""</span>
514	<span class="sd"> To allow deepcopy to work with OrderedDict.</span>
515	<span class="sd"> </span>
516	<span class="sd"> >>> from copy import deepcopy</span>
517	<span class="sd"> >>> a = OrderedDict([(1, 1), (2, 2), (3, 3)])</span>
518	<span class="sd"> >>> a['test'] = {}</span>
519	<span class="sd"> >>> b = deepcopy(a)</span>
520	<span class="sd"> >>> b == a</span>
521	<span class="sd"> True</span>
522	<span class="sd"> >>> b is a</span>
523	<span class="sd"> False</span>
524	<span class="sd"> >>> a['test'] is b['test']</span>
525	<span class="sd"> False</span>
526	<span class="sd"> """</span>
527	<span class="kn">from</span> <span class="nn">copy</span> <span class="kn">import</span> <span class="n">deepcopy</span>
528	<span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="n">__class__</span><span class="p">(</span><span class="n">deepcopy</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">items</span><span class="p">(),</span> <span class="n">memo</span><span class="p">),</span> <span class="bp">self</span><span class="o">.</span><span class="n">strict</span><span class="p">)</span>
529
530
531	<span class="c">### Read-only methods ###</span>
532
533	<div class="viewcode-block" id="OrderedDict.copy"><a class="viewcode-back" href="../../../dev/api/sas.data_util.html#sas.data_util.odict.OrderedDict.copy">[docs]</a> <span class="k">def</span> <span class="nf">copy</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
534	<span class="sd">"""</span>
535	<span class="sd"> >>> OrderedDict(((1, 3), (3, 2), (2, 1))).copy()</span>
536	<span class="sd"> OrderedDict([(1, 3), (3, 2), (2, 1)])</span>
537	<span class="sd"> """</span>
538	<span class="k">return</span> <span class="n">OrderedDict</span><span class="p">(</span><span class="bp">self</span><span class="p">)</span>
539	</div>
540	<div class="viewcode-block" id="OrderedDict.items"><a class="viewcode-back" href="../../../dev/api/sas.data_util.html#sas.data_util.odict.OrderedDict.items">[docs]</a> <span class="k">def</span> <span class="nf">items</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
541	<span class="sd">"""</span>
542	<span class="sd"> ``items`` returns a list of tuples representing all the </span>
543	<span class="sd"> ``(key, value)`` pairs in the dictionary.</span>
544	<span class="sd"> </span>
545	<span class="sd"> >>> d = OrderedDict(((1, 3), (3, 2), (2, 1)))</span>
546	<span class="sd"> >>> d.items()</span>
547	<span class="sd"> [(1, 3), (3, 2), (2, 1)]</span>
548	<span class="sd"> >>> d.clear()</span>
549	<span class="sd"> >>> d.items()</span>
550	<span class="sd"> []</span>
551	<span class="sd"> """</span>
552	<span class="k">return</span> <span class="nb">zip</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">_sequence</span><span class="p">,</span> <span class="bp">self</span><span class="o">.</span><span class="n">values</span><span class="p">())</span>
553	</div>
554	<div class="viewcode-block" id="OrderedDict.keys"><a class="viewcode-back" href="../../../dev/api/sas.data_util.html#sas.data_util.odict.OrderedDict.keys">[docs]</a> <span class="k">def</span> <span class="nf">keys</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
555	<span class="sd">"""</span>
556	<span class="sd"> Return a list of keys in the ``OrderedDict``.</span>
557	<span class="sd"> </span>
558	<span class="sd"> >>> d = OrderedDict(((1, 3), (3, 2), (2, 1)))</span>
559	<span class="sd"> >>> d.keys()</span>
560	<span class="sd"> [1, 3, 2]</span>
561	<span class="sd"> """</span>
562	<span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="n">_sequence</span><span class="p">[:]</span>
563	</div>
564	<div class="viewcode-block" id="OrderedDict.values"><a class="viewcode-back" href="../../../dev/api/sas.data_util.html#sas.data_util.odict.OrderedDict.values">[docs]</a> <span class="k">def</span> <span class="nf">values</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">values</span><span class="o">=</span><span class="bp">None</span><span class="p">):</span>
565	<span class="sd">"""</span>
566	<span class="sd"> Return a list of all the values in the OrderedDict.</span>
567	<span class="sd"> </span>
568	<span class="sd"> Optionally you can pass in a list of values, which will replace the</span>
569	<span class="sd"> current list. The value list must be the same len as the OrderedDict.</span>
570	<span class="sd"> </span>
571	<span class="sd"> >>> d = OrderedDict(((1, 3), (3, 2), (2, 1)))</span>
572	<span class="sd"> >>> d.values()</span>
573	<span class="sd"> [3, 2, 1]</span>
574	<span class="sd"> """</span>
575	<span class="k">return</span> <span class="p">[</span><span class="bp">self</span><span class="p">[</span><span class="n">key</span><span class="p">]</span> <span class="k">for</span> <span class="n">key</span> <span class="ow">in</span> <span class="bp">self</span><span class="o">.</span><span class="n">_sequence</span><span class="p">]</span>
576	</div>
577	<div class="viewcode-block" id="OrderedDict.iteritems"><a class="viewcode-back" href="../../../dev/api/sas.data_util.html#sas.data_util.odict.OrderedDict.iteritems">[docs]</a> <span class="k">def</span> <span class="nf">iteritems</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
578	<span class="sd">"""</span>
579	<span class="sd"> >>> ii = OrderedDict(((1, 3), (3, 2), (2, 1))).iteritems()</span>
580	<span class="sd"> >>> ii.next()</span>
581	<span class="sd"> (1, 3)</span>
582	<span class="sd"> >>> ii.next()</span>
583	<span class="sd"> (3, 2)</span>
584	<span class="sd"> >>> ii.next()</span>
585	<span class="sd"> (2, 1)</span>
586	<span class="sd"> >>> ii.next()</span>
587	<span class="sd"> Traceback (most recent call last):</span>
588	<span class="sd"> StopIteration</span>
589	<span class="sd"> """</span>
590	<span class="k">def</span> <span class="nf">make_iter</span><span class="p">(</span><span class="bp">self</span><span class="o">=</span><span class="bp">self</span><span class="p">):</span>
591	<span class="n">keys</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="n">iterkeys</span><span class="p">()</span>
592	<span class="k">while</span> <span class="bp">True</span><span class="p">:</span>
593	<span class="n">key</span> <span class="o">=</span> <span class="n">keys</span><span class="o">.</span><span class="n">next</span><span class="p">()</span>
594	<span class="k">yield</span> <span class="p">(</span><span class="n">key</span><span class="p">,</span> <span class="bp">self</span><span class="p">[</span><span class="n">key</span><span class="p">])</span>
595	<span class="k">return</span> <span class="n">make_iter</span><span class="p">()</span>
596	</div>
597	<div class="viewcode-block" id="OrderedDict.iterkeys"><a class="viewcode-back" href="../../../dev/api/sas.data_util.html#sas.data_util.odict.OrderedDict.iterkeys">[docs]</a> <span class="k">def</span> <span class="nf">iterkeys</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
598	<span class="sd">"""</span>
599	<span class="sd"> >>> ii = OrderedDict(((1, 3), (3, 2), (2, 1))).iterkeys()</span>
600	<span class="sd"> >>> ii.next()</span>
601	<span class="sd"> 1</span>
602	<span class="sd"> >>> ii.next()</span>
603	<span class="sd"> 3</span>
604	<span class="sd"> >>> ii.next()</span>
605	<span class="sd"> 2</span>
606	<span class="sd"> >>> ii.next()</span>
607	<span class="sd"> Traceback (most recent call last):</span>
608	<span class="sd"> StopIteration</span>
609	<span class="sd"> """</span>
610	<span class="k">return</span> <span class="nb">iter</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">_sequence</span><span class="p">)</span>
611	</div>
612	<span class="n">__iter__</span> <span class="o">=</span> <span class="n">iterkeys</span>
613
614	<div class="viewcode-block" id="OrderedDict.itervalues"><a class="viewcode-back" href="../../../dev/api/sas.data_util.html#sas.data_util.odict.OrderedDict.itervalues">[docs]</a> <span class="k">def</span> <span class="nf">itervalues</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
615	<span class="sd">"""</span>
616	<span class="sd"> >>> iv = OrderedDict(((1, 3), (3, 2), (2, 1))).itervalues()</span>
617	<span class="sd"> >>> iv.next()</span>
618	<span class="sd"> 3</span>
619	<span class="sd"> >>> iv.next()</span>
620	<span class="sd"> 2</span>
621	<span class="sd"> >>> iv.next()</span>
622	<span class="sd"> 1</span>
623	<span class="sd"> >>> iv.next()</span>
624	<span class="sd"> Traceback (most recent call last):</span>
625	<span class="sd"> StopIteration</span>
626	<span class="sd"> """</span>
627	<span class="k">def</span> <span class="nf">make_iter</span><span class="p">(</span><span class="bp">self</span><span class="o">=</span><span class="bp">self</span><span class="p">):</span>
628	<span class="n">keys</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="n">iterkeys</span><span class="p">()</span>
629	<span class="k">while</span> <span class="bp">True</span><span class="p">:</span>
630	<span class="k">yield</span> <span class="bp">self</span><span class="p">[</span><span class="n">keys</span><span class="o">.</span><span class="n">next</span><span class="p">()]</span>
631	<span class="k">return</span> <span class="n">make_iter</span><span class="p">()</span>
632
633	<span class="c">### Read-write methods ###</span>
634	</div>
635	<div class="viewcode-block" id="OrderedDict.clear"><a class="viewcode-back" href="../../../dev/api/sas.data_util.html#sas.data_util.odict.OrderedDict.clear">[docs]</a> <span class="k">def</span> <span class="nf">clear</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
636	<span class="sd">"""</span>
637	<span class="sd"> >>> d = OrderedDict(((1, 3), (3, 2), (2, 1)))</span>
638	<span class="sd"> >>> d.clear()</span>
639	<span class="sd"> >>> d</span>
640	<span class="sd"> OrderedDict([])</span>
641	<span class="sd"> """</span>
642	<span class="nb">dict</span><span class="o">.</span><span class="n">clear</span><span class="p">(</span><span class="bp">self</span><span class="p">)</span>
643	<span class="bp">self</span><span class="o">.</span><span class="n">_sequence</span> <span class="o">=</span> <span class="p">[]</span>
644	</div>
645	<div class="viewcode-block" id="OrderedDict.pop"><a class="viewcode-back" href="../../../dev/api/sas.data_util.html#sas.data_util.odict.OrderedDict.pop">[docs]</a> <span class="k">def</span> <span class="nf">pop</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">key</span><span class="p">,</span> <span class="o">*</span><span class="n">args</span><span class="p">):</span>
646	<span class="sd">"""</span>
647	<span class="sd"> No dict.pop in Python 2.2, gotta reimplement it</span>
648	<span class="sd"> </span>
649	<span class="sd"> >>> d = OrderedDict(((1, 3), (3, 2), (2, 1)))</span>
650	<span class="sd"> >>> d.pop(3)</span>
651	<span class="sd"> 2</span>
652	<span class="sd"> >>> d</span>
653	<span class="sd"> OrderedDict([(1, 3), (2, 1)])</span>
654	<span class="sd"> >>> d.pop(4)</span>
655	<span class="sd"> Traceback (most recent call last):</span>
656	<span class="sd"> KeyError: 4</span>
657	<span class="sd"> >>> d.pop(4, 0)</span>
658	<span class="sd"> 0</span>
659	<span class="sd"> >>> d.pop(4, 0, 1)</span>
660	<span class="sd"> Traceback (most recent call last):</span>
661	<span class="sd"> TypeError: pop expected at most 2 arguments, got 3</span>
662	<span class="sd"> """</span>
663	<span class="k">if</span> <span class="nb">len</span><span class="p">(</span><span class="n">args</span><span class="p">)</span> <span class="o">></span> <span class="mi">1</span><span class="p">:</span>
664	<span class="k">raise</span> <span class="ne">TypeError</span><span class="p">,</span> <span class="p">(</span><span class="s">'pop expected at most 2 arguments, got </span><span class="si">%s</span><span class="s">'</span> <span class="o">%</span>
665	<span class="p">(</span><span class="nb">len</span><span class="p">(</span><span class="n">args</span><span class="p">)</span> <span class="o">+</span> <span class="mi">1</span><span class="p">))</span>
666	<span class="k">if</span> <span class="n">key</span> <span class="ow">in</span> <span class="bp">self</span><span class="p">:</span>
667	<span class="n">val</span> <span class="o">=</span> <span class="bp">self</span><span class="p">[</span><span class="n">key</span><span class="p">]</span>
668	<span class="k">del</span> <span class="bp">self</span><span class="p">[</span><span class="n">key</span><span class="p">]</span>
669	<span class="k">else</span><span class="p">:</span>
670	<span class="k">try</span><span class="p">:</span>
671	<span class="n">val</span> <span class="o">=</span> <span class="n">args</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span>
672	<span class="k">except</span> <span class="ne">IndexError</span><span class="p">:</span>
673	<span class="k">raise</span> <span class="ne">KeyError</span><span class="p">(</span><span class="n">key</span><span class="p">)</span>
674	<span class="k">return</span> <span class="n">val</span>
675	</div>
676	<div class="viewcode-block" id="OrderedDict.popitem"><a class="viewcode-back" href="../../../dev/api/sas.data_util.html#sas.data_util.odict.OrderedDict.popitem">[docs]</a> <span class="k">def</span> <span class="nf">popitem</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">i</span><span class="o">=-</span><span class="mi">1</span><span class="p">):</span>
677	<span class="sd">"""</span>
678	<span class="sd"> Delete and return an item specified by index, not a random one as in</span>
679	<span class="sd"> dict. The index is -1 by default (the last item).</span>
680	<span class="sd"> </span>
681	<span class="sd"> >>> d = OrderedDict(((1, 3), (3, 2), (2, 1)))</span>
682	<span class="sd"> >>> d.popitem()</span>
683	<span class="sd"> (2, 1)</span>
684	<span class="sd"> >>> d</span>
685	<span class="sd"> OrderedDict([(1, 3), (3, 2)])</span>
686	<span class="sd"> >>> d.popitem(0)</span>
687	<span class="sd"> (1, 3)</span>
688	<span class="sd"> >>> OrderedDict().popitem()</span>
689	<span class="sd"> Traceback (most recent call last):</span>
690	<span class="sd"> KeyError: 'popitem(): dictionary is empty'</span>
691	<span class="sd"> >>> d.popitem(2)</span>
692	<span class="sd"> Traceback (most recent call last):</span>
693	<span class="sd"> IndexError: popitem(): index 2 not valid</span>
694	<span class="sd"> """</span>
695	<span class="k">if</span> <span class="ow">not</span> <span class="bp">self</span><span class="o">.</span><span class="n">_sequence</span><span class="p">:</span>
696	<span class="k">raise</span> <span class="ne">KeyError</span><span class="p">(</span><span class="s">'popitem(): dictionary is empty'</span><span class="p">)</span>
697	<span class="k">try</span><span class="p">:</span>
698	<span class="n">key</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="n">_sequence</span><span class="p">[</span><span class="n">i</span><span class="p">]</span>
699	<span class="k">except</span> <span class="ne">IndexError</span><span class="p">:</span>
700	<span class="k">raise</span> <span class="ne">IndexError</span><span class="p">(</span><span class="s">'popitem(): index </span><span class="si">%s</span><span class="s"> not valid'</span> <span class="o">%</span> <span class="n">i</span><span class="p">)</span>
701	<span class="k">return</span> <span class="p">(</span><span class="n">key</span><span class="p">,</span> <span class="bp">self</span><span class="o">.</span><span class="n">pop</span><span class="p">(</span><span class="n">key</span><span class="p">))</span>
702	</div>
703	<div class="viewcode-block" id="OrderedDict.setdefault"><a class="viewcode-back" href="../../../dev/api/sas.data_util.html#sas.data_util.odict.OrderedDict.setdefault">[docs]</a> <span class="k">def</span> <span class="nf">setdefault</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">key</span><span class="p">,</span> <span class="n">defval</span> <span class="o">=</span> <span class="bp">None</span><span class="p">):</span>
704	<span class="sd">"""</span>
705	<span class="sd"> >>> d = OrderedDict(((1, 3), (3, 2), (2, 1)))</span>
706	<span class="sd"> >>> d.setdefault(1)</span>
707	<span class="sd"> 3</span>
708	<span class="sd"> >>> d.setdefault(4) is None</span>
709	<span class="sd"> True</span>
710	<span class="sd"> >>> d</span>
711	<span class="sd"> OrderedDict([(1, 3), (3, 2), (2, 1), (4, None)])</span>
712	<span class="sd"> >>> d.setdefault(5, 0)</span>
713	<span class="sd"> 0</span>
714	<span class="sd"> >>> d</span>
715	<span class="sd"> OrderedDict([(1, 3), (3, 2), (2, 1), (4, None), (5, 0)])</span>
716	<span class="sd"> """</span>
717	<span class="k">if</span> <span class="n">key</span> <span class="ow">in</span> <span class="bp">self</span><span class="p">:</span>
718	<span class="k">return</span> <span class="bp">self</span><span class="p">[</span><span class="n">key</span><span class="p">]</span>
719	<span class="k">else</span><span class="p">:</span>
720	<span class="bp">self</span><span class="p">[</span><span class="n">key</span><span class="p">]</span> <span class="o">=</span> <span class="n">defval</span>
721	<span class="k">return</span> <span class="n">defval</span>
722	</div>
723	<div class="viewcode-block" id="OrderedDict.update"><a class="viewcode-back" href="../../../dev/api/sas.data_util.html#sas.data_util.odict.OrderedDict.update">[docs]</a> <span class="k">def</span> <span class="nf">update</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">from_od</span><span class="p">):</span>
724	<span class="sd">"""</span>
725	<span class="sd"> Update from another OrderedDict or sequence of (key, value) pairs</span>
726	<span class="sd"> </span>
727	<span class="sd"> >>> d = OrderedDict(((1, 0), (0, 1)))</span>
728	<span class="sd"> >>> d.update(OrderedDict(((1, 3), (3, 2), (2, 1))))</span>
729	<span class="sd"> >>> d</span>
730	<span class="sd"> OrderedDict([(1, 3), (0, 1), (3, 2), (2, 1)])</span>
731	<span class="sd"> >>> d.update({4: 4})</span>
732	<span class="sd"> Traceback (most recent call last):</span>
733	<span class="sd"> TypeError: undefined order, cannot get items from dict</span>
734	<span class="sd"> >>> d.update((4, 4))</span>
735	<span class="sd"> Traceback (most recent call last):</span>
736	<span class="sd"> TypeError: cannot convert dictionary update sequence element "4" to a 2-item sequence</span>
737	<span class="sd"> """</span>
738	<span class="k">if</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">from_od</span><span class="p">,</span> <span class="n">OrderedDict</span><span class="p">):</span>
739	<span class="k">for</span> <span class="n">key</span><span class="p">,</span> <span class="n">val</span> <span class="ow">in</span> <span class="n">from_od</span><span class="o">.</span><span class="n">items</span><span class="p">():</span>
740	<span class="bp">self</span><span class="p">[</span><span class="n">key</span><span class="p">]</span> <span class="o">=</span> <span class="n">val</span>
741	<span class="k">elif</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">from_od</span><span class="p">,</span> <span class="nb">dict</span><span class="p">):</span>
742	<span class="c"># we lose compatibility with other ordered dict types this way</span>
743	<span class="k">raise</span> <span class="ne">TypeError</span><span class="p">(</span><span class="s">'undefined order, cannot get items from dict'</span><span class="p">)</span>
744	<span class="k">else</span><span class="p">:</span>
745	<span class="c"># FIXME: efficiency?</span>
746	<span class="c"># sequence of 2-item sequences, or error</span>
747	<span class="k">for</span> <span class="n">item</span> <span class="ow">in</span> <span class="n">from_od</span><span class="p">:</span>
748	<span class="k">try</span><span class="p">:</span>
749	<span class="n">key</span><span class="p">,</span> <span class="n">val</span> <span class="o">=</span> <span class="n">item</span>
750	<span class="k">except</span> <span class="ne">TypeError</span><span class="p">:</span>
751	<span class="k">raise</span> <span class="ne">TypeError</span><span class="p">(</span><span class="s">'cannot convert dictionary update'</span>
752	<span class="s">' sequence element "</span><span class="si">%s</span><span class="s">" to a 2-item sequence'</span> <span class="o">%</span> <span class="n">item</span><span class="p">)</span>
753	<span class="bp">self</span><span class="p">[</span><span class="n">key</span><span class="p">]</span> <span class="o">=</span> <span class="n">val</span>
754	</div>
755	<div class="viewcode-block" id="OrderedDict.rename"><a class="viewcode-back" href="../../../dev/api/sas.data_util.html#sas.data_util.odict.OrderedDict.rename">[docs]</a> <span class="k">def</span> <span class="nf">rename</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">old_key</span><span class="p">,</span> <span class="n">new_key</span><span class="p">):</span>
756	<span class="sd">"""</span>
757	<span class="sd"> Rename the key for a given value, without modifying sequence order.</span>
758	<span class="sd"> </span>
759	<span class="sd"> For the case where new_key already exists this raise an exception,</span>
760	<span class="sd"> since if new_key exists, it is ambiguous as to what happens to the</span>
761	<span class="sd"> associated values, and the position of new_key in the sequence.</span>
762	<span class="sd"> </span>
763	<span class="sd"> >>> od = OrderedDict()</span>
764	<span class="sd"> >>> od['a'] = 1</span>
765	<span class="sd"> >>> od['b'] = 2</span>
766	<span class="sd"> >>> od.items()</span>
767	<span class="sd"> [('a', 1), ('b', 2)]</span>
768	<span class="sd"> >>> od.rename('b', 'c')</span>
769	<span class="sd"> >>> od.items()</span>
770	<span class="sd"> [('a', 1), ('c', 2)]</span>
771	<span class="sd"> >>> od.rename('c', 'a')</span>
772	<span class="sd"> Traceback (most recent call last):</span>
773	<span class="sd"> ValueError: New key already exists: 'a'</span>
774	<span class="sd"> >>> od.rename('d', 'b')</span>
775	<span class="sd"> Traceback (most recent call last):</span>
776	<span class="sd"> KeyError: 'd'</span>
777	<span class="sd"> """</span>
778	<span class="k">if</span> <span class="n">new_key</span> <span class="o">==</span> <span class="n">old_key</span><span class="p">:</span>
779	<span class="c"># no-op</span>
780	<span class="k">return</span>
781	<span class="k">if</span> <span class="n">new_key</span> <span class="ow">in</span> <span class="bp">self</span><span class="p">:</span>
782	<span class="k">raise</span> <span class="ne">ValueError</span><span class="p">(</span><span class="s">"New key already exists: </span><span class="si">%r</span><span class="s">"</span> <span class="o">%</span> <span class="n">new_key</span><span class="p">)</span>
783	<span class="c"># rename sequence entry</span>
784	<span class="n">value</span> <span class="o">=</span> <span class="bp">self</span><span class="p">[</span><span class="n">old_key</span><span class="p">]</span>
785	<span class="n">old_idx</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="n">_sequence</span><span class="o">.</span><span class="n">index</span><span class="p">(</span><span class="n">old_key</span><span class="p">)</span>
786	<span class="bp">self</span><span class="o">.</span><span class="n">_sequence</span><span class="p">[</span><span class="n">old_idx</span><span class="p">]</span> <span class="o">=</span> <span class="n">new_key</span>
787	<span class="c"># rename internal dict entry</span>
788	<span class="nb">dict</span><span class="o">.</span><span class="n">__delitem__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">old_key</span><span class="p">)</span>
789	<span class="nb">dict</span><span class="o">.</span><span class="n">__setitem__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">new_key</span><span class="p">,</span> <span class="n">value</span><span class="p">)</span>
790	</div>
791	<div class="viewcode-block" id="OrderedDict.setitems"><a class="viewcode-back" href="../../../dev/api/sas.data_util.html#sas.data_util.odict.OrderedDict.setitems">[docs]</a> <span class="k">def</span> <span class="nf">setitems</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">items</span><span class="p">):</span>
792	<span class="sd">"""</span>
793	<span class="sd"> This method allows you to set the items in the dict.</span>
794	<span class="sd"> </span>
795	<span class="sd"> It takes a list of tuples - of the same sort returned by the ``items``</span>
796	<span class="sd"> method.</span>
797	<span class="sd"> </span>
798	<span class="sd"> >>> d = OrderedDict()</span>
799	<span class="sd"> >>> d.setitems(((3, 1), (2, 3), (1, 2)))</span>
800	<span class="sd"> >>> d</span>
801	<span class="sd"> OrderedDict([(3, 1), (2, 3), (1, 2)])</span>
802	<span class="sd"> """</span>
803	<span class="bp">self</span><span class="o">.</span><span class="n">clear</span><span class="p">()</span>
804	<span class="c"># FIXME: this allows you to pass in an OrderedDict as well :-)</span>
805	<span class="bp">self</span><span class="o">.</span><span class="n">update</span><span class="p">(</span><span class="n">items</span><span class="p">)</span>
806	</div>
807	<div class="viewcode-block" id="OrderedDict.setkeys"><a class="viewcode-back" href="../../../dev/api/sas.data_util.html#sas.data_util.odict.OrderedDict.setkeys">[docs]</a> <span class="k">def</span> <span class="nf">setkeys</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">keys</span><span class="p">):</span>
808	<span class="sd">"""</span>
809	<span class="sd"> ``setkeys`` all ows you to pass in a new list of keys which will</span>
810	<span class="sd"> replace the current set. This must contain the same set of keys, but</span>
811	<span class="sd"> need not be in the same order.</span>
812	<span class="sd"> </span>
813	<span class="sd"> If you pass in new keys that don't match, a ``KeyError`` will be</span>
814	<span class="sd"> raised.</span>
815	<span class="sd"> </span>
816	<span class="sd"> >>> d = OrderedDict(((1, 3), (3, 2), (2, 1)))</span>
817	<span class="sd"> >>> d.keys()</span>
818	<span class="sd"> [1, 3, 2]</span>
819	<span class="sd"> >>> d.setkeys((1, 2, 3))</span>
820	<span class="sd"> >>> d</span>
821	<span class="sd"> OrderedDict([(1, 3), (2, 1), (3, 2)])</span>
822	<span class="sd"> >>> d.setkeys(['a', 'b', 'c'])</span>
823	<span class="sd"> Traceback (most recent call last):</span>
824	<span class="sd"> KeyError: 'Keylist is not the same as current keylist.'</span>
825	<span class="sd"> """</span>
826	<span class="c"># FIXME: Efficiency? (use set for Python 2.4 :-)</span>
827	<span class="c"># NOTE: list(keys) rather than keys[:] because keys[:] returns</span>
828	<span class="c"># a tuple, if keys is a tuple.</span>
829	<span class="n">kcopy</span> <span class="o">=</span> <span class="nb">list</span><span class="p">(</span><span class="n">keys</span><span class="p">)</span>
830	<span class="n">kcopy</span><span class="o">.</span><span class="n">sort</span><span class="p">()</span>
831	<span class="bp">self</span><span class="o">.</span><span class="n">_sequence</span><span class="o">.</span><span class="n">sort</span><span class="p">()</span>
832	<span class="k">if</span> <span class="n">kcopy</span> <span class="o">!=</span> <span class="bp">self</span><span class="o">.</span><span class="n">_sequence</span><span class="p">:</span>
833	<span class="k">raise</span> <span class="ne">KeyError</span><span class="p">(</span><span class="s">'Keylist is not the same as current keylist.'</span><span class="p">)</span>
834	<span class="c"># NOTE: This makes the _sequence attribute a new object, instead</span>
835	<span class="c"># of changing it in place.</span>
836	<span class="c"># FIXME: efficiency?</span>
837	<span class="bp">self</span><span class="o">.</span><span class="n">_sequence</span> <span class="o">=</span> <span class="nb">list</span><span class="p">(</span><span class="n">keys</span><span class="p">)</span>
838	</div>
839	<div class="viewcode-block" id="OrderedDict.setvalues"><a class="viewcode-back" href="../../../dev/api/sas.data_util.html#sas.data_util.odict.OrderedDict.setvalues">[docs]</a> <span class="k">def</span> <span class="nf">setvalues</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">values</span><span class="p">):</span>
840	<span class="sd">"""</span>
841	<span class="sd"> You can pass in a list of values, which will replace the</span>
842	<span class="sd"> current list. The value list must be the same len as the OrderedDict.</span>
843	<span class="sd"> </span>
844	<span class="sd"> (Or a ``ValueError`` is raised.)</span>
845	<span class="sd"> </span>
846	<span class="sd"> >>> d = OrderedDict(((1, 3), (3, 2), (2, 1)))</span>
847	<span class="sd"> >>> d.setvalues((1, 2, 3))</span>
848	<span class="sd"> >>> d</span>
849	<span class="sd"> OrderedDict([(1, 1), (3, 2), (2, 3)])</span>
850	<span class="sd"> >>> d.setvalues([6])</span>
851	<span class="sd"> Traceback (most recent call last):</span>
852	<span class="sd"> ValueError: Value list is not the same length as the OrderedDict.</span>
853	<span class="sd"> """</span>
854	<span class="k">if</span> <span class="nb">len</span><span class="p">(</span><span class="n">values</span><span class="p">)</span> <span class="o">!=</span> <span class="nb">len</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
855	<span class="c"># FIXME: correct error to raise?</span>
856	<span class="k">raise</span> <span class="ne">ValueError</span><span class="p">(</span><span class="s">'Value list is not the same length as the '</span>
857	<span class="s">'OrderedDict.'</span><span class="p">)</span>
858	<span class="bp">self</span><span class="o">.</span><span class="n">update</span><span class="p">(</span><span class="nb">zip</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">values</span><span class="p">))</span>
859
860	<span class="c">### Sequence Methods ###</span>
861	</div>
862	<div class="viewcode-block" id="OrderedDict.index"><a class="viewcode-back" href="../../../dev/api/sas.data_util.html#sas.data_util.odict.OrderedDict.index">[docs]</a> <span class="k">def</span> <span class="nf">index</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">key</span><span class="p">):</span>
863	<span class="sd">"""</span>
864	<span class="sd"> Return the position of the specified key in the OrderedDict.</span>
865	<span class="sd"> </span>
866	<span class="sd"> >>> d = OrderedDict(((1, 3), (3, 2), (2, 1)))</span>
867	<span class="sd"> >>> d.index(3)</span>
868	<span class="sd"> 1</span>
869	<span class="sd"> >>> d.index(4)</span>
870	<span class="sd"> Traceback (most recent call last):</span>
871	<span class="sd"> ValueError: list.index(x): x not in list</span>
872	<span class="sd"> """</span>
873	<span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="n">_sequence</span><span class="o">.</span><span class="n">index</span><span class="p">(</span><span class="n">key</span><span class="p">)</span>
874	</div>
875	<div class="viewcode-block" id="OrderedDict.insert"><a class="viewcode-back" href="../../../dev/api/sas.data_util.html#sas.data_util.odict.OrderedDict.insert">[docs]</a> <span class="k">def</span> <span class="nf">insert</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">index</span><span class="p">,</span> <span class="n">key</span><span class="p">,</span> <span class="n">value</span><span class="p">):</span>
876	<span class="sd">"""</span>
877	<span class="sd"> Takes ``index``, ``key``, and ``value`` as arguments.</span>
878	<span class="sd"> </span>
879	<span class="sd"> Sets ``key`` to ``value``, so that ``key`` is at position ``index`` in</span>
880	<span class="sd"> the OrderedDict.</span>
881	<span class="sd"> </span>
882	<span class="sd"> >>> d = OrderedDict(((1, 3), (3, 2), (2, 1)))</span>
883	<span class="sd"> >>> d.insert(0, 4, 0)</span>
884	<span class="sd"> >>> d</span>
885	<span class="sd"> OrderedDict([(4, 0), (1, 3), (3, 2), (2, 1)])</span>
886	<span class="sd"> >>> d.insert(0, 2, 1)</span>
887	<span class="sd"> >>> d</span>
888	<span class="sd"> OrderedDict([(2, 1), (4, 0), (1, 3), (3, 2)])</span>
889	<span class="sd"> >>> d.insert(8, 8, 1)</span>
890	<span class="sd"> >>> d</span>
891	<span class="sd"> OrderedDict([(2, 1), (4, 0), (1, 3), (3, 2), (8, 1)])</span>
892	<span class="sd"> """</span>
893	<span class="k">if</span> <span class="n">key</span> <span class="ow">in</span> <span class="bp">self</span><span class="p">:</span>
894	<span class="c"># FIXME: efficiency?</span>
895	<span class="k">del</span> <span class="bp">self</span><span class="p">[</span><span class="n">key</span><span class="p">]</span>
896	<span class="bp">self</span><span class="o">.</span><span class="n">_sequence</span><span class="o">.</span><span class="n">insert</span><span class="p">(</span><span class="n">index</span><span class="p">,</span> <span class="n">key</span><span class="p">)</span>
897	<span class="nb">dict</span><span class="o">.</span><span class="n">__setitem__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">key</span><span class="p">,</span> <span class="n">value</span><span class="p">)</span>
898	</div>
899	<div class="viewcode-block" id="OrderedDict.reverse"><a class="viewcode-back" href="../../../dev/api/sas.data_util.html#sas.data_util.odict.OrderedDict.reverse">[docs]</a> <span class="k">def</span> <span class="nf">reverse</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
900	<span class="sd">"""</span>
901	<span class="sd"> Reverse the order of the OrderedDict.</span>
902	<span class="sd"> </span>
903	<span class="sd"> >>> d = OrderedDict(((1, 3), (3, 2), (2, 1)))</span>
904	<span class="sd"> >>> d.reverse()</span>
905	<span class="sd"> >>> d</span>
906	<span class="sd"> OrderedDict([(2, 1), (3, 2), (1, 3)])</span>
907	<span class="sd"> """</span>
908	<span class="bp">self</span><span class="o">.</span><span class="n">_sequence</span><span class="o">.</span><span class="n">reverse</span><span class="p">()</span>
909	</div>
910	<div class="viewcode-block" id="OrderedDict.sort"><a class="viewcode-back" href="../../../dev/api/sas.data_util.html#sas.data_util.odict.OrderedDict.sort">[docs]</a> <span class="k">def</span> <span class="nf">sort</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="o"></span><span class="n">args</span><span class="p">,</span> <span class="o">*</span><span class="n">kwargs</span><span class="p">):</span>
911	<span class="sd">"""</span>
912	<span class="sd"> Sort the key order in the OrderedDict.</span>
913	<span class="sd"> </span>
914	<span class="sd"> This method takes the same arguments as the ``list.sort`` method on</span>
915	<span class="sd"> your version of Python.</span>
916	<span class="sd"> </span>
917	<span class="sd"> >>> d = OrderedDict(((4, 1), (2, 2), (3, 3), (1, 4)))</span>
918	<span class="sd"> >>> d.sort()</span>
919	<span class="sd"> >>> d</span>
920	<span class="sd"> OrderedDict([(1, 4), (2, 2), (3, 3), (4, 1)])</span>
921	<span class="sd"> """</span>
922	<span class="bp">self</span><span class="o">.</span><span class="n">_sequence</span><span class="o">.</span><span class="n">sort</span><span class="p">(</span><span class="o"></span><span class="n">args</span><span class="p">,</span> <span class="o">*</span><span class="n">kwargs</span><span class="p">)</span>
923	</div></div>
924	<span class="k">class</span> <span class="nc">Keys</span><span class="p">(</span><span class="nb">object</span><span class="p">):</span>
925	<span class="c"># FIXME: should this object be a subclass of list?</span>
926	<span class="sd">"""</span>
927	<span class="sd"> Custom object for accessing the keys of an OrderedDict.</span>
928	<span class="sd"> </span>
929	<span class="sd"> Can be called like the normal ``OrderedDict.keys`` method, but also</span>
930	<span class="sd"> supports indexing and sequence methods.</span>
931	<span class="sd"> """</span>
932
933	<span class="k">def</span> <span class="nf">__init__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">main</span><span class="p">):</span>
934	<span class="bp">self</span><span class="o">.</span><span class="n">_main</span> <span class="o">=</span> <span class="n">main</span>
935
936	<span class="k">def</span> <span class="nf">__call__</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
937	<span class="sd">"""Pretend to be the keys method."""</span>
938	<span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="n">_main</span><span class="o">.</span><span class="n">_keys</span><span class="p">()</span>
939
940	<span class="k">def</span> <span class="nf">__getitem__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">index</span><span class="p">):</span>
941	<span class="sd">"""Fetch the key at position i."""</span>
942	<span class="c"># NOTE: this automatically supports slicing :-)</span>
943	<span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="n">_main</span><span class="o">.</span><span class="n">_sequence</span><span class="p">[</span><span class="n">index</span><span class="p">]</span>
944
945	<span class="k">def</span> <span class="nf">__setitem__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">index</span><span class="p">,</span> <span class="n">name</span><span class="p">):</span>
946	<span class="sd">"""</span>
947	<span class="sd"> You cannot assign to keys, but you can do slice assignment to re-order</span>
948	<span class="sd"> them.</span>
949	<span class="sd"> </span>
950	<span class="sd"> You can only do slice assignment if the new set of keys is a reordering</span>
951	<span class="sd"> of the original set.</span>
952	<span class="sd"> """</span>
953	<span class="k">if</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">index</span><span class="p">,</span> <span class="n">types</span><span class="o">.</span><span class="n">SliceType</span><span class="p">):</span>
954	<span class="c"># FIXME: efficiency?</span>
955	<span class="c"># check length is the same</span>
956	<span class="n">indexes</span> <span class="o">=</span> <span class="nb">range</span><span class="p">(</span><span class="nb">len</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">_main</span><span class="o">.</span><span class="n">_sequence</span><span class="p">))[</span><span class="n">index</span><span class="p">]</span>
957	<span class="k">if</span> <span class="nb">len</span><span class="p">(</span><span class="n">indexes</span><span class="p">)</span> <span class="o">!=</span> <span class="nb">len</span><span class="p">(</span><span class="n">name</span><span class="p">):</span>
958	<span class="k">raise</span> <span class="ne">ValueError</span><span class="p">(</span><span class="s">'attempt to assign sequence of size </span><span class="si">%s</span><span class="s"> '</span>
959	<span class="s">'to slice of size </span><span class="si">%s</span><span class="s">'</span> <span class="o">%</span> <span class="p">(</span><span class="nb">len</span><span class="p">(</span><span class="n">name</span><span class="p">),</span> <span class="nb">len</span><span class="p">(</span><span class="n">indexes</span><span class="p">)))</span>
960	<span class="c"># check they are the same keys</span>
961	<span class="c"># FIXME: Use set</span>
962	<span class="n">old_keys</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="n">_main</span><span class="o">.</span><span class="n">_sequence</span><span class="p">[</span><span class="n">index</span><span class="p">]</span>
963	<span class="n">new_keys</span> <span class="o">=</span> <span class="nb">list</span><span class="p">(</span><span class="n">name</span><span class="p">)</span>
964	<span class="n">old_keys</span><span class="o">.</span><span class="n">sort</span><span class="p">()</span>
965	<span class="n">new_keys</span><span class="o">.</span><span class="n">sort</span><span class="p">()</span>
966	<span class="k">if</span> <span class="n">old_keys</span> <span class="o">!=</span> <span class="n">new_keys</span><span class="p">:</span>
967	<span class="k">raise</span> <span class="ne">KeyError</span><span class="p">(</span><span class="s">'Keylist is not the same as current keylist.'</span><span class="p">)</span>
968	<span class="n">orig_vals</span> <span class="o">=</span> <span class="p">[</span><span class="bp">self</span><span class="o">.</span><span class="n">_main</span><span class="p">[</span><span class="n">k</span><span class="p">]</span> <span class="k">for</span> <span class="n">k</span> <span class="ow">in</span> <span class="n">name</span><span class="p">]</span>
969	<span class="k">del</span> <span class="bp">self</span><span class="o">.</span><span class="n">_main</span><span class="p">[</span><span class="n">index</span><span class="p">]</span>
970	<span class="n">vals</span> <span class="o">=</span> <span class="nb">zip</span><span class="p">(</span><span class="n">indexes</span><span class="p">,</span> <span class="n">name</span><span class="p">,</span> <span class="n">orig_vals</span><span class="p">)</span>
971	<span class="n">vals</span><span class="o">.</span><span class="n">sort</span><span class="p">()</span>
972	<span class="k">for</span> <span class="n">i</span><span class="p">,</span> <span class="n">k</span><span class="p">,</span> <span class="n">v</span> <span class="ow">in</span> <span class="n">vals</span><span class="p">:</span>
973	<span class="k">if</span> <span class="bp">self</span><span class="o">.</span><span class="n">_main</span><span class="o">.</span><span class="n">strict</span> <span class="ow">and</span> <span class="n">k</span> <span class="ow">in</span> <span class="bp">self</span><span class="o">.</span><span class="n">_main</span><span class="p">:</span>
974	<span class="k">raise</span> <span class="ne">ValueError</span><span class="p">(</span><span class="s">'slice assignment must be from '</span>
975	<span class="s">'unique keys'</span><span class="p">)</span>
976	<span class="bp">self</span><span class="o">.</span><span class="n">_main</span><span class="o">.</span><span class="n">insert</span><span class="p">(</span><span class="n">i</span><span class="p">,</span> <span class="n">k</span><span class="p">,</span> <span class="n">v</span><span class="p">)</span>
977	<span class="k">else</span><span class="p">:</span>
978	<span class="k">raise</span> <span class="ne">ValueError</span><span class="p">(</span><span class="s">'Cannot assign to keys'</span><span class="p">)</span>
979
980	<span class="c">### following methods pinched from UserList and adapted ###</span>
981	<span class="k">def</span> <span class="nf">__repr__</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span> <span class="k">return</span> <span class="nb">repr</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">_main</span><span class="o">.</span><span class="n">_sequence</span><span class="p">)</span>
982
983	<span class="c"># FIXME: do we need to check if we are comparing with another ``Keys``</span>
984	<span class="c"># object? (like the __cast method of UserList)</span>
985	<span class="k">def</span> <span class="nf">__lt__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">other</span><span class="p">):</span> <span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="n">_main</span><span class="o">.</span><span class="n">_sequence</span> <span class="o"><</span> <span class="n">other</span>
986	<span class="k">def</span> <span class="nf">__le__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">other</span><span class="p">):</span> <span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="n">_main</span><span class="o">.</span><span class="n">_sequence</span> <span class="o"><=</span> <span class="n">other</span>
987	<span class="k">def</span> <span class="nf">__eq__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">other</span><span class="p">):</span> <span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="n">_main</span><span class="o">.</span><span class="n">_sequence</span> <span class="o">==</span> <span class="n">other</span>
988	<span class="k">def</span> <span class="nf">__ne__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">other</span><span class="p">):</span> <span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="n">_main</span><span class="o">.</span><span class="n">_sequence</span> <span class="o">!=</span> <span class="n">other</span>
989	<span class="k">def</span> <span class="nf">__gt__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">other</span><span class="p">):</span> <span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="n">_main</span><span class="o">.</span><span class="n">_sequence</span> <span class="o">></span> <span class="n">other</span>
990	<span class="k">def</span> <span class="nf">__ge__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">other</span><span class="p">):</span> <span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="n">_main</span><span class="o">.</span><span class="n">_sequence</span> <span class="o">>=</span> <span class="n">other</span>
991	<span class="c"># FIXME: do we need __cmp__ as well as rich comparisons?</span>
992	<span class="k">def</span> <span class="nf">__cmp__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">other</span><span class="p">):</span> <span class="k">return</span> <span class="nb">cmp</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">_main</span><span class="o">.</span><span class="n">_sequence</span><span class="p">,</span> <span class="n">other</span><span class="p">)</span>
993
994	<span class="k">def</span> <span class="nf">__contains__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">item</span><span class="p">):</span> <span class="k">return</span> <span class="n">item</span> <span class="ow">in</span> <span class="bp">self</span><span class="o">.</span><span class="n">_main</span><span class="o">.</span><span class="n">_sequence</span>
995	<span class="k">def</span> <span class="nf">__len__</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span> <span class="k">return</span> <span class="nb">len</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">_main</span><span class="o">.</span><span class="n">_sequence</span><span class="p">)</span>
996	<span class="k">def</span> <span class="nf">__iter__</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span> <span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="n">_main</span><span class="o">.</span><span class="n">iterkeys</span><span class="p">()</span>
997	<span class="k">def</span> <span class="nf">count</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">item</span><span class="p">):</span> <span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="n">_main</span><span class="o">.</span><span class="n">_sequence</span><span class="o">.</span><span class="n">count</span><span class="p">(</span><span class="n">item</span><span class="p">)</span>
998	<span class="k">def</span> <span class="nf">index</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">item</span><span class="p">,</span> <span class="o"></span><span class="n">args</span><span class="p">):</span> <span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="n">_main</span><span class="o">.</span><span class="n">_sequence</span><span class="o">.</span><span class="n">index</span><span class="p">(</span><span class="n">item</span><span class="p">,</span> <span class="o"></span><span class="n">args</span><span class="p">)</span>
999	<span class="k">def</span> <span class="nf">reverse</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span> <span class="bp">self</span><span class="o">.</span><span class="n">_main</span><span class="o">.</span><span class="n">_sequence</span><span class="o">.</span><span class="n">reverse</span><span class="p">()</span>
1000	<span class="k">def</span> <span class="nf">sort</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="o"></span><span class="n">args</span><span class="p">,</span> <span class="o"></span><span class="n">kwds</span><span class="p">):</span> <span class="bp">self</span><span class="o">.</span><span class="n">_main</span><span class="o">.</span><span class="n">_sequence</span><span class="o">.</span><span class="n">sort</span><span class="p">(</span><span class="o"></span><span class="n">args</span><span class="p">,</span> <span class="o">**</span><span class="n">kwds</span><span class="p">)</span>
1001	<span class="k">def</span> <span class="nf">__mul__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">n</span><span class="p">):</span> <span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="n">_main</span><span class="o">.</span><span class="n">_sequence</span><span class="o">*</span><span class="n">n</span>
1002	<span class="n">__rmul__</span> <span class="o">=</span> <span class="n">__mul__</span>
1003	<span class="k">def</span> <span class="nf">__add__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">other</span><span class="p">):</span> <span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="n">_main</span><span class="o">.</span><span class="n">_sequence</span> <span class="o">+</span> <span class="n">other</span>
1004	<span class="k">def</span> <span class="nf">__radd__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">other</span><span class="p">):</span> <span class="k">return</span> <span class="n">other</span> <span class="o">+</span> <span class="bp">self</span><span class="o">.</span><span class="n">_main</span><span class="o">.</span><span class="n">_sequence</span>
1005
1006	<span class="c">## following methods not implemented for keys ##</span>
1007	<span class="k">def</span> <span class="nf">__delitem__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">i</span><span class="p">):</span> <span class="k">raise</span> <span class="ne">TypeError</span><span class="p">(</span><span class="s">'Can</span><span class="se">\'</span><span class="s">t delete items from keys'</span><span class="p">)</span>
1008	<span class="k">def</span> <span class="nf">__iadd__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">other</span><span class="p">):</span> <span class="k">raise</span> <span class="ne">TypeError</span><span class="p">(</span><span class="s">'Can</span><span class="se">\'</span><span class="s">t add in place to keys'</span><span class="p">)</span>
1009	<span class="k">def</span> <span class="nf">__imul__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">n</span><span class="p">):</span> <span class="k">raise</span> <span class="ne">TypeError</span><span class="p">(</span><span class="s">'Can</span><span class="se">\'</span><span class="s">t multiply keys in place'</span><span class="p">)</span>
1010	<span class="k">def</span> <span class="nf">append</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">item</span><span class="p">):</span> <span class="k">raise</span> <span class="ne">TypeError</span><span class="p">(</span><span class="s">'Can</span><span class="se">\'</span><span class="s">t append items to keys'</span><span class="p">)</span>
1011	<span class="k">def</span> <span class="nf">insert</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">i</span><span class="p">,</span> <span class="n">item</span><span class="p">):</span> <span class="k">raise</span> <span class="ne">TypeError</span><span class="p">(</span><span class="s">'Can</span><span class="se">\'</span><span class="s">t insert items into keys'</span><span class="p">)</span>
1012	<span class="k">def</span> <span class="nf">pop</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">i</span><span class="o">=-</span><span class="mi">1</span><span class="p">):</span> <span class="k">raise</span> <span class="ne">TypeError</span><span class="p">(</span><span class="s">'Can</span><span class="se">\'</span><span class="s">t pop items from keys'</span><span class="p">)</span>
1013	<span class="k">def</span> <span class="nf">remove</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">item</span><span class="p">):</span> <span class="k">raise</span> <span class="ne">TypeError</span><span class="p">(</span><span class="s">'Can</span><span class="se">\'</span><span class="s">t remove items from keys'</span><span class="p">)</span>
1014	<span class="k">def</span> <span class="nf">extend</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">other</span><span class="p">):</span> <span class="k">raise</span> <span class="ne">TypeError</span><span class="p">(</span><span class="s">'Can</span><span class="se">\'</span><span class="s">t extend keys'</span><span class="p">)</span>
1015
1016	<span class="k">class</span> <span class="nc">Items</span><span class="p">(</span><span class="nb">object</span><span class="p">):</span>
1017	<span class="sd">"""</span>
1018	<span class="sd"> Custom object for accessing the items of an OrderedDict.</span>
1019	<span class="sd"> </span>
1020	<span class="sd"> Can be called like the normal ``OrderedDict.items`` method, but also</span>
1021	<span class="sd"> supports indexing and sequence methods.</span>
1022	<span class="sd"> """</span>
1023
1024	<span class="k">def</span> <span class="nf">__init__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">main</span><span class="p">):</span>
1025	<span class="bp">self</span><span class="o">.</span><span class="n">_main</span> <span class="o">=</span> <span class="n">main</span>
1026
1027	<span class="k">def</span> <span class="nf">__call__</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
1028	<span class="sd">"""Pretend to be the items method."""</span>
1029	<span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="n">_main</span><span class="o">.</span><span class="n">_items</span><span class="p">()</span>
1030
1031	<span class="k">def</span> <span class="nf">__getitem__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">index</span><span class="p">):</span>
1032	<span class="sd">"""Fetch the item at position i."""</span>
1033	<span class="k">if</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">index</span><span class="p">,</span> <span class="n">types</span><span class="o">.</span><span class="n">SliceType</span><span class="p">):</span>
1034	<span class="c"># fetching a slice returns an OrderedDict</span>
1035	<span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="n">_main</span><span class="p">[</span><span class="n">index</span><span class="p">]</span><span class="o">.</span><span class="n">items</span><span class="p">()</span>
1036	<span class="n">key</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="n">_main</span><span class="o">.</span><span class="n">_sequence</span><span class="p">[</span><span class="n">index</span><span class="p">]</span>
1037	<span class="k">return</span> <span class="p">(</span><span class="n">key</span><span class="p">,</span> <span class="bp">self</span><span class="o">.</span><span class="n">_main</span><span class="p">[</span><span class="n">key</span><span class="p">])</span>
1038
1039	<span class="k">def</span> <span class="nf">__setitem__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">index</span><span class="p">,</span> <span class="n">item</span><span class="p">):</span>
1040	<span class="sd">"""Set item at position i to item."""</span>
1041	<span class="k">if</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">index</span><span class="p">,</span> <span class="n">types</span><span class="o">.</span><span class="n">SliceType</span><span class="p">):</span>
1042	<span class="c"># NOTE: item must be an iterable (list of tuples)</span>
1043	<span class="bp">self</span><span class="o">.</span><span class="n">_main</span><span class="p">[</span><span class="n">index</span><span class="p">]</span> <span class="o">=</span> <span class="n">OrderedDict</span><span class="p">(</span><span class="n">item</span><span class="p">)</span>
1044	<span class="k">else</span><span class="p">:</span>
1045	<span class="c"># FIXME: Does this raise a sensible error?</span>
1046	<span class="n">orig</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="n">_main</span><span class="o">.</span><span class="n">keys</span><span class="p">[</span><span class="n">index</span><span class="p">]</span>
1047	<span class="n">key</span><span class="p">,</span> <span class="n">value</span> <span class="o">=</span> <span class="n">item</span>
1048	<span class="k">if</span> <span class="bp">self</span><span class="o">.</span><span class="n">_main</span><span class="o">.</span><span class="n">strict</span> <span class="ow">and</span> <span class="n">key</span> <span class="ow">in</span> <span class="bp">self</span> <span class="ow">and</span> <span class="p">(</span><span class="n">key</span> <span class="o">!=</span> <span class="n">orig</span><span class="p">):</span>
1049	<span class="k">raise</span> <span class="ne">ValueError</span><span class="p">(</span><span class="s">'slice assignment must be from '</span>
1050	<span class="s">'unique keys'</span><span class="p">)</span>
1051	<span class="c"># delete the current one</span>
1052	<span class="k">del</span> <span class="bp">self</span><span class="o">.</span><span class="n">_main</span><span class="p">[</span><span class="bp">self</span><span class="o">.</span><span class="n">_main</span><span class="o">.</span><span class="n">_sequence</span><span class="p">[</span><span class="n">index</span><span class="p">]]</span>
1053	<span class="bp">self</span><span class="o">.</span><span class="n">_main</span><span class="o">.</span><span class="n">insert</span><span class="p">(</span><span class="n">index</span><span class="p">,</span> <span class="n">key</span><span class="p">,</span> <span class="n">value</span><span class="p">)</span>
1054
1055	<span class="k">def</span> <span class="nf">__delitem__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">i</span><span class="p">):</span>
1056	<span class="sd">"""Delete the item at position i."""</span>
1057	<span class="n">key</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="n">_main</span><span class="o">.</span><span class="n">_sequence</span><span class="p">[</span><span class="n">i</span><span class="p">]</span>
1058	<span class="k">if</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">i</span><span class="p">,</span> <span class="n">types</span><span class="o">.</span><span class="n">SliceType</span><span class="p">):</span>
1059	<span class="k">for</span> <span class="n">k</span> <span class="ow">in</span> <span class="n">key</span><span class="p">:</span>
1060	<span class="c"># FIXME: efficiency?</span>
1061	<span class="k">del</span> <span class="bp">self</span><span class="o">.</span><span class="n">_main</span><span class="p">[</span><span class="n">k</span><span class="p">]</span>
1062	<span class="k">else</span><span class="p">:</span>
1063	<span class="k">del</span> <span class="bp">self</span><span class="o">.</span><span class="n">_main</span><span class="p">[</span><span class="n">key</span><span class="p">]</span>
1064
1065	<span class="c">### following methods pinched from UserList and adapted ###</span>
1066	<span class="k">def</span> <span class="nf">__repr__</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span> <span class="k">return</span> <span class="nb">repr</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">_main</span><span class="o">.</span><span class="n">items</span><span class="p">())</span>
1067
1068	<span class="c"># FIXME: do we need to check if we are comparing with another ``Items``</span>
1069	<span class="c"># object? (like the __cast method of UserList)</span>
1070	<span class="k">def</span> <span class="nf">__lt__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">other</span><span class="p">):</span> <span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="n">_main</span><span class="o">.</span><span class="n">items</span><span class="p">()</span> <span class="o"><</span> <span class="n">other</span>
1071	<span class="k">def</span> <span class="nf">__le__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">other</span><span class="p">):</span> <span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="n">_main</span><span class="o">.</span><span class="n">items</span><span class="p">()</span> <span class="o"><=</span> <span class="n">other</span>
1072	<span class="k">def</span> <span class="nf">__eq__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">other</span><span class="p">):</span> <span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="n">_main</span><span class="o">.</span><span class="n">items</span><span class="p">()</span> <span class="o">==</span> <span class="n">other</span>
1073	<span class="k">def</span> <span class="nf">__ne__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">other</span><span class="p">):</span> <span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="n">_main</span><span class="o">.</span><span class="n">items</span><span class="p">()</span> <span class="o">!=</span> <span class="n">other</span>
1074	<span class="k">def</span> <span class="nf">__gt__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">other</span><span class="p">):</span> <span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="n">_main</span><span class="o">.</span><span class="n">items</span><span class="p">()</span> <span class="o">></span> <span class="n">other</span>
1075	<span class="k">def</span> <span class="nf">__ge__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">other</span><span class="p">):</span> <span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="n">_main</span><span class="o">.</span><span class="n">items</span><span class="p">()</span> <span class="o">>=</span> <span class="n">other</span>
1076	<span class="k">def</span> <span class="nf">__cmp__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">other</span><span class="p">):</span> <span class="k">return</span> <span class="nb">cmp</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">_main</span><span class="o">.</span><span class="n">items</span><span class="p">(),</span> <span class="n">other</span><span class="p">)</span>
1077
1078	<span class="k">def</span> <span class="nf">__contains__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">item</span><span class="p">):</span> <span class="k">return</span> <span class="n">item</span> <span class="ow">in</span> <span class="bp">self</span><span class="o">.</span><span class="n">_main</span><span class="o">.</span><span class="n">items</span><span class="p">()</span>
1079	<span class="k">def</span> <span class="nf">__len__</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span> <span class="k">return</span> <span class="nb">len</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">_main</span><span class="o">.</span><span class="n">_sequence</span><span class="p">)</span> <span class="c"># easier :-)</span>
1080	<span class="k">def</span> <span class="nf">__iter__</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span> <span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="n">_main</span><span class="o">.</span><span class="n">iteritems</span><span class="p">()</span>
1081	<span class="k">def</span> <span class="nf">count</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">item</span><span class="p">):</span> <span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="n">_main</span><span class="o">.</span><span class="n">items</span><span class="p">()</span><span class="o">.</span><span class="n">count</span><span class="p">(</span><span class="n">item</span><span class="p">)</span>
1082	<span class="k">def</span> <span class="nf">index</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">item</span><span class="p">,</span> <span class="o"></span><span class="n">args</span><span class="p">):</span> <span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="n">_main</span><span class="o">.</span><span class="n">items</span><span class="p">()</span><span class="o">.</span><span class="n">index</span><span class="p">(</span><span class="n">item</span><span class="p">,</span> <span class="o"></span><span class="n">args</span><span class="p">)</span>
1083	<span class="k">def</span> <span class="nf">reverse</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span> <span class="bp">self</span><span class="o">.</span><span class="n">_main</span><span class="o">.</span><span class="n">reverse</span><span class="p">()</span>
1084	<span class="k">def</span> <span class="nf">sort</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="o"></span><span class="n">args</span><span class="p">,</span> <span class="o"></span><span class="n">kwds</span><span class="p">):</span> <span class="bp">self</span><span class="o">.</span><span class="n">_main</span><span class="o">.</span><span class="n">sort</span><span class="p">(</span><span class="o"></span><span class="n">args</span><span class="p">,</span> <span class="o">**</span><span class="n">kwds</span><span class="p">)</span>
1085	<span class="k">def</span> <span class="nf">__mul__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">n</span><span class="p">):</span> <span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="n">_main</span><span class="o">.</span><span class="n">items</span><span class="p">()</span><span class="o">*</span><span class="n">n</span>
1086	<span class="n">__rmul__</span> <span class="o">=</span> <span class="n">__mul__</span>
1087	<span class="k">def</span> <span class="nf">__add__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">other</span><span class="p">):</span> <span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="n">_main</span><span class="o">.</span><span class="n">items</span><span class="p">()</span> <span class="o">+</span> <span class="n">other</span>
1088	<span class="k">def</span> <span class="nf">__radd__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">other</span><span class="p">):</span> <span class="k">return</span> <span class="n">other</span> <span class="o">+</span> <span class="bp">self</span><span class="o">.</span><span class="n">_main</span><span class="o">.</span><span class="n">items</span><span class="p">()</span>
1089
1090	<span class="k">def</span> <span class="nf">append</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">item</span><span class="p">):</span>
1091	<span class="sd">"""Add an item to the end."""</span>
1092	<span class="c"># FIXME: this is only append if the key isn't already present</span>
1093	<span class="n">key</span><span class="p">,</span> <span class="n">value</span> <span class="o">=</span> <span class="n">item</span>
1094	<span class="bp">self</span><span class="o">.</span><span class="n">_main</span><span class="p">[</span><span class="n">key</span><span class="p">]</span> <span class="o">=</span> <span class="n">value</span>
1095
1096	<span class="k">def</span> <span class="nf">insert</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">i</span><span class="p">,</span> <span class="n">item</span><span class="p">):</span>
1097	<span class="n">key</span><span class="p">,</span> <span class="n">value</span> <span class="o">=</span> <span class="n">item</span>
1098	<span class="bp">self</span><span class="o">.</span><span class="n">_main</span><span class="o">.</span><span class="n">insert</span><span class="p">(</span><span class="n">i</span><span class="p">,</span> <span class="n">key</span><span class="p">,</span> <span class="n">value</span><span class="p">)</span>
1099
1100	<span class="k">def</span> <span class="nf">pop</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">i</span><span class="o">=-</span><span class="mi">1</span><span class="p">):</span>
1101	<span class="n">key</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="n">_main</span><span class="o">.</span><span class="n">_sequence</span><span class="p">[</span><span class="n">i</span><span class="p">]</span>
1102	<span class="k">return</span> <span class="p">(</span><span class="n">key</span><span class="p">,</span> <span class="bp">self</span><span class="o">.</span><span class="n">_main</span><span class="o">.</span><span class="n">pop</span><span class="p">(</span><span class="n">key</span><span class="p">))</span>
1103
1104	<span class="k">def</span> <span class="nf">remove</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">item</span><span class="p">):</span>
1105	<span class="n">key</span><span class="p">,</span> <span class="n">value</span> <span class="o">=</span> <span class="n">item</span>
1106	<span class="k">try</span><span class="p">:</span>
1107	<span class="k">assert</span> <span class="n">value</span> <span class="o">==</span> <span class="bp">self</span><span class="o">.</span><span class="n">_main</span><span class="p">[</span><span class="n">key</span><span class="p">]</span>
1108	<span class="k">except</span> <span class="p">(</span><span class="ne">KeyError</span><span class="p">,</span> <span class="ne">AssertionError</span><span class="p">):</span>
1109	<span class="k">raise</span> <span class="ne">ValueError</span><span class="p">(</span><span class="s">'ValueError: list.remove(x): x not in list'</span><span class="p">)</span>
1110	<span class="k">else</span><span class="p">:</span>
1111	<span class="k">del</span> <span class="bp">self</span><span class="o">.</span><span class="n">_main</span><span class="p">[</span><span class="n">key</span><span class="p">]</span>
1112
1113	<span class="k">def</span> <span class="nf">extend</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">other</span><span class="p">):</span>
1114	<span class="c"># FIXME: is only a true extend if none of the keys already present</span>
1115	<span class="k">for</span> <span class="n">item</span> <span class="ow">in</span> <span class="n">other</span><span class="p">:</span>
1116	<span class="n">key</span><span class="p">,</span> <span class="n">value</span> <span class="o">=</span> <span class="n">item</span>
1117	<span class="bp">self</span><span class="o">.</span><span class="n">_main</span><span class="p">[</span><span class="n">key</span><span class="p">]</span> <span class="o">=</span> <span class="n">value</span>
1118
1119	<span class="k">def</span> <span class="nf">__iadd__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">other</span><span class="p">):</span>
1120	<span class="bp">self</span><span class="o">.</span><span class="n">extend</span><span class="p">(</span><span class="n">other</span><span class="p">)</span>
1121
1122	<span class="c">## following methods not implemented for items ##</span>
1123
1124	<span class="k">def</span> <span class="nf">__imul__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">n</span><span class="p">):</span> <span class="k">raise</span> <span class="ne">TypeError</span><span class="p">(</span><span class="s">'Can</span><span class="se">\'</span><span class="s">t multiply items in place'</span><span class="p">)</span>
1125
1126	<span class="k">class</span> <span class="nc">Values</span><span class="p">(</span><span class="nb">object</span><span class="p">):</span>
1127	<span class="sd">"""</span>
1128	<span class="sd"> Custom object for accessing the values of an OrderedDict.</span>
1129	<span class="sd"> </span>
1130	<span class="sd"> Can be called like the normal ``OrderedDict.values`` method, but also</span>
1131	<span class="sd"> supports indexing and sequence methods.</span>
1132	<span class="sd"> """</span>
1133
1134	<span class="k">def</span> <span class="nf">__init__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">main</span><span class="p">):</span>
1135	<span class="bp">self</span><span class="o">.</span><span class="n">_main</span> <span class="o">=</span> <span class="n">main</span>
1136
1137	<span class="k">def</span> <span class="nf">__call__</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
1138	<span class="sd">"""Pretend to be the values method."""</span>
1139	<span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="n">_main</span><span class="o">.</span><span class="n">_values</span><span class="p">()</span>
1140
1141	<span class="k">def</span> <span class="nf">__getitem__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">index</span><span class="p">):</span>
1142	<span class="sd">"""Fetch the value at position i."""</span>
1143	<span class="k">if</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">index</span><span class="p">,</span> <span class="n">types</span><span class="o">.</span><span class="n">SliceType</span><span class="p">):</span>
1144	<span class="k">return</span> <span class="p">[</span><span class="bp">self</span><span class="o">.</span><span class="n">_main</span><span class="p">[</span><span class="n">key</span><span class="p">]</span> <span class="k">for</span> <span class="n">key</span> <span class="ow">in</span> <span class="bp">self</span><span class="o">.</span><span class="n">_main</span><span class="o">.</span><span class="n">_sequence</span><span class="p">[</span><span class="n">index</span><span class="p">]]</span>
1145	<span class="k">else</span><span class="p">:</span>
1146	<span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="n">_main</span><span class="p">[</span><span class="bp">self</span><span class="o">.</span><span class="n">_main</span><span class="o">.</span><span class="n">_sequence</span><span class="p">[</span><span class="n">index</span><span class="p">]]</span>
1147
1148	<span class="k">def</span> <span class="nf">__setitem__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">index</span><span class="p">,</span> <span class="n">value</span><span class="p">):</span>
1149	<span class="sd">"""</span>
1150	<span class="sd"> Set the value at position i to value.</span>
1151	<span class="sd"> </span>
1152	<span class="sd"> You can only do slice assignment to values if you supply a sequence of</span>
1153	<span class="sd"> equal length to the slice you are replacing.</span>
1154	<span class="sd"> """</span>
1155	<span class="k">if</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">index</span><span class="p">,</span> <span class="n">types</span><span class="o">.</span><span class="n">SliceType</span><span class="p">):</span>
1156	<span class="n">keys</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="n">_main</span><span class="o">.</span><span class="n">_sequence</span><span class="p">[</span><span class="n">index</span><span class="p">]</span>
1157	<span class="k">if</span> <span class="nb">len</span><span class="p">(</span><span class="n">keys</span><span class="p">)</span> <span class="o">!=</span> <span class="nb">len</span><span class="p">(</span><span class="n">value</span><span class="p">):</span>
1158	<span class="k">raise</span> <span class="ne">ValueError</span><span class="p">(</span><span class="s">'attempt to assign sequence of size </span><span class="si">%s</span><span class="s"> '</span>
1159	<span class="s">'to slice of size </span><span class="si">%s</span><span class="s">'</span> <span class="o">%</span> <span class="p">(</span><span class="nb">len</span><span class="p">(</span><span class="n">name</span><span class="p">),</span> <span class="nb">len</span><span class="p">(</span><span class="n">keys</span><span class="p">)))</span>
1160	<span class="c"># FIXME: efficiency? Would be better to calculate the indexes</span>
1161	<span class="c"># directly from the slice object</span>
1162	<span class="c"># NOTE: the new keys can collide with existing keys (or even</span>
1163	<span class="c"># contain duplicates) - these will overwrite</span>
1164	<span class="k">for</span> <span class="n">key</span><span class="p">,</span> <span class="n">val</span> <span class="ow">in</span> <span class="nb">zip</span><span class="p">(</span><span class="n">keys</span><span class="p">,</span> <span class="n">value</span><span class="p">):</span>
1165	<span class="bp">self</span><span class="o">.</span><span class="n">_main</span><span class="p">[</span><span class="n">key</span><span class="p">]</span> <span class="o">=</span> <span class="n">val</span>
1166	<span class="k">else</span><span class="p">:</span>
1167	<span class="bp">self</span><span class="o">.</span><span class="n">_main</span><span class="p">[</span><span class="bp">self</span><span class="o">.</span><span class="n">_main</span><span class="o">.</span><span class="n">_sequence</span><span class="p">[</span><span class="n">index</span><span class="p">]]</span> <span class="o">=</span> <span class="n">value</span>
1168
1169	<span class="c">### following methods pinched from UserList and adapted ###</span>
1170	<span class="k">def</span> <span class="nf">__repr__</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span> <span class="k">return</span> <span class="nb">repr</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">_main</span><span class="o">.</span><span class="n">values</span><span class="p">())</span>
1171
1172	<span class="c"># FIXME: do we need to check if we are comparing with another ``Values``</span>
1173	<span class="c"># object? (like the __cast method of UserList)</span>
1174	<span class="k">def</span> <span class="nf">__lt__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">other</span><span class="p">):</span> <span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="n">_main</span><span class="o">.</span><span class="n">values</span><span class="p">()</span> <span class="o"><</span> <span class="n">other</span>
1175	<span class="k">def</span> <span class="nf">__le__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">other</span><span class="p">):</span> <span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="n">_main</span><span class="o">.</span><span class="n">values</span><span class="p">()</span> <span class="o"><=</span> <span class="n">other</span>
1176	<span class="k">def</span> <span class="nf">__eq__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">other</span><span class="p">):</span> <span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="n">_main</span><span class="o">.</span><span class="n">values</span><span class="p">()</span> <span class="o">==</span> <span class="n">other</span>
1177	<span class="k">def</span> <span class="nf">__ne__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">other</span><span class="p">):</span> <span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="n">_main</span><span class="o">.</span><span class="n">values</span><span class="p">()</span> <span class="o">!=</span> <span class="n">other</span>
1178	<span class="k">def</span> <span class="nf">__gt__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">other</span><span class="p">):</span> <span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="n">_main</span><span class="o">.</span><span class="n">values</span><span class="p">()</span> <span class="o">></span> <span class="n">other</span>
1179	<span class="k">def</span> <span class="nf">__ge__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">other</span><span class="p">):</span> <span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="n">_main</span><span class="o">.</span><span class="n">values</span><span class="p">()</span> <span class="o">>=</span> <span class="n">other</span>
1180	<span class="k">def</span> <span class="nf">__cmp__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">other</span><span class="p">):</span> <span class="k">return</span> <span class="nb">cmp</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">_main</span><span class="o">.</span><span class="n">values</span><span class="p">(),</span> <span class="n">other</span><span class="p">)</span>
1181
1182	<span class="k">def</span> <span class="nf">__contains__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">item</span><span class="p">):</span> <span class="k">return</span> <span class="n">item</span> <span class="ow">in</span> <span class="bp">self</span><span class="o">.</span><span class="n">_main</span><span class="o">.</span><span class="n">values</span><span class="p">()</span>
1183	<span class="k">def</span> <span class="nf">__len__</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span> <span class="k">return</span> <span class="nb">len</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">_main</span><span class="o">.</span><span class="n">_sequence</span><span class="p">)</span> <span class="c"># easier :-)</span>
1184	<span class="k">def</span> <span class="nf">__iter__</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span> <span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="n">_main</span><span class="o">.</span><span class="n">itervalues</span><span class="p">()</span>
1185	<span class="k">def</span> <span class="nf">count</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">item</span><span class="p">):</span> <span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="n">_main</span><span class="o">.</span><span class="n">values</span><span class="p">()</span><span class="o">.</span><span class="n">count</span><span class="p">(</span><span class="n">item</span><span class="p">)</span>
1186	<span class="k">def</span> <span class="nf">index</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">item</span><span class="p">,</span> <span class="o"></span><span class="n">args</span><span class="p">):</span> <span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="n">_main</span><span class="o">.</span><span class="n">values</span><span class="p">()</span><span class="o">.</span><span class="n">index</span><span class="p">(</span><span class="n">item</span><span class="p">,</span> <span class="o"></span><span class="n">args</span><span class="p">)</span>
1187
1188	<span class="k">def</span> <span class="nf">reverse</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
1189	<span class="sd">"""Reverse the values"""</span>
1190	<span class="n">vals</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="n">_main</span><span class="o">.</span><span class="n">values</span><span class="p">()</span>
1191	<span class="n">vals</span><span class="o">.</span><span class="n">reverse</span><span class="p">()</span>
1192	<span class="c"># FIXME: efficiency</span>
1193	<span class="bp">self</span><span class="p">[:]</span> <span class="o">=</span> <span class="n">vals</span>
1194
1195	<span class="k">def</span> <span class="nf">sort</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="o"></span><span class="n">args</span><span class="p">,</span> <span class="o">*</span><span class="n">kwds</span><span class="p">):</span>
1196	<span class="sd">"""Sort the values."""</span>
1197	<span class="n">vals</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="n">_main</span><span class="o">.</span><span class="n">values</span><span class="p">()</span>
1198	<span class="n">vals</span><span class="o">.</span><span class="n">sort</span><span class="p">(</span><span class="o"></span><span class="n">args</span><span class="p">,</span> <span class="o">*</span><span class="n">kwds</span><span class="p">)</span>
1199	<span class="bp">self</span><span class="p">[:]</span> <span class="o">=</span> <span class="n">vals</span>
1200
1201	<span class="k">def</span> <span class="nf">__mul__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">n</span><span class="p">):</span> <span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="n">_main</span><span class="o">.</span><span class="n">values</span><span class="p">()</span><span class="o">*</span><span class="n">n</span>
1202	<span class="n">__rmul__</span> <span class="o">=</span> <span class="n">__mul__</span>
1203	<span class="k">def</span> <span class="nf">__add__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">other</span><span class="p">):</span> <span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="n">_main</span><span class="o">.</span><span class="n">values</span><span class="p">()</span> <span class="o">+</span> <span class="n">other</span>
1204	<span class="k">def</span> <span class="nf">__radd__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">other</span><span class="p">):</span> <span class="k">return</span> <span class="n">other</span> <span class="o">+</span> <span class="bp">self</span><span class="o">.</span><span class="n">_main</span><span class="o">.</span><span class="n">values</span><span class="p">()</span>
1205
1206	<span class="c">## following methods not implemented for values ##</span>
1207	<span class="k">def</span> <span class="nf">__delitem__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">i</span><span class="p">):</span> <span class="k">raise</span> <span class="ne">TypeError</span><span class="p">(</span><span class="s">'Can</span><span class="se">\'</span><span class="s">t delete items from values'</span><span class="p">)</span>
1208	<span class="k">def</span> <span class="nf">__iadd__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">other</span><span class="p">):</span> <span class="k">raise</span> <span class="ne">TypeError</span><span class="p">(</span><span class="s">'Can</span><span class="se">\'</span><span class="s">t add in place to values'</span><span class="p">)</span>
1209	<span class="k">def</span> <span class="nf">__imul__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">n</span><span class="p">):</span> <span class="k">raise</span> <span class="ne">TypeError</span><span class="p">(</span><span class="s">'Can</span><span class="se">\'</span><span class="s">t multiply values in place'</span><span class="p">)</span>
1210	<span class="k">def</span> <span class="nf">append</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">item</span><span class="p">):</span> <span class="k">raise</span> <span class="ne">TypeError</span><span class="p">(</span><span class="s">'Can</span><span class="se">\'</span><span class="s">t append items to values'</span><span class="p">)</span>
1211	<span class="k">def</span> <span class="nf">insert</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">i</span><span class="p">,</span> <span class="n">item</span><span class="p">):</span> <span class="k">raise</span> <span class="ne">TypeError</span><span class="p">(</span><span class="s">'Can</span><span class="se">\'</span><span class="s">t insert items into values'</span><span class="p">)</span>
1212	<span class="k">def</span> <span class="nf">pop</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">i</span><span class="o">=-</span><span class="mi">1</span><span class="p">):</span> <span class="k">raise</span> <span class="ne">TypeError</span><span class="p">(</span><span class="s">'Can</span><span class="se">\'</span><span class="s">t pop items from values'</span><span class="p">)</span>
1213	<span class="k">def</span> <span class="nf">remove</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">item</span><span class="p">):</span> <span class="k">raise</span> <span class="ne">TypeError</span><span class="p">(</span><span class="s">'Can</span><span class="se">\'</span><span class="s">t remove items from values'</span><span class="p">)</span>
1214	<span class="k">def</span> <span class="nf">extend</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">other</span><span class="p">):</span> <span class="k">raise</span> <span class="ne">TypeError</span><span class="p">(</span><span class="s">'Can</span><span class="se">\'</span><span class="s">t extend values'</span><span class="p">)</span>
1215
1216	<div class="viewcode-block" id="SequenceOrderedDict"><a class="viewcode-back" href="../../../dev/api/sas.data_util.html#sas.data_util.odict.SequenceOrderedDict">[docs]</a><span class="k">class</span> <span class="nc">SequenceOrderedDict</span><span class="p">(</span><span class="n">OrderedDict</span><span class="p">):</span>
1217	<span class="sd">"""</span>
1218	<span class="sd"> Experimental version of OrderedDict that has a custom object for ``keys``,</span>
1219	<span class="sd"> ``values``, and ``items``.</span>
1220	<span class="sd"> </span>
1221	<span class="sd"> These are callable sequence objects that work as methods, or can be</span>
1222	<span class="sd"> manipulated directly as sequences.</span>
1223	<span class="sd"> </span>
1224	<span class="sd"> Test for ``keys``, ``items`` and ``values``.</span>
1225	<span class="sd"> </span>
1226	<span class="sd"> >>> d = SequenceOrderedDict(((1, 2), (2, 3), (3, 4)))</span>
1227	<span class="sd"> >>> d</span>
1228	<span class="sd"> SequenceOrderedDict([(1, 2), (2, 3), (3, 4)])</span>
1229	<span class="sd"> >>> d.keys</span>
1230	<span class="sd"> [1, 2, 3]</span>
1231	<span class="sd"> >>> d.keys()</span>
1232	<span class="sd"> [1, 2, 3]</span>
1233	<span class="sd"> >>> d.setkeys((3, 2, 1))</span>
1234	<span class="sd"> >>> d</span>
1235	<span class="sd"> SequenceOrderedDict([(3, 4), (2, 3), (1, 2)])</span>
1236	<span class="sd"> >>> d.setkeys((1, 2, 3))</span>
1237	<span class="sd"> >>> d.keys[0]</span>
1238	<span class="sd"> 1</span>
1239	<span class="sd"> >>> d.keys[:]</span>
1240	<span class="sd"> [1, 2, 3]</span>
1241	<span class="sd"> >>> d.keys[-1]</span>
1242	<span class="sd"> 3</span>
1243	<span class="sd"> >>> d.keys[-2]</span>
1244	<span class="sd"> 2</span>
1245	<span class="sd"> >>> d.keys[0:2] = [2, 1]</span>
1246	<span class="sd"> >>> d</span>
1247	<span class="sd"> SequenceOrderedDict([(2, 3), (1, 2), (3, 4)])</span>
1248	<span class="sd"> >>> d.keys.reverse()</span>
1249	<span class="sd"> >>> d.keys</span>
1250	<span class="sd"> [3, 1, 2]</span>
1251	<span class="sd"> >>> d.keys = [1, 2, 3]</span>
1252	<span class="sd"> >>> d</span>
1253	<span class="sd"> SequenceOrderedDict([(1, 2), (2, 3), (3, 4)])</span>
1254	<span class="sd"> >>> d.keys = [3, 1, 2]</span>
1255	<span class="sd"> >>> d</span>
1256	<span class="sd"> SequenceOrderedDict([(3, 4), (1, 2), (2, 3)])</span>
1257	<span class="sd"> >>> a = SequenceOrderedDict()</span>
1258	<span class="sd"> >>> b = SequenceOrderedDict()</span>
1259	<span class="sd"> >>> a.keys == b.keys</span>
1260	<span class="sd"> 1</span>
1261	<span class="sd"> >>> a['a'] = 3</span>
1262	<span class="sd"> >>> a.keys == b.keys</span>
1263	<span class="sd"> 0</span>
1264	<span class="sd"> >>> b['a'] = 3</span>
1265	<span class="sd"> >>> a.keys == b.keys</span>
1266	<span class="sd"> 1</span>
1267	<span class="sd"> >>> b['b'] = 3</span>
1268	<span class="sd"> >>> a.keys == b.keys</span>
1269	<span class="sd"> 0</span>
1270	<span class="sd"> >>> a.keys > b.keys</span>
1271	<span class="sd"> 0</span>
1272	<span class="sd"> >>> a.keys < b.keys</span>
1273	<span class="sd"> 1</span>
1274	<span class="sd"> >>> 'a' in a.keys</span>
1275	<span class="sd"> 1</span>
1276	<span class="sd"> >>> len(b.keys)</span>
1277	<span class="sd"> 2</span>
1278	<span class="sd"> >>> 'c' in d.keys</span>
1279	<span class="sd"> 0</span>
1280	<span class="sd"> >>> 1 in d.keys</span>
1281	<span class="sd"> 1</span>
1282	<span class="sd"> >>> [v for v in d.keys]</span>
1283	<span class="sd"> [3, 1, 2]</span>
1284	<span class="sd"> >>> d.keys.sort()</span>
1285	<span class="sd"> >>> d.keys</span>
1286	<span class="sd"> [1, 2, 3]</span>
1287	<span class="sd"> >>> d = SequenceOrderedDict(((1, 2), (2, 3), (3, 4)), strict=True)</span>
1288	<span class="sd"> >>> d.keys[::-1] = [1, 2, 3]</span>
1289	<span class="sd"> >>> d</span>
1290	<span class="sd"> SequenceOrderedDict([(3, 4), (2, 3), (1, 2)])</span>
1291	<span class="sd"> >>> d.keys[:2]</span>
1292	<span class="sd"> [3, 2]</span>
1293	<span class="sd"> >>> d.keys[:2] = [1, 3]</span>
1294	<span class="sd"> Traceback (most recent call last):</span>
1295	<span class="sd"> KeyError: 'Keylist is not the same as current keylist.'</span>
1296
1297	<span class="sd"> >>> d = SequenceOrderedDict(((1, 2), (2, 3), (3, 4)))</span>
1298	<span class="sd"> >>> d</span>
1299	<span class="sd"> SequenceOrderedDict([(1, 2), (2, 3), (3, 4)])</span>
1300	<span class="sd"> >>> d.values</span>
1301	<span class="sd"> [2, 3, 4]</span>
1302	<span class="sd"> >>> d.values()</span>
1303	<span class="sd"> [2, 3, 4]</span>
1304	<span class="sd"> >>> d.setvalues((4, 3, 2))</span>
1305	<span class="sd"> >>> d</span>
1306	<span class="sd"> SequenceOrderedDict([(1, 4), (2, 3), (3, 2)])</span>
1307	<span class="sd"> >>> d.values[::-1]</span>
1308	<span class="sd"> [2, 3, 4]</span>
1309	<span class="sd"> >>> d.values[0]</span>
1310	<span class="sd"> 4</span>
1311	<span class="sd"> >>> d.values[-2]</span>
1312	<span class="sd"> 3</span>
1313	<span class="sd"> >>> del d.values[0]</span>
1314	<span class="sd"> Traceback (most recent call last):</span>
1315	<span class="sd"> TypeError: Can't delete items from values</span>
1316	<span class="sd"> >>> d.values[::2] = [2, 4]</span>
1317	<span class="sd"> >>> d</span>
1318	<span class="sd"> SequenceOrderedDict([(1, 2), (2, 3), (3, 4)])</span>
1319	<span class="sd"> >>> 7 in d.values</span>
1320	<span class="sd"> 0</span>
1321	<span class="sd"> >>> len(d.values)</span>
1322	<span class="sd"> 3</span>
1323	<span class="sd"> >>> [val for val in d.values]</span>
1324	<span class="sd"> [2, 3, 4]</span>
1325	<span class="sd"> >>> d.values[-1] = 2</span>
1326	<span class="sd"> >>> d.values.count(2)</span>
1327	<span class="sd"> 2</span>
1328	<span class="sd"> >>> d.values.index(2)</span>
1329	<span class="sd"> 0</span>
1330	<span class="sd"> >>> d.values[-1] = 7</span>
1331	<span class="sd"> >>> d.values</span>
1332	<span class="sd"> [2, 3, 7]</span>
1333	<span class="sd"> >>> d.values.reverse()</span>
1334	<span class="sd"> >>> d.values</span>
1335	<span class="sd"> [7, 3, 2]</span>
1336	<span class="sd"> >>> d.values.sort()</span>
1337	<span class="sd"> >>> d.values</span>
1338	<span class="sd"> [2, 3, 7]</span>
1339	<span class="sd"> >>> d.values.append('anything')</span>
1340	<span class="sd"> Traceback (most recent call last):</span>
1341	<span class="sd"> TypeError: Can't append items to values</span>
1342	<span class="sd"> >>> d.values = (1, 2, 3)</span>
1343	<span class="sd"> >>> d</span>
1344	<span class="sd"> SequenceOrderedDict([(1, 1), (2, 2), (3, 3)])</span>
1345	<span class="sd"> </span>
1346	<span class="sd"> >>> d = SequenceOrderedDict(((1, 2), (2, 3), (3, 4)))</span>
1347	<span class="sd"> >>> d</span>
1348	<span class="sd"> SequenceOrderedDict([(1, 2), (2, 3), (3, 4)])</span>
1349	<span class="sd"> >>> d.items()</span>
1350	<span class="sd"> [(1, 2), (2, 3), (3, 4)]</span>
1351	<span class="sd"> >>> d.setitems([(3, 4), (2 ,3), (1, 2)])</span>
1352	<span class="sd"> >>> d</span>
1353	<span class="sd"> SequenceOrderedDict([(3, 4), (2, 3), (1, 2)])</span>
1354	<span class="sd"> >>> d.items[0]</span>
1355	<span class="sd"> (3, 4)</span>
1356	<span class="sd"> >>> d.items[:-1]</span>
1357	<span class="sd"> [(3, 4), (2, 3)]</span>
1358	<span class="sd"> >>> d.items[1] = (6, 3)</span>
1359	<span class="sd"> >>> d.items</span>
1360	<span class="sd"> [(3, 4), (6, 3), (1, 2)]</span>
1361	<span class="sd"> >>> d.items[1:2] = [(9, 9)]</span>
1362	<span class="sd"> >>> d</span>
1363	<span class="sd"> SequenceOrderedDict([(3, 4), (9, 9), (1, 2)])</span>
1364	<span class="sd"> >>> del d.items[1:2]</span>
1365	<span class="sd"> >>> d</span>
1366	<span class="sd"> SequenceOrderedDict([(3, 4), (1, 2)])</span>
1367	<span class="sd"> >>> (3, 4) in d.items</span>
1368	<span class="sd"> 1</span>
1369	<span class="sd"> >>> (4, 3) in d.items</span>
1370	<span class="sd"> 0</span>
1371	<span class="sd"> >>> len(d.items)</span>
1372	<span class="sd"> 2</span>
1373	<span class="sd"> >>> [v for v in d.items]</span>
1374	<span class="sd"> [(3, 4), (1, 2)]</span>
1375	<span class="sd"> >>> d.items.count((3, 4))</span>
1376	<span class="sd"> 1</span>
1377	<span class="sd"> >>> d.items.index((1, 2))</span>
1378	<span class="sd"> 1</span>
1379	<span class="sd"> >>> d.items.index((2, 1))</span>
1380	<span class="sd"> Traceback (most recent call last):</span>
1381	<span class="sd"> ValueError: list.index(x): x not in list</span>
1382	<span class="sd"> >>> d.items.reverse()</span>
1383	<span class="sd"> >>> d.items</span>
1384	<span class="sd"> [(1, 2), (3, 4)]</span>
1385	<span class="sd"> >>> d.items.reverse()</span>
1386	<span class="sd"> >>> d.items.sort()</span>
1387	<span class="sd"> >>> d.items</span>
1388	<span class="sd"> [(1, 2), (3, 4)]</span>
1389	<span class="sd"> >>> d.items.append((5, 6))</span>
1390	<span class="sd"> >>> d.items</span>
1391	<span class="sd"> [(1, 2), (3, 4), (5, 6)]</span>
1392	<span class="sd"> >>> d.items.insert(0, (0, 0))</span>
1393	<span class="sd"> >>> d.items</span>
1394	<span class="sd"> [(0, 0), (1, 2), (3, 4), (5, 6)]</span>
1395	<span class="sd"> >>> d.items.insert(-1, (7, 8))</span>
1396	<span class="sd"> >>> d.items</span>
1397	<span class="sd"> [(0, 0), (1, 2), (3, 4), (7, 8), (5, 6)]</span>
1398	<span class="sd"> >>> d.items.pop()</span>
1399	<span class="sd"> (5, 6)</span>
1400	<span class="sd"> >>> d.items</span>
1401	<span class="sd"> [(0, 0), (1, 2), (3, 4), (7, 8)]</span>
1402	<span class="sd"> >>> d.items.remove((1, 2))</span>
1403	<span class="sd"> >>> d.items</span>
1404	<span class="sd"> [(0, 0), (3, 4), (7, 8)]</span>
1405	<span class="sd"> >>> d.items.extend([(1, 2), (5, 6)])</span>
1406	<span class="sd"> >>> d.items</span>
1407	<span class="sd"> [(0, 0), (3, 4), (7, 8), (1, 2), (5, 6)]</span>
1408	<span class="sd"> """</span>
1409
1410	<span class="k">def</span> <span class="nf">__init__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">init_val</span><span class="o">=</span><span class="p">(),</span> <span class="n">strict</span><span class="o">=</span><span class="bp">True</span><span class="p">):</span>
1411	<span class="n">OrderedDict</span><span class="o">.</span><span class="n">__init__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">init_val</span><span class="p">,</span> <span class="n">strict</span><span class="o">=</span><span class="n">strict</span><span class="p">)</span>
1412	<span class="bp">self</span><span class="o">.</span><span class="n">_keys</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="n">keys</span>
1413	<span class="bp">self</span><span class="o">.</span><span class="n">_values</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="n">values</span>
1414	<span class="bp">self</span><span class="o">.</span><span class="n">_items</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="n">items</span>
1415	<span class="bp">self</span><span class="o">.</span><span class="n">keys</span> <span class="o">=</span> <span class="n">Keys</span><span class="p">(</span><span class="bp">self</span><span class="p">)</span>
1416	<span class="bp">self</span><span class="o">.</span><span class="n">values</span> <span class="o">=</span> <span class="n">Values</span><span class="p">(</span><span class="bp">self</span><span class="p">)</span>
1417	<span class="bp">self</span><span class="o">.</span><span class="n">items</span> <span class="o">=</span> <span class="n">Items</span><span class="p">(</span><span class="bp">self</span><span class="p">)</span>
1418	<span class="bp">self</span><span class="o">.</span><span class="n">_att_dict</span> <span class="o">=</span> <span class="p">{</span>
1419	<span class="s">'keys'</span><span class="p">:</span> <span class="bp">self</span><span class="o">.</span><span class="n">setkeys</span><span class="p">,</span>
1420	<span class="s">'items'</span><span class="p">:</span> <span class="bp">self</span><span class="o">.</span><span class="n">setitems</span><span class="p">,</span>
1421	<span class="s">'values'</span><span class="p">:</span> <span class="bp">self</span><span class="o">.</span><span class="n">setvalues</span><span class="p">,</span>
1422	<span class="p">}</span>
1423
1424	<span class="k">def</span> <span class="nf">__setattr__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">name</span><span class="p">,</span> <span class="n">value</span><span class="p">):</span>
1425	<span class="sd">"""Protect keys, items, and values."""</span>
1426	<span class="k">if</span> <span class="ow">not</span> <span class="s">'_att_dict'</span> <span class="ow">in</span> <span class="bp">self</span><span class="o">.</span><span class="n">__dict__</span><span class="p">:</span>
1427	<span class="nb">object</span><span class="o">.</span><span class="n">__setattr__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">name</span><span class="p">,</span> <span class="n">value</span><span class="p">)</span>
1428	<span class="k">else</span><span class="p">:</span>
1429	<span class="k">try</span><span class="p">:</span>
1430	<span class="n">fun</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="n">_att_dict</span><span class="p">[</span><span class="n">name</span><span class="p">]</span>
1431	<span class="k">except</span> <span class="ne">KeyError</span><span class="p">:</span>
1432	<span class="n">OrderedDict</span><span class="o">.</span><span class="n">__setattr__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">name</span><span class="p">,</span> <span class="n">value</span><span class="p">)</span>
1433	<span class="k">else</span><span class="p">:</span>
1434	<span class="n">fun</span><span class="p">(</span><span class="n">value</span><span class="p">)</span>
1435	</div>
1436	<span class="k">if</span> <span class="n">__name__</span> <span class="o">==</span> <span class="s">'__main__'</span><span class="p">:</span>
1437	<span class="k">if</span> <span class="n">INTP_VER</span> <span class="o"><</span> <span class="p">(</span><span class="mi">2</span><span class="p">,</span> <span class="mi">3</span><span class="p">):</span>
1438	<span class="k">raise</span> <span class="ne">RuntimeError</span><span class="p">(</span><span class="s">"Tests require Python v.2.3 or later"</span><span class="p">)</span>
1439	<span class="c"># turn off warnings for tests</span>
1440	<span class="n">warnings</span><span class="o">.</span><span class="n">filterwarnings</span><span class="p">(</span><span class="s">'ignore'</span><span class="p">)</span>
1441	<span class="c"># run the code tests in doctest format</span>
1442	<span class="kn">import</span> <span class="nn">doctest</span>
1443	<span class="n">m</span> <span class="o">=</span> <span class="n">sys</span><span class="o">.</span><span class="n">modules</span><span class="o">.</span><span class="n">get</span><span class="p">(</span><span class="s">'__main__'</span><span class="p">)</span>
1444	<span class="n">globs</span> <span class="o">=</span> <span class="n">m</span><span class="o">.</span><span class="n">__dict__</span><span class="o">.</span><span class="n">copy</span><span class="p">()</span>
1445	<span class="n">globs</span><span class="o">.</span><span class="n">update</span><span class="p">({</span>
1446	<span class="s">'INTP_VER'</span><span class="p">:</span> <span class="n">INTP_VER</span><span class="p">,</span>
1447	<span class="p">})</span>
1448	<span class="n">doctest</span><span class="o">.</span><span class="n">testmod</span><span class="p">(</span><span class="n">m</span><span class="p">,</span> <span class="n">globs</span><span class="o">=</span><span class="n">globs</span><span class="p">)</span>
1449	</pre></div>
1450
1451	</div>
1452	</div>
1453	</div>
1454	<div class="sphinxsidebar">
1455	<div class="sphinxsidebarwrapper">
1456	<div id="searchbox" style="display: none">
1457	<h3>Quick search</h3>
1458	<form class="search" action="../../../search.html" method="get">
1459	<input type="text" name="q" />
1460	<input type="submit" value="Go" />
1461	<input type="hidden" name="check_keywords" value="yes" />
1462	<input type="hidden" name="area" value="default" />
1463	</form>
1464	<p class="searchtip" style="font-size: 90%">
1465	Enter search terms or a module, class or function name.
1466	</p>
1467	</div>
1468	<script type="text/javascript">$('#searchbox').show(0);</script>
1469	</div>
1470	</div>
1471	<div class="clearer"></div>
1472	</div>
1473	<div class="related">
1474	<h3>Navigation</h3>
1475	<ul>
1476	<li class="right" style="margin-right: 10px">
1477	<a href="../../../genindex.html" title="General Index"
1478	>index</a></li>
1479	<li class="right" >
1480	<a href="../../../py-modindex.html" title="Python Module Index"
1481	>modules</a> \|</li>
1482	<li><a href="../../../index.html">SasView 3.0.0 documentation</a> »</li>
1483	<li><a href="../../index.html" >Module code</a> »</li>
1484	</ul>
1485	</div>
1486	<div class="footer">
1487	© Copyright 2013, The SasView Project.
1488	Created using <a href="http://sphinx-doc.org/">Sphinx</a> 1.2.3.
1489	</div>
1490	</body>
1491	</html>

Note: See TracBrowser for help on using the repository browser.

SasView

source: sasview/_modules/sas/data_util/odict.html @ a462c6a

Download in other formats: