mirror of
https://github.com/evennia/evennia.git
synced 2026-03-18 22:06:30 +01:00
1386 lines
No EOL
197 KiB
HTML
1386 lines
No EOL
197 KiB
HTML
|
|
<!DOCTYPE html>
|
|
|
|
<html xmlns="http://www.w3.org/1999/xhtml">
|
|
<head>
|
|
<meta charset="utf-8" />
|
|
<title>collections — Evennia 1.0-dev documentation</title>
|
|
<link rel="stylesheet" href="../_static/nature.css" type="text/css" />
|
|
<link rel="stylesheet" href="../_static/pygments.css" type="text/css" />
|
|
<script id="documentation_options" data-url_root="../" src="../_static/documentation_options.js"></script>
|
|
<script src="../_static/jquery.js"></script>
|
|
<script src="../_static/underscore.js"></script>
|
|
<script src="../_static/doctools.js"></script>
|
|
<script src="../_static/language_data.js"></script>
|
|
<link rel="shortcut icon" href="../_static/favicon.ico"/>
|
|
<link rel="index" title="Index" href="../genindex.html" />
|
|
<link rel="search" title="Search" href="../search.html" />
|
|
</head><body>
|
|
<div class="related" role="navigation" aria-label="related navigation">
|
|
<h3>Navigation</h3>
|
|
<ul>
|
|
<li class="right" style="margin-right: 10px">
|
|
<a href="../genindex.html" title="General Index"
|
|
accesskey="I">index</a></li>
|
|
<li class="right" >
|
|
<a href="../py-modindex.html" title="Python Module Index"
|
|
>modules</a> |</li>
|
|
<li class="nav-item nav-item-0"><a href="../index.html">Evennia 1.0-dev documentation</a> »</li>
|
|
<li class="nav-item nav-item-1"><a href="index.html" accesskey="U">Module code</a> »</li>
|
|
</ul>
|
|
</div>
|
|
|
|
<div class="document">
|
|
<div class="documentwrapper">
|
|
<div class="bodywrapper">
|
|
<div class="body" role="main">
|
|
|
|
<h1>Source code for collections</h1><div class="highlight"><pre>
|
|
<span></span><span class="sd">'''This module implements specialized container datatypes providing</span>
|
|
<span class="sd">alternatives to Python's general purpose built-in containers, dict,</span>
|
|
<span class="sd">list, set, and tuple.</span>
|
|
|
|
<span class="sd">* namedtuple factory function for creating tuple subclasses with named fields</span>
|
|
<span class="sd">* deque list-like container with fast appends and pops on either end</span>
|
|
<span class="sd">* ChainMap dict-like class for creating a single view of multiple mappings</span>
|
|
<span class="sd">* Counter dict subclass for counting hashable objects</span>
|
|
<span class="sd">* OrderedDict dict subclass that remembers the order entries were added</span>
|
|
<span class="sd">* defaultdict dict subclass that calls a factory function to supply missing values</span>
|
|
<span class="sd">* UserDict wrapper around dictionary objects for easier dict subclassing</span>
|
|
<span class="sd">* UserList wrapper around list objects for easier list subclassing</span>
|
|
<span class="sd">* UserString wrapper around string objects for easier string subclassing</span>
|
|
|
|
<span class="sd">'''</span>
|
|
|
|
<span class="n">__all__</span> <span class="o">=</span> <span class="p">[</span><span class="s1">'deque'</span><span class="p">,</span> <span class="s1">'defaultdict'</span><span class="p">,</span> <span class="s1">'namedtuple'</span><span class="p">,</span> <span class="s1">'UserDict'</span><span class="p">,</span> <span class="s1">'UserList'</span><span class="p">,</span>
|
|
<span class="s1">'UserString'</span><span class="p">,</span> <span class="s1">'Counter'</span><span class="p">,</span> <span class="s1">'OrderedDict'</span><span class="p">,</span> <span class="s1">'ChainMap'</span><span class="p">]</span>
|
|
|
|
<span class="kn">import</span> <span class="nn">_collections_abc</span>
|
|
<span class="kn">from</span> <span class="nn">operator</span> <span class="k">import</span> <span class="n">itemgetter</span> <span class="k">as</span> <span class="n">_itemgetter</span><span class="p">,</span> <span class="n">eq</span> <span class="k">as</span> <span class="n">_eq</span>
|
|
<span class="kn">from</span> <span class="nn">keyword</span> <span class="k">import</span> <span class="n">iskeyword</span> <span class="k">as</span> <span class="n">_iskeyword</span>
|
|
<span class="kn">import</span> <span class="nn">sys</span> <span class="k">as</span> <span class="nn">_sys</span>
|
|
<span class="kn">import</span> <span class="nn">heapq</span> <span class="k">as</span> <span class="nn">_heapq</span>
|
|
<span class="kn">from</span> <span class="nn">_weakref</span> <span class="k">import</span> <span class="n">proxy</span> <span class="k">as</span> <span class="n">_proxy</span>
|
|
<span class="kn">from</span> <span class="nn">itertools</span> <span class="k">import</span> <span class="n">repeat</span> <span class="k">as</span> <span class="n">_repeat</span><span class="p">,</span> <span class="n">chain</span> <span class="k">as</span> <span class="n">_chain</span><span class="p">,</span> <span class="n">starmap</span> <span class="k">as</span> <span class="n">_starmap</span>
|
|
<span class="kn">from</span> <span class="nn">reprlib</span> <span class="k">import</span> <span class="n">recursive_repr</span> <span class="k">as</span> <span class="n">_recursive_repr</span>
|
|
|
|
<span class="k">try</span><span class="p">:</span>
|
|
<span class="kn">from</span> <span class="nn">_collections</span> <span class="k">import</span> <span class="n">deque</span>
|
|
<span class="k">except</span> <span class="ne">ImportError</span><span class="p">:</span>
|
|
<span class="k">pass</span>
|
|
<span class="k">else</span><span class="p">:</span>
|
|
<span class="n">_collections_abc</span><span class="o">.</span><span class="n">MutableSequence</span><span class="o">.</span><span class="n">register</span><span class="p">(</span><span class="n">deque</span><span class="p">)</span>
|
|
|
|
<span class="k">try</span><span class="p">:</span>
|
|
<span class="kn">from</span> <span class="nn">_collections</span> <span class="k">import</span> <span class="n">defaultdict</span>
|
|
<span class="k">except</span> <span class="ne">ImportError</span><span class="p">:</span>
|
|
<span class="k">pass</span>
|
|
|
|
|
|
<span class="k">def</span> <span class="nf">__getattr__</span><span class="p">(</span><span class="n">name</span><span class="p">):</span>
|
|
<span class="c1"># For backwards compatibility, continue to make the collections ABCs</span>
|
|
<span class="c1"># through Python 3.6 available through the collections module.</span>
|
|
<span class="c1"># Note, no new collections ABCs were added in Python 3.7</span>
|
|
<span class="k">if</span> <span class="n">name</span> <span class="ow">in</span> <span class="n">_collections_abc</span><span class="o">.</span><span class="n">__all__</span><span class="p">:</span>
|
|
<span class="n">obj</span> <span class="o">=</span> <span class="nb">getattr</span><span class="p">(</span><span class="n">_collections_abc</span><span class="p">,</span> <span class="n">name</span><span class="p">)</span>
|
|
<span class="kn">import</span> <span class="nn">warnings</span>
|
|
<span class="n">warnings</span><span class="o">.</span><span class="n">warn</span><span class="p">(</span><span class="s2">"Using or importing the ABCs from 'collections' instead "</span>
|
|
<span class="s2">"of from 'collections.abc' is deprecated since Python 3.3,"</span>
|
|
<span class="s2">"and in 3.9 it will stop working"</span><span class="p">,</span>
|
|
<span class="ne">DeprecationWarning</span><span class="p">,</span> <span class="n">stacklevel</span><span class="o">=</span><span class="mi">2</span><span class="p">)</span>
|
|
<span class="nb">globals</span><span class="p">()[</span><span class="n">name</span><span class="p">]</span> <span class="o">=</span> <span class="n">obj</span>
|
|
<span class="k">return</span> <span class="n">obj</span>
|
|
<span class="k">raise</span> <span class="ne">AttributeError</span><span class="p">(</span><span class="n">f</span><span class="s1">'module </span><span class="si">{__name__!r}</span><span class="s1"> has no attribute </span><span class="si">{name!r}</span><span class="s1">'</span><span class="p">)</span>
|
|
|
|
<span class="c1">################################################################################</span>
|
|
<span class="c1">### OrderedDict</span>
|
|
<span class="c1">################################################################################</span>
|
|
|
|
<span class="k">class</span> <span class="nc">_OrderedDictKeysView</span><span class="p">(</span><span class="n">_collections_abc</span><span class="o">.</span><span class="n">KeysView</span><span class="p">):</span>
|
|
|
|
<span class="k">def</span> <span class="nf">__reversed__</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
|
|
<span class="k">yield from</span> <span class="nb">reversed</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">_mapping</span><span class="p">)</span>
|
|
|
|
<span class="k">class</span> <span class="nc">_OrderedDictItemsView</span><span class="p">(</span><span class="n">_collections_abc</span><span class="o">.</span><span class="n">ItemsView</span><span class="p">):</span>
|
|
|
|
<span class="k">def</span> <span class="nf">__reversed__</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
|
|
<span class="k">for</span> <span class="n">key</span> <span class="ow">in</span> <span class="nb">reversed</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">_mapping</span><span class="p">):</span>
|
|
<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="o">.</span><span class="n">_mapping</span><span class="p">[</span><span class="n">key</span><span class="p">])</span>
|
|
|
|
<span class="k">class</span> <span class="nc">_OrderedDictValuesView</span><span class="p">(</span><span class="n">_collections_abc</span><span class="o">.</span><span class="n">ValuesView</span><span class="p">):</span>
|
|
|
|
<span class="k">def</span> <span class="nf">__reversed__</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
|
|
<span class="k">for</span> <span class="n">key</span> <span class="ow">in</span> <span class="nb">reversed</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">_mapping</span><span class="p">):</span>
|
|
<span class="k">yield</span> <span class="bp">self</span><span class="o">.</span><span class="n">_mapping</span><span class="p">[</span><span class="n">key</span><span class="p">]</span>
|
|
|
|
<span class="k">class</span> <span class="nc">_Link</span><span class="p">(</span><span class="nb">object</span><span class="p">):</span>
|
|
<span class="vm">__slots__</span> <span class="o">=</span> <span class="s1">'prev'</span><span class="p">,</span> <span class="s1">'next'</span><span class="p">,</span> <span class="s1">'key'</span><span class="p">,</span> <span class="s1">'__weakref__'</span>
|
|
|
|
<span class="k">class</span> <span class="nc">OrderedDict</span><span class="p">(</span><span class="nb">dict</span><span class="p">):</span>
|
|
<span class="s1">'Dictionary that remembers insertion order'</span>
|
|
<span class="c1"># An inherited dict maps keys to values.</span>
|
|
<span class="c1"># The inherited dict provides __getitem__, __len__, __contains__, and get.</span>
|
|
<span class="c1"># The remaining methods are order-aware.</span>
|
|
<span class="c1"># Big-O running times for all methods are the same as regular dictionaries.</span>
|
|
|
|
<span class="c1"># The internal self.__map dict maps keys to links in a doubly linked list.</span>
|
|
<span class="c1"># The circular doubly linked list starts and ends with a sentinel element.</span>
|
|
<span class="c1"># The sentinel element never gets deleted (this simplifies the algorithm).</span>
|
|
<span class="c1"># The sentinel is in self.__hardroot with a weakref proxy in self.__root.</span>
|
|
<span class="c1"># The prev links are weakref proxies (to prevent circular references).</span>
|
|
<span class="c1"># Individual links are kept alive by the hard reference in self.__map.</span>
|
|
<span class="c1"># Those hard references disappear when a key is deleted from an OrderedDict.</span>
|
|
|
|
<span class="k">def</span> <span class="nf">__init__</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="sd">'''Initialize an ordered dictionary. The signature is the same as</span>
|
|
<span class="sd"> regular dictionaries. Keyword argument order is preserved.</span>
|
|
<span class="sd"> '''</span>
|
|
<span class="k">if</span> <span class="ow">not</span> <span class="n">args</span><span class="p">:</span>
|
|
<span class="k">raise</span> <span class="ne">TypeError</span><span class="p">(</span><span class="s2">"descriptor '__init__' of 'OrderedDict' object "</span>
|
|
<span class="s2">"needs an argument"</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="o">=</span> <span class="n">args</span>
|
|
<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>
|
|
<span class="k">raise</span> <span class="ne">TypeError</span><span class="p">(</span><span class="s1">'expected at most 1 arguments, got </span><span class="si">%d</span><span class="s1">'</span> <span class="o">%</span> <span class="nb">len</span><span class="p">(</span><span class="n">args</span><span class="p">))</span>
|
|
<span class="k">try</span><span class="p">:</span>
|
|
<span class="bp">self</span><span class="o">.</span><span class="n">__root</span>
|
|
<span class="k">except</span> <span class="ne">AttributeError</span><span class="p">:</span>
|
|
<span class="bp">self</span><span class="o">.</span><span class="n">__hardroot</span> <span class="o">=</span> <span class="n">_Link</span><span class="p">()</span>
|
|
<span class="bp">self</span><span class="o">.</span><span class="n">__root</span> <span class="o">=</span> <span class="n">root</span> <span class="o">=</span> <span class="n">_proxy</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">__hardroot</span><span class="p">)</span>
|
|
<span class="n">root</span><span class="o">.</span><span class="n">prev</span> <span class="o">=</span> <span class="n">root</span><span class="o">.</span><span class="n">next</span> <span class="o">=</span> <span class="n">root</span>
|
|
<span class="bp">self</span><span class="o">.</span><span class="n">__map</span> <span class="o">=</span> <span class="p">{}</span>
|
|
<span class="bp">self</span><span class="o">.</span><span class="n">__update</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="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">value</span><span class="p">,</span>
|
|
<span class="n">dict_setitem</span><span class="o">=</span><span class="nb">dict</span><span class="o">.</span><span class="fm">__setitem__</span><span class="p">,</span> <span class="n">proxy</span><span class="o">=</span><span class="n">_proxy</span><span class="p">,</span> <span class="n">Link</span><span class="o">=</span><span class="n">_Link</span><span class="p">):</span>
|
|
<span class="s1">'od.__setitem__(i, y) <==> od[i]=y'</span>
|
|
<span class="c1"># Setting a new item creates a new link at the end of the linked list,</span>
|
|
<span class="c1"># and the inherited dictionary is updated with the new key/value pair.</span>
|
|
<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>
|
|
<span class="bp">self</span><span class="o">.</span><span class="n">__map</span><span class="p">[</span><span class="n">key</span><span class="p">]</span> <span class="o">=</span> <span class="n">link</span> <span class="o">=</span> <span class="n">Link</span><span class="p">()</span>
|
|
<span class="n">root</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="n">__root</span>
|
|
<span class="n">last</span> <span class="o">=</span> <span class="n">root</span><span class="o">.</span><span class="n">prev</span>
|
|
<span class="n">link</span><span class="o">.</span><span class="n">prev</span><span class="p">,</span> <span class="n">link</span><span class="o">.</span><span class="n">next</span><span class="p">,</span> <span class="n">link</span><span class="o">.</span><span class="n">key</span> <span class="o">=</span> <span class="n">last</span><span class="p">,</span> <span class="n">root</span><span class="p">,</span> <span class="n">key</span>
|
|
<span class="n">last</span><span class="o">.</span><span class="n">next</span> <span class="o">=</span> <span class="n">link</span>
|
|
<span class="n">root</span><span class="o">.</span><span class="n">prev</span> <span class="o">=</span> <span class="n">proxy</span><span class="p">(</span><span class="n">link</span><span class="p">)</span>
|
|
<span class="n">dict_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>
|
|
|
|
<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> <span class="n">dict_delitem</span><span class="o">=</span><span class="nb">dict</span><span class="o">.</span><span class="fm">__delitem__</span><span class="p">):</span>
|
|
<span class="s1">'od.__delitem__(y) <==> del od[y]'</span>
|
|
<span class="c1"># Deleting an existing item uses self.__map to find the link which gets</span>
|
|
<span class="c1"># removed by updating the links in the predecessor and successor nodes.</span>
|
|
<span class="n">dict_delitem</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">link</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="n">__map</span><span class="o">.</span><span class="n">pop</span><span class="p">(</span><span class="n">key</span><span class="p">)</span>
|
|
<span class="n">link_prev</span> <span class="o">=</span> <span class="n">link</span><span class="o">.</span><span class="n">prev</span>
|
|
<span class="n">link_next</span> <span class="o">=</span> <span class="n">link</span><span class="o">.</span><span class="n">next</span>
|
|
<span class="n">link_prev</span><span class="o">.</span><span class="n">next</span> <span class="o">=</span> <span class="n">link_next</span>
|
|
<span class="n">link_next</span><span class="o">.</span><span class="n">prev</span> <span class="o">=</span> <span class="n">link_prev</span>
|
|
<span class="n">link</span><span class="o">.</span><span class="n">prev</span> <span class="o">=</span> <span class="kc">None</span>
|
|
<span class="n">link</span><span class="o">.</span><span class="n">next</span> <span class="o">=</span> <span class="kc">None</span>
|
|
|
|
<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="s1">'od.__iter__() <==> iter(od)'</span>
|
|
<span class="c1"># Traverse the linked list in order.</span>
|
|
<span class="n">root</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="n">__root</span>
|
|
<span class="n">curr</span> <span class="o">=</span> <span class="n">root</span><span class="o">.</span><span class="n">next</span>
|
|
<span class="k">while</span> <span class="n">curr</span> <span class="ow">is</span> <span class="ow">not</span> <span class="n">root</span><span class="p">:</span>
|
|
<span class="k">yield</span> <span class="n">curr</span><span class="o">.</span><span class="n">key</span>
|
|
<span class="n">curr</span> <span class="o">=</span> <span class="n">curr</span><span class="o">.</span><span class="n">next</span>
|
|
|
|
<span class="k">def</span> <span class="nf">__reversed__</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
|
|
<span class="s1">'od.__reversed__() <==> reversed(od)'</span>
|
|
<span class="c1"># Traverse the linked list in reverse order.</span>
|
|
<span class="n">root</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="n">__root</span>
|
|
<span class="n">curr</span> <span class="o">=</span> <span class="n">root</span><span class="o">.</span><span class="n">prev</span>
|
|
<span class="k">while</span> <span class="n">curr</span> <span class="ow">is</span> <span class="ow">not</span> <span class="n">root</span><span class="p">:</span>
|
|
<span class="k">yield</span> <span class="n">curr</span><span class="o">.</span><span class="n">key</span>
|
|
<span class="n">curr</span> <span class="o">=</span> <span class="n">curr</span><span class="o">.</span><span class="n">prev</span>
|
|
|
|
<span class="k">def</span> <span class="nf">clear</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
|
|
<span class="s1">'od.clear() -> None. Remove all items from od.'</span>
|
|
<span class="n">root</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="n">__root</span>
|
|
<span class="n">root</span><span class="o">.</span><span class="n">prev</span> <span class="o">=</span> <span class="n">root</span><span class="o">.</span><span class="n">next</span> <span class="o">=</span> <span class="n">root</span>
|
|
<span class="bp">self</span><span class="o">.</span><span class="n">__map</span><span class="o">.</span><span class="n">clear</span><span class="p">()</span>
|
|
<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>
|
|
|
|
<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">last</span><span class="o">=</span><span class="kc">True</span><span class="p">):</span>
|
|
<span class="sd">'''Remove and return a (key, value) pair from the dictionary.</span>
|
|
|
|
<span class="sd"> Pairs are returned in LIFO order if last is true or FIFO order if false.</span>
|
|
<span class="sd"> '''</span>
|
|
<span class="k">if</span> <span class="ow">not</span> <span class="bp">self</span><span class="p">:</span>
|
|
<span class="k">raise</span> <span class="ne">KeyError</span><span class="p">(</span><span class="s1">'dictionary is empty'</span><span class="p">)</span>
|
|
<span class="n">root</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="n">__root</span>
|
|
<span class="k">if</span> <span class="n">last</span><span class="p">:</span>
|
|
<span class="n">link</span> <span class="o">=</span> <span class="n">root</span><span class="o">.</span><span class="n">prev</span>
|
|
<span class="n">link_prev</span> <span class="o">=</span> <span class="n">link</span><span class="o">.</span><span class="n">prev</span>
|
|
<span class="n">link_prev</span><span class="o">.</span><span class="n">next</span> <span class="o">=</span> <span class="n">root</span>
|
|
<span class="n">root</span><span class="o">.</span><span class="n">prev</span> <span class="o">=</span> <span class="n">link_prev</span>
|
|
<span class="k">else</span><span class="p">:</span>
|
|
<span class="n">link</span> <span class="o">=</span> <span class="n">root</span><span class="o">.</span><span class="n">next</span>
|
|
<span class="n">link_next</span> <span class="o">=</span> <span class="n">link</span><span class="o">.</span><span class="n">next</span>
|
|
<span class="n">root</span><span class="o">.</span><span class="n">next</span> <span class="o">=</span> <span class="n">link_next</span>
|
|
<span class="n">link_next</span><span class="o">.</span><span class="n">prev</span> <span class="o">=</span> <span class="n">root</span>
|
|
<span class="n">key</span> <span class="o">=</span> <span class="n">link</span><span class="o">.</span><span class="n">key</span>
|
|
<span class="k">del</span> <span class="bp">self</span><span class="o">.</span><span class="n">__map</span><span class="p">[</span><span class="n">key</span><span class="p">]</span>
|
|
<span class="n">value</span> <span class="o">=</span> <span class="nb">dict</span><span class="o">.</span><span class="n">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="k">return</span> <span class="n">key</span><span class="p">,</span> <span class="n">value</span>
|
|
|
|
<span class="k">def</span> <span class="nf">move_to_end</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">last</span><span class="o">=</span><span class="kc">True</span><span class="p">):</span>
|
|
<span class="sd">'''Move an existing element to the end (or beginning if last is false).</span>
|
|
|
|
<span class="sd"> Raise KeyError if the element does not exist.</span>
|
|
<span class="sd"> '''</span>
|
|
<span class="n">link</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="n">__map</span><span class="p">[</span><span class="n">key</span><span class="p">]</span>
|
|
<span class="n">link_prev</span> <span class="o">=</span> <span class="n">link</span><span class="o">.</span><span class="n">prev</span>
|
|
<span class="n">link_next</span> <span class="o">=</span> <span class="n">link</span><span class="o">.</span><span class="n">next</span>
|
|
<span class="n">soft_link</span> <span class="o">=</span> <span class="n">link_next</span><span class="o">.</span><span class="n">prev</span>
|
|
<span class="n">link_prev</span><span class="o">.</span><span class="n">next</span> <span class="o">=</span> <span class="n">link_next</span>
|
|
<span class="n">link_next</span><span class="o">.</span><span class="n">prev</span> <span class="o">=</span> <span class="n">link_prev</span>
|
|
<span class="n">root</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="n">__root</span>
|
|
<span class="k">if</span> <span class="n">last</span><span class="p">:</span>
|
|
<span class="n">last</span> <span class="o">=</span> <span class="n">root</span><span class="o">.</span><span class="n">prev</span>
|
|
<span class="n">link</span><span class="o">.</span><span class="n">prev</span> <span class="o">=</span> <span class="n">last</span>
|
|
<span class="n">link</span><span class="o">.</span><span class="n">next</span> <span class="o">=</span> <span class="n">root</span>
|
|
<span class="n">root</span><span class="o">.</span><span class="n">prev</span> <span class="o">=</span> <span class="n">soft_link</span>
|
|
<span class="n">last</span><span class="o">.</span><span class="n">next</span> <span class="o">=</span> <span class="n">link</span>
|
|
<span class="k">else</span><span class="p">:</span>
|
|
<span class="n">first</span> <span class="o">=</span> <span class="n">root</span><span class="o">.</span><span class="n">next</span>
|
|
<span class="n">link</span><span class="o">.</span><span class="n">prev</span> <span class="o">=</span> <span class="n">root</span>
|
|
<span class="n">link</span><span class="o">.</span><span class="n">next</span> <span class="o">=</span> <span class="n">first</span>
|
|
<span class="n">first</span><span class="o">.</span><span class="n">prev</span> <span class="o">=</span> <span class="n">soft_link</span>
|
|
<span class="n">root</span><span class="o">.</span><span class="n">next</span> <span class="o">=</span> <span class="n">link</span>
|
|
|
|
<span class="k">def</span> <span class="nf">__sizeof__</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
|
|
<span class="n">sizeof</span> <span class="o">=</span> <span class="n">_sys</span><span class="o">.</span><span class="n">getsizeof</span>
|
|
<span class="n">n</span> <span class="o">=</span> <span class="nb">len</span><span class="p">(</span><span class="bp">self</span><span class="p">)</span> <span class="o">+</span> <span class="mi">1</span> <span class="c1"># number of links including root</span>
|
|
<span class="n">size</span> <span class="o">=</span> <span class="n">sizeof</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="vm">__dict__</span><span class="p">)</span> <span class="c1"># instance dictionary</span>
|
|
<span class="n">size</span> <span class="o">+=</span> <span class="n">sizeof</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">__map</span><span class="p">)</span> <span class="o">*</span> <span class="mi">2</span> <span class="c1"># internal dict and inherited dict</span>
|
|
<span class="n">size</span> <span class="o">+=</span> <span class="n">sizeof</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">__hardroot</span><span class="p">)</span> <span class="o">*</span> <span class="n">n</span> <span class="c1"># link objects</span>
|
|
<span class="n">size</span> <span class="o">+=</span> <span class="n">sizeof</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">__root</span><span class="p">)</span> <span class="o">*</span> <span class="n">n</span> <span class="c1"># proxy objects</span>
|
|
<span class="k">return</span> <span class="n">size</span>
|
|
|
|
<span class="n">update</span> <span class="o">=</span> <span class="n">__update</span> <span class="o">=</span> <span class="n">_collections_abc</span><span class="o">.</span><span class="n">MutableMapping</span><span class="o">.</span><span class="n">update</span>
|
|
|
|
<span class="k">def</span> <span class="nf">keys</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
|
|
<span class="s2">"D.keys() -> a set-like object providing a view on D's keys"</span>
|
|
<span class="k">return</span> <span class="n">_OrderedDictKeysView</span><span class="p">(</span><span class="bp">self</span><span class="p">)</span>
|
|
|
|
<span class="k">def</span> <span class="nf">items</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
|
|
<span class="s2">"D.items() -> a set-like object providing a view on D's items"</span>
|
|
<span class="k">return</span> <span class="n">_OrderedDictItemsView</span><span class="p">(</span><span class="bp">self</span><span class="p">)</span>
|
|
|
|
<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="s2">"D.values() -> an object providing a view on D's values"</span>
|
|
<span class="k">return</span> <span class="n">_OrderedDictValuesView</span><span class="p">(</span><span class="bp">self</span><span class="p">)</span>
|
|
|
|
<span class="fm">__ne__</span> <span class="o">=</span> <span class="n">_collections_abc</span><span class="o">.</span><span class="n">MutableMapping</span><span class="o">.</span><span class="fm">__ne__</span>
|
|
|
|
<span class="n">__marker</span> <span class="o">=</span> <span class="nb">object</span><span class="p">()</span>
|
|
|
|
<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="n">default</span><span class="o">=</span><span class="n">__marker</span><span class="p">):</span>
|
|
<span class="sd">'''od.pop(k[,d]) -> v, remove specified key and return the corresponding</span>
|
|
<span class="sd"> value. If key is not found, d is returned if given, otherwise KeyError</span>
|
|
<span class="sd"> is raised.</span>
|
|
|
|
<span class="sd"> '''</span>
|
|
<span class="k">if</span> <span class="n">key</span> <span class="ow">in</span> <span class="bp">self</span><span class="p">:</span>
|
|
<span class="n">result</span> <span class="o">=</span> <span class="bp">self</span><span class="p">[</span><span class="n">key</span><span class="p">]</span>
|
|
<span class="k">del</span> <span class="bp">self</span><span class="p">[</span><span class="n">key</span><span class="p">]</span>
|
|
<span class="k">return</span> <span class="n">result</span>
|
|
<span class="k">if</span> <span class="n">default</span> <span class="ow">is</span> <span class="bp">self</span><span class="o">.</span><span class="n">__marker</span><span class="p">:</span>
|
|
<span class="k">raise</span> <span class="ne">KeyError</span><span class="p">(</span><span class="n">key</span><span class="p">)</span>
|
|
<span class="k">return</span> <span class="n">default</span>
|
|
|
|
<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">default</span><span class="o">=</span><span class="kc">None</span><span class="p">):</span>
|
|
<span class="sd">'''Insert key with a value of default if key is not in the dictionary.</span>
|
|
|
|
<span class="sd"> Return the value for key if key is in the dictionary, else default.</span>
|
|
<span class="sd"> '''</span>
|
|
<span class="k">if</span> <span class="n">key</span> <span class="ow">in</span> <span class="bp">self</span><span class="p">:</span>
|
|
<span class="k">return</span> <span class="bp">self</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="o">=</span> <span class="n">default</span>
|
|
<span class="k">return</span> <span class="n">default</span>
|
|
|
|
<span class="nd">@_recursive_repr</span><span class="p">()</span>
|
|
<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="s1">'od.__repr__() <==> repr(od)'</span>
|
|
<span class="k">if</span> <span class="ow">not</span> <span class="bp">self</span><span class="p">:</span>
|
|
<span class="k">return</span> <span class="s1">'</span><span class="si">%s</span><span class="s1">()'</span> <span class="o">%</span> <span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="vm">__class__</span><span class="o">.</span><span class="vm">__name__</span><span class="p">,)</span>
|
|
<span class="k">return</span> <span class="s1">'</span><span class="si">%s</span><span class="s1">(</span><span class="si">%r</span><span class="s1">)'</span> <span class="o">%</span> <span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="vm">__class__</span><span class="o">.</span><span class="vm">__name__</span><span class="p">,</span> <span class="nb">list</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="k">def</span> <span class="nf">__reduce__</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
|
|
<span class="s1">'Return state information for pickling'</span>
|
|
<span class="n">inst_dict</span> <span class="o">=</span> <span class="nb">vars</span><span class="p">(</span><span class="bp">self</span><span class="p">)</span><span class="o">.</span><span class="n">copy</span><span class="p">()</span>
|
|
<span class="k">for</span> <span class="n">k</span> <span class="ow">in</span> <span class="nb">vars</span><span class="p">(</span><span class="n">OrderedDict</span><span class="p">()):</span>
|
|
<span class="n">inst_dict</span><span class="o">.</span><span class="n">pop</span><span class="p">(</span><span class="n">k</span><span class="p">,</span> <span class="kc">None</span><span class="p">)</span>
|
|
<span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="vm">__class__</span><span class="p">,</span> <span class="p">(),</span> <span class="n">inst_dict</span> <span class="ow">or</span> <span class="kc">None</span><span class="p">,</span> <span class="kc">None</span><span class="p">,</span> <span class="nb">iter</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="k">def</span> <span class="nf">copy</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
|
|
<span class="s1">'od.copy() -> a shallow copy of od'</span>
|
|
<span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="vm">__class__</span><span class="p">(</span><span class="bp">self</span><span class="p">)</span>
|
|
|
|
<span class="nd">@classmethod</span>
|
|
<span class="k">def</span> <span class="nf">fromkeys</span><span class="p">(</span><span class="bp">cls</span><span class="p">,</span> <span class="n">iterable</span><span class="p">,</span> <span class="n">value</span><span class="o">=</span><span class="kc">None</span><span class="p">):</span>
|
|
<span class="sd">'''Create a new ordered dictionary with keys from iterable and values set to value.</span>
|
|
<span class="sd"> '''</span>
|
|
<span class="bp">self</span> <span class="o">=</span> <span class="bp">cls</span><span class="p">()</span>
|
|
<span class="k">for</span> <span class="n">key</span> <span class="ow">in</span> <span class="n">iterable</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">value</span>
|
|
<span class="k">return</span> <span class="bp">self</span>
|
|
|
|
<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="sd">'''od.__eq__(y) <==> od==y. Comparison to another OD is order-sensitive</span>
|
|
<span class="sd"> while comparison to a regular mapping is order-insensitive.</span>
|
|
|
|
<span class="sd"> '''</span>
|
|
<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>
|
|
<span class="k">return</span> <span class="nb">dict</span><span class="o">.</span><span class="fm">__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="ow">and</span> <span class="nb">all</span><span class="p">(</span><span class="nb">map</span><span class="p">(</span><span class="n">_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="nb">dict</span><span class="o">.</span><span class="fm">__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">try</span><span class="p">:</span>
|
|
<span class="kn">from</span> <span class="nn">_collections</span> <span class="k">import</span> <span class="n">OrderedDict</span>
|
|
<span class="k">except</span> <span class="ne">ImportError</span><span class="p">:</span>
|
|
<span class="c1"># Leave the pure Python version in place.</span>
|
|
<span class="k">pass</span>
|
|
|
|
|
|
<span class="c1">################################################################################</span>
|
|
<span class="c1">### namedtuple</span>
|
|
<span class="c1">################################################################################</span>
|
|
|
|
<span class="n">_nt_itemgetters</span> <span class="o">=</span> <span class="p">{}</span>
|
|
|
|
<span class="k">def</span> <span class="nf">namedtuple</span><span class="p">(</span><span class="n">typename</span><span class="p">,</span> <span class="n">field_names</span><span class="p">,</span> <span class="o">*</span><span class="p">,</span> <span class="n">rename</span><span class="o">=</span><span class="kc">False</span><span class="p">,</span> <span class="n">defaults</span><span class="o">=</span><span class="kc">None</span><span class="p">,</span> <span class="n">module</span><span class="o">=</span><span class="kc">None</span><span class="p">):</span>
|
|
<span class="sd">"""Returns a new subclass of tuple with named fields.</span>
|
|
|
|
<span class="sd"> >>> Point = namedtuple('Point', ['x', 'y'])</span>
|
|
<span class="sd"> >>> Point.__doc__ # docstring for the new class</span>
|
|
<span class="sd"> 'Point(x, y)'</span>
|
|
<span class="sd"> >>> p = Point(11, y=22) # instantiate with positional args or keywords</span>
|
|
<span class="sd"> >>> p[0] + p[1] # indexable like a plain tuple</span>
|
|
<span class="sd"> 33</span>
|
|
<span class="sd"> >>> x, y = p # unpack like a regular tuple</span>
|
|
<span class="sd"> >>> x, y</span>
|
|
<span class="sd"> (11, 22)</span>
|
|
<span class="sd"> >>> p.x + p.y # fields also accessible by name</span>
|
|
<span class="sd"> 33</span>
|
|
<span class="sd"> >>> d = p._asdict() # convert to a dictionary</span>
|
|
<span class="sd"> >>> d['x']</span>
|
|
<span class="sd"> 11</span>
|
|
<span class="sd"> >>> Point(**d) # convert from a dictionary</span>
|
|
<span class="sd"> Point(x=11, y=22)</span>
|
|
<span class="sd"> >>> p._replace(x=100) # _replace() is like str.replace() but targets named fields</span>
|
|
<span class="sd"> Point(x=100, y=22)</span>
|
|
|
|
<span class="sd"> """</span>
|
|
|
|
<span class="c1"># Validate the field names. At the user's option, either generate an error</span>
|
|
<span class="c1"># message or automatically replace the field name with a valid name.</span>
|
|
<span class="k">if</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">field_names</span><span class="p">,</span> <span class="nb">str</span><span class="p">):</span>
|
|
<span class="n">field_names</span> <span class="o">=</span> <span class="n">field_names</span><span class="o">.</span><span class="n">replace</span><span class="p">(</span><span class="s1">','</span><span class="p">,</span> <span class="s1">' '</span><span class="p">)</span><span class="o">.</span><span class="n">split</span><span class="p">()</span>
|
|
<span class="n">field_names</span> <span class="o">=</span> <span class="nb">list</span><span class="p">(</span><span class="nb">map</span><span class="p">(</span><span class="nb">str</span><span class="p">,</span> <span class="n">field_names</span><span class="p">))</span>
|
|
<span class="n">typename</span> <span class="o">=</span> <span class="n">_sys</span><span class="o">.</span><span class="n">intern</span><span class="p">(</span><span class="nb">str</span><span class="p">(</span><span class="n">typename</span><span class="p">))</span>
|
|
|
|
<span class="k">if</span> <span class="n">rename</span><span class="p">:</span>
|
|
<span class="n">seen</span> <span class="o">=</span> <span class="nb">set</span><span class="p">()</span>
|
|
<span class="k">for</span> <span class="n">index</span><span class="p">,</span> <span class="n">name</span> <span class="ow">in</span> <span class="nb">enumerate</span><span class="p">(</span><span class="n">field_names</span><span class="p">):</span>
|
|
<span class="k">if</span> <span class="p">(</span><span class="ow">not</span> <span class="n">name</span><span class="o">.</span><span class="n">isidentifier</span><span class="p">()</span>
|
|
<span class="ow">or</span> <span class="n">_iskeyword</span><span class="p">(</span><span class="n">name</span><span class="p">)</span>
|
|
<span class="ow">or</span> <span class="n">name</span><span class="o">.</span><span class="n">startswith</span><span class="p">(</span><span class="s1">'_'</span><span class="p">)</span>
|
|
<span class="ow">or</span> <span class="n">name</span> <span class="ow">in</span> <span class="n">seen</span><span class="p">):</span>
|
|
<span class="n">field_names</span><span class="p">[</span><span class="n">index</span><span class="p">]</span> <span class="o">=</span> <span class="n">f</span><span class="s1">'_</span><span class="si">{index}</span><span class="s1">'</span>
|
|
<span class="n">seen</span><span class="o">.</span><span class="n">add</span><span class="p">(</span><span class="n">name</span><span class="p">)</span>
|
|
|
|
<span class="k">for</span> <span class="n">name</span> <span class="ow">in</span> <span class="p">[</span><span class="n">typename</span><span class="p">]</span> <span class="o">+</span> <span class="n">field_names</span><span class="p">:</span>
|
|
<span class="k">if</span> <span class="nb">type</span><span class="p">(</span><span class="n">name</span><span class="p">)</span> <span class="ow">is</span> <span class="ow">not</span> <span class="nb">str</span><span class="p">:</span>
|
|
<span class="k">raise</span> <span class="ne">TypeError</span><span class="p">(</span><span class="s1">'Type names and field names must be strings'</span><span class="p">)</span>
|
|
<span class="k">if</span> <span class="ow">not</span> <span class="n">name</span><span class="o">.</span><span class="n">isidentifier</span><span class="p">():</span>
|
|
<span class="k">raise</span> <span class="ne">ValueError</span><span class="p">(</span><span class="s1">'Type names and field names must be valid '</span>
|
|
<span class="n">f</span><span class="s1">'identifiers: </span><span class="si">{name!r}</span><span class="s1">'</span><span class="p">)</span>
|
|
<span class="k">if</span> <span class="n">_iskeyword</span><span class="p">(</span><span class="n">name</span><span class="p">):</span>
|
|
<span class="k">raise</span> <span class="ne">ValueError</span><span class="p">(</span><span class="s1">'Type names and field names cannot be a '</span>
|
|
<span class="n">f</span><span class="s1">'keyword: </span><span class="si">{name!r}</span><span class="s1">'</span><span class="p">)</span>
|
|
|
|
<span class="n">seen</span> <span class="o">=</span> <span class="nb">set</span><span class="p">()</span>
|
|
<span class="k">for</span> <span class="n">name</span> <span class="ow">in</span> <span class="n">field_names</span><span class="p">:</span>
|
|
<span class="k">if</span> <span class="n">name</span><span class="o">.</span><span class="n">startswith</span><span class="p">(</span><span class="s1">'_'</span><span class="p">)</span> <span class="ow">and</span> <span class="ow">not</span> <span class="n">rename</span><span class="p">:</span>
|
|
<span class="k">raise</span> <span class="ne">ValueError</span><span class="p">(</span><span class="s1">'Field names cannot start with an underscore: '</span>
|
|
<span class="n">f</span><span class="s1">'</span><span class="si">{name!r}</span><span class="s1">'</span><span class="p">)</span>
|
|
<span class="k">if</span> <span class="n">name</span> <span class="ow">in</span> <span class="n">seen</span><span class="p">:</span>
|
|
<span class="k">raise</span> <span class="ne">ValueError</span><span class="p">(</span><span class="n">f</span><span class="s1">'Encountered duplicate field name: </span><span class="si">{name!r}</span><span class="s1">'</span><span class="p">)</span>
|
|
<span class="n">seen</span><span class="o">.</span><span class="n">add</span><span class="p">(</span><span class="n">name</span><span class="p">)</span>
|
|
|
|
<span class="n">field_defaults</span> <span class="o">=</span> <span class="p">{}</span>
|
|
<span class="k">if</span> <span class="n">defaults</span> <span class="ow">is</span> <span class="ow">not</span> <span class="kc">None</span><span class="p">:</span>
|
|
<span class="n">defaults</span> <span class="o">=</span> <span class="nb">tuple</span><span class="p">(</span><span class="n">defaults</span><span class="p">)</span>
|
|
<span class="k">if</span> <span class="nb">len</span><span class="p">(</span><span class="n">defaults</span><span class="p">)</span> <span class="o">></span> <span class="nb">len</span><span class="p">(</span><span class="n">field_names</span><span class="p">):</span>
|
|
<span class="k">raise</span> <span class="ne">TypeError</span><span class="p">(</span><span class="s1">'Got more default values than field names'</span><span class="p">)</span>
|
|
<span class="n">field_defaults</span> <span class="o">=</span> <span class="nb">dict</span><span class="p">(</span><span class="nb">reversed</span><span class="p">(</span><span class="nb">list</span><span class="p">(</span><span class="nb">zip</span><span class="p">(</span><span class="nb">reversed</span><span class="p">(</span><span class="n">field_names</span><span class="p">),</span>
|
|
<span class="nb">reversed</span><span class="p">(</span><span class="n">defaults</span><span class="p">)))))</span>
|
|
|
|
<span class="c1"># Variables used in the methods and docstrings</span>
|
|
<span class="n">field_names</span> <span class="o">=</span> <span class="nb">tuple</span><span class="p">(</span><span class="nb">map</span><span class="p">(</span><span class="n">_sys</span><span class="o">.</span><span class="n">intern</span><span class="p">,</span> <span class="n">field_names</span><span class="p">))</span>
|
|
<span class="n">num_fields</span> <span class="o">=</span> <span class="nb">len</span><span class="p">(</span><span class="n">field_names</span><span class="p">)</span>
|
|
<span class="n">arg_list</span> <span class="o">=</span> <span class="nb">repr</span><span class="p">(</span><span class="n">field_names</span><span class="p">)</span><span class="o">.</span><span class="n">replace</span><span class="p">(</span><span class="s2">"'"</span><span class="p">,</span> <span class="s2">""</span><span class="p">)[</span><span class="mi">1</span><span class="p">:</span><span class="o">-</span><span class="mi">1</span><span class="p">]</span>
|
|
<span class="n">repr_fmt</span> <span class="o">=</span> <span class="s1">'('</span> <span class="o">+</span> <span class="s1">', '</span><span class="o">.</span><span class="n">join</span><span class="p">(</span><span class="n">f</span><span class="s1">'</span><span class="si">{name}</span><span class="s1">=</span><span class="si">%r</span><span class="s1">'</span> <span class="k">for</span> <span class="n">name</span> <span class="ow">in</span> <span class="n">field_names</span><span class="p">)</span> <span class="o">+</span> <span class="s1">')'</span>
|
|
<span class="n">tuple_new</span> <span class="o">=</span> <span class="nb">tuple</span><span class="o">.</span><span class="fm">__new__</span>
|
|
<span class="n">_len</span> <span class="o">=</span> <span class="nb">len</span>
|
|
|
|
<span class="c1"># Create all the named tuple methods to be added to the class namespace</span>
|
|
|
|
<span class="n">s</span> <span class="o">=</span> <span class="n">f</span><span class="s1">'def __new__(_cls, </span><span class="si">{arg_list}</span><span class="s1">): return _tuple_new(_cls, (</span><span class="si">{arg_list}</span><span class="s1">))'</span>
|
|
<span class="n">namespace</span> <span class="o">=</span> <span class="p">{</span><span class="s1">'_tuple_new'</span><span class="p">:</span> <span class="n">tuple_new</span><span class="p">,</span> <span class="s1">'__name__'</span><span class="p">:</span> <span class="n">f</span><span class="s1">'namedtuple_</span><span class="si">{typename}</span><span class="s1">'</span><span class="p">}</span>
|
|
<span class="c1"># Note: exec() has the side-effect of interning the field names</span>
|
|
<span class="n">exec</span><span class="p">(</span><span class="n">s</span><span class="p">,</span> <span class="n">namespace</span><span class="p">)</span>
|
|
<span class="fm">__new__</span> <span class="o">=</span> <span class="n">namespace</span><span class="p">[</span><span class="s1">'__new__'</span><span class="p">]</span>
|
|
<span class="fm">__new__</span><span class="o">.</span><span class="vm">__doc__</span> <span class="o">=</span> <span class="n">f</span><span class="s1">'Create new instance of </span><span class="si">{typename}</span><span class="s1">(</span><span class="si">{arg_list}</span><span class="s1">)'</span>
|
|
<span class="k">if</span> <span class="n">defaults</span> <span class="ow">is</span> <span class="ow">not</span> <span class="kc">None</span><span class="p">:</span>
|
|
<span class="fm">__new__</span><span class="o">.</span><span class="vm">__defaults__</span> <span class="o">=</span> <span class="n">defaults</span>
|
|
|
|
<span class="nd">@classmethod</span>
|
|
<span class="k">def</span> <span class="nf">_make</span><span class="p">(</span><span class="bp">cls</span><span class="p">,</span> <span class="n">iterable</span><span class="p">):</span>
|
|
<span class="n">result</span> <span class="o">=</span> <span class="n">tuple_new</span><span class="p">(</span><span class="bp">cls</span><span class="p">,</span> <span class="n">iterable</span><span class="p">)</span>
|
|
<span class="k">if</span> <span class="n">_len</span><span class="p">(</span><span class="n">result</span><span class="p">)</span> <span class="o">!=</span> <span class="n">num_fields</span><span class="p">:</span>
|
|
<span class="k">raise</span> <span class="ne">TypeError</span><span class="p">(</span><span class="n">f</span><span class="s1">'Expected </span><span class="si">{num_fields}</span><span class="s1"> arguments, got {len(result)}'</span><span class="p">)</span>
|
|
<span class="k">return</span> <span class="n">result</span>
|
|
|
|
<span class="n">_make</span><span class="o">.</span><span class="vm">__func__</span><span class="o">.</span><span class="vm">__doc__</span> <span class="o">=</span> <span class="p">(</span><span class="n">f</span><span class="s1">'Make a new </span><span class="si">{typename}</span><span class="s1"> object from a sequence '</span>
|
|
<span class="s1">'or iterable'</span><span class="p">)</span>
|
|
|
|
<span class="k">def</span> <span class="nf">_replace</span><span class="p">(</span><span class="n">_self</span><span class="p">,</span> <span class="o">**</span><span class="n">kwds</span><span class="p">):</span>
|
|
<span class="n">result</span> <span class="o">=</span> <span class="n">_self</span><span class="o">.</span><span class="n">_make</span><span class="p">(</span><span class="nb">map</span><span class="p">(</span><span class="n">kwds</span><span class="o">.</span><span class="n">pop</span><span class="p">,</span> <span class="n">field_names</span><span class="p">,</span> <span class="n">_self</span><span class="p">))</span>
|
|
<span class="k">if</span> <span class="n">kwds</span><span class="p">:</span>
|
|
<span class="k">raise</span> <span class="ne">ValueError</span><span class="p">(</span><span class="n">f</span><span class="s1">'Got unexpected field names: {list(kwds)!r}'</span><span class="p">)</span>
|
|
<span class="k">return</span> <span class="n">result</span>
|
|
|
|
<span class="n">_replace</span><span class="o">.</span><span class="vm">__doc__</span> <span class="o">=</span> <span class="p">(</span><span class="n">f</span><span class="s1">'Return a new </span><span class="si">{typename}</span><span class="s1"> object replacing specified '</span>
|
|
<span class="s1">'fields with new values'</span><span class="p">)</span>
|
|
|
|
<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="s1">'Return a nicely formatted representation string'</span>
|
|
<span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="vm">__class__</span><span class="o">.</span><span class="vm">__name__</span> <span class="o">+</span> <span class="n">repr_fmt</span> <span class="o">%</span> <span class="bp">self</span>
|
|
|
|
<span class="k">def</span> <span class="nf">_asdict</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
|
|
<span class="s1">'Return a new OrderedDict which maps field names to their values.'</span>
|
|
<span class="k">return</span> <span class="n">OrderedDict</span><span class="p">(</span><span class="nb">zip</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">_fields</span><span class="p">,</span> <span class="bp">self</span><span class="p">))</span>
|
|
|
|
<span class="k">def</span> <span class="nf">__getnewargs__</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
|
|
<span class="s1">'Return self as a plain tuple. Used by copy and pickle.'</span>
|
|
<span class="k">return</span> <span class="nb">tuple</span><span class="p">(</span><span class="bp">self</span><span class="p">)</span>
|
|
|
|
<span class="c1"># Modify function metadata to help with introspection and debugging</span>
|
|
|
|
<span class="k">for</span> <span class="n">method</span> <span class="ow">in</span> <span class="p">(</span><span class="fm">__new__</span><span class="p">,</span> <span class="n">_make</span><span class="o">.</span><span class="vm">__func__</span><span class="p">,</span> <span class="n">_replace</span><span class="p">,</span>
|
|
<span class="fm">__repr__</span><span class="p">,</span> <span class="n">_asdict</span><span class="p">,</span> <span class="n">__getnewargs__</span><span class="p">):</span>
|
|
<span class="n">method</span><span class="o">.</span><span class="vm">__qualname__</span> <span class="o">=</span> <span class="n">f</span><span class="s1">'</span><span class="si">{typename}</span><span class="s1">.</span><span class="si">{method.__name__}</span><span class="s1">'</span>
|
|
|
|
<span class="c1"># Build-up the class namespace dictionary</span>
|
|
<span class="c1"># and use type() to build the result class</span>
|
|
<span class="n">class_namespace</span> <span class="o">=</span> <span class="p">{</span>
|
|
<span class="s1">'__doc__'</span><span class="p">:</span> <span class="n">f</span><span class="s1">'</span><span class="si">{typename}</span><span class="s1">(</span><span class="si">{arg_list}</span><span class="s1">)'</span><span class="p">,</span>
|
|
<span class="s1">'__slots__'</span><span class="p">:</span> <span class="p">(),</span>
|
|
<span class="s1">'_fields'</span><span class="p">:</span> <span class="n">field_names</span><span class="p">,</span>
|
|
<span class="s1">'_field_defaults'</span><span class="p">:</span> <span class="n">field_defaults</span><span class="p">,</span>
|
|
<span class="c1"># alternate spelling for backward compatibility</span>
|
|
<span class="s1">'_fields_defaults'</span><span class="p">:</span> <span class="n">field_defaults</span><span class="p">,</span>
|
|
<span class="s1">'__new__'</span><span class="p">:</span> <span class="fm">__new__</span><span class="p">,</span>
|
|
<span class="s1">'_make'</span><span class="p">:</span> <span class="n">_make</span><span class="p">,</span>
|
|
<span class="s1">'_replace'</span><span class="p">:</span> <span class="n">_replace</span><span class="p">,</span>
|
|
<span class="s1">'__repr__'</span><span class="p">:</span> <span class="fm">__repr__</span><span class="p">,</span>
|
|
<span class="s1">'_asdict'</span><span class="p">:</span> <span class="n">_asdict</span><span class="p">,</span>
|
|
<span class="s1">'__getnewargs__'</span><span class="p">:</span> <span class="n">__getnewargs__</span><span class="p">,</span>
|
|
<span class="p">}</span>
|
|
<span class="n">cache</span> <span class="o">=</span> <span class="n">_nt_itemgetters</span>
|
|
<span class="k">for</span> <span class="n">index</span><span class="p">,</span> <span class="n">name</span> <span class="ow">in</span> <span class="nb">enumerate</span><span class="p">(</span><span class="n">field_names</span><span class="p">):</span>
|
|
<span class="k">try</span><span class="p">:</span>
|
|
<span class="n">itemgetter_object</span><span class="p">,</span> <span class="n">doc</span> <span class="o">=</span> <span class="n">cache</span><span class="p">[</span><span class="n">index</span><span class="p">]</span>
|
|
<span class="k">except</span> <span class="ne">KeyError</span><span class="p">:</span>
|
|
<span class="n">itemgetter_object</span> <span class="o">=</span> <span class="n">_itemgetter</span><span class="p">(</span><span class="n">index</span><span class="p">)</span>
|
|
<span class="n">doc</span> <span class="o">=</span> <span class="n">f</span><span class="s1">'Alias for field number </span><span class="si">{index}</span><span class="s1">'</span>
|
|
<span class="n">cache</span><span class="p">[</span><span class="n">index</span><span class="p">]</span> <span class="o">=</span> <span class="n">itemgetter_object</span><span class="p">,</span> <span class="n">doc</span>
|
|
<span class="n">class_namespace</span><span class="p">[</span><span class="n">name</span><span class="p">]</span> <span class="o">=</span> <span class="nb">property</span><span class="p">(</span><span class="n">itemgetter_object</span><span class="p">,</span> <span class="n">doc</span><span class="o">=</span><span class="n">doc</span><span class="p">)</span>
|
|
|
|
<span class="n">result</span> <span class="o">=</span> <span class="nb">type</span><span class="p">(</span><span class="n">typename</span><span class="p">,</span> <span class="p">(</span><span class="nb">tuple</span><span class="p">,),</span> <span class="n">class_namespace</span><span class="p">)</span>
|
|
|
|
<span class="c1"># For pickling to work, the __module__ variable needs to be set to the frame</span>
|
|
<span class="c1"># where the named tuple is created. Bypass this step in environments where</span>
|
|
<span class="c1"># sys._getframe is not defined (Jython for example) or sys._getframe is not</span>
|
|
<span class="c1"># defined for arguments greater than 0 (IronPython), or where the user has</span>
|
|
<span class="c1"># specified a particular module.</span>
|
|
<span class="k">if</span> <span class="n">module</span> <span class="ow">is</span> <span class="kc">None</span><span class="p">:</span>
|
|
<span class="k">try</span><span class="p">:</span>
|
|
<span class="n">module</span> <span class="o">=</span> <span class="n">_sys</span><span class="o">.</span><span class="n">_getframe</span><span class="p">(</span><span class="mi">1</span><span class="p">)</span><span class="o">.</span><span class="n">f_globals</span><span class="o">.</span><span class="n">get</span><span class="p">(</span><span class="s1">'__name__'</span><span class="p">,</span> <span class="s1">'__main__'</span><span class="p">)</span>
|
|
<span class="k">except</span> <span class="p">(</span><span class="ne">AttributeError</span><span class="p">,</span> <span class="ne">ValueError</span><span class="p">):</span>
|
|
<span class="k">pass</span>
|
|
<span class="k">if</span> <span class="n">module</span> <span class="ow">is</span> <span class="ow">not</span> <span class="kc">None</span><span class="p">:</span>
|
|
<span class="n">result</span><span class="o">.</span><span class="vm">__module__</span> <span class="o">=</span> <span class="n">module</span>
|
|
|
|
<span class="k">return</span> <span class="n">result</span>
|
|
|
|
|
|
<span class="c1">########################################################################</span>
|
|
<span class="c1">### Counter</span>
|
|
<span class="c1">########################################################################</span>
|
|
|
|
<span class="k">def</span> <span class="nf">_count_elements</span><span class="p">(</span><span class="n">mapping</span><span class="p">,</span> <span class="n">iterable</span><span class="p">):</span>
|
|
<span class="s1">'Tally elements from the iterable.'</span>
|
|
<span class="n">mapping_get</span> <span class="o">=</span> <span class="n">mapping</span><span class="o">.</span><span class="n">get</span>
|
|
<span class="k">for</span> <span class="n">elem</span> <span class="ow">in</span> <span class="n">iterable</span><span class="p">:</span>
|
|
<span class="n">mapping</span><span class="p">[</span><span class="n">elem</span><span class="p">]</span> <span class="o">=</span> <span class="n">mapping_get</span><span class="p">(</span><span class="n">elem</span><span class="p">,</span> <span class="mi">0</span><span class="p">)</span> <span class="o">+</span> <span class="mi">1</span>
|
|
|
|
<span class="k">try</span><span class="p">:</span> <span class="c1"># Load C helper function if available</span>
|
|
<span class="kn">from</span> <span class="nn">_collections</span> <span class="k">import</span> <span class="n">_count_elements</span>
|
|
<span class="k">except</span> <span class="ne">ImportError</span><span class="p">:</span>
|
|
<span class="k">pass</span>
|
|
|
|
<span class="k">class</span> <span class="nc">Counter</span><span class="p">(</span><span class="nb">dict</span><span class="p">):</span>
|
|
<span class="sd">'''Dict subclass for counting hashable items. Sometimes called a bag</span>
|
|
<span class="sd"> or multiset. Elements are stored as dictionary keys and their counts</span>
|
|
<span class="sd"> are stored as dictionary values.</span>
|
|
|
|
<span class="sd"> >>> c = Counter('abcdeabcdabcaba') # count elements from a string</span>
|
|
|
|
<span class="sd"> >>> c.most_common(3) # three most common elements</span>
|
|
<span class="sd"> [('a', 5), ('b', 4), ('c', 3)]</span>
|
|
<span class="sd"> >>> sorted(c) # list all unique elements</span>
|
|
<span class="sd"> ['a', 'b', 'c', 'd', 'e']</span>
|
|
<span class="sd"> >>> ''.join(sorted(c.elements())) # list elements with repetitions</span>
|
|
<span class="sd"> 'aaaaabbbbcccdde'</span>
|
|
<span class="sd"> >>> sum(c.values()) # total of all counts</span>
|
|
<span class="sd"> 15</span>
|
|
|
|
<span class="sd"> >>> c['a'] # count of letter 'a'</span>
|
|
<span class="sd"> 5</span>
|
|
<span class="sd"> >>> for elem in 'shazam': # update counts from an iterable</span>
|
|
<span class="sd"> ... c[elem] += 1 # by adding 1 to each element's count</span>
|
|
<span class="sd"> >>> c['a'] # now there are seven 'a'</span>
|
|
<span class="sd"> 7</span>
|
|
<span class="sd"> >>> del c['b'] # remove all 'b'</span>
|
|
<span class="sd"> >>> c['b'] # now there are zero 'b'</span>
|
|
<span class="sd"> 0</span>
|
|
|
|
<span class="sd"> >>> d = Counter('simsalabim') # make another counter</span>
|
|
<span class="sd"> >>> c.update(d) # add in the second counter</span>
|
|
<span class="sd"> >>> c['a'] # now there are nine 'a'</span>
|
|
<span class="sd"> 9</span>
|
|
|
|
<span class="sd"> >>> c.clear() # empty the counter</span>
|
|
<span class="sd"> >>> c</span>
|
|
<span class="sd"> Counter()</span>
|
|
|
|
<span class="sd"> Note: If a count is set to zero or reduced to zero, it will remain</span>
|
|
<span class="sd"> in the counter until the entry is deleted or the counter is cleared:</span>
|
|
|
|
<span class="sd"> >>> c = Counter('aaabbc')</span>
|
|
<span class="sd"> >>> c['b'] -= 2 # reduce the count of 'b' by two</span>
|
|
<span class="sd"> >>> c.most_common() # 'b' is still in, but its count is zero</span>
|
|
<span class="sd"> [('a', 3), ('c', 1), ('b', 0)]</span>
|
|
|
|
<span class="sd"> '''</span>
|
|
<span class="c1"># References:</span>
|
|
<span class="c1"># http://en.wikipedia.org/wiki/Multiset</span>
|
|
<span class="c1"># http://www.gnu.org/software/smalltalk/manual-base/html_node/Bag.html</span>
|
|
<span class="c1"># http://www.demo2s.com/Tutorial/Cpp/0380__set-multiset/Catalog0380__set-multiset.htm</span>
|
|
<span class="c1"># http://code.activestate.com/recipes/259174/</span>
|
|
<span class="c1"># Knuth, TAOCP Vol. II section 4.6.3</span>
|
|
|
|
<span class="k">def</span> <span class="nf">__init__</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="sd">'''Create a new, empty Counter object. And if given, count elements</span>
|
|
<span class="sd"> from an input iterable. Or, initialize the count from another mapping</span>
|
|
<span class="sd"> of elements to their counts.</span>
|
|
|
|
<span class="sd"> >>> c = Counter() # a new, empty counter</span>
|
|
<span class="sd"> >>> c = Counter('gallahad') # a new counter from an iterable</span>
|
|
<span class="sd"> >>> c = Counter({'a': 4, 'b': 2}) # a new counter from a mapping</span>
|
|
<span class="sd"> >>> c = Counter(a=4, b=2) # a new counter from keyword args</span>
|
|
|
|
<span class="sd"> '''</span>
|
|
<span class="k">if</span> <span class="ow">not</span> <span class="n">args</span><span class="p">:</span>
|
|
<span class="k">raise</span> <span class="ne">TypeError</span><span class="p">(</span><span class="s2">"descriptor '__init__' of 'Counter' object "</span>
|
|
<span class="s2">"needs an argument"</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="o">=</span> <span class="n">args</span>
|
|
<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>
|
|
<span class="k">raise</span> <span class="ne">TypeError</span><span class="p">(</span><span class="s1">'expected at most 1 arguments, got </span><span class="si">%d</span><span class="s1">'</span> <span class="o">%</span> <span class="nb">len</span><span class="p">(</span><span class="n">args</span><span class="p">))</span>
|
|
<span class="nb">super</span><span class="p">(</span><span class="n">Counter</span><span class="p">,</span> <span class="bp">self</span><span class="p">)</span><span class="o">.</span><span class="fm">__init__</span><span class="p">()</span>
|
|
<span class="bp">self</span><span class="o">.</span><span class="n">update</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="k">def</span> <span class="nf">__missing__</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="s1">'The count of elements not in the Counter is zero.'</span>
|
|
<span class="c1"># Needed so that self[missing_item] does not raise KeyError</span>
|
|
<span class="k">return</span> <span class="mi">0</span>
|
|
|
|
<span class="k">def</span> <span class="nf">most_common</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">n</span><span class="o">=</span><span class="kc">None</span><span class="p">):</span>
|
|
<span class="sd">'''List the n most common elements and their counts from the most</span>
|
|
<span class="sd"> common to the least. If n is None, then list all element counts.</span>
|
|
|
|
<span class="sd"> >>> Counter('abcdeabcdabcaba').most_common(3)</span>
|
|
<span class="sd"> [('a', 5), ('b', 4), ('c', 3)]</span>
|
|
|
|
<span class="sd"> '''</span>
|
|
<span class="c1"># Emulate Bag.sortedByCount from Smalltalk</span>
|
|
<span class="k">if</span> <span class="n">n</span> <span class="ow">is</span> <span class="kc">None</span><span class="p">:</span>
|
|
<span class="k">return</span> <span class="nb">sorted</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">key</span><span class="o">=</span><span class="n">_itemgetter</span><span class="p">(</span><span class="mi">1</span><span class="p">),</span> <span class="n">reverse</span><span class="o">=</span><span class="kc">True</span><span class="p">)</span>
|
|
<span class="k">return</span> <span class="n">_heapq</span><span class="o">.</span><span class="n">nlargest</span><span class="p">(</span><span class="n">n</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">key</span><span class="o">=</span><span class="n">_itemgetter</span><span class="p">(</span><span class="mi">1</span><span class="p">))</span>
|
|
|
|
<span class="k">def</span> <span class="nf">elements</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
|
|
<span class="sd">'''Iterator over elements repeating each as many times as its count.</span>
|
|
|
|
<span class="sd"> >>> c = Counter('ABCABC')</span>
|
|
<span class="sd"> >>> sorted(c.elements())</span>
|
|
<span class="sd"> ['A', 'A', 'B', 'B', 'C', 'C']</span>
|
|
|
|
<span class="sd"> # Knuth's example for prime factors of 1836: 2**2 * 3**3 * 17**1</span>
|
|
<span class="sd"> >>> prime_factors = Counter({2: 2, 3: 3, 17: 1})</span>
|
|
<span class="sd"> >>> product = 1</span>
|
|
<span class="sd"> >>> for factor in prime_factors.elements(): # loop over factors</span>
|
|
<span class="sd"> ... product *= factor # and multiply them</span>
|
|
<span class="sd"> >>> product</span>
|
|
<span class="sd"> 1836</span>
|
|
|
|
<span class="sd"> Note, if an element's count has been set to zero or is a negative</span>
|
|
<span class="sd"> number, elements() will ignore it.</span>
|
|
|
|
<span class="sd"> '''</span>
|
|
<span class="c1"># Emulate Bag.do from Smalltalk and Multiset.begin from C++.</span>
|
|
<span class="k">return</span> <span class="n">_chain</span><span class="o">.</span><span class="n">from_iterable</span><span class="p">(</span><span class="n">_starmap</span><span class="p">(</span><span class="n">_repeat</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="c1"># Override dict methods where necessary</span>
|
|
|
|
<span class="nd">@classmethod</span>
|
|
<span class="k">def</span> <span class="nf">fromkeys</span><span class="p">(</span><span class="bp">cls</span><span class="p">,</span> <span class="n">iterable</span><span class="p">,</span> <span class="n">v</span><span class="o">=</span><span class="kc">None</span><span class="p">):</span>
|
|
<span class="c1"># There is no equivalent method for counters because setting v=1</span>
|
|
<span class="c1"># means that no element can have a count greater than one.</span>
|
|
<span class="k">raise</span> <span class="ne">NotImplementedError</span><span class="p">(</span>
|
|
<span class="s1">'Counter.fromkeys() is undefined. Use Counter(iterable) instead.'</span><span class="p">)</span>
|
|
|
|
<span class="k">def</span> <span class="nf">update</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="sd">'''Like dict.update() but add counts instead of replacing them.</span>
|
|
|
|
<span class="sd"> Source can be an iterable, a dictionary, or another Counter instance.</span>
|
|
|
|
<span class="sd"> >>> c = Counter('which')</span>
|
|
<span class="sd"> >>> c.update('witch') # add elements from another iterable</span>
|
|
<span class="sd"> >>> d = Counter('watch')</span>
|
|
<span class="sd"> >>> c.update(d) # add elements from another counter</span>
|
|
<span class="sd"> >>> c['h'] # four 'h' in which, witch, and watch</span>
|
|
<span class="sd"> 4</span>
|
|
|
|
<span class="sd"> '''</span>
|
|
<span class="c1"># The regular dict.update() operation makes no sense here because the</span>
|
|
<span class="c1"># replace behavior results in the some of original untouched counts</span>
|
|
<span class="c1"># being mixed-in with all of the other counts for a mismash that</span>
|
|
<span class="c1"># doesn't have a straight-forward interpretation in most counting</span>
|
|
<span class="c1"># contexts. Instead, we implement straight-addition. Both the inputs</span>
|
|
<span class="c1"># and outputs are allowed to contain zero and negative counts.</span>
|
|
|
|
<span class="k">if</span> <span class="ow">not</span> <span class="n">args</span><span class="p">:</span>
|
|
<span class="k">raise</span> <span class="ne">TypeError</span><span class="p">(</span><span class="s2">"descriptor 'update' of 'Counter' object "</span>
|
|
<span class="s2">"needs an argument"</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="o">=</span> <span class="n">args</span>
|
|
<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>
|
|
<span class="k">raise</span> <span class="ne">TypeError</span><span class="p">(</span><span class="s1">'expected at most 1 arguments, got </span><span class="si">%d</span><span class="s1">'</span> <span class="o">%</span> <span class="nb">len</span><span class="p">(</span><span class="n">args</span><span class="p">))</span>
|
|
<span class="n">iterable</span> <span class="o">=</span> <span class="n">args</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span> <span class="k">if</span> <span class="n">args</span> <span class="k">else</span> <span class="kc">None</span>
|
|
<span class="k">if</span> <span class="n">iterable</span> <span class="ow">is</span> <span class="ow">not</span> <span class="kc">None</span><span class="p">:</span>
|
|
<span class="k">if</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">iterable</span><span class="p">,</span> <span class="n">_collections_abc</span><span class="o">.</span><span class="n">Mapping</span><span class="p">):</span>
|
|
<span class="k">if</span> <span class="bp">self</span><span class="p">:</span>
|
|
<span class="n">self_get</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="n">get</span>
|
|
<span class="k">for</span> <span class="n">elem</span><span class="p">,</span> <span class="n">count</span> <span class="ow">in</span> <span class="n">iterable</span><span class="o">.</span><span class="n">items</span><span class="p">():</span>
|
|
<span class="bp">self</span><span class="p">[</span><span class="n">elem</span><span class="p">]</span> <span class="o">=</span> <span class="n">count</span> <span class="o">+</span> <span class="n">self_get</span><span class="p">(</span><span class="n">elem</span><span class="p">,</span> <span class="mi">0</span><span class="p">)</span>
|
|
<span class="k">else</span><span class="p">:</span>
|
|
<span class="nb">super</span><span class="p">(</span><span class="n">Counter</span><span class="p">,</span> <span class="bp">self</span><span class="p">)</span><span class="o">.</span><span class="n">update</span><span class="p">(</span><span class="n">iterable</span><span class="p">)</span> <span class="c1"># fast path when counter is empty</span>
|
|
<span class="k">else</span><span class="p">:</span>
|
|
<span class="n">_count_elements</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">iterable</span><span class="p">)</span>
|
|
<span class="k">if</span> <span class="n">kwds</span><span class="p">:</span>
|
|
<span class="bp">self</span><span class="o">.</span><span class="n">update</span><span class="p">(</span><span class="n">kwds</span><span class="p">)</span>
|
|
|
|
<span class="k">def</span> <span class="nf">subtract</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="sd">'''Like dict.update() but subtracts counts instead of replacing them.</span>
|
|
<span class="sd"> Counts can be reduced below zero. Both the inputs and outputs are</span>
|
|
<span class="sd"> allowed to contain zero and negative counts.</span>
|
|
|
|
<span class="sd"> Source can be an iterable, a dictionary, or another Counter instance.</span>
|
|
|
|
<span class="sd"> >>> c = Counter('which')</span>
|
|
<span class="sd"> >>> c.subtract('witch') # subtract elements from another iterable</span>
|
|
<span class="sd"> >>> c.subtract(Counter('watch')) # subtract elements from another counter</span>
|
|
<span class="sd"> >>> c['h'] # 2 in which, minus 1 in witch, minus 1 in watch</span>
|
|
<span class="sd"> 0</span>
|
|
<span class="sd"> >>> c['w'] # 1 in which, minus 1 in witch, minus 1 in watch</span>
|
|
<span class="sd"> -1</span>
|
|
|
|
<span class="sd"> '''</span>
|
|
<span class="k">if</span> <span class="ow">not</span> <span class="n">args</span><span class="p">:</span>
|
|
<span class="k">raise</span> <span class="ne">TypeError</span><span class="p">(</span><span class="s2">"descriptor 'subtract' of 'Counter' object "</span>
|
|
<span class="s2">"needs an argument"</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="o">=</span> <span class="n">args</span>
|
|
<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>
|
|
<span class="k">raise</span> <span class="ne">TypeError</span><span class="p">(</span><span class="s1">'expected at most 1 arguments, got </span><span class="si">%d</span><span class="s1">'</span> <span class="o">%</span> <span class="nb">len</span><span class="p">(</span><span class="n">args</span><span class="p">))</span>
|
|
<span class="n">iterable</span> <span class="o">=</span> <span class="n">args</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span> <span class="k">if</span> <span class="n">args</span> <span class="k">else</span> <span class="kc">None</span>
|
|
<span class="k">if</span> <span class="n">iterable</span> <span class="ow">is</span> <span class="ow">not</span> <span class="kc">None</span><span class="p">:</span>
|
|
<span class="n">self_get</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="n">get</span>
|
|
<span class="k">if</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">iterable</span><span class="p">,</span> <span class="n">_collections_abc</span><span class="o">.</span><span class="n">Mapping</span><span class="p">):</span>
|
|
<span class="k">for</span> <span class="n">elem</span><span class="p">,</span> <span class="n">count</span> <span class="ow">in</span> <span class="n">iterable</span><span class="o">.</span><span class="n">items</span><span class="p">():</span>
|
|
<span class="bp">self</span><span class="p">[</span><span class="n">elem</span><span class="p">]</span> <span class="o">=</span> <span class="n">self_get</span><span class="p">(</span><span class="n">elem</span><span class="p">,</span> <span class="mi">0</span><span class="p">)</span> <span class="o">-</span> <span class="n">count</span>
|
|
<span class="k">else</span><span class="p">:</span>
|
|
<span class="k">for</span> <span class="n">elem</span> <span class="ow">in</span> <span class="n">iterable</span><span class="p">:</span>
|
|
<span class="bp">self</span><span class="p">[</span><span class="n">elem</span><span class="p">]</span> <span class="o">=</span> <span class="n">self_get</span><span class="p">(</span><span class="n">elem</span><span class="p">,</span> <span class="mi">0</span><span class="p">)</span> <span class="o">-</span> <span class="mi">1</span>
|
|
<span class="k">if</span> <span class="n">kwds</span><span class="p">:</span>
|
|
<span class="bp">self</span><span class="o">.</span><span class="n">subtract</span><span class="p">(</span><span class="n">kwds</span><span class="p">)</span>
|
|
|
|
<span class="k">def</span> <span class="nf">copy</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
|
|
<span class="s1">'Return a shallow copy.'</span>
|
|
<span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="vm">__class__</span><span class="p">(</span><span class="bp">self</span><span class="p">)</span>
|
|
|
|
<span class="k">def</span> <span class="nf">__reduce__</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="vm">__class__</span><span class="p">,</span> <span class="p">(</span><span class="nb">dict</span><span class="p">(</span><span class="bp">self</span><span class="p">),)</span>
|
|
|
|
<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">elem</span><span class="p">):</span>
|
|
<span class="s1">'Like dict.__delitem__() but does not raise KeyError for missing values.'</span>
|
|
<span class="k">if</span> <span class="n">elem</span> <span class="ow">in</span> <span class="bp">self</span><span class="p">:</span>
|
|
<span class="nb">super</span><span class="p">()</span><span class="o">.</span><span class="fm">__delitem__</span><span class="p">(</span><span class="n">elem</span><span class="p">)</span>
|
|
|
|
<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">if</span> <span class="ow">not</span> <span class="bp">self</span><span class="p">:</span>
|
|
<span class="k">return</span> <span class="s1">'</span><span class="si">%s</span><span class="s1">()'</span> <span class="o">%</span> <span class="bp">self</span><span class="o">.</span><span class="vm">__class__</span><span class="o">.</span><span class="vm">__name__</span>
|
|
<span class="k">try</span><span class="p">:</span>
|
|
<span class="n">items</span> <span class="o">=</span> <span class="s1">', '</span><span class="o">.</span><span class="n">join</span><span class="p">(</span><span class="nb">map</span><span class="p">(</span><span class="s1">'</span><span class="si">%r</span><span class="s1">: </span><span class="si">%r</span><span class="s1">'</span><span class="o">.</span><span class="fm">__mod__</span><span class="p">,</span> <span class="bp">self</span><span class="o">.</span><span class="n">most_common</span><span class="p">()))</span>
|
|
<span class="k">return</span> <span class="s1">'</span><span class="si">%s</span><span class="s1">({</span><span class="si">%s</span><span class="s1">})'</span> <span class="o">%</span> <span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="vm">__class__</span><span class="o">.</span><span class="vm">__name__</span><span class="p">,</span> <span class="n">items</span><span class="p">)</span>
|
|
<span class="k">except</span> <span class="ne">TypeError</span><span class="p">:</span>
|
|
<span class="c1"># handle case where values are not orderable</span>
|
|
<span class="k">return</span> <span class="s1">'</span><span class="si">{0}</span><span class="s1">(</span><span class="si">{1!r}</span><span class="s1">)'</span><span class="o">.</span><span class="n">format</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="vm">__class__</span><span class="o">.</span><span class="vm">__name__</span><span class="p">,</span> <span class="nb">dict</span><span class="p">(</span><span class="bp">self</span><span class="p">))</span>
|
|
|
|
<span class="c1"># Multiset-style mathematical operations discussed in:</span>
|
|
<span class="c1"># Knuth TAOCP Volume II section 4.6.3 exercise 19</span>
|
|
<span class="c1"># and at http://en.wikipedia.org/wiki/Multiset</span>
|
|
<span class="c1">#</span>
|
|
<span class="c1"># Outputs guaranteed to only include positive counts.</span>
|
|
<span class="c1">#</span>
|
|
<span class="c1"># To strip negative and zero counts, add-in an empty counter:</span>
|
|
<span class="c1"># c += Counter()</span>
|
|
|
|
<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="sd">'''Add counts from two counters.</span>
|
|
|
|
<span class="sd"> >>> Counter('abbb') + Counter('bcc')</span>
|
|
<span class="sd"> Counter({'b': 4, 'c': 2, 'a': 1})</span>
|
|
|
|
<span class="sd"> '''</span>
|
|
<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">Counter</span><span class="p">):</span>
|
|
<span class="k">return</span> <span class="bp">NotImplemented</span>
|
|
<span class="n">result</span> <span class="o">=</span> <span class="n">Counter</span><span class="p">()</span>
|
|
<span class="k">for</span> <span class="n">elem</span><span class="p">,</span> <span class="n">count</span> <span class="ow">in</span> <span class="bp">self</span><span class="o">.</span><span class="n">items</span><span class="p">():</span>
|
|
<span class="n">newcount</span> <span class="o">=</span> <span class="n">count</span> <span class="o">+</span> <span class="n">other</span><span class="p">[</span><span class="n">elem</span><span class="p">]</span>
|
|
<span class="k">if</span> <span class="n">newcount</span> <span class="o">></span> <span class="mi">0</span><span class="p">:</span>
|
|
<span class="n">result</span><span class="p">[</span><span class="n">elem</span><span class="p">]</span> <span class="o">=</span> <span class="n">newcount</span>
|
|
<span class="k">for</span> <span class="n">elem</span><span class="p">,</span> <span class="n">count</span> <span class="ow">in</span> <span class="n">other</span><span class="o">.</span><span class="n">items</span><span class="p">():</span>
|
|
<span class="k">if</span> <span class="n">elem</span> <span class="ow">not</span> <span class="ow">in</span> <span class="bp">self</span> <span class="ow">and</span> <span class="n">count</span> <span class="o">></span> <span class="mi">0</span><span class="p">:</span>
|
|
<span class="n">result</span><span class="p">[</span><span class="n">elem</span><span class="p">]</span> <span class="o">=</span> <span class="n">count</span>
|
|
<span class="k">return</span> <span class="n">result</span>
|
|
|
|
<span class="k">def</span> <span class="nf">__sub__</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="sd">''' Subtract count, but keep only results with positive counts.</span>
|
|
|
|
<span class="sd"> >>> Counter('abbbc') - Counter('bccd')</span>
|
|
<span class="sd"> Counter({'b': 2, 'a': 1})</span>
|
|
|
|
<span class="sd"> '''</span>
|
|
<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">Counter</span><span class="p">):</span>
|
|
<span class="k">return</span> <span class="bp">NotImplemented</span>
|
|
<span class="n">result</span> <span class="o">=</span> <span class="n">Counter</span><span class="p">()</span>
|
|
<span class="k">for</span> <span class="n">elem</span><span class="p">,</span> <span class="n">count</span> <span class="ow">in</span> <span class="bp">self</span><span class="o">.</span><span class="n">items</span><span class="p">():</span>
|
|
<span class="n">newcount</span> <span class="o">=</span> <span class="n">count</span> <span class="o">-</span> <span class="n">other</span><span class="p">[</span><span class="n">elem</span><span class="p">]</span>
|
|
<span class="k">if</span> <span class="n">newcount</span> <span class="o">></span> <span class="mi">0</span><span class="p">:</span>
|
|
<span class="n">result</span><span class="p">[</span><span class="n">elem</span><span class="p">]</span> <span class="o">=</span> <span class="n">newcount</span>
|
|
<span class="k">for</span> <span class="n">elem</span><span class="p">,</span> <span class="n">count</span> <span class="ow">in</span> <span class="n">other</span><span class="o">.</span><span class="n">items</span><span class="p">():</span>
|
|
<span class="k">if</span> <span class="n">elem</span> <span class="ow">not</span> <span class="ow">in</span> <span class="bp">self</span> <span class="ow">and</span> <span class="n">count</span> <span class="o"><</span> <span class="mi">0</span><span class="p">:</span>
|
|
<span class="n">result</span><span class="p">[</span><span class="n">elem</span><span class="p">]</span> <span class="o">=</span> <span class="mi">0</span> <span class="o">-</span> <span class="n">count</span>
|
|
<span class="k">return</span> <span class="n">result</span>
|
|
|
|
<span class="k">def</span> <span class="nf">__or__</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="sd">'''Union is the maximum of value in either of the input counters.</span>
|
|
|
|
<span class="sd"> >>> Counter('abbb') | Counter('bcc')</span>
|
|
<span class="sd"> Counter({'b': 3, 'c': 2, 'a': 1})</span>
|
|
|
|
<span class="sd"> '''</span>
|
|
<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">Counter</span><span class="p">):</span>
|
|
<span class="k">return</span> <span class="bp">NotImplemented</span>
|
|
<span class="n">result</span> <span class="o">=</span> <span class="n">Counter</span><span class="p">()</span>
|
|
<span class="k">for</span> <span class="n">elem</span><span class="p">,</span> <span class="n">count</span> <span class="ow">in</span> <span class="bp">self</span><span class="o">.</span><span class="n">items</span><span class="p">():</span>
|
|
<span class="n">other_count</span> <span class="o">=</span> <span class="n">other</span><span class="p">[</span><span class="n">elem</span><span class="p">]</span>
|
|
<span class="n">newcount</span> <span class="o">=</span> <span class="n">other_count</span> <span class="k">if</span> <span class="n">count</span> <span class="o"><</span> <span class="n">other_count</span> <span class="k">else</span> <span class="n">count</span>
|
|
<span class="k">if</span> <span class="n">newcount</span> <span class="o">></span> <span class="mi">0</span><span class="p">:</span>
|
|
<span class="n">result</span><span class="p">[</span><span class="n">elem</span><span class="p">]</span> <span class="o">=</span> <span class="n">newcount</span>
|
|
<span class="k">for</span> <span class="n">elem</span><span class="p">,</span> <span class="n">count</span> <span class="ow">in</span> <span class="n">other</span><span class="o">.</span><span class="n">items</span><span class="p">():</span>
|
|
<span class="k">if</span> <span class="n">elem</span> <span class="ow">not</span> <span class="ow">in</span> <span class="bp">self</span> <span class="ow">and</span> <span class="n">count</span> <span class="o">></span> <span class="mi">0</span><span class="p">:</span>
|
|
<span class="n">result</span><span class="p">[</span><span class="n">elem</span><span class="p">]</span> <span class="o">=</span> <span class="n">count</span>
|
|
<span class="k">return</span> <span class="n">result</span>
|
|
|
|
<span class="k">def</span> <span class="nf">__and__</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="sd">''' Intersection is the minimum of corresponding counts.</span>
|
|
|
|
<span class="sd"> >>> Counter('abbb') & Counter('bcc')</span>
|
|
<span class="sd"> Counter({'b': 1})</span>
|
|
|
|
<span class="sd"> '''</span>
|
|
<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">Counter</span><span class="p">):</span>
|
|
<span class="k">return</span> <span class="bp">NotImplemented</span>
|
|
<span class="n">result</span> <span class="o">=</span> <span class="n">Counter</span><span class="p">()</span>
|
|
<span class="k">for</span> <span class="n">elem</span><span class="p">,</span> <span class="n">count</span> <span class="ow">in</span> <span class="bp">self</span><span class="o">.</span><span class="n">items</span><span class="p">():</span>
|
|
<span class="n">other_count</span> <span class="o">=</span> <span class="n">other</span><span class="p">[</span><span class="n">elem</span><span class="p">]</span>
|
|
<span class="n">newcount</span> <span class="o">=</span> <span class="n">count</span> <span class="k">if</span> <span class="n">count</span> <span class="o"><</span> <span class="n">other_count</span> <span class="k">else</span> <span class="n">other_count</span>
|
|
<span class="k">if</span> <span class="n">newcount</span> <span class="o">></span> <span class="mi">0</span><span class="p">:</span>
|
|
<span class="n">result</span><span class="p">[</span><span class="n">elem</span><span class="p">]</span> <span class="o">=</span> <span class="n">newcount</span>
|
|
<span class="k">return</span> <span class="n">result</span>
|
|
|
|
<span class="k">def</span> <span class="nf">__pos__</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
|
|
<span class="s1">'Adds an empty counter, effectively stripping negative and zero counts'</span>
|
|
<span class="n">result</span> <span class="o">=</span> <span class="n">Counter</span><span class="p">()</span>
|
|
<span class="k">for</span> <span class="n">elem</span><span class="p">,</span> <span class="n">count</span> <span class="ow">in</span> <span class="bp">self</span><span class="o">.</span><span class="n">items</span><span class="p">():</span>
|
|
<span class="k">if</span> <span class="n">count</span> <span class="o">></span> <span class="mi">0</span><span class="p">:</span>
|
|
<span class="n">result</span><span class="p">[</span><span class="n">elem</span><span class="p">]</span> <span class="o">=</span> <span class="n">count</span>
|
|
<span class="k">return</span> <span class="n">result</span>
|
|
|
|
<span class="k">def</span> <span class="nf">__neg__</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
|
|
<span class="sd">'''Subtracts from an empty counter. Strips positive and zero counts,</span>
|
|
<span class="sd"> and flips the sign on negative counts.</span>
|
|
|
|
<span class="sd"> '''</span>
|
|
<span class="n">result</span> <span class="o">=</span> <span class="n">Counter</span><span class="p">()</span>
|
|
<span class="k">for</span> <span class="n">elem</span><span class="p">,</span> <span class="n">count</span> <span class="ow">in</span> <span class="bp">self</span><span class="o">.</span><span class="n">items</span><span class="p">():</span>
|
|
<span class="k">if</span> <span class="n">count</span> <span class="o"><</span> <span class="mi">0</span><span class="p">:</span>
|
|
<span class="n">result</span><span class="p">[</span><span class="n">elem</span><span class="p">]</span> <span class="o">=</span> <span class="mi">0</span> <span class="o">-</span> <span class="n">count</span>
|
|
<span class="k">return</span> <span class="n">result</span>
|
|
|
|
<span class="k">def</span> <span class="nf">_keep_positive</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
|
|
<span class="sd">'''Internal method to strip elements with a negative or zero count'''</span>
|
|
<span class="n">nonpositive</span> <span class="o">=</span> <span class="p">[</span><span class="n">elem</span> <span class="k">for</span> <span class="n">elem</span><span class="p">,</span> <span class="n">count</span> <span class="ow">in</span> <span class="bp">self</span><span class="o">.</span><span class="n">items</span><span class="p">()</span> <span class="k">if</span> <span class="ow">not</span> <span class="n">count</span> <span class="o">></span> <span class="mi">0</span><span class="p">]</span>
|
|
<span class="k">for</span> <span class="n">elem</span> <span class="ow">in</span> <span class="n">nonpositive</span><span class="p">:</span>
|
|
<span class="k">del</span> <span class="bp">self</span><span class="p">[</span><span class="n">elem</span><span class="p">]</span>
|
|
<span class="k">return</span> <span class="bp">self</span>
|
|
|
|
<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="sd">'''Inplace add from another counter, keeping only positive counts.</span>
|
|
|
|
<span class="sd"> >>> c = Counter('abbb')</span>
|
|
<span class="sd"> >>> c += Counter('bcc')</span>
|
|
<span class="sd"> >>> c</span>
|
|
<span class="sd"> Counter({'b': 4, 'c': 2, 'a': 1})</span>
|
|
|
|
<span class="sd"> '''</span>
|
|
<span class="k">for</span> <span class="n">elem</span><span class="p">,</span> <span class="n">count</span> <span class="ow">in</span> <span class="n">other</span><span class="o">.</span><span class="n">items</span><span class="p">():</span>
|
|
<span class="bp">self</span><span class="p">[</span><span class="n">elem</span><span class="p">]</span> <span class="o">+=</span> <span class="n">count</span>
|
|
<span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="n">_keep_positive</span><span class="p">()</span>
|
|
|
|
<span class="k">def</span> <span class="nf">__isub__</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="sd">'''Inplace subtract counter, but keep only results with positive counts.</span>
|
|
|
|
<span class="sd"> >>> c = Counter('abbbc')</span>
|
|
<span class="sd"> >>> c -= Counter('bccd')</span>
|
|
<span class="sd"> >>> c</span>
|
|
<span class="sd"> Counter({'b': 2, 'a': 1})</span>
|
|
|
|
<span class="sd"> '''</span>
|
|
<span class="k">for</span> <span class="n">elem</span><span class="p">,</span> <span class="n">count</span> <span class="ow">in</span> <span class="n">other</span><span class="o">.</span><span class="n">items</span><span class="p">():</span>
|
|
<span class="bp">self</span><span class="p">[</span><span class="n">elem</span><span class="p">]</span> <span class="o">-=</span> <span class="n">count</span>
|
|
<span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="n">_keep_positive</span><span class="p">()</span>
|
|
|
|
<span class="k">def</span> <span class="nf">__ior__</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="sd">'''Inplace union is the maximum of value from either counter.</span>
|
|
|
|
<span class="sd"> >>> c = Counter('abbb')</span>
|
|
<span class="sd"> >>> c |= Counter('bcc')</span>
|
|
<span class="sd"> >>> c</span>
|
|
<span class="sd"> Counter({'b': 3, 'c': 2, 'a': 1})</span>
|
|
|
|
<span class="sd"> '''</span>
|
|
<span class="k">for</span> <span class="n">elem</span><span class="p">,</span> <span class="n">other_count</span> <span class="ow">in</span> <span class="n">other</span><span class="o">.</span><span class="n">items</span><span class="p">():</span>
|
|
<span class="n">count</span> <span class="o">=</span> <span class="bp">self</span><span class="p">[</span><span class="n">elem</span><span class="p">]</span>
|
|
<span class="k">if</span> <span class="n">other_count</span> <span class="o">></span> <span class="n">count</span><span class="p">:</span>
|
|
<span class="bp">self</span><span class="p">[</span><span class="n">elem</span><span class="p">]</span> <span class="o">=</span> <span class="n">other_count</span>
|
|
<span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="n">_keep_positive</span><span class="p">()</span>
|
|
|
|
<span class="k">def</span> <span class="nf">__iand__</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="sd">'''Inplace intersection is the minimum of corresponding counts.</span>
|
|
|
|
<span class="sd"> >>> c = Counter('abbb')</span>
|
|
<span class="sd"> >>> c &= Counter('bcc')</span>
|
|
<span class="sd"> >>> c</span>
|
|
<span class="sd"> Counter({'b': 1})</span>
|
|
|
|
<span class="sd"> '''</span>
|
|
<span class="k">for</span> <span class="n">elem</span><span class="p">,</span> <span class="n">count</span> <span class="ow">in</span> <span class="bp">self</span><span class="o">.</span><span class="n">items</span><span class="p">():</span>
|
|
<span class="n">other_count</span> <span class="o">=</span> <span class="n">other</span><span class="p">[</span><span class="n">elem</span><span class="p">]</span>
|
|
<span class="k">if</span> <span class="n">other_count</span> <span class="o"><</span> <span class="n">count</span><span class="p">:</span>
|
|
<span class="bp">self</span><span class="p">[</span><span class="n">elem</span><span class="p">]</span> <span class="o">=</span> <span class="n">other_count</span>
|
|
<span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="n">_keep_positive</span><span class="p">()</span>
|
|
|
|
|
|
<span class="c1">########################################################################</span>
|
|
<span class="c1">### ChainMap</span>
|
|
<span class="c1">########################################################################</span>
|
|
|
|
<span class="k">class</span> <span class="nc">ChainMap</span><span class="p">(</span><span class="n">_collections_abc</span><span class="o">.</span><span class="n">MutableMapping</span><span class="p">):</span>
|
|
<span class="sd">''' A ChainMap groups multiple dicts (or other mappings) together</span>
|
|
<span class="sd"> to create a single, updateable view.</span>
|
|
|
|
<span class="sd"> The underlying mappings are stored in a list. That list is public and can</span>
|
|
<span class="sd"> be accessed or updated using the *maps* attribute. There is no other</span>
|
|
<span class="sd"> state.</span>
|
|
|
|
<span class="sd"> Lookups search the underlying mappings successively until a key is found.</span>
|
|
<span class="sd"> In contrast, writes, updates, and deletions only operate on the first</span>
|
|
<span class="sd"> mapping.</span>
|
|
|
|
<span class="sd"> '''</span>
|
|
|
|
<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="o">*</span><span class="n">maps</span><span class="p">):</span>
|
|
<span class="sd">'''Initialize a ChainMap by setting *maps* to the given mappings.</span>
|
|
<span class="sd"> If no mappings are provided, a single empty dictionary is used.</span>
|
|
|
|
<span class="sd"> '''</span>
|
|
<span class="bp">self</span><span class="o">.</span><span class="n">maps</span> <span class="o">=</span> <span class="nb">list</span><span class="p">(</span><span class="n">maps</span><span class="p">)</span> <span class="ow">or</span> <span class="p">[{}]</span> <span class="c1"># always at least one map</span>
|
|
|
|
<span class="k">def</span> <span class="nf">__missing__</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">raise</span> <span class="ne">KeyError</span><span class="p">(</span><span class="n">key</span><span class="p">)</span>
|
|
|
|
<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>
|
|
<span class="k">for</span> <span class="n">mapping</span> <span class="ow">in</span> <span class="bp">self</span><span class="o">.</span><span class="n">maps</span><span class="p">:</span>
|
|
<span class="k">try</span><span class="p">:</span>
|
|
<span class="k">return</span> <span class="n">mapping</span><span class="p">[</span><span class="n">key</span><span class="p">]</span> <span class="c1"># can't use 'key in mapping' with defaultdict</span>
|
|
<span class="k">except</span> <span class="ne">KeyError</span><span class="p">:</span>
|
|
<span class="k">pass</span>
|
|
<span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="fm">__missing__</span><span class="p">(</span><span class="n">key</span><span class="p">)</span> <span class="c1"># support subclasses that define __missing__</span>
|
|
|
|
<span class="k">def</span> <span class="nf">get</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">default</span><span class="o">=</span><span class="kc">None</span><span class="p">):</span>
|
|
<span class="k">return</span> <span class="bp">self</span><span class="p">[</span><span class="n">key</span><span class="p">]</span> <span class="k">if</span> <span class="n">key</span> <span class="ow">in</span> <span class="bp">self</span> <span class="k">else</span> <span class="n">default</span>
|
|
|
|
<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="nb">set</span><span class="p">()</span><span class="o">.</span><span class="n">union</span><span class="p">(</span><span class="o">*</span><span class="bp">self</span><span class="o">.</span><span class="n">maps</span><span class="p">))</span> <span class="c1"># reuses stored hash values if possible</span>
|
|
|
|
<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="n">d</span> <span class="o">=</span> <span class="p">{}</span>
|
|
<span class="k">for</span> <span class="n">mapping</span> <span class="ow">in</span> <span class="nb">reversed</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">maps</span><span class="p">):</span>
|
|
<span class="n">d</span><span class="o">.</span><span class="n">update</span><span class="p">(</span><span class="n">mapping</span><span class="p">)</span> <span class="c1"># reuses stored hash values if possible</span>
|
|
<span class="k">return</span> <span class="nb">iter</span><span class="p">(</span><span class="n">d</span><span class="p">)</span>
|
|
|
|
<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">key</span><span class="p">):</span>
|
|
<span class="k">return</span> <span class="nb">any</span><span class="p">(</span><span class="n">key</span> <span class="ow">in</span> <span class="n">m</span> <span class="k">for</span> <span class="n">m</span> <span class="ow">in</span> <span class="bp">self</span><span class="o">.</span><span class="n">maps</span><span class="p">)</span>
|
|
|
|
<span class="k">def</span> <span class="nf">__bool__</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
|
|
<span class="k">return</span> <span class="nb">any</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">maps</span><span class="p">)</span>
|
|
|
|
<span class="nd">@_recursive_repr</span><span class="p">()</span>
|
|
<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="s1">'</span><span class="si">{0.__class__.__name__}</span><span class="s1">(</span><span class="si">{1}</span><span class="s1">)'</span><span class="o">.</span><span class="n">format</span><span class="p">(</span>
|
|
<span class="bp">self</span><span class="p">,</span> <span class="s1">', '</span><span class="o">.</span><span class="n">join</span><span class="p">(</span><span class="nb">map</span><span class="p">(</span><span class="nb">repr</span><span class="p">,</span> <span class="bp">self</span><span class="o">.</span><span class="n">maps</span><span class="p">)))</span>
|
|
|
|
<span class="nd">@classmethod</span>
|
|
<span class="k">def</span> <span class="nf">fromkeys</span><span class="p">(</span><span class="bp">cls</span><span class="p">,</span> <span class="n">iterable</span><span class="p">,</span> <span class="o">*</span><span class="n">args</span><span class="p">):</span>
|
|
<span class="s1">'Create a ChainMap with a single dict created from the iterable.'</span>
|
|
<span class="k">return</span> <span class="bp">cls</span><span class="p">(</span><span class="nb">dict</span><span class="o">.</span><span class="n">fromkeys</span><span class="p">(</span><span class="n">iterable</span><span class="p">,</span> <span class="o">*</span><span class="n">args</span><span class="p">))</span>
|
|
|
|
<span class="k">def</span> <span class="nf">copy</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
|
|
<span class="s1">'New ChainMap or subclass with a new copy of maps[0] and refs to maps[1:]'</span>
|
|
<span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="vm">__class__</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">maps</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span><span class="o">.</span><span class="n">copy</span><span class="p">(),</span> <span class="o">*</span><span class="bp">self</span><span class="o">.</span><span class="n">maps</span><span class="p">[</span><span class="mi">1</span><span class="p">:])</span>
|
|
|
|
<span class="n">__copy__</span> <span class="o">=</span> <span class="n">copy</span>
|
|
|
|
<span class="k">def</span> <span class="nf">new_child</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">m</span><span class="o">=</span><span class="kc">None</span><span class="p">):</span> <span class="c1"># like Django's Context.push()</span>
|
|
<span class="sd">'''New ChainMap with a new map followed by all previous maps.</span>
|
|
<span class="sd"> If no map is provided, an empty dict is used.</span>
|
|
<span class="sd"> '''</span>
|
|
<span class="k">if</span> <span class="n">m</span> <span class="ow">is</span> <span class="kc">None</span><span class="p">:</span>
|
|
<span class="n">m</span> <span class="o">=</span> <span class="p">{}</span>
|
|
<span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="vm">__class__</span><span class="p">(</span><span class="n">m</span><span class="p">,</span> <span class="o">*</span><span class="bp">self</span><span class="o">.</span><span class="n">maps</span><span class="p">)</span>
|
|
|
|
<span class="nd">@property</span>
|
|
<span class="k">def</span> <span class="nf">parents</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span> <span class="c1"># like Django's Context.pop()</span>
|
|
<span class="s1">'New ChainMap from maps[1:].'</span>
|
|
<span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="vm">__class__</span><span class="p">(</span><span class="o">*</span><span class="bp">self</span><span class="o">.</span><span class="n">maps</span><span class="p">[</span><span class="mi">1</span><span class="p">:])</span>
|
|
|
|
<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">value</span><span class="p">):</span>
|
|
<span class="bp">self</span><span class="o">.</span><span class="n">maps</span><span class="p">[</span><span class="mi">0</span><span class="p">][</span><span class="n">key</span><span class="p">]</span> <span class="o">=</span> <span class="n">value</span>
|
|
|
|
<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>
|
|
<span class="k">try</span><span class="p">:</span>
|
|
<span class="k">del</span> <span class="bp">self</span><span class="o">.</span><span class="n">maps</span><span class="p">[</span><span class="mi">0</span><span class="p">][</span><span class="n">key</span><span class="p">]</span>
|
|
<span class="k">except</span> <span class="ne">KeyError</span><span class="p">:</span>
|
|
<span class="k">raise</span> <span class="ne">KeyError</span><span class="p">(</span><span class="s1">'Key not found in the first mapping: </span><span class="si">{!r}</span><span class="s1">'</span><span class="o">.</span><span class="n">format</span><span class="p">(</span><span class="n">key</span><span class="p">))</span>
|
|
|
|
<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="s1">'Remove and return an item pair from maps[0]. Raise KeyError is maps[0] is empty.'</span>
|
|
<span class="k">try</span><span class="p">:</span>
|
|
<span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="n">maps</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span><span class="o">.</span><span class="n">popitem</span><span class="p">()</span>
|
|
<span class="k">except</span> <span class="ne">KeyError</span><span class="p">:</span>
|
|
<span class="k">raise</span> <span class="ne">KeyError</span><span class="p">(</span><span class="s1">'No keys found in the first mapping.'</span><span class="p">)</span>
|
|
|
|
<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>
|
|
<span class="s1">'Remove *key* from maps[0] and return its value. Raise KeyError if *key* not in maps[0].'</span>
|
|
<span class="k">try</span><span class="p">:</span>
|
|
<span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="n">maps</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span><span class="o">.</span><span class="n">pop</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>
|
|
<span class="k">except</span> <span class="ne">KeyError</span><span class="p">:</span>
|
|
<span class="k">raise</span> <span class="ne">KeyError</span><span class="p">(</span><span class="s1">'Key not found in the first mapping: </span><span class="si">{!r}</span><span class="s1">'</span><span class="o">.</span><span class="n">format</span><span class="p">(</span><span class="n">key</span><span class="p">))</span>
|
|
|
|
<span class="k">def</span> <span class="nf">clear</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
|
|
<span class="s1">'Clear maps[0], leaving maps[1:] intact.'</span>
|
|
<span class="bp">self</span><span class="o">.</span><span class="n">maps</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span><span class="o">.</span><span class="n">clear</span><span class="p">()</span>
|
|
|
|
|
|
<span class="c1">################################################################################</span>
|
|
<span class="c1">### UserDict</span>
|
|
<span class="c1">################################################################################</span>
|
|
|
|
<span class="k">class</span> <span class="nc">UserDict</span><span class="p">(</span><span class="n">_collections_abc</span><span class="o">.</span><span class="n">MutableMapping</span><span class="p">):</span>
|
|
|
|
<span class="c1"># Start by filling-out the abstract methods</span>
|
|
<span class="k">def</span> <span class="nf">__init__</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>
|
|
<span class="k">if</span> <span class="ow">not</span> <span class="n">args</span><span class="p">:</span>
|
|
<span class="k">raise</span> <span class="ne">TypeError</span><span class="p">(</span><span class="s2">"descriptor '__init__' of 'UserDict' object "</span>
|
|
<span class="s2">"needs an argument"</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="o">=</span> <span class="n">args</span>
|
|
<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>
|
|
<span class="k">raise</span> <span class="ne">TypeError</span><span class="p">(</span><span class="s1">'expected at most 1 arguments, got </span><span class="si">%d</span><span class="s1">'</span> <span class="o">%</span> <span class="nb">len</span><span class="p">(</span><span class="n">args</span><span class="p">))</span>
|
|
<span class="k">if</span> <span class="n">args</span><span class="p">:</span>
|
|
<span class="nb">dict</span> <span class="o">=</span> <span class="n">args</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span>
|
|
<span class="k">elif</span> <span class="s1">'dict'</span> <span class="ow">in</span> <span class="n">kwargs</span><span class="p">:</span>
|
|
<span class="nb">dict</span> <span class="o">=</span> <span class="n">kwargs</span><span class="o">.</span><span class="n">pop</span><span class="p">(</span><span class="s1">'dict'</span><span class="p">)</span>
|
|
<span class="kn">import</span> <span class="nn">warnings</span>
|
|
<span class="n">warnings</span><span class="o">.</span><span class="n">warn</span><span class="p">(</span><span class="s2">"Passing 'dict' as keyword argument is deprecated"</span><span class="p">,</span>
|
|
<span class="ne">DeprecationWarning</span><span class="p">,</span> <span class="n">stacklevel</span><span class="o">=</span><span class="mi">2</span><span class="p">)</span>
|
|
<span class="k">else</span><span class="p">:</span>
|
|
<span class="nb">dict</span> <span class="o">=</span> <span class="kc">None</span>
|
|
<span class="bp">self</span><span class="o">.</span><span class="n">data</span> <span class="o">=</span> <span class="p">{}</span>
|
|
<span class="k">if</span> <span class="nb">dict</span> <span class="ow">is</span> <span class="ow">not</span> <span class="kc">None</span><span class="p">:</span>
|
|
<span class="bp">self</span><span class="o">.</span><span class="n">update</span><span class="p">(</span><span class="nb">dict</span><span class="p">)</span>
|
|
<span class="k">if</span> <span class="nb">len</span><span class="p">(</span><span class="n">kwargs</span><span class="p">):</span>
|
|
<span class="bp">self</span><span class="o">.</span><span class="n">update</span><span class="p">(</span><span class="n">kwargs</span><span class="p">)</span>
|
|
<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">data</span><span class="p">)</span>
|
|
<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>
|
|
<span class="k">if</span> <span class="n">key</span> <span class="ow">in</span> <span class="bp">self</span><span class="o">.</span><span class="n">data</span><span class="p">:</span>
|
|
<span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="n">data</span><span class="p">[</span><span class="n">key</span><span class="p">]</span>
|
|
<span class="k">if</span> <span class="nb">hasattr</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="vm">__class__</span><span class="p">,</span> <span class="s2">"__missing__"</span><span class="p">):</span>
|
|
<span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="vm">__class__</span><span class="o">.</span><span class="fm">__missing__</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">raise</span> <span class="ne">KeyError</span><span class="p">(</span><span class="n">key</span><span class="p">)</span>
|
|
<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">item</span><span class="p">):</span> <span class="bp">self</span><span class="o">.</span><span class="n">data</span><span class="p">[</span><span class="n">key</span><span class="p">]</span> <span class="o">=</span> <span class="n">item</span>
|
|
<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> <span class="k">del</span> <span class="bp">self</span><span class="o">.</span><span class="n">data</span><span class="p">[</span><span class="n">key</span><span class="p">]</span>
|
|
<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="nb">iter</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">data</span><span class="p">)</span>
|
|
|
|
<span class="c1"># Modify __contains__ to work correctly when __missing__ is present</span>
|
|
<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">key</span><span class="p">):</span>
|
|
<span class="k">return</span> <span class="n">key</span> <span class="ow">in</span> <span class="bp">self</span><span class="o">.</span><span class="n">data</span>
|
|
|
|
<span class="c1"># Now, add the methods in dicts but not in MutableMapping</span>
|
|
<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">data</span><span class="p">)</span>
|
|
<span class="k">def</span> <span class="nf">__copy__</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
|
|
<span class="n">inst</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="vm">__class__</span><span class="o">.</span><span class="fm">__new__</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="vm">__class__</span><span class="p">)</span>
|
|
<span class="n">inst</span><span class="o">.</span><span class="vm">__dict__</span><span class="o">.</span><span class="n">update</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="vm">__dict__</span><span class="p">)</span>
|
|
<span class="c1"># Create a copy and avoid triggering descriptors</span>
|
|
<span class="n">inst</span><span class="o">.</span><span class="vm">__dict__</span><span class="p">[</span><span class="s2">"data"</span><span class="p">]</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="vm">__dict__</span><span class="p">[</span><span class="s2">"data"</span><span class="p">]</span><span class="o">.</span><span class="n">copy</span><span class="p">()</span>
|
|
<span class="k">return</span> <span class="n">inst</span>
|
|
|
|
<span class="k">def</span> <span class="nf">copy</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
|
|
<span class="k">if</span> <span class="bp">self</span><span class="o">.</span><span class="vm">__class__</span> <span class="ow">is</span> <span class="n">UserDict</span><span class="p">:</span>
|
|
<span class="k">return</span> <span class="n">UserDict</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">data</span><span class="o">.</span><span class="n">copy</span><span class="p">())</span>
|
|
<span class="kn">import</span> <span class="nn">copy</span>
|
|
<span class="n">data</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="n">data</span>
|
|
<span class="k">try</span><span class="p">:</span>
|
|
<span class="bp">self</span><span class="o">.</span><span class="n">data</span> <span class="o">=</span> <span class="p">{}</span>
|
|
<span class="n">c</span> <span class="o">=</span> <span class="n">copy</span><span class="o">.</span><span class="n">copy</span><span class="p">(</span><span class="bp">self</span><span class="p">)</span>
|
|
<span class="k">finally</span><span class="p">:</span>
|
|
<span class="bp">self</span><span class="o">.</span><span class="n">data</span> <span class="o">=</span> <span class="n">data</span>
|
|
<span class="n">c</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="k">return</span> <span class="n">c</span>
|
|
|
|
<span class="nd">@classmethod</span>
|
|
<span class="k">def</span> <span class="nf">fromkeys</span><span class="p">(</span><span class="bp">cls</span><span class="p">,</span> <span class="n">iterable</span><span class="p">,</span> <span class="n">value</span><span class="o">=</span><span class="kc">None</span><span class="p">):</span>
|
|
<span class="n">d</span> <span class="o">=</span> <span class="bp">cls</span><span class="p">()</span>
|
|
<span class="k">for</span> <span class="n">key</span> <span class="ow">in</span> <span class="n">iterable</span><span class="p">:</span>
|
|
<span class="n">d</span><span class="p">[</span><span class="n">key</span><span class="p">]</span> <span class="o">=</span> <span class="n">value</span>
|
|
<span class="k">return</span> <span class="n">d</span>
|
|
|
|
|
|
|
|
<span class="c1">################################################################################</span>
|
|
<span class="c1">### UserList</span>
|
|
<span class="c1">################################################################################</span>
|
|
|
|
<span class="k">class</span> <span class="nc">UserList</span><span class="p">(</span><span class="n">_collections_abc</span><span class="o">.</span><span class="n">MutableSequence</span><span class="p">):</span>
|
|
<span class="sd">"""A more or less complete user-defined wrapper around list objects."""</span>
|
|
<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">initlist</span><span class="o">=</span><span class="kc">None</span><span class="p">):</span>
|
|
<span class="bp">self</span><span class="o">.</span><span class="n">data</span> <span class="o">=</span> <span class="p">[]</span>
|
|
<span class="k">if</span> <span class="n">initlist</span> <span class="ow">is</span> <span class="ow">not</span> <span class="kc">None</span><span class="p">:</span>
|
|
<span class="c1"># XXX should this accept an arbitrary sequence?</span>
|
|
<span class="k">if</span> <span class="nb">type</span><span class="p">(</span><span class="n">initlist</span><span class="p">)</span> <span class="o">==</span> <span class="nb">type</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">data</span><span class="p">):</span>
|
|
<span class="bp">self</span><span class="o">.</span><span class="n">data</span><span class="p">[:]</span> <span class="o">=</span> <span class="n">initlist</span>
|
|
<span class="k">elif</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">initlist</span><span class="p">,</span> <span class="n">UserList</span><span class="p">):</span>
|
|
<span class="bp">self</span><span class="o">.</span><span class="n">data</span><span class="p">[:]</span> <span class="o">=</span> <span class="n">initlist</span><span class="o">.</span><span class="n">data</span><span class="p">[:]</span>
|
|
<span class="k">else</span><span class="p">:</span>
|
|
<span class="bp">self</span><span class="o">.</span><span class="n">data</span> <span class="o">=</span> <span class="nb">list</span><span class="p">(</span><span class="n">initlist</span><span class="p">)</span>
|
|
<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">data</span><span class="p">)</span>
|
|
<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">data</span> <span class="o"><</span> <span class="bp">self</span><span class="o">.</span><span class="n">__cast</span><span class="p">(</span><span class="n">other</span><span class="p">)</span>
|
|
<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">data</span> <span class="o"><=</span> <span class="bp">self</span><span class="o">.</span><span class="n">__cast</span><span class="p">(</span><span class="n">other</span><span class="p">)</span>
|
|
<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">data</span> <span class="o">==</span> <span class="bp">self</span><span class="o">.</span><span class="n">__cast</span><span class="p">(</span><span class="n">other</span><span class="p">)</span>
|
|
<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">data</span> <span class="o">></span> <span class="bp">self</span><span class="o">.</span><span class="n">__cast</span><span class="p">(</span><span class="n">other</span><span class="p">)</span>
|
|
<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">data</span> <span class="o">>=</span> <span class="bp">self</span><span class="o">.</span><span class="n">__cast</span><span class="p">(</span><span class="n">other</span><span class="p">)</span>
|
|
<span class="k">def</span> <span class="nf">__cast</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="n">data</span> <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">UserList</span><span class="p">)</span> <span class="k">else</span> <span class="n">other</span>
|
|
<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">data</span>
|
|
<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">data</span><span class="p">)</span>
|
|
<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">i</span><span class="p">):</span>
|
|
<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="nb">slice</span><span class="p">):</span>
|
|
<span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="vm">__class__</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">data</span><span class="p">[</span><span class="n">i</span><span class="p">])</span>
|
|
<span class="k">else</span><span class="p">:</span>
|
|
<span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="n">data</span><span class="p">[</span><span class="n">i</span><span class="p">]</span>
|
|
<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">i</span><span class="p">,</span> <span class="n">item</span><span class="p">):</span> <span class="bp">self</span><span class="o">.</span><span class="n">data</span><span class="p">[</span><span class="n">i</span><span class="p">]</span> <span class="o">=</span> <span class="n">item</span>
|
|
<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">del</span> <span class="bp">self</span><span class="o">.</span><span class="n">data</span><span class="p">[</span><span class="n">i</span><span class="p">]</span>
|
|
<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">if</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">other</span><span class="p">,</span> <span class="n">UserList</span><span class="p">):</span>
|
|
<span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="vm">__class__</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">data</span> <span class="o">+</span> <span class="n">other</span><span class="o">.</span><span class="n">data</span><span class="p">)</span>
|
|
<span class="k">elif</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">other</span><span class="p">,</span> <span class="nb">type</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">data</span><span class="p">)):</span>
|
|
<span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="vm">__class__</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">data</span> <span class="o">+</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="vm">__class__</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">data</span> <span class="o">+</span> <span class="nb">list</span><span class="p">(</span><span class="n">other</span><span class="p">))</span>
|
|
<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">if</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">other</span><span class="p">,</span> <span class="n">UserList</span><span class="p">):</span>
|
|
<span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="vm">__class__</span><span class="p">(</span><span class="n">other</span><span class="o">.</span><span class="n">data</span> <span class="o">+</span> <span class="bp">self</span><span class="o">.</span><span class="n">data</span><span class="p">)</span>
|
|
<span class="k">elif</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">other</span><span class="p">,</span> <span class="nb">type</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">data</span><span class="p">)):</span>
|
|
<span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="vm">__class__</span><span class="p">(</span><span class="n">other</span> <span class="o">+</span> <span class="bp">self</span><span class="o">.</span><span class="n">data</span><span class="p">)</span>
|
|
<span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="vm">__class__</span><span class="p">(</span><span class="nb">list</span><span class="p">(</span><span class="n">other</span><span class="p">)</span> <span class="o">+</span> <span class="bp">self</span><span class="o">.</span><span class="n">data</span><span class="p">)</span>
|
|
<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">if</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">other</span><span class="p">,</span> <span class="n">UserList</span><span class="p">):</span>
|
|
<span class="bp">self</span><span class="o">.</span><span class="n">data</span> <span class="o">+=</span> <span class="n">other</span><span class="o">.</span><span class="n">data</span>
|
|
<span class="k">elif</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">other</span><span class="p">,</span> <span class="nb">type</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">data</span><span class="p">)):</span>
|
|
<span class="bp">self</span><span class="o">.</span><span class="n">data</span> <span class="o">+=</span> <span class="n">other</span>
|
|
<span class="k">else</span><span class="p">:</span>
|
|
<span class="bp">self</span><span class="o">.</span><span class="n">data</span> <span class="o">+=</span> <span class="nb">list</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="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="vm">__class__</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">data</span><span class="o">*</span><span class="n">n</span><span class="p">)</span>
|
|
<span class="fm">__rmul__</span> <span class="o">=</span> <span class="fm">__mul__</span>
|
|
<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="bp">self</span><span class="o">.</span><span class="n">data</span> <span class="o">*=</span> <span class="n">n</span>
|
|
<span class="k">return</span> <span class="bp">self</span>
|
|
<span class="k">def</span> <span class="nf">__copy__</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
|
|
<span class="n">inst</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="vm">__class__</span><span class="o">.</span><span class="fm">__new__</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="vm">__class__</span><span class="p">)</span>
|
|
<span class="n">inst</span><span class="o">.</span><span class="vm">__dict__</span><span class="o">.</span><span class="n">update</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="vm">__dict__</span><span class="p">)</span>
|
|
<span class="c1"># Create a copy and avoid triggering descriptors</span>
|
|
<span class="n">inst</span><span class="o">.</span><span class="vm">__dict__</span><span class="p">[</span><span class="s2">"data"</span><span class="p">]</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="vm">__dict__</span><span class="p">[</span><span class="s2">"data"</span><span class="p">][:]</span>
|
|
<span class="k">return</span> <span class="n">inst</span>
|
|
<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="bp">self</span><span class="o">.</span><span class="n">data</span><span class="o">.</span><span class="n">append</span><span class="p">(</span><span class="n">item</span><span class="p">)</span>
|
|
<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="bp">self</span><span class="o">.</span><span class="n">data</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">item</span><span class="p">)</span>
|
|
<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">return</span> <span class="bp">self</span><span class="o">.</span><span class="n">data</span><span class="o">.</span><span class="n">pop</span><span class="p">(</span><span class="n">i</span><span class="p">)</span>
|
|
<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="bp">self</span><span class="o">.</span><span class="n">data</span><span class="o">.</span><span class="n">remove</span><span class="p">(</span><span class="n">item</span><span class="p">)</span>
|
|
<span class="k">def</span> <span class="nf">clear</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">data</span><span class="o">.</span><span class="n">clear</span><span class="p">()</span>
|
|
<span class="k">def</span> <span class="nf">copy</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="vm">__class__</span><span class="p">(</span><span class="bp">self</span><span class="p">)</span>
|
|
<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">data</span><span class="o">.</span><span class="n">count</span><span class="p">(</span><span class="n">item</span><span class="p">)</span>
|
|
<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">data</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>
|
|
<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">data</span><span class="o">.</span><span class="n">reverse</span><span class="p">()</span>
|
|
<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">data</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>
|
|
<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">if</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">other</span><span class="p">,</span> <span class="n">UserList</span><span class="p">):</span>
|
|
<span class="bp">self</span><span class="o">.</span><span class="n">data</span><span class="o">.</span><span class="n">extend</span><span class="p">(</span><span class="n">other</span><span class="o">.</span><span class="n">data</span><span class="p">)</span>
|
|
<span class="k">else</span><span class="p">:</span>
|
|
<span class="bp">self</span><span class="o">.</span><span class="n">data</span><span class="o">.</span><span class="n">extend</span><span class="p">(</span><span class="n">other</span><span class="p">)</span>
|
|
|
|
|
|
|
|
<span class="c1">################################################################################</span>
|
|
<span class="c1">### UserString</span>
|
|
<span class="c1">################################################################################</span>
|
|
|
|
<span class="k">class</span> <span class="nc">UserString</span><span class="p">(</span><span class="n">_collections_abc</span><span class="o">.</span><span class="n">Sequence</span><span class="p">):</span>
|
|
<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">seq</span><span class="p">):</span>
|
|
<span class="k">if</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">seq</span><span class="p">,</span> <span class="nb">str</span><span class="p">):</span>
|
|
<span class="bp">self</span><span class="o">.</span><span class="n">data</span> <span class="o">=</span> <span class="n">seq</span>
|
|
<span class="k">elif</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">seq</span><span class="p">,</span> <span class="n">UserString</span><span class="p">):</span>
|
|
<span class="bp">self</span><span class="o">.</span><span class="n">data</span> <span class="o">=</span> <span class="n">seq</span><span class="o">.</span><span class="n">data</span><span class="p">[:]</span>
|
|
<span class="k">else</span><span class="p">:</span>
|
|
<span class="bp">self</span><span class="o">.</span><span class="n">data</span> <span class="o">=</span> <span class="nb">str</span><span class="p">(</span><span class="n">seq</span><span class="p">)</span>
|
|
<span class="k">def</span> <span class="nf">__str__</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span> <span class="k">return</span> <span class="nb">str</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">data</span><span class="p">)</span>
|
|
<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">data</span><span class="p">)</span>
|
|
<span class="k">def</span> <span class="nf">__int__</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span> <span class="k">return</span> <span class="nb">int</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">data</span><span class="p">)</span>
|
|
<span class="k">def</span> <span class="nf">__float__</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span> <span class="k">return</span> <span class="nb">float</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">data</span><span class="p">)</span>
|
|
<span class="k">def</span> <span class="nf">__complex__</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span> <span class="k">return</span> <span class="nb">complex</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">data</span><span class="p">)</span>
|
|
<span class="k">def</span> <span class="nf">__hash__</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span> <span class="k">return</span> <span class="nb">hash</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">data</span><span class="p">)</span>
|
|
<span class="k">def</span> <span class="nf">__getnewargs__</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
|
|
<span class="k">return</span> <span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">data</span><span class="p">[:],)</span>
|
|
|
|
<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">string</span><span class="p">):</span>
|
|
<span class="k">if</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">string</span><span class="p">,</span> <span class="n">UserString</span><span class="p">):</span>
|
|
<span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="n">data</span> <span class="o">==</span> <span class="n">string</span><span class="o">.</span><span class="n">data</span>
|
|
<span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="n">data</span> <span class="o">==</span> <span class="n">string</span>
|
|
<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">string</span><span class="p">):</span>
|
|
<span class="k">if</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">string</span><span class="p">,</span> <span class="n">UserString</span><span class="p">):</span>
|
|
<span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="n">data</span> <span class="o"><</span> <span class="n">string</span><span class="o">.</span><span class="n">data</span>
|
|
<span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="n">data</span> <span class="o"><</span> <span class="n">string</span>
|
|
<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">string</span><span class="p">):</span>
|
|
<span class="k">if</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">string</span><span class="p">,</span> <span class="n">UserString</span><span class="p">):</span>
|
|
<span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="n">data</span> <span class="o"><=</span> <span class="n">string</span><span class="o">.</span><span class="n">data</span>
|
|
<span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="n">data</span> <span class="o"><=</span> <span class="n">string</span>
|
|
<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">string</span><span class="p">):</span>
|
|
<span class="k">if</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">string</span><span class="p">,</span> <span class="n">UserString</span><span class="p">):</span>
|
|
<span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="n">data</span> <span class="o">></span> <span class="n">string</span><span class="o">.</span><span class="n">data</span>
|
|
<span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="n">data</span> <span class="o">></span> <span class="n">string</span>
|
|
<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">string</span><span class="p">):</span>
|
|
<span class="k">if</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">string</span><span class="p">,</span> <span class="n">UserString</span><span class="p">):</span>
|
|
<span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="n">data</span> <span class="o">>=</span> <span class="n">string</span><span class="o">.</span><span class="n">data</span>
|
|
<span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="n">data</span> <span class="o">>=</span> <span class="n">string</span>
|
|
|
|
<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">char</span><span class="p">):</span>
|
|
<span class="k">if</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">char</span><span class="p">,</span> <span class="n">UserString</span><span class="p">):</span>
|
|
<span class="n">char</span> <span class="o">=</span> <span class="n">char</span><span class="o">.</span><span class="n">data</span>
|
|
<span class="k">return</span> <span class="n">char</span> <span class="ow">in</span> <span class="bp">self</span><span class="o">.</span><span class="n">data</span>
|
|
|
|
<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">data</span><span class="p">)</span>
|
|
<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> <span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="vm">__class__</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">data</span><span class="p">[</span><span class="n">index</span><span class="p">])</span>
|
|
<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">if</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">other</span><span class="p">,</span> <span class="n">UserString</span><span class="p">):</span>
|
|
<span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="vm">__class__</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">data</span> <span class="o">+</span> <span class="n">other</span><span class="o">.</span><span class="n">data</span><span class="p">)</span>
|
|
<span class="k">elif</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">other</span><span class="p">,</span> <span class="nb">str</span><span class="p">):</span>
|
|
<span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="vm">__class__</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">data</span> <span class="o">+</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="vm">__class__</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">data</span> <span class="o">+</span> <span class="nb">str</span><span class="p">(</span><span class="n">other</span><span class="p">))</span>
|
|
<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">if</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">other</span><span class="p">,</span> <span class="nb">str</span><span class="p">):</span>
|
|
<span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="vm">__class__</span><span class="p">(</span><span class="n">other</span> <span class="o">+</span> <span class="bp">self</span><span class="o">.</span><span class="n">data</span><span class="p">)</span>
|
|
<span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="vm">__class__</span><span class="p">(</span><span class="nb">str</span><span class="p">(</span><span class="n">other</span><span class="p">)</span> <span class="o">+</span> <span class="bp">self</span><span class="o">.</span><span class="n">data</span><span class="p">)</span>
|
|
<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="vm">__class__</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">data</span><span class="o">*</span><span class="n">n</span><span class="p">)</span>
|
|
<span class="fm">__rmul__</span> <span class="o">=</span> <span class="fm">__mul__</span>
|
|
<span class="k">def</span> <span class="nf">__mod__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</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="vm">__class__</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">data</span> <span class="o">%</span> <span class="n">args</span><span class="p">)</span>
|
|
<span class="k">def</span> <span class="nf">__rmod__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="nb">format</span><span class="p">):</span>
|
|
<span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="vm">__class__</span><span class="p">(</span><span class="nb">format</span> <span class="o">%</span> <span class="n">args</span><span class="p">)</span>
|
|
|
|
<span class="c1"># the following methods are defined in alphabetical order:</span>
|
|
<span class="k">def</span> <span class="nf">capitalize</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="vm">__class__</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">data</span><span class="o">.</span><span class="n">capitalize</span><span class="p">())</span>
|
|
<span class="k">def</span> <span class="nf">casefold</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="vm">__class__</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">data</span><span class="o">.</span><span class="n">casefold</span><span class="p">())</span>
|
|
<span class="k">def</span> <span class="nf">center</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">width</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="vm">__class__</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">data</span><span class="o">.</span><span class="n">center</span><span class="p">(</span><span class="n">width</span><span class="p">,</span> <span class="o">*</span><span class="n">args</span><span class="p">))</span>
|
|
<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">sub</span><span class="p">,</span> <span class="n">start</span><span class="o">=</span><span class="mi">0</span><span class="p">,</span> <span class="n">end</span><span class="o">=</span><span class="n">_sys</span><span class="o">.</span><span class="n">maxsize</span><span class="p">):</span>
|
|
<span class="k">if</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">sub</span><span class="p">,</span> <span class="n">UserString</span><span class="p">):</span>
|
|
<span class="n">sub</span> <span class="o">=</span> <span class="n">sub</span><span class="o">.</span><span class="n">data</span>
|
|
<span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="n">data</span><span class="o">.</span><span class="n">count</span><span class="p">(</span><span class="n">sub</span><span class="p">,</span> <span class="n">start</span><span class="p">,</span> <span class="n">end</span><span class="p">)</span>
|
|
<span class="k">def</span> <span class="nf">encode</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">encoding</span><span class="o">=</span><span class="kc">None</span><span class="p">,</span> <span class="n">errors</span><span class="o">=</span><span class="kc">None</span><span class="p">):</span> <span class="c1"># XXX improve this?</span>
|
|
<span class="k">if</span> <span class="n">encoding</span><span class="p">:</span>
|
|
<span class="k">if</span> <span class="n">errors</span><span class="p">:</span>
|
|
<span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="vm">__class__</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">data</span><span class="o">.</span><span class="n">encode</span><span class="p">(</span><span class="n">encoding</span><span class="p">,</span> <span class="n">errors</span><span class="p">))</span>
|
|
<span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="vm">__class__</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">data</span><span class="o">.</span><span class="n">encode</span><span class="p">(</span><span class="n">encoding</span><span class="p">))</span>
|
|
<span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="vm">__class__</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">data</span><span class="o">.</span><span class="n">encode</span><span class="p">())</span>
|
|
<span class="k">def</span> <span class="nf">endswith</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">suffix</span><span class="p">,</span> <span class="n">start</span><span class="o">=</span><span class="mi">0</span><span class="p">,</span> <span class="n">end</span><span class="o">=</span><span class="n">_sys</span><span class="o">.</span><span class="n">maxsize</span><span class="p">):</span>
|
|
<span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="n">data</span><span class="o">.</span><span class="n">endswith</span><span class="p">(</span><span class="n">suffix</span><span class="p">,</span> <span class="n">start</span><span class="p">,</span> <span class="n">end</span><span class="p">)</span>
|
|
<span class="k">def</span> <span class="nf">expandtabs</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">tabsize</span><span class="o">=</span><span class="mi">8</span><span class="p">):</span>
|
|
<span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="vm">__class__</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">data</span><span class="o">.</span><span class="n">expandtabs</span><span class="p">(</span><span class="n">tabsize</span><span class="p">))</span>
|
|
<span class="k">def</span> <span class="nf">find</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">sub</span><span class="p">,</span> <span class="n">start</span><span class="o">=</span><span class="mi">0</span><span class="p">,</span> <span class="n">end</span><span class="o">=</span><span class="n">_sys</span><span class="o">.</span><span class="n">maxsize</span><span class="p">):</span>
|
|
<span class="k">if</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">sub</span><span class="p">,</span> <span class="n">UserString</span><span class="p">):</span>
|
|
<span class="n">sub</span> <span class="o">=</span> <span class="n">sub</span><span class="o">.</span><span class="n">data</span>
|
|
<span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="n">data</span><span class="o">.</span><span class="n">find</span><span class="p">(</span><span class="n">sub</span><span class="p">,</span> <span class="n">start</span><span class="p">,</span> <span class="n">end</span><span class="p">)</span>
|
|
<span class="k">def</span> <span class="nf">format</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="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="n">data</span><span class="o">.</span><span class="n">format</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="k">def</span> <span class="nf">format_map</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">mapping</span><span class="p">):</span>
|
|
<span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="n">data</span><span class="o">.</span><span class="n">format_map</span><span class="p">(</span><span class="n">mapping</span><span class="p">)</span>
|
|
<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">sub</span><span class="p">,</span> <span class="n">start</span><span class="o">=</span><span class="mi">0</span><span class="p">,</span> <span class="n">end</span><span class="o">=</span><span class="n">_sys</span><span class="o">.</span><span class="n">maxsize</span><span class="p">):</span>
|
|
<span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="n">data</span><span class="o">.</span><span class="n">index</span><span class="p">(</span><span class="n">sub</span><span class="p">,</span> <span class="n">start</span><span class="p">,</span> <span class="n">end</span><span class="p">)</span>
|
|
<span class="k">def</span> <span class="nf">isalpha</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">data</span><span class="o">.</span><span class="n">isalpha</span><span class="p">()</span>
|
|
<span class="k">def</span> <span class="nf">isalnum</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">data</span><span class="o">.</span><span class="n">isalnum</span><span class="p">()</span>
|
|
<span class="k">def</span> <span class="nf">isascii</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">data</span><span class="o">.</span><span class="n">isascii</span><span class="p">()</span>
|
|
<span class="k">def</span> <span class="nf">isdecimal</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">data</span><span class="o">.</span><span class="n">isdecimal</span><span class="p">()</span>
|
|
<span class="k">def</span> <span class="nf">isdigit</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">data</span><span class="o">.</span><span class="n">isdigit</span><span class="p">()</span>
|
|
<span class="k">def</span> <span class="nf">isidentifier</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">data</span><span class="o">.</span><span class="n">isidentifier</span><span class="p">()</span>
|
|
<span class="k">def</span> <span class="nf">islower</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">data</span><span class="o">.</span><span class="n">islower</span><span class="p">()</span>
|
|
<span class="k">def</span> <span class="nf">isnumeric</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">data</span><span class="o">.</span><span class="n">isnumeric</span><span class="p">()</span>
|
|
<span class="k">def</span> <span class="nf">isprintable</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">data</span><span class="o">.</span><span class="n">isprintable</span><span class="p">()</span>
|
|
<span class="k">def</span> <span class="nf">isspace</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">data</span><span class="o">.</span><span class="n">isspace</span><span class="p">()</span>
|
|
<span class="k">def</span> <span class="nf">istitle</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">data</span><span class="o">.</span><span class="n">istitle</span><span class="p">()</span>
|
|
<span class="k">def</span> <span class="nf">isupper</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">data</span><span class="o">.</span><span class="n">isupper</span><span class="p">()</span>
|
|
<span class="k">def</span> <span class="nf">join</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">seq</span><span class="p">):</span> <span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="n">data</span><span class="o">.</span><span class="n">join</span><span class="p">(</span><span class="n">seq</span><span class="p">)</span>
|
|
<span class="k">def</span> <span class="nf">ljust</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">width</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="vm">__class__</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">data</span><span class="o">.</span><span class="n">ljust</span><span class="p">(</span><span class="n">width</span><span class="p">,</span> <span class="o">*</span><span class="n">args</span><span class="p">))</span>
|
|
<span class="k">def</span> <span class="nf">lower</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="vm">__class__</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">data</span><span class="o">.</span><span class="n">lower</span><span class="p">())</span>
|
|
<span class="k">def</span> <span class="nf">lstrip</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">chars</span><span class="o">=</span><span class="kc">None</span><span class="p">):</span> <span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="vm">__class__</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">data</span><span class="o">.</span><span class="n">lstrip</span><span class="p">(</span><span class="n">chars</span><span class="p">))</span>
|
|
<span class="n">maketrans</span> <span class="o">=</span> <span class="nb">str</span><span class="o">.</span><span class="n">maketrans</span>
|
|
<span class="k">def</span> <span class="nf">partition</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">sep</span><span class="p">):</span>
|
|
<span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="n">data</span><span class="o">.</span><span class="n">partition</span><span class="p">(</span><span class="n">sep</span><span class="p">)</span>
|
|
<span class="k">def</span> <span class="nf">replace</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">old</span><span class="p">,</span> <span class="n">new</span><span class="p">,</span> <span class="n">maxsplit</span><span class="o">=-</span><span class="mi">1</span><span class="p">):</span>
|
|
<span class="k">if</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">old</span><span class="p">,</span> <span class="n">UserString</span><span class="p">):</span>
|
|
<span class="n">old</span> <span class="o">=</span> <span class="n">old</span><span class="o">.</span><span class="n">data</span>
|
|
<span class="k">if</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">new</span><span class="p">,</span> <span class="n">UserString</span><span class="p">):</span>
|
|
<span class="n">new</span> <span class="o">=</span> <span class="n">new</span><span class="o">.</span><span class="n">data</span>
|
|
<span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="vm">__class__</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">data</span><span class="o">.</span><span class="n">replace</span><span class="p">(</span><span class="n">old</span><span class="p">,</span> <span class="n">new</span><span class="p">,</span> <span class="n">maxsplit</span><span class="p">))</span>
|
|
<span class="k">def</span> <span class="nf">rfind</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">sub</span><span class="p">,</span> <span class="n">start</span><span class="o">=</span><span class="mi">0</span><span class="p">,</span> <span class="n">end</span><span class="o">=</span><span class="n">_sys</span><span class="o">.</span><span class="n">maxsize</span><span class="p">):</span>
|
|
<span class="k">if</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">sub</span><span class="p">,</span> <span class="n">UserString</span><span class="p">):</span>
|
|
<span class="n">sub</span> <span class="o">=</span> <span class="n">sub</span><span class="o">.</span><span class="n">data</span>
|
|
<span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="n">data</span><span class="o">.</span><span class="n">rfind</span><span class="p">(</span><span class="n">sub</span><span class="p">,</span> <span class="n">start</span><span class="p">,</span> <span class="n">end</span><span class="p">)</span>
|
|
<span class="k">def</span> <span class="nf">rindex</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">sub</span><span class="p">,</span> <span class="n">start</span><span class="o">=</span><span class="mi">0</span><span class="p">,</span> <span class="n">end</span><span class="o">=</span><span class="n">_sys</span><span class="o">.</span><span class="n">maxsize</span><span class="p">):</span>
|
|
<span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="n">data</span><span class="o">.</span><span class="n">rindex</span><span class="p">(</span><span class="n">sub</span><span class="p">,</span> <span class="n">start</span><span class="p">,</span> <span class="n">end</span><span class="p">)</span>
|
|
<span class="k">def</span> <span class="nf">rjust</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">width</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="vm">__class__</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">data</span><span class="o">.</span><span class="n">rjust</span><span class="p">(</span><span class="n">width</span><span class="p">,</span> <span class="o">*</span><span class="n">args</span><span class="p">))</span>
|
|
<span class="k">def</span> <span class="nf">rpartition</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">sep</span><span class="p">):</span>
|
|
<span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="n">data</span><span class="o">.</span><span class="n">rpartition</span><span class="p">(</span><span class="n">sep</span><span class="p">)</span>
|
|
<span class="k">def</span> <span class="nf">rstrip</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">chars</span><span class="o">=</span><span class="kc">None</span><span class="p">):</span>
|
|
<span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="vm">__class__</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">data</span><span class="o">.</span><span class="n">rstrip</span><span class="p">(</span><span class="n">chars</span><span class="p">))</span>
|
|
<span class="k">def</span> <span class="nf">split</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">sep</span><span class="o">=</span><span class="kc">None</span><span class="p">,</span> <span class="n">maxsplit</span><span class="o">=-</span><span class="mi">1</span><span class="p">):</span>
|
|
<span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="n">data</span><span class="o">.</span><span class="n">split</span><span class="p">(</span><span class="n">sep</span><span class="p">,</span> <span class="n">maxsplit</span><span class="p">)</span>
|
|
<span class="k">def</span> <span class="nf">rsplit</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">sep</span><span class="o">=</span><span class="kc">None</span><span class="p">,</span> <span class="n">maxsplit</span><span class="o">=-</span><span class="mi">1</span><span class="p">):</span>
|
|
<span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="n">data</span><span class="o">.</span><span class="n">rsplit</span><span class="p">(</span><span class="n">sep</span><span class="p">,</span> <span class="n">maxsplit</span><span class="p">)</span>
|
|
<span class="k">def</span> <span class="nf">splitlines</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">keepends</span><span class="o">=</span><span class="kc">False</span><span class="p">):</span> <span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="n">data</span><span class="o">.</span><span class="n">splitlines</span><span class="p">(</span><span class="n">keepends</span><span class="p">)</span>
|
|
<span class="k">def</span> <span class="nf">startswith</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">prefix</span><span class="p">,</span> <span class="n">start</span><span class="o">=</span><span class="mi">0</span><span class="p">,</span> <span class="n">end</span><span class="o">=</span><span class="n">_sys</span><span class="o">.</span><span class="n">maxsize</span><span class="p">):</span>
|
|
<span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="n">data</span><span class="o">.</span><span class="n">startswith</span><span class="p">(</span><span class="n">prefix</span><span class="p">,</span> <span class="n">start</span><span class="p">,</span> <span class="n">end</span><span class="p">)</span>
|
|
<span class="k">def</span> <span class="nf">strip</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">chars</span><span class="o">=</span><span class="kc">None</span><span class="p">):</span> <span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="vm">__class__</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">data</span><span class="o">.</span><span class="n">strip</span><span class="p">(</span><span class="n">chars</span><span class="p">))</span>
|
|
<span class="k">def</span> <span class="nf">swapcase</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="vm">__class__</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">data</span><span class="o">.</span><span class="n">swapcase</span><span class="p">())</span>
|
|
<span class="k">def</span> <span class="nf">title</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="vm">__class__</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">data</span><span class="o">.</span><span class="n">title</span><span class="p">())</span>
|
|
<span class="k">def</span> <span class="nf">translate</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="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="vm">__class__</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">data</span><span class="o">.</span><span class="n">translate</span><span class="p">(</span><span class="o">*</span><span class="n">args</span><span class="p">))</span>
|
|
<span class="k">def</span> <span class="nf">upper</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="vm">__class__</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">data</span><span class="o">.</span><span class="n">upper</span><span class="p">())</span>
|
|
<span class="k">def</span> <span class="nf">zfill</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">width</span><span class="p">):</span> <span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="vm">__class__</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">data</span><span class="o">.</span><span class="n">zfill</span><span class="p">(</span><span class="n">width</span><span class="p">))</span>
|
|
</pre></div>
|
|
|
|
</div>
|
|
</div>
|
|
</div>
|
|
<div class="sphinxsidebar" role="navigation" aria-label="main navigation">
|
|
<div class="sphinxsidebarwrapper">
|
|
<p class="logo"><a href="../index.html">
|
|
<img class="logo" src="../_static/evennia_logo.png" alt="Logo"/>
|
|
</a></p>
|
|
<div id="searchbox" style="display: none" role="search">
|
|
<h3 id="searchlabel">Quick search</h3>
|
|
<div class="searchformwrapper">
|
|
<form class="search" action="../search.html" method="get">
|
|
<input type="text" name="q" aria-labelledby="searchlabel" />
|
|
<input type="submit" value="Go" />
|
|
</form>
|
|
</div>
|
|
</div>
|
|
<script>$('#searchbox').show(0);</script>
|
|
<h3>Versions</h3>
|
|
<ul>
|
|
<li><a href="collections.html">1.0-dev (develop branch)</a></li>
|
|
<li><a href="../../0.9.1/index.html">0.9.1 (master branch)</a></li>
|
|
</ul>
|
|
|
|
</div>
|
|
</div>
|
|
<div class="clearer"></div>
|
|
</div>
|
|
<div class="related" role="navigation" aria-label="related navigation">
|
|
<h3>Navigation</h3>
|
|
<ul>
|
|
<li class="right" style="margin-right: 10px">
|
|
<a href="../genindex.html" title="General Index"
|
|
>index</a></li>
|
|
<li class="right" >
|
|
<a href="../py-modindex.html" title="Python Module Index"
|
|
>modules</a> |</li>
|
|
<li class="nav-item nav-item-0"><a href="../index.html">Evennia 1.0-dev documentation</a> »</li>
|
|
<li class="nav-item nav-item-1"><a href="index.html" >Module code</a> »</li>
|
|
</ul>
|
|
</div>
|
|
<div class="footer" role="contentinfo">
|
|
© Copyright 2020, The Evennia developer community.
|
|
Created using <a href="http://sphinx-doc.org/">Sphinx</a> 2.4.4.
|
|
</div>
|
|
</body>
|
|
</html> |