Andreas/evennia
1
0
Fork 0
mirror of https://github.com/evennia/evennia.git synced 2026-03-21 15:26:30 +01:00
Code Issues Projects Releases Packages Wiki Activity Actions
evennia/docs/5.x/_modules/collections/abc.html
Griatch c5437c1273 Add 5.x documentation
2025-07-01 10:01:48 +02:00

1340 lines
No EOL
138 KiB
HTML
Raw Blame History

<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="utf-8" />
<meta name="viewport" content="width=device-width, initial-scale=1.0" />
<title>collections.abc &#8212; Evennia latest documentation</title>
<link rel="stylesheet" href="../../_static/nature.css" type="text/css" />
<link rel="stylesheet" href="../../_static/pygments.css" type="text/css" />
<link rel="stylesheet" type="text/css" href="../../_static/pygments.css?v=d75fae25" />
<link rel="stylesheet" type="text/css" href="../../_static/nature.css?v=245aff17" />
<script id="documentation_options" data-url_root="../../" src="../../_static/documentation_options.js"></script>
<script src="../../_static/documentation_options.js?v=c6e86fd7"></script>
<script src="../../_static/doctools.js?v=9bcbadda"></script>
<script src="../../_static/sphinx_highlight.js?v=dc90522c"></script>
<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 latest</a> &#187;</li>
<li class="nav-item nav-item-1"><a href="../index.html" >Module code</a> &#187;</li>
<li class="nav-item nav-item-2"><a href="../collections.html" accesskey="U">collections</a> &#187;</li>
<li class="nav-item nav-item-this"><a href="">collections.abc</a></li>
</ul>
</div>
<div class="document">
<div class="documentwrapper">
<div class="sphinxsidebar" role="navigation" aria-label="main navigation">
<div class="sphinxsidebarwrapper">
<search 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" autocomplete="off" autocorrect="off" autocapitalize="off" spellcheck="false"/>
<input type="submit" value="Go" />
</form>
</div>
</search>
<script>document.getElementById('searchbox').style.display = "block"</script><h3>Links</h3>
<ul>
<li><a href="https://www.evennia.com/docs/latest/index.html">Documentation Top</a> </li>
<li><a href="https://www.evennia.com">Evennia Home</a> </li>
<li><a href="https://github.com/evennia/evennia">Github</a> </li>
<li><a href="http://games.evennia.com">Game Index</a> </li>
<li>
<a href="https://discord.gg/AJJpcRUhtF">Discord</a> -
<a href="https://github.com/evennia/evennia/discussions">Discussions</a> -
<a href="https://evennia.blogspot.com/">Blog</a>
</li>
</ul>
</div>
</div>
<div class="bodywrapper">
<div class="body" role="main">
<h1>Source code for collections.abc</h1><div class="highlight"><pre>
<span></span><span class="c1"># Copyright 2007 Google, Inc. All Rights Reserved.</span>
<span class="c1"># Licensed to PSF under a Contributor Agreement.</span>
<span class="sd">&quot;&quot;&quot;Abstract Base Classes (ABCs) for collections, according to PEP 3119.</span>
<span class="sd">Unit tests are in test_collections.</span>
<span class="sd">&quot;&quot;&quot;</span>
<span class="c1">############ Maintenance notes #########################################</span>
<span class="c1">#</span>
<span class="c1"># ABCs are different from other standard library modules in that they</span>
<span class="c1"># specify compliance tests. In general, once an ABC has been published,</span>
<span class="c1"># new methods (either abstract or concrete) cannot be added.</span>
<span class="c1">#</span>
<span class="c1"># Though classes that inherit from an ABC would automatically receive a</span>
<span class="c1"># new mixin method, registered classes would become non-compliant and</span>
<span class="c1"># violate the contract promised by ``isinstance(someobj, SomeABC)``.</span>
<span class="c1">#</span>
<span class="c1"># Though irritating, the correct procedure for adding new abstract or</span>
<span class="c1"># mixin methods is to create a new ABC as a subclass of the previous</span>
<span class="c1"># ABC. For example, union(), intersection(), and difference() cannot</span>
<span class="c1"># be added to Set but could go into a new ABC that extends Set.</span>
<span class="c1">#</span>
<span class="c1"># Because they are so hard to change, new ABCs should have their APIs</span>
<span class="c1"># carefully thought through prior to publication.</span>
<span class="c1">#</span>
<span class="c1"># Since ABCMeta only checks for the presence of methods, it is possible</span>
<span class="c1"># to alter the signature of a method by adding optional arguments</span>
<span class="c1"># or changing parameters names. This is still a bit dubious but at</span>
<span class="c1"># least it won&#39;t cause isinstance() to return an incorrect result.</span>
<span class="c1">#</span>
<span class="c1">#</span>
<span class="c1">#######################################################################</span>
<span class="kn">from</span><span class="w"> </span><span class="nn">abc</span><span class="w"> </span><span class="kn">import</span> <span class="n">ABCMeta</span><span class="p">,</span> <span class="n">abstractmethod</span>
<span class="kn">import</span><span class="w"> </span><span class="nn">sys</span>
<span class="n">GenericAlias</span> <span class="o">=</span> <span class="nb">type</span><span class="p">(</span><span class="nb">list</span><span class="p">[</span><span class="nb">int</span><span class="p">])</span>
<span class="n">EllipsisType</span> <span class="o">=</span> <span class="nb">type</span><span class="p">(</span><span class="o">...</span><span class="p">)</span>
<span class="k">def</span><span class="w"> </span><span class="nf">_f</span><span class="p">():</span> <span class="k">pass</span>
<span class="n">FunctionType</span> <span class="o">=</span> <span class="nb">type</span><span class="p">(</span><span class="n">_f</span><span class="p">)</span>
<span class="k">del</span> <span class="n">_f</span>
<span class="n">__all__</span> <span class="o">=</span> <span class="p">[</span><span class="s2">&quot;Awaitable&quot;</span><span class="p">,</span> <span class="s2">&quot;Coroutine&quot;</span><span class="p">,</span>
<span class="s2">&quot;AsyncIterable&quot;</span><span class="p">,</span> <span class="s2">&quot;AsyncIterator&quot;</span><span class="p">,</span> <span class="s2">&quot;AsyncGenerator&quot;</span><span class="p">,</span>
<span class="s2">&quot;Hashable&quot;</span><span class="p">,</span> <span class="s2">&quot;Iterable&quot;</span><span class="p">,</span> <span class="s2">&quot;Iterator&quot;</span><span class="p">,</span> <span class="s2">&quot;Generator&quot;</span><span class="p">,</span> <span class="s2">&quot;Reversible&quot;</span><span class="p">,</span>
<span class="s2">&quot;Sized&quot;</span><span class="p">,</span> <span class="s2">&quot;Container&quot;</span><span class="p">,</span> <span class="s2">&quot;Callable&quot;</span><span class="p">,</span> <span class="s2">&quot;Collection&quot;</span><span class="p">,</span>
<span class="s2">&quot;Set&quot;</span><span class="p">,</span> <span class="s2">&quot;MutableSet&quot;</span><span class="p">,</span>
<span class="s2">&quot;Mapping&quot;</span><span class="p">,</span> <span class="s2">&quot;MutableMapping&quot;</span><span class="p">,</span>
<span class="s2">&quot;MappingView&quot;</span><span class="p">,</span> <span class="s2">&quot;KeysView&quot;</span><span class="p">,</span> <span class="s2">&quot;ItemsView&quot;</span><span class="p">,</span> <span class="s2">&quot;ValuesView&quot;</span><span class="p">,</span>
<span class="s2">&quot;Sequence&quot;</span><span class="p">,</span> <span class="s2">&quot;MutableSequence&quot;</span><span class="p">,</span>
<span class="s2">&quot;ByteString&quot;</span><span class="p">,</span> <span class="s2">&quot;Buffer&quot;</span><span class="p">,</span>
<span class="p">]</span>
<span class="c1"># This module has been renamed from collections.abc to _collections_abc to</span>
<span class="c1"># speed up interpreter startup. Some of the types such as MutableMapping are</span>
<span class="c1"># required early but collections module imports a lot of other modules.</span>
<span class="c1"># See issue #19218</span>
<span class="vm">__name__</span> <span class="o">=</span> <span class="s2">&quot;collections.abc&quot;</span>
<span class="c1"># Private list of types that we want to register with the various ABCs</span>
<span class="c1"># so that they will pass tests like:</span>
<span class="c1"># it = iter(somebytearray)</span>
<span class="c1"># assert isinstance(it, Iterable)</span>
<span class="c1"># Note: in other implementations, these types might not be distinct</span>
<span class="c1"># and they may have their own implementation specific types that</span>
<span class="c1"># are not included on this list.</span>
<span class="n">bytes_iterator</span> <span class="o">=</span> <span class="nb">type</span><span class="p">(</span><span class="nb">iter</span><span class="p">(</span><span class="sa">b</span><span class="s1">&#39;&#39;</span><span class="p">))</span>
<span class="n">bytearray_iterator</span> <span class="o">=</span> <span class="nb">type</span><span class="p">(</span><span class="nb">iter</span><span class="p">(</span><span class="nb">bytearray</span><span class="p">()))</span>
<span class="c1">#callable_iterator = ???</span>
<span class="n">dict_keyiterator</span> <span class="o">=</span> <span class="nb">type</span><span class="p">(</span><span class="nb">iter</span><span class="p">({}</span><span class="o">.</span><span class="n">keys</span><span class="p">()))</span>
<span class="n">dict_valueiterator</span> <span class="o">=</span> <span class="nb">type</span><span class="p">(</span><span class="nb">iter</span><span class="p">({}</span><span class="o">.</span><span class="n">values</span><span class="p">()))</span>
<span class="n">dict_itemiterator</span> <span class="o">=</span> <span class="nb">type</span><span class="p">(</span><span class="nb">iter</span><span class="p">({}</span><span class="o">.</span><span class="n">items</span><span class="p">()))</span>
<span class="n">list_iterator</span> <span class="o">=</span> <span class="nb">type</span><span class="p">(</span><span class="nb">iter</span><span class="p">([]))</span>
<span class="n">list_reverseiterator</span> <span class="o">=</span> <span class="nb">type</span><span class="p">(</span><span class="nb">iter</span><span class="p">(</span><span class="nb">reversed</span><span class="p">([])))</span>
<span class="n">range_iterator</span> <span class="o">=</span> <span class="nb">type</span><span class="p">(</span><span class="nb">iter</span><span class="p">(</span><span class="nb">range</span><span class="p">(</span><span class="mi">0</span><span class="p">)))</span>
<span class="n">longrange_iterator</span> <span class="o">=</span> <span class="nb">type</span><span class="p">(</span><span class="nb">iter</span><span class="p">(</span><span class="nb">range</span><span class="p">(</span><span class="mi">1</span> <span class="o">&lt;&lt;</span> <span class="mi">1000</span><span class="p">)))</span>
<span class="n">set_iterator</span> <span class="o">=</span> <span class="nb">type</span><span class="p">(</span><span class="nb">iter</span><span class="p">(</span><span class="nb">set</span><span class="p">()))</span>
<span class="n">str_iterator</span> <span class="o">=</span> <span class="nb">type</span><span class="p">(</span><span class="nb">iter</span><span class="p">(</span><span class="s2">&quot;&quot;</span><span class="p">))</span>
<span class="n">tuple_iterator</span> <span class="o">=</span> <span class="nb">type</span><span class="p">(</span><span class="nb">iter</span><span class="p">(()))</span>
<span class="n">zip_iterator</span> <span class="o">=</span> <span class="nb">type</span><span class="p">(</span><span class="nb">iter</span><span class="p">(</span><span class="nb">zip</span><span class="p">()))</span>
<span class="c1">## views ##</span>
<span class="n">dict_keys</span> <span class="o">=</span> <span class="nb">type</span><span class="p">({}</span><span class="o">.</span><span class="n">keys</span><span class="p">())</span>
<span class="n">dict_values</span> <span class="o">=</span> <span class="nb">type</span><span class="p">({}</span><span class="o">.</span><span class="n">values</span><span class="p">())</span>
<span class="n">dict_items</span> <span class="o">=</span> <span class="nb">type</span><span class="p">({}</span><span class="o">.</span><span class="n">items</span><span class="p">())</span>
<span class="c1">## misc ##</span>
<span class="n">mappingproxy</span> <span class="o">=</span> <span class="nb">type</span><span class="p">(</span><span class="nb">type</span><span class="o">.</span><span class="vm">__dict__</span><span class="p">)</span>
<span class="k">def</span><span class="w"> </span><span class="nf">_get_framelocalsproxy</span><span class="p">():</span>
<span class="k">return</span> <span class="nb">type</span><span class="p">(</span><span class="n">sys</span><span class="o">.</span><span class="n">_getframe</span><span class="p">()</span><span class="o">.</span><span class="n">f_locals</span><span class="p">)</span>
<span class="n">framelocalsproxy</span> <span class="o">=</span> <span class="n">_get_framelocalsproxy</span><span class="p">()</span>
<span class="k">del</span> <span class="n">_get_framelocalsproxy</span>
<span class="n">generator</span> <span class="o">=</span> <span class="nb">type</span><span class="p">((</span><span class="k">lambda</span><span class="p">:</span> <span class="p">(</span><span class="k">yield</span><span class="p">))())</span>
<span class="c1">## coroutine ##</span>
<span class="k">async</span> <span class="k">def</span><span class="w"> </span><span class="nf">_coro</span><span class="p">():</span> <span class="k">pass</span>
<span class="n">_coro</span> <span class="o">=</span> <span class="n">_coro</span><span class="p">()</span>
<span class="n">coroutine</span> <span class="o">=</span> <span class="nb">type</span><span class="p">(</span><span class="n">_coro</span><span class="p">)</span>
<span class="n">_coro</span><span class="o">.</span><span class="n">close</span><span class="p">()</span> <span class="c1"># Prevent ResourceWarning</span>
<span class="k">del</span> <span class="n">_coro</span>
<span class="c1">## asynchronous generator ##</span>
<span class="k">async</span> <span class="k">def</span><span class="w"> </span><span class="nf">_ag</span><span class="p">():</span> <span class="k">yield</span>
<span class="n">_ag</span> <span class="o">=</span> <span class="n">_ag</span><span class="p">()</span>
<span class="n">async_generator</span> <span class="o">=</span> <span class="nb">type</span><span class="p">(</span><span class="n">_ag</span><span class="p">)</span>
<span class="k">del</span> <span class="n">_ag</span>
<span class="c1">### ONE-TRICK PONIES ###</span>
<span class="k">def</span><span class="w"> </span><span class="nf">_check_methods</span><span class="p">(</span><span class="n">C</span><span class="p">,</span> <span class="o">*</span><span class="n">methods</span><span class="p">):</span>
<span class="n">mro</span> <span class="o">=</span> <span class="n">C</span><span class="o">.</span><span class="vm">__mro__</span>
<span class="k">for</span> <span class="n">method</span> <span class="ow">in</span> <span class="n">methods</span><span class="p">:</span>
<span class="k">for</span> <span class="n">B</span> <span class="ow">in</span> <span class="n">mro</span><span class="p">:</span>
<span class="k">if</span> <span class="n">method</span> <span class="ow">in</span> <span class="n">B</span><span class="o">.</span><span class="vm">__dict__</span><span class="p">:</span>
<span class="k">if</span> <span class="n">B</span><span class="o">.</span><span class="vm">__dict__</span><span class="p">[</span><span class="n">method</span><span class="p">]</span> <span class="ow">is</span> <span class="kc">None</span><span class="p">:</span>
<span class="k">return</span> <span class="bp">NotImplemented</span>
<span class="k">break</span>
<span class="k">else</span><span class="p">:</span>
<span class="k">return</span> <span class="bp">NotImplemented</span>
<span class="k">return</span> <span class="kc">True</span>
<span class="k">class</span><span class="w"> </span><span class="nc">Hashable</span><span class="p">(</span><span class="n">metaclass</span><span class="o">=</span><span class="n">ABCMeta</span><span class="p">):</span>
<span class="vm">__slots__</span> <span class="o">=</span> <span class="p">()</span>
<span class="nd">@abstractmethod</span>
<span class="k">def</span><span class="w"> </span><span class="fm">__hash__</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
<span class="k">return</span> <span class="mi">0</span>
<span class="nd">@classmethod</span>
<span class="k">def</span><span class="w"> </span><span class="nf">__subclasshook__</span><span class="p">(</span><span class="bp">cls</span><span class="p">,</span> <span class="n">C</span><span class="p">):</span>
<span class="k">if</span> <span class="bp">cls</span> <span class="ow">is</span> <span class="n">Hashable</span><span class="p">:</span>
<span class="k">return</span> <span class="n">_check_methods</span><span class="p">(</span><span class="n">C</span><span class="p">,</span> <span class="s2">&quot;__hash__&quot;</span><span class="p">)</span>
<span class="k">return</span> <span class="bp">NotImplemented</span>
<span class="k">class</span><span class="w"> </span><span class="nc">Awaitable</span><span class="p">(</span><span class="n">metaclass</span><span class="o">=</span><span class="n">ABCMeta</span><span class="p">):</span>
<span class="vm">__slots__</span> <span class="o">=</span> <span class="p">()</span>
<span class="nd">@abstractmethod</span>
<span class="k">def</span><span class="w"> </span><span class="fm">__await__</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
<span class="k">yield</span>
<span class="nd">@classmethod</span>
<span class="k">def</span><span class="w"> </span><span class="nf">__subclasshook__</span><span class="p">(</span><span class="bp">cls</span><span class="p">,</span> <span class="n">C</span><span class="p">):</span>
<span class="k">if</span> <span class="bp">cls</span> <span class="ow">is</span> <span class="n">Awaitable</span><span class="p">:</span>
<span class="k">return</span> <span class="n">_check_methods</span><span class="p">(</span><span class="n">C</span><span class="p">,</span> <span class="s2">&quot;__await__&quot;</span><span class="p">)</span>
<span class="k">return</span> <span class="bp">NotImplemented</span>
<span class="n">__class_getitem__</span> <span class="o">=</span> <span class="nb">classmethod</span><span class="p">(</span><span class="n">GenericAlias</span><span class="p">)</span>
<span class="k">class</span><span class="w"> </span><span class="nc">Coroutine</span><span class="p">(</span><span class="n">Awaitable</span><span class="p">):</span>
<span class="vm">__slots__</span> <span class="o">=</span> <span class="p">()</span>
<span class="nd">@abstractmethod</span>
<span class="k">def</span><span class="w"> </span><span class="nf">send</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">value</span><span class="p">):</span>
<span class="w"> </span><span class="sd">&quot;&quot;&quot;Send a value into the coroutine.</span>
<span class="sd"> Return next yielded value or raise StopIteration.</span>
<span class="sd"> &quot;&quot;&quot;</span>
<span class="k">raise</span> <span class="ne">StopIteration</span>
<span class="nd">@abstractmethod</span>
<span class="k">def</span><span class="w"> </span><span class="nf">throw</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">typ</span><span class="p">,</span> <span class="n">val</span><span class="o">=</span><span class="kc">None</span><span class="p">,</span> <span class="n">tb</span><span class="o">=</span><span class="kc">None</span><span class="p">):</span>
<span class="w"> </span><span class="sd">&quot;&quot;&quot;Raise an exception in the coroutine.</span>
<span class="sd"> Return next yielded value or raise StopIteration.</span>
<span class="sd"> &quot;&quot;&quot;</span>
<span class="k">if</span> <span class="n">val</span> <span class="ow">is</span> <span class="kc">None</span><span class="p">:</span>
<span class="k">if</span> <span class="n">tb</span> <span class="ow">is</span> <span class="kc">None</span><span class="p">:</span>
<span class="k">raise</span> <span class="n">typ</span>
<span class="n">val</span> <span class="o">=</span> <span class="n">typ</span><span class="p">()</span>
<span class="k">if</span> <span class="n">tb</span> <span class="ow">is</span> <span class="ow">not</span> <span class="kc">None</span><span class="p">:</span>
<span class="n">val</span> <span class="o">=</span> <span class="n">val</span><span class="o">.</span><span class="n">with_traceback</span><span class="p">(</span><span class="n">tb</span><span class="p">)</span>
<span class="k">raise</span> <span class="n">val</span>
<span class="k">def</span><span class="w"> </span><span class="nf">close</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
<span class="w"> </span><span class="sd">&quot;&quot;&quot;Raise GeneratorExit inside coroutine.</span>
<span class="sd"> &quot;&quot;&quot;</span>
<span class="k">try</span><span class="p">:</span>
<span class="bp">self</span><span class="o">.</span><span class="n">throw</span><span class="p">(</span><span class="ne">GeneratorExit</span><span class="p">)</span>
<span class="k">except</span> <span class="p">(</span><span class="ne">GeneratorExit</span><span class="p">,</span> <span class="ne">StopIteration</span><span class="p">):</span>
<span class="k">pass</span>
<span class="k">else</span><span class="p">:</span>
<span class="k">raise</span> <span class="ne">RuntimeError</span><span class="p">(</span><span class="s2">&quot;coroutine ignored GeneratorExit&quot;</span><span class="p">)</span>
<span class="nd">@classmethod</span>
<span class="k">def</span><span class="w"> </span><span class="nf">__subclasshook__</span><span class="p">(</span><span class="bp">cls</span><span class="p">,</span> <span class="n">C</span><span class="p">):</span>
<span class="k">if</span> <span class="bp">cls</span> <span class="ow">is</span> <span class="n">Coroutine</span><span class="p">:</span>
<span class="k">return</span> <span class="n">_check_methods</span><span class="p">(</span><span class="n">C</span><span class="p">,</span> <span class="s1">&#39;__await__&#39;</span><span class="p">,</span> <span class="s1">&#39;send&#39;</span><span class="p">,</span> <span class="s1">&#39;throw&#39;</span><span class="p">,</span> <span class="s1">&#39;close&#39;</span><span class="p">)</span>
<span class="k">return</span> <span class="bp">NotImplemented</span>
<span class="n">Coroutine</span><span class="o">.</span><span class="n">register</span><span class="p">(</span><span class="n">coroutine</span><span class="p">)</span>
<span class="k">class</span><span class="w"> </span><span class="nc">AsyncIterable</span><span class="p">(</span><span class="n">metaclass</span><span class="o">=</span><span class="n">ABCMeta</span><span class="p">):</span>
<span class="vm">__slots__</span> <span class="o">=</span> <span class="p">()</span>
<span class="nd">@abstractmethod</span>
<span class="k">def</span><span class="w"> </span><span class="fm">__aiter__</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
<span class="k">return</span> <span class="n">AsyncIterator</span><span class="p">()</span>
<span class="nd">@classmethod</span>
<span class="k">def</span><span class="w"> </span><span class="nf">__subclasshook__</span><span class="p">(</span><span class="bp">cls</span><span class="p">,</span> <span class="n">C</span><span class="p">):</span>
<span class="k">if</span> <span class="bp">cls</span> <span class="ow">is</span> <span class="n">AsyncIterable</span><span class="p">:</span>
<span class="k">return</span> <span class="n">_check_methods</span><span class="p">(</span><span class="n">C</span><span class="p">,</span> <span class="s2">&quot;__aiter__&quot;</span><span class="p">)</span>
<span class="k">return</span> <span class="bp">NotImplemented</span>
<span class="n">__class_getitem__</span> <span class="o">=</span> <span class="nb">classmethod</span><span class="p">(</span><span class="n">GenericAlias</span><span class="p">)</span>
<span class="k">class</span><span class="w"> </span><span class="nc">AsyncIterator</span><span class="p">(</span><span class="n">AsyncIterable</span><span class="p">):</span>
<span class="vm">__slots__</span> <span class="o">=</span> <span class="p">()</span>
<span class="nd">@abstractmethod</span>
<span class="k">async</span> <span class="k">def</span><span class="w"> </span><span class="fm">__anext__</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
<span class="w"> </span><span class="sd">&quot;&quot;&quot;Return the next item or raise StopAsyncIteration when exhausted.&quot;&quot;&quot;</span>
<span class="k">raise</span> <span class="ne">StopAsyncIteration</span>
<span class="k">def</span><span class="w"> </span><span class="fm">__aiter__</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="nd">@classmethod</span>
<span class="k">def</span><span class="w"> </span><span class="nf">__subclasshook__</span><span class="p">(</span><span class="bp">cls</span><span class="p">,</span> <span class="n">C</span><span class="p">):</span>
<span class="k">if</span> <span class="bp">cls</span> <span class="ow">is</span> <span class="n">AsyncIterator</span><span class="p">:</span>
<span class="k">return</span> <span class="n">_check_methods</span><span class="p">(</span><span class="n">C</span><span class="p">,</span> <span class="s2">&quot;__anext__&quot;</span><span class="p">,</span> <span class="s2">&quot;__aiter__&quot;</span><span class="p">)</span>
<span class="k">return</span> <span class="bp">NotImplemented</span>
<span class="k">class</span><span class="w"> </span><span class="nc">AsyncGenerator</span><span class="p">(</span><span class="n">AsyncIterator</span><span class="p">):</span>
<span class="vm">__slots__</span> <span class="o">=</span> <span class="p">()</span>
<span class="k">async</span> <span class="k">def</span><span class="w"> </span><span class="fm">__anext__</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
<span class="w"> </span><span class="sd">&quot;&quot;&quot;Return the next item from the asynchronous generator.</span>
<span class="sd"> When exhausted, raise StopAsyncIteration.</span>
<span class="sd"> &quot;&quot;&quot;</span>
<span class="k">return</span> <span class="k">await</span> <span class="bp">self</span><span class="o">.</span><span class="n">asend</span><span class="p">(</span><span class="kc">None</span><span class="p">)</span>
<span class="nd">@abstractmethod</span>
<span class="k">async</span> <span class="k">def</span><span class="w"> </span><span class="nf">asend</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">value</span><span class="p">):</span>
<span class="w"> </span><span class="sd">&quot;&quot;&quot;Send a value into the asynchronous generator.</span>
<span class="sd"> Return next yielded value or raise StopAsyncIteration.</span>
<span class="sd"> &quot;&quot;&quot;</span>
<span class="k">raise</span> <span class="ne">StopAsyncIteration</span>
<span class="nd">@abstractmethod</span>
<span class="k">async</span> <span class="k">def</span><span class="w"> </span><span class="nf">athrow</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">typ</span><span class="p">,</span> <span class="n">val</span><span class="o">=</span><span class="kc">None</span><span class="p">,</span> <span class="n">tb</span><span class="o">=</span><span class="kc">None</span><span class="p">):</span>
<span class="w"> </span><span class="sd">&quot;&quot;&quot;Raise an exception in the asynchronous generator.</span>
<span class="sd"> Return next yielded value or raise StopAsyncIteration.</span>
<span class="sd"> &quot;&quot;&quot;</span>
<span class="k">if</span> <span class="n">val</span> <span class="ow">is</span> <span class="kc">None</span><span class="p">:</span>
<span class="k">if</span> <span class="n">tb</span> <span class="ow">is</span> <span class="kc">None</span><span class="p">:</span>
<span class="k">raise</span> <span class="n">typ</span>
<span class="n">val</span> <span class="o">=</span> <span class="n">typ</span><span class="p">()</span>
<span class="k">if</span> <span class="n">tb</span> <span class="ow">is</span> <span class="ow">not</span> <span class="kc">None</span><span class="p">:</span>
<span class="n">val</span> <span class="o">=</span> <span class="n">val</span><span class="o">.</span><span class="n">with_traceback</span><span class="p">(</span><span class="n">tb</span><span class="p">)</span>
<span class="k">raise</span> <span class="n">val</span>
<span class="k">async</span> <span class="k">def</span><span class="w"> </span><span class="nf">aclose</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
<span class="w"> </span><span class="sd">&quot;&quot;&quot;Raise GeneratorExit inside coroutine.</span>
<span class="sd"> &quot;&quot;&quot;</span>
<span class="k">try</span><span class="p">:</span>
<span class="k">await</span> <span class="bp">self</span><span class="o">.</span><span class="n">athrow</span><span class="p">(</span><span class="ne">GeneratorExit</span><span class="p">)</span>
<span class="k">except</span> <span class="p">(</span><span class="ne">GeneratorExit</span><span class="p">,</span> <span class="ne">StopAsyncIteration</span><span class="p">):</span>
<span class="k">pass</span>
<span class="k">else</span><span class="p">:</span>
<span class="k">raise</span> <span class="ne">RuntimeError</span><span class="p">(</span><span class="s2">&quot;asynchronous generator ignored GeneratorExit&quot;</span><span class="p">)</span>
<span class="nd">@classmethod</span>
<span class="k">def</span><span class="w"> </span><span class="nf">__subclasshook__</span><span class="p">(</span><span class="bp">cls</span><span class="p">,</span> <span class="n">C</span><span class="p">):</span>
<span class="k">if</span> <span class="bp">cls</span> <span class="ow">is</span> <span class="n">AsyncGenerator</span><span class="p">:</span>
<span class="k">return</span> <span class="n">_check_methods</span><span class="p">(</span><span class="n">C</span><span class="p">,</span> <span class="s1">&#39;__aiter__&#39;</span><span class="p">,</span> <span class="s1">&#39;__anext__&#39;</span><span class="p">,</span>
<span class="s1">&#39;asend&#39;</span><span class="p">,</span> <span class="s1">&#39;athrow&#39;</span><span class="p">,</span> <span class="s1">&#39;aclose&#39;</span><span class="p">)</span>
<span class="k">return</span> <span class="bp">NotImplemented</span>
<span class="n">AsyncGenerator</span><span class="o">.</span><span class="n">register</span><span class="p">(</span><span class="n">async_generator</span><span class="p">)</span>
<span class="k">class</span><span class="w"> </span><span class="nc">Iterable</span><span class="p">(</span><span class="n">metaclass</span><span class="o">=</span><span class="n">ABCMeta</span><span class="p">):</span>
<span class="vm">__slots__</span> <span class="o">=</span> <span class="p">()</span>
<span class="nd">@abstractmethod</span>
<span class="k">def</span><span class="w"> </span><span class="fm">__iter__</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
<span class="k">while</span> <span class="kc">False</span><span class="p">:</span>
<span class="k">yield</span> <span class="kc">None</span>
<span class="nd">@classmethod</span>
<span class="k">def</span><span class="w"> </span><span class="nf">__subclasshook__</span><span class="p">(</span><span class="bp">cls</span><span class="p">,</span> <span class="n">C</span><span class="p">):</span>
<span class="k">if</span> <span class="bp">cls</span> <span class="ow">is</span> <span class="n">Iterable</span><span class="p">:</span>
<span class="k">return</span> <span class="n">_check_methods</span><span class="p">(</span><span class="n">C</span><span class="p">,</span> <span class="s2">&quot;__iter__&quot;</span><span class="p">)</span>
<span class="k">return</span> <span class="bp">NotImplemented</span>
<span class="n">__class_getitem__</span> <span class="o">=</span> <span class="nb">classmethod</span><span class="p">(</span><span class="n">GenericAlias</span><span class="p">)</span>
<span class="k">class</span><span class="w"> </span><span class="nc">Iterator</span><span class="p">(</span><span class="n">Iterable</span><span class="p">):</span>
<span class="vm">__slots__</span> <span class="o">=</span> <span class="p">()</span>
<span class="nd">@abstractmethod</span>
<span class="k">def</span><span class="w"> </span><span class="fm">__next__</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
<span class="s1">&#39;Return the next item from the iterator. When exhausted, raise StopIteration&#39;</span>
<span class="k">raise</span> <span class="ne">StopIteration</span>
<span class="k">def</span><span class="w"> </span><span class="fm">__iter__</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
<span class="k">return</span> <span class="bp">self</span>
<span class="nd">@classmethod</span>
<span class="k">def</span><span class="w"> </span><span class="nf">__subclasshook__</span><span class="p">(</span><span class="bp">cls</span><span class="p">,</span> <span class="n">C</span><span class="p">):</span>
<span class="k">if</span> <span class="bp">cls</span> <span class="ow">is</span> <span class="n">Iterator</span><span class="p">:</span>
<span class="k">return</span> <span class="n">_check_methods</span><span class="p">(</span><span class="n">C</span><span class="p">,</span> <span class="s1">&#39;__iter__&#39;</span><span class="p">,</span> <span class="s1">&#39;__next__&#39;</span><span class="p">)</span>
<span class="k">return</span> <span class="bp">NotImplemented</span>
<span class="n">Iterator</span><span class="o">.</span><span class="n">register</span><span class="p">(</span><span class="n">bytes_iterator</span><span class="p">)</span>
<span class="n">Iterator</span><span class="o">.</span><span class="n">register</span><span class="p">(</span><span class="n">bytearray_iterator</span><span class="p">)</span>
<span class="c1">#Iterator.register(callable_iterator)</span>
<span class="n">Iterator</span><span class="o">.</span><span class="n">register</span><span class="p">(</span><span class="n">dict_keyiterator</span><span class="p">)</span>
<span class="n">Iterator</span><span class="o">.</span><span class="n">register</span><span class="p">(</span><span class="n">dict_valueiterator</span><span class="p">)</span>
<span class="n">Iterator</span><span class="o">.</span><span class="n">register</span><span class="p">(</span><span class="n">dict_itemiterator</span><span class="p">)</span>
<span class="n">Iterator</span><span class="o">.</span><span class="n">register</span><span class="p">(</span><span class="n">list_iterator</span><span class="p">)</span>
<span class="n">Iterator</span><span class="o">.</span><span class="n">register</span><span class="p">(</span><span class="n">list_reverseiterator</span><span class="p">)</span>
<span class="n">Iterator</span><span class="o">.</span><span class="n">register</span><span class="p">(</span><span class="n">range_iterator</span><span class="p">)</span>
<span class="n">Iterator</span><span class="o">.</span><span class="n">register</span><span class="p">(</span><span class="n">longrange_iterator</span><span class="p">)</span>
<span class="n">Iterator</span><span class="o">.</span><span class="n">register</span><span class="p">(</span><span class="n">set_iterator</span><span class="p">)</span>
<span class="n">Iterator</span><span class="o">.</span><span class="n">register</span><span class="p">(</span><span class="n">str_iterator</span><span class="p">)</span>
<span class="n">Iterator</span><span class="o">.</span><span class="n">register</span><span class="p">(</span><span class="n">tuple_iterator</span><span class="p">)</span>
<span class="n">Iterator</span><span class="o">.</span><span class="n">register</span><span class="p">(</span><span class="n">zip_iterator</span><span class="p">)</span>
<span class="k">class</span><span class="w"> </span><span class="nc">Reversible</span><span class="p">(</span><span class="n">Iterable</span><span class="p">):</span>
<span class="vm">__slots__</span> <span class="o">=</span> <span class="p">()</span>
<span class="nd">@abstractmethod</span>
<span class="k">def</span><span class="w"> </span><span class="fm">__reversed__</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
<span class="k">while</span> <span class="kc">False</span><span class="p">:</span>
<span class="k">yield</span> <span class="kc">None</span>
<span class="nd">@classmethod</span>
<span class="k">def</span><span class="w"> </span><span class="nf">__subclasshook__</span><span class="p">(</span><span class="bp">cls</span><span class="p">,</span> <span class="n">C</span><span class="p">):</span>
<span class="k">if</span> <span class="bp">cls</span> <span class="ow">is</span> <span class="n">Reversible</span><span class="p">:</span>
<span class="k">return</span> <span class="n">_check_methods</span><span class="p">(</span><span class="n">C</span><span class="p">,</span> <span class="s2">&quot;__reversed__&quot;</span><span class="p">,</span> <span class="s2">&quot;__iter__&quot;</span><span class="p">)</span>
<span class="k">return</span> <span class="bp">NotImplemented</span>
<span class="k">class</span><span class="w"> </span><span class="nc">Generator</span><span class="p">(</span><span class="n">Iterator</span><span class="p">):</span>
<span class="vm">__slots__</span> <span class="o">=</span> <span class="p">()</span>
<span class="k">def</span><span class="w"> </span><span class="fm">__next__</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
<span class="w"> </span><span class="sd">&quot;&quot;&quot;Return the next item from the generator.</span>
<span class="sd"> When exhausted, raise StopIteration.</span>
<span class="sd"> &quot;&quot;&quot;</span>
<span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="n">send</span><span class="p">(</span><span class="kc">None</span><span class="p">)</span>
<span class="nd">@abstractmethod</span>
<span class="k">def</span><span class="w"> </span><span class="nf">send</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">value</span><span class="p">):</span>
<span class="w"> </span><span class="sd">&quot;&quot;&quot;Send a value into the generator.</span>
<span class="sd"> Return next yielded value or raise StopIteration.</span>
<span class="sd"> &quot;&quot;&quot;</span>
<span class="k">raise</span> <span class="ne">StopIteration</span>
<span class="nd">@abstractmethod</span>
<span class="k">def</span><span class="w"> </span><span class="nf">throw</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">typ</span><span class="p">,</span> <span class="n">val</span><span class="o">=</span><span class="kc">None</span><span class="p">,</span> <span class="n">tb</span><span class="o">=</span><span class="kc">None</span><span class="p">):</span>
<span class="w"> </span><span class="sd">&quot;&quot;&quot;Raise an exception in the generator.</span>
<span class="sd"> Return next yielded value or raise StopIteration.</span>
<span class="sd"> &quot;&quot;&quot;</span>
<span class="k">if</span> <span class="n">val</span> <span class="ow">is</span> <span class="kc">None</span><span class="p">:</span>
<span class="k">if</span> <span class="n">tb</span> <span class="ow">is</span> <span class="kc">None</span><span class="p">:</span>
<span class="k">raise</span> <span class="n">typ</span>
<span class="n">val</span> <span class="o">=</span> <span class="n">typ</span><span class="p">()</span>
<span class="k">if</span> <span class="n">tb</span> <span class="ow">is</span> <span class="ow">not</span> <span class="kc">None</span><span class="p">:</span>
<span class="n">val</span> <span class="o">=</span> <span class="n">val</span><span class="o">.</span><span class="n">with_traceback</span><span class="p">(</span><span class="n">tb</span><span class="p">)</span>
<span class="k">raise</span> <span class="n">val</span>
<span class="k">def</span><span class="w"> </span><span class="nf">close</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
<span class="w"> </span><span class="sd">&quot;&quot;&quot;Raise GeneratorExit inside generator.</span>
<span class="sd"> &quot;&quot;&quot;</span>
<span class="k">try</span><span class="p">:</span>
<span class="bp">self</span><span class="o">.</span><span class="n">throw</span><span class="p">(</span><span class="ne">GeneratorExit</span><span class="p">)</span>
<span class="k">except</span> <span class="p">(</span><span class="ne">GeneratorExit</span><span class="p">,</span> <span class="ne">StopIteration</span><span class="p">):</span>
<span class="k">pass</span>
<span class="k">else</span><span class="p">:</span>
<span class="k">raise</span> <span class="ne">RuntimeError</span><span class="p">(</span><span class="s2">&quot;generator ignored GeneratorExit&quot;</span><span class="p">)</span>
<span class="nd">@classmethod</span>
<span class="k">def</span><span class="w"> </span><span class="nf">__subclasshook__</span><span class="p">(</span><span class="bp">cls</span><span class="p">,</span> <span class="n">C</span><span class="p">):</span>
<span class="k">if</span> <span class="bp">cls</span> <span class="ow">is</span> <span class="n">Generator</span><span class="p">:</span>
<span class="k">return</span> <span class="n">_check_methods</span><span class="p">(</span><span class="n">C</span><span class="p">,</span> <span class="s1">&#39;__iter__&#39;</span><span class="p">,</span> <span class="s1">&#39;__next__&#39;</span><span class="p">,</span>
<span class="s1">&#39;send&#39;</span><span class="p">,</span> <span class="s1">&#39;throw&#39;</span><span class="p">,</span> <span class="s1">&#39;close&#39;</span><span class="p">)</span>
<span class="k">return</span> <span class="bp">NotImplemented</span>
<span class="n">Generator</span><span class="o">.</span><span class="n">register</span><span class="p">(</span><span class="n">generator</span><span class="p">)</span>
<span class="k">class</span><span class="w"> </span><span class="nc">Sized</span><span class="p">(</span><span class="n">metaclass</span><span class="o">=</span><span class="n">ABCMeta</span><span class="p">):</span>
<span class="vm">__slots__</span> <span class="o">=</span> <span class="p">()</span>
<span class="nd">@abstractmethod</span>
<span class="k">def</span><span class="w"> </span><span class="fm">__len__</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
<span class="k">return</span> <span class="mi">0</span>
<span class="nd">@classmethod</span>
<span class="k">def</span><span class="w"> </span><span class="nf">__subclasshook__</span><span class="p">(</span><span class="bp">cls</span><span class="p">,</span> <span class="n">C</span><span class="p">):</span>
<span class="k">if</span> <span class="bp">cls</span> <span class="ow">is</span> <span class="n">Sized</span><span class="p">:</span>
<span class="k">return</span> <span class="n">_check_methods</span><span class="p">(</span><span class="n">C</span><span class="p">,</span> <span class="s2">&quot;__len__&quot;</span><span class="p">)</span>
<span class="k">return</span> <span class="bp">NotImplemented</span>
<span class="k">class</span><span class="w"> </span><span class="nc">Container</span><span class="p">(</span><span class="n">metaclass</span><span class="o">=</span><span class="n">ABCMeta</span><span class="p">):</span>
<span class="vm">__slots__</span> <span class="o">=</span> <span class="p">()</span>
<span class="nd">@abstractmethod</span>
<span class="k">def</span><span class="w"> </span><span class="fm">__contains__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">x</span><span class="p">):</span>
<span class="k">return</span> <span class="kc">False</span>
<span class="nd">@classmethod</span>
<span class="k">def</span><span class="w"> </span><span class="nf">__subclasshook__</span><span class="p">(</span><span class="bp">cls</span><span class="p">,</span> <span class="n">C</span><span class="p">):</span>
<span class="k">if</span> <span class="bp">cls</span> <span class="ow">is</span> <span class="n">Container</span><span class="p">:</span>
<span class="k">return</span> <span class="n">_check_methods</span><span class="p">(</span><span class="n">C</span><span class="p">,</span> <span class="s2">&quot;__contains__&quot;</span><span class="p">)</span>
<span class="k">return</span> <span class="bp">NotImplemented</span>
<span class="n">__class_getitem__</span> <span class="o">=</span> <span class="nb">classmethod</span><span class="p">(</span><span class="n">GenericAlias</span><span class="p">)</span>
<span class="k">class</span><span class="w"> </span><span class="nc">Collection</span><span class="p">(</span><span class="n">Sized</span><span class="p">,</span> <span class="n">Iterable</span><span class="p">,</span> <span class="n">Container</span><span class="p">):</span>
<span class="vm">__slots__</span> <span class="o">=</span> <span class="p">()</span>
<span class="nd">@classmethod</span>
<span class="k">def</span><span class="w"> </span><span class="nf">__subclasshook__</span><span class="p">(</span><span class="bp">cls</span><span class="p">,</span> <span class="n">C</span><span class="p">):</span>
<span class="k">if</span> <span class="bp">cls</span> <span class="ow">is</span> <span class="n">Collection</span><span class="p">:</span>
<span class="k">return</span> <span class="n">_check_methods</span><span class="p">(</span><span class="n">C</span><span class="p">,</span> <span class="s2">&quot;__len__&quot;</span><span class="p">,</span> <span class="s2">&quot;__iter__&quot;</span><span class="p">,</span> <span class="s2">&quot;__contains__&quot;</span><span class="p">)</span>
<span class="k">return</span> <span class="bp">NotImplemented</span>
<span class="k">class</span><span class="w"> </span><span class="nc">Buffer</span><span class="p">(</span><span class="n">metaclass</span><span class="o">=</span><span class="n">ABCMeta</span><span class="p">):</span>
<span class="vm">__slots__</span> <span class="o">=</span> <span class="p">()</span>
<span class="nd">@abstractmethod</span>
<span class="k">def</span><span class="w"> </span><span class="nf">__buffer__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">flags</span><span class="p">:</span> <span class="nb">int</span><span class="p">,</span> <span class="o">/</span><span class="p">)</span> <span class="o">-&gt;</span> <span class="nb">memoryview</span><span class="p">:</span>
<span class="k">raise</span> <span class="ne">NotImplementedError</span>
<span class="nd">@classmethod</span>
<span class="k">def</span><span class="w"> </span><span class="nf">__subclasshook__</span><span class="p">(</span><span class="bp">cls</span><span class="p">,</span> <span class="n">C</span><span class="p">):</span>
<span class="k">if</span> <span class="bp">cls</span> <span class="ow">is</span> <span class="n">Buffer</span><span class="p">:</span>
<span class="k">return</span> <span class="n">_check_methods</span><span class="p">(</span><span class="n">C</span><span class="p">,</span> <span class="s2">&quot;__buffer__&quot;</span><span class="p">)</span>
<span class="k">return</span> <span class="bp">NotImplemented</span>
<span class="k">class</span><span class="w"> </span><span class="nc">_CallableGenericAlias</span><span class="p">(</span><span class="n">GenericAlias</span><span class="p">):</span>
<span class="w"> </span><span class="sd">&quot;&quot;&quot; Represent `Callable[argtypes, resulttype]`.</span>
<span class="sd"> This sets ``__args__`` to a tuple containing the flattened ``argtypes``</span>
<span class="sd"> followed by ``resulttype``.</span>
<span class="sd"> Example: ``Callable[[int, str], float]`` sets ``__args__`` to</span>
<span class="sd"> ``(int, str, float)``.</span>
<span class="sd"> &quot;&quot;&quot;</span>
<span class="vm">__slots__</span> <span class="o">=</span> <span class="p">()</span>
<span class="k">def</span><span class="w"> </span><span class="fm">__new__</span><span class="p">(</span><span class="bp">cls</span><span class="p">,</span> <span class="n">origin</span><span class="p">,</span> <span class="n">args</span><span class="p">):</span>
<span class="k">if</span> <span class="ow">not</span> <span class="p">(</span><span class="nb">isinstance</span><span class="p">(</span><span class="n">args</span><span class="p">,</span> <span class="nb">tuple</span><span class="p">)</span> <span class="ow">and</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">2</span><span class="p">):</span>
<span class="k">raise</span> <span class="ne">TypeError</span><span class="p">(</span>
<span class="s2">&quot;Callable must be used as Callable[[arg, ...], result].&quot;</span><span class="p">)</span>
<span class="n">t_args</span><span class="p">,</span> <span class="n">t_result</span> <span class="o">=</span> <span class="n">args</span>
<span class="k">if</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">t_args</span><span class="p">,</span> <span class="p">(</span><span class="nb">tuple</span><span class="p">,</span> <span class="nb">list</span><span class="p">)):</span>
<span class="n">args</span> <span class="o">=</span> <span class="p">(</span><span class="o">*</span><span class="n">t_args</span><span class="p">,</span> <span class="n">t_result</span><span class="p">)</span>
<span class="k">elif</span> <span class="ow">not</span> <span class="n">_is_param_expr</span><span class="p">(</span><span class="n">t_args</span><span class="p">):</span>
<span class="k">raise</span> <span class="ne">TypeError</span><span class="p">(</span><span class="sa">f</span><span class="s2">&quot;Expected a list of types, an ellipsis, &quot;</span>
<span class="sa">f</span><span class="s2">&quot;ParamSpec, or Concatenate. Got </span><span class="si">{</span><span class="n">t_args</span><span class="si">}</span><span class="s2">&quot;</span><span class="p">)</span>
<span class="k">return</span> <span class="nb">super</span><span class="p">()</span><span class="o">.</span><span class="fm">__new__</span><span class="p">(</span><span class="bp">cls</span><span class="p">,</span> <span class="n">origin</span><span class="p">,</span> <span class="n">args</span><span class="p">)</span>
<span class="k">def</span><span class="w"> </span><span class="fm">__repr__</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
<span class="k">if</span> <span class="nb">len</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">__args__</span><span class="p">)</span> <span class="o">==</span> <span class="mi">2</span> <span class="ow">and</span> <span class="n">_is_param_expr</span><span class="p">(</span><span class="bp">self</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">return</span> <span class="nb">super</span><span class="p">()</span><span class="o">.</span><span class="fm">__repr__</span><span class="p">()</span>
<span class="k">return</span> <span class="p">(</span><span class="sa">f</span><span class="s1">&#39;collections.abc.Callable&#39;</span>
<span class="sa">f</span><span class="s1">&#39;[[</span><span class="si">{</span><span class="s2">&quot;, &quot;</span><span class="o">.</span><span class="n">join</span><span class="p">([</span><span class="n">_type_repr</span><span class="p">(</span><span class="n">a</span><span class="p">)</span><span class="w"> </span><span class="k">for</span><span class="w"> </span><span class="n">a</span><span class="w"> </span><span class="ow">in</span><span class="w"> </span><span class="bp">self</span><span class="o">.</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="si">}</span><span class="s1">], &#39;</span>
<span class="sa">f</span><span class="s1">&#39;</span><span class="si">{</span><span class="n">_type_repr</span><span class="p">(</span><span class="bp">self</span><span class="o">.</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="si">}</span><span class="s1">]&#39;</span><span class="p">)</span>
<span class="k">def</span><span class="w"> </span><span class="nf">__reduce__</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
<span class="n">args</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="n">__args__</span>
<span class="k">if</span> <span class="ow">not</span> <span class="p">(</span><span class="nb">len</span><span class="p">(</span><span class="n">args</span><span class="p">)</span> <span class="o">==</span> <span class="mi">2</span> <span class="ow">and</span> <span class="n">_is_param_expr</span><span class="p">(</span><span class="n">args</span><span class="p">[</span><span class="mi">0</span><span class="p">])):</span>
<span class="n">args</span> <span class="o">=</span> <span class="nb">list</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="n">args</span><span class="p">[</span><span class="o">-</span><span class="mi">1</span><span class="p">]</span>
<span class="k">return</span> <span class="n">_CallableGenericAlias</span><span class="p">,</span> <span class="p">(</span><span class="n">Callable</span><span class="p">,</span> <span class="n">args</span><span class="p">)</span>
<span class="k">def</span><span class="w"> </span><span class="fm">__getitem__</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="c1"># Called during TypeVar substitution, returns the custom subclass</span>
<span class="c1"># rather than the default types.GenericAlias object. Most of the</span>
<span class="c1"># code is copied from typing&#39;s _GenericAlias and the builtin</span>
<span class="c1"># types.GenericAlias.</span>
<span class="k">if</span> <span class="ow">not</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">item</span><span class="p">,</span> <span class="nb">tuple</span><span class="p">):</span>
<span class="n">item</span> <span class="o">=</span> <span class="p">(</span><span class="n">item</span><span class="p">,)</span>
<span class="n">new_args</span> <span class="o">=</span> <span class="nb">super</span><span class="p">()</span><span class="o">.</span><span class="fm">__getitem__</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="c1"># args[0] occurs due to things like Z[[int, str, bool]] from PEP 612</span>
<span class="k">if</span> <span class="ow">not</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">new_args</span><span class="p">[</span><span class="mi">0</span><span class="p">],</span> <span class="p">(</span><span class="nb">tuple</span><span class="p">,</span> <span class="nb">list</span><span class="p">)):</span>
<span class="n">t_result</span> <span class="o">=</span> <span class="n">new_args</span><span class="p">[</span><span class="o">-</span><span class="mi">1</span><span class="p">]</span>
<span class="n">t_args</span> <span class="o">=</span> <span class="n">new_args</span><span class="p">[:</span><span class="o">-</span><span class="mi">1</span><span class="p">]</span>
<span class="n">new_args</span> <span class="o">=</span> <span class="p">(</span><span class="n">t_args</span><span class="p">,</span> <span class="n">t_result</span><span class="p">)</span>
<span class="k">return</span> <span class="n">_CallableGenericAlias</span><span class="p">(</span><span class="n">Callable</span><span class="p">,</span> <span class="nb">tuple</span><span class="p">(</span><span class="n">new_args</span><span class="p">))</span>
<span class="k">def</span><span class="w"> </span><span class="nf">_is_param_expr</span><span class="p">(</span><span class="n">obj</span><span class="p">):</span>
<span class="w"> </span><span class="sd">&quot;&quot;&quot;Checks if obj matches either a list of types, ``...``, ``ParamSpec`` or</span>
<span class="sd"> ``_ConcatenateGenericAlias`` from typing.py</span>
<span class="sd"> &quot;&quot;&quot;</span>
<span class="k">if</span> <span class="n">obj</span> <span class="ow">is</span> <span class="bp">Ellipsis</span><span class="p">:</span>
<span class="k">return</span> <span class="kc">True</span>
<span class="k">if</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">obj</span><span class="p">,</span> <span class="nb">list</span><span class="p">):</span>
<span class="k">return</span> <span class="kc">True</span>
<span class="n">obj</span> <span class="o">=</span> <span class="nb">type</span><span class="p">(</span><span class="n">obj</span><span class="p">)</span>
<span class="n">names</span> <span class="o">=</span> <span class="p">(</span><span class="s1">&#39;ParamSpec&#39;</span><span class="p">,</span> <span class="s1">&#39;_ConcatenateGenericAlias&#39;</span><span class="p">)</span>
<span class="k">return</span> <span class="n">obj</span><span class="o">.</span><span class="vm">__module__</span> <span class="o">==</span> <span class="s1">&#39;typing&#39;</span> <span class="ow">and</span> <span class="nb">any</span><span class="p">(</span><span class="n">obj</span><span class="o">.</span><span class="vm">__name__</span> <span class="o">==</span> <span class="n">name</span> <span class="k">for</span> <span class="n">name</span> <span class="ow">in</span> <span class="n">names</span><span class="p">)</span>
<span class="k">def</span><span class="w"> </span><span class="nf">_type_repr</span><span class="p">(</span><span class="n">obj</span><span class="p">):</span>
<span class="w"> </span><span class="sd">&quot;&quot;&quot;Return the repr() of an object, special-casing types (internal helper).</span>
<span class="sd"> Copied from :mod:`typing` since collections.abc</span>
<span class="sd"> shouldn&#39;t depend on that module.</span>
<span class="sd"> (Keep this roughly in sync with the typing version.)</span>
<span class="sd"> &quot;&quot;&quot;</span>
<span class="k">if</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">obj</span><span class="p">,</span> <span class="nb">type</span><span class="p">):</span>
<span class="k">if</span> <span class="n">obj</span><span class="o">.</span><span class="vm">__module__</span> <span class="o">==</span> <span class="s1">&#39;builtins&#39;</span><span class="p">:</span>
<span class="k">return</span> <span class="n">obj</span><span class="o">.</span><span class="vm">__qualname__</span>
<span class="k">return</span> <span class="sa">f</span><span class="s1">&#39;</span><span class="si">{</span><span class="n">obj</span><span class="o">.</span><span class="vm">__module__</span><span class="si">}</span><span class="s1">.</span><span class="si">{</span><span class="n">obj</span><span class="o">.</span><span class="vm">__qualname__</span><span class="si">}</span><span class="s1">&#39;</span>
<span class="k">if</span> <span class="n">obj</span> <span class="ow">is</span> <span class="bp">Ellipsis</span><span class="p">:</span>
<span class="k">return</span> <span class="s1">&#39;...&#39;</span>
<span class="k">if</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">obj</span><span class="p">,</span> <span class="n">FunctionType</span><span class="p">):</span>
<span class="k">return</span> <span class="n">obj</span><span class="o">.</span><span class="vm">__name__</span>
<span class="k">return</span> <span class="nb">repr</span><span class="p">(</span><span class="n">obj</span><span class="p">)</span>
<span class="k">class</span><span class="w"> </span><span class="nc">Callable</span><span class="p">(</span><span class="n">metaclass</span><span class="o">=</span><span class="n">ABCMeta</span><span class="p">):</span>
<span class="vm">__slots__</span> <span class="o">=</span> <span class="p">()</span>
<span class="nd">@abstractmethod</span>
<span class="k">def</span><span class="w"> </span><span class="fm">__call__</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="kc">False</span>
<span class="nd">@classmethod</span>
<span class="k">def</span><span class="w"> </span><span class="nf">__subclasshook__</span><span class="p">(</span><span class="bp">cls</span><span class="p">,</span> <span class="n">C</span><span class="p">):</span>
<span class="k">if</span> <span class="bp">cls</span> <span class="ow">is</span> <span class="n">Callable</span><span class="p">:</span>
<span class="k">return</span> <span class="n">_check_methods</span><span class="p">(</span><span class="n">C</span><span class="p">,</span> <span class="s2">&quot;__call__&quot;</span><span class="p">)</span>
<span class="k">return</span> <span class="bp">NotImplemented</span>
<span class="n">__class_getitem__</span> <span class="o">=</span> <span class="nb">classmethod</span><span class="p">(</span><span class="n">_CallableGenericAlias</span><span class="p">)</span>
<span class="c1">### SETS ###</span>
<span class="k">class</span><span class="w"> </span><span class="nc">Set</span><span class="p">(</span><span class="n">Collection</span><span class="p">):</span>
<span class="w"> </span><span class="sd">&quot;&quot;&quot;A set is a finite, iterable container.</span>
<span class="sd"> This class provides concrete generic implementations of all</span>
<span class="sd"> methods except for __contains__, __iter__ and __len__.</span>
<span class="sd"> To override the comparisons (presumably for speed, as the</span>
<span class="sd"> semantics are fixed), redefine __le__ and __ge__,</span>
<span class="sd"> then the other operations will automatically follow suit.</span>
<span class="sd"> &quot;&quot;&quot;</span>
<span class="vm">__slots__</span> <span class="o">=</span> <span class="p">()</span>
<span class="k">def</span><span class="w"> </span><span class="fm">__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">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">Set</span><span class="p">):</span>
<span class="k">return</span> <span class="bp">NotImplemented</span>
<span class="k">if</span> <span class="nb">len</span><span class="p">(</span><span class="bp">self</span><span class="p">)</span> <span class="o">&gt;</span> <span class="nb">len</span><span class="p">(</span><span class="n">other</span><span class="p">):</span>
<span class="k">return</span> <span class="kc">False</span>
<span class="k">for</span> <span class="n">elem</span> <span class="ow">in</span> <span class="bp">self</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="n">other</span><span class="p">:</span>
<span class="k">return</span> <span class="kc">False</span>
<span class="k">return</span> <span class="kc">True</span>
<span class="k">def</span><span class="w"> </span><span class="fm">__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">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">Set</span><span class="p">):</span>
<span class="k">return</span> <span class="bp">NotImplemented</span>
<span class="k">return</span> <span class="nb">len</span><span class="p">(</span><span class="bp">self</span><span class="p">)</span> <span class="o">&lt;</span> <span class="nb">len</span><span class="p">(</span><span class="n">other</span><span class="p">)</span> <span class="ow">and</span> <span class="bp">self</span><span class="o">.</span><span class="fm">__le__</span><span class="p">(</span><span class="n">other</span><span class="p">)</span>
<span class="k">def</span><span class="w"> </span><span class="fm">__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">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">Set</span><span class="p">):</span>
<span class="k">return</span> <span class="bp">NotImplemented</span>
<span class="k">return</span> <span class="nb">len</span><span class="p">(</span><span class="bp">self</span><span class="p">)</span> <span class="o">&gt;</span> <span class="nb">len</span><span class="p">(</span><span class="n">other</span><span class="p">)</span> <span class="ow">and</span> <span class="bp">self</span><span class="o">.</span><span class="fm">__ge__</span><span class="p">(</span><span class="n">other</span><span class="p">)</span>
<span class="k">def</span><span class="w"> </span><span class="fm">__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">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">Set</span><span class="p">):</span>
<span class="k">return</span> <span class="bp">NotImplemented</span>
<span class="k">if</span> <span class="nb">len</span><span class="p">(</span><span class="bp">self</span><span class="p">)</span> <span class="o">&lt;</span> <span class="nb">len</span><span class="p">(</span><span class="n">other</span><span class="p">):</span>
<span class="k">return</span> <span class="kc">False</span>
<span class="k">for</span> <span class="n">elem</span> <span class="ow">in</span> <span class="n">other</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="p">:</span>
<span class="k">return</span> <span class="kc">False</span>
<span class="k">return</span> <span class="kc">True</span>
<span class="k">def</span><span class="w"> </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">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">Set</span><span class="p">):</span>
<span class="k">return</span> <span class="bp">NotImplemented</span>
<span class="k">return</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="nb">len</span><span class="p">(</span><span class="n">other</span><span class="p">)</span> <span class="ow">and</span> <span class="bp">self</span><span class="o">.</span><span class="fm">__le__</span><span class="p">(</span><span class="n">other</span><span class="p">)</span>
<span class="nd">@classmethod</span>
<span class="k">def</span><span class="w"> </span><span class="nf">_from_iterable</span><span class="p">(</span><span class="bp">cls</span><span class="p">,</span> <span class="n">it</span><span class="p">):</span>
<span class="w"> </span><span class="sd">&#39;&#39;&#39;Construct an instance of the class from any iterable input.</span>
<span class="sd"> Must override this method if the class constructor signature</span>
<span class="sd"> does not accept an iterable for an input.</span>
<span class="sd"> &#39;&#39;&#39;</span>
<span class="k">return</span> <span class="bp">cls</span><span class="p">(</span><span class="n">it</span><span class="p">)</span>
<span class="k">def</span><span class="w"> </span><span class="fm">__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="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">Iterable</span><span class="p">):</span>
<span class="k">return</span> <span class="bp">NotImplemented</span>
<span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="n">_from_iterable</span><span class="p">(</span><span class="n">value</span> <span class="k">for</span> <span class="n">value</span> <span class="ow">in</span> <span class="n">other</span> <span class="k">if</span> <span class="n">value</span> <span class="ow">in</span> <span class="bp">self</span><span class="p">)</span>
<span class="fm">__rand__</span> <span class="o">=</span> <span class="fm">__and__</span>
<span class="k">def</span><span class="w"> </span><span class="nf">isdisjoint</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="s1">&#39;Return True if two sets have a null intersection.&#39;</span>
<span class="k">for</span> <span class="n">value</span> <span class="ow">in</span> <span class="n">other</span><span class="p">:</span>
<span class="k">if</span> <span class="n">value</span> <span class="ow">in</span> <span class="bp">self</span><span class="p">:</span>
<span class="k">return</span> <span class="kc">False</span>
<span class="k">return</span> <span class="kc">True</span>
<span class="k">def</span><span class="w"> </span><span class="fm">__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="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">Iterable</span><span class="p">):</span>
<span class="k">return</span> <span class="bp">NotImplemented</span>
<span class="n">chain</span> <span class="o">=</span> <span class="p">(</span><span class="n">e</span> <span class="k">for</span> <span class="n">s</span> <span class="ow">in</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">for</span> <span class="n">e</span> <span class="ow">in</span> <span class="n">s</span><span class="p">)</span>
<span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="n">_from_iterable</span><span class="p">(</span><span class="n">chain</span><span class="p">)</span>
<span class="fm">__ror__</span> <span class="o">=</span> <span class="fm">__or__</span>
<span class="k">def</span><span class="w"> </span><span class="fm">__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="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">Set</span><span class="p">):</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">Iterable</span><span class="p">):</span>
<span class="k">return</span> <span class="bp">NotImplemented</span>
<span class="n">other</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="n">_from_iterable</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">_from_iterable</span><span class="p">(</span><span class="n">value</span> <span class="k">for</span> <span class="n">value</span> <span class="ow">in</span> <span class="bp">self</span>
<span class="k">if</span> <span class="n">value</span> <span class="ow">not</span> <span class="ow">in</span> <span class="n">other</span><span class="p">)</span>
<span class="k">def</span><span class="w"> </span><span class="fm">__rsub__</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="ow">not</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">other</span><span class="p">,</span> <span class="n">Set</span><span class="p">):</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">Iterable</span><span class="p">):</span>
<span class="k">return</span> <span class="bp">NotImplemented</span>
<span class="n">other</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="n">_from_iterable</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">_from_iterable</span><span class="p">(</span><span class="n">value</span> <span class="k">for</span> <span class="n">value</span> <span class="ow">in</span> <span class="n">other</span>
<span class="k">if</span> <span class="n">value</span> <span class="ow">not</span> <span class="ow">in</span> <span class="bp">self</span><span class="p">)</span>
<span class="k">def</span><span class="w"> </span><span class="fm">__xor__</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="ow">not</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">other</span><span class="p">,</span> <span class="n">Set</span><span class="p">):</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">Iterable</span><span class="p">):</span>
<span class="k">return</span> <span class="bp">NotImplemented</span>
<span class="n">other</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="n">_from_iterable</span><span class="p">(</span><span class="n">other</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">other</span><span class="p">)</span> <span class="o">|</span> <span class="p">(</span><span class="n">other</span> <span class="o">-</span> <span class="bp">self</span><span class="p">)</span>
<span class="fm">__rxor__</span> <span class="o">=</span> <span class="fm">__xor__</span>
<span class="k">def</span><span class="w"> </span><span class="nf">_hash</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
<span class="w"> </span><span class="sd">&quot;&quot;&quot;Compute the hash value of a set.</span>
<span class="sd"> Note that we don&#39;t define __hash__: not all sets are hashable.</span>
<span class="sd"> But if you define a hashable set type, its __hash__ should</span>
<span class="sd"> call this function.</span>
<span class="sd"> This must be compatible __eq__.</span>
<span class="sd"> All sets ought to compare equal if they contain the same</span>
<span class="sd"> elements, regardless of how they are implemented, and</span>
<span class="sd"> regardless of the order of the elements; so there&#39;s not much</span>
<span class="sd"> freedom for __eq__ or __hash__. We match the algorithm used</span>
<span class="sd"> by the built-in frozenset type.</span>
<span class="sd"> &quot;&quot;&quot;</span>
<span class="n">MAX</span> <span class="o">=</span> <span class="n">sys</span><span class="o">.</span><span class="n">maxsize</span>
<span class="n">MASK</span> <span class="o">=</span> <span class="mi">2</span> <span class="o">*</span> <span class="n">MAX</span> <span class="o">+</span> <span class="mi">1</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="n">h</span> <span class="o">=</span> <span class="mi">1927868237</span> <span class="o">*</span> <span class="p">(</span><span class="n">n</span> <span class="o">+</span> <span class="mi">1</span><span class="p">)</span>
<span class="n">h</span> <span class="o">&amp;=</span> <span class="n">MASK</span>
<span class="k">for</span> <span class="n">x</span> <span class="ow">in</span> <span class="bp">self</span><span class="p">:</span>
<span class="n">hx</span> <span class="o">=</span> <span class="nb">hash</span><span class="p">(</span><span class="n">x</span><span class="p">)</span>
<span class="n">h</span> <span class="o">^=</span> <span class="p">(</span><span class="n">hx</span> <span class="o">^</span> <span class="p">(</span><span class="n">hx</span> <span class="o">&lt;&lt;</span> <span class="mi">16</span><span class="p">)</span> <span class="o">^</span> <span class="mi">89869747</span><span class="p">)</span> <span class="o">*</span> <span class="mi">3644798167</span>
<span class="n">h</span> <span class="o">&amp;=</span> <span class="n">MASK</span>
<span class="n">h</span> <span class="o">^=</span> <span class="p">(</span><span class="n">h</span> <span class="o">&gt;&gt;</span> <span class="mi">11</span><span class="p">)</span> <span class="o">^</span> <span class="p">(</span><span class="n">h</span> <span class="o">&gt;&gt;</span> <span class="mi">25</span><span class="p">)</span>
<span class="n">h</span> <span class="o">=</span> <span class="n">h</span> <span class="o">*</span> <span class="mi">69069</span> <span class="o">+</span> <span class="mi">907133923</span>
<span class="n">h</span> <span class="o">&amp;=</span> <span class="n">MASK</span>
<span class="k">if</span> <span class="n">h</span> <span class="o">&gt;</span> <span class="n">MAX</span><span class="p">:</span>
<span class="n">h</span> <span class="o">-=</span> <span class="n">MASK</span> <span class="o">+</span> <span class="mi">1</span>
<span class="k">if</span> <span class="n">h</span> <span class="o">==</span> <span class="o">-</span><span class="mi">1</span><span class="p">:</span>
<span class="n">h</span> <span class="o">=</span> <span class="mi">590923713</span>
<span class="k">return</span> <span class="n">h</span>
<span class="n">Set</span><span class="o">.</span><span class="n">register</span><span class="p">(</span><span class="nb">frozenset</span><span class="p">)</span>
<div class="viewcode-block" id="MutableSet">
<a class="viewcode-back" href="../../api/evennia.utils.dbserialize.html#evennia.utils.dbserialize.MutableSet">[docs]</a>
<span class="k">class</span><span class="w"> </span><span class="nc">MutableSet</span><span class="p">(</span><span class="n">Set</span><span class="p">):</span>
<span class="w"> </span><span class="sd">&quot;&quot;&quot;A mutable set is a finite, iterable container.</span>
<span class="sd"> This class provides concrete generic implementations of all</span>
<span class="sd"> methods except for __contains__, __iter__, __len__,</span>
<span class="sd"> add(), and discard().</span>
<span class="sd"> To override the comparisons (presumably for speed, as the</span>
<span class="sd"> semantics are fixed), all you have to do is redefine __le__ and</span>
<span class="sd"> then the other operations will automatically follow suit.</span>
<span class="sd"> &quot;&quot;&quot;</span>
<span class="vm">__slots__</span> <span class="o">=</span> <span class="p">()</span>
<div class="viewcode-block" id="MutableSet.add">
<a class="viewcode-back" href="../../api/evennia.utils.dbserialize.html#evennia.utils.dbserialize.MutableSet.add">[docs]</a>
<span class="nd">@abstractmethod</span>
<span class="k">def</span><span class="w"> </span><span class="nf">add</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">value</span><span class="p">):</span>
<span class="w"> </span><span class="sd">&quot;&quot;&quot;Add an element.&quot;&quot;&quot;</span>
<span class="k">raise</span> <span class="ne">NotImplementedError</span></div>
<div class="viewcode-block" id="MutableSet.discard">
<a class="viewcode-back" href="../../api/evennia.utils.dbserialize.html#evennia.utils.dbserialize.MutableSet.discard">[docs]</a>
<span class="nd">@abstractmethod</span>
<span class="k">def</span><span class="w"> </span><span class="nf">discard</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">value</span><span class="p">):</span>
<span class="w"> </span><span class="sd">&quot;&quot;&quot;Remove an element. Do not raise an exception if absent.&quot;&quot;&quot;</span>
<span class="k">raise</span> <span class="ne">NotImplementedError</span></div>
<div class="viewcode-block" id="MutableSet.remove">
<a class="viewcode-back" href="../../api/evennia.utils.dbserialize.html#evennia.utils.dbserialize.MutableSet.remove">[docs]</a>
<span class="k">def</span><span class="w"> </span><span class="nf">remove</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">value</span><span class="p">):</span>
<span class="w"> </span><span class="sd">&quot;&quot;&quot;Remove an element. If not a member, raise a KeyError.&quot;&quot;&quot;</span>
<span class="k">if</span> <span class="n">value</span> <span class="ow">not</span> <span class="ow">in</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="n">value</span><span class="p">)</span>
<span class="bp">self</span><span class="o">.</span><span class="n">discard</span><span class="p">(</span><span class="n">value</span><span class="p">)</span></div>
<div class="viewcode-block" id="MutableSet.pop">
<a class="viewcode-back" href="../../api/evennia.utils.dbserialize.html#evennia.utils.dbserialize.MutableSet.pop">[docs]</a>
<span class="k">def</span><span class="w"> </span><span class="nf">pop</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
<span class="w"> </span><span class="sd">&quot;&quot;&quot;Return the popped value. Raise KeyError if empty.&quot;&quot;&quot;</span>
<span class="n">it</span> <span class="o">=</span> <span class="nb">iter</span><span class="p">(</span><span class="bp">self</span><span class="p">)</span>
<span class="k">try</span><span class="p">:</span>
<span class="n">value</span> <span class="o">=</span> <span class="nb">next</span><span class="p">(</span><span class="n">it</span><span class="p">)</span>
<span class="k">except</span> <span class="ne">StopIteration</span><span class="p">:</span>
<span class="k">raise</span> <span class="ne">KeyError</span> <span class="kn">from</span><span class="w"> </span><span class="kc">None</span>
<span class="bp">self</span><span class="o">.</span><span class="n">discard</span><span class="p">(</span><span class="n">value</span><span class="p">)</span>
<span class="k">return</span> <span class="n">value</span></div>
<div class="viewcode-block" id="MutableSet.clear">
<a class="viewcode-back" href="../../api/evennia.utils.dbserialize.html#evennia.utils.dbserialize.MutableSet.clear">[docs]</a>
<span class="k">def</span><span class="w"> </span><span class="nf">clear</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
<span class="w"> </span><span class="sd">&quot;&quot;&quot;This is slow (creates N new iterators!) but effective.&quot;&quot;&quot;</span>
<span class="k">try</span><span class="p">:</span>
<span class="k">while</span> <span class="kc">True</span><span class="p">:</span>
<span class="bp">self</span><span class="o">.</span><span class="n">pop</span><span class="p">()</span>
<span class="k">except</span> <span class="ne">KeyError</span><span class="p">:</span>
<span class="k">pass</span></div>
<span class="k">def</span><span class="w"> </span><span class="fm">__ior__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">it</span><span class="p">):</span>
<span class="k">for</span> <span class="n">value</span> <span class="ow">in</span> <span class="n">it</span><span class="p">:</span>
<span class="bp">self</span><span class="o">.</span><span class="n">add</span><span class="p">(</span><span class="n">value</span><span class="p">)</span>
<span class="k">return</span> <span class="bp">self</span>
<span class="k">def</span><span class="w"> </span><span class="fm">__iand__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">it</span><span class="p">):</span>
<span class="k">for</span> <span class="n">value</span> <span class="ow">in</span> <span class="p">(</span><span class="bp">self</span> <span class="o">-</span> <span class="n">it</span><span class="p">):</span>
<span class="bp">self</span><span class="o">.</span><span class="n">discard</span><span class="p">(</span><span class="n">value</span><span class="p">)</span>
<span class="k">return</span> <span class="bp">self</span>
<span class="k">def</span><span class="w"> </span><span class="fm">__ixor__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">it</span><span class="p">):</span>
<span class="k">if</span> <span class="n">it</span> <span class="ow">is</span> <span class="bp">self</span><span class="p">:</span>
<span class="bp">self</span><span class="o">.</span><span class="n">clear</span><span class="p">()</span>
<span class="k">else</span><span class="p">:</span>
<span class="k">if</span> <span class="ow">not</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">it</span><span class="p">,</span> <span class="n">Set</span><span class="p">):</span>
<span class="n">it</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="n">_from_iterable</span><span class="p">(</span><span class="n">it</span><span class="p">)</span>
<span class="k">for</span> <span class="n">value</span> <span class="ow">in</span> <span class="n">it</span><span class="p">:</span>
<span class="k">if</span> <span class="n">value</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">discard</span><span class="p">(</span><span class="n">value</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">add</span><span class="p">(</span><span class="n">value</span><span class="p">)</span>
<span class="k">return</span> <span class="bp">self</span>
<span class="k">def</span><span class="w"> </span><span class="fm">__isub__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">it</span><span class="p">):</span>
<span class="k">if</span> <span class="n">it</span> <span class="ow">is</span> <span class="bp">self</span><span class="p">:</span>
<span class="bp">self</span><span class="o">.</span><span class="n">clear</span><span class="p">()</span>
<span class="k">else</span><span class="p">:</span>
<span class="k">for</span> <span class="n">value</span> <span class="ow">in</span> <span class="n">it</span><span class="p">:</span>
<span class="bp">self</span><span class="o">.</span><span class="n">discard</span><span class="p">(</span><span class="n">value</span><span class="p">)</span>
<span class="k">return</span> <span class="bp">self</span></div>
<span class="n">MutableSet</span><span class="o">.</span><span class="n">register</span><span class="p">(</span><span class="nb">set</span><span class="p">)</span>
<span class="c1">### MAPPINGS ###</span>
<span class="k">class</span><span class="w"> </span><span class="nc">Mapping</span><span class="p">(</span><span class="n">Collection</span><span class="p">):</span>
<span class="w"> </span><span class="sd">&quot;&quot;&quot;A Mapping is a generic container for associating key/value</span>
<span class="sd"> pairs.</span>
<span class="sd"> This class provides concrete generic implementations of all</span>
<span class="sd"> methods except for __getitem__, __iter__, and __len__.</span>
<span class="sd"> &quot;&quot;&quot;</span>
<span class="vm">__slots__</span> <span class="o">=</span> <span class="p">()</span>
<span class="c1"># Tell ABCMeta.__new__ that this class should have TPFLAGS_MAPPING set.</span>
<span class="n">__abc_tpflags__</span> <span class="o">=</span> <span class="mi">1</span> <span class="o">&lt;&lt;</span> <span class="mi">6</span> <span class="c1"># Py_TPFLAGS_MAPPING</span>
<span class="nd">@abstractmethod</span>
<span class="k">def</span><span class="w"> </span><span class="fm">__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">raise</span> <span class="ne">KeyError</span>
<span class="k">def</span><span class="w"> </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="s1">&#39;D.get(k[,d]) -&gt; D[k] if k in D, else d. d defaults to None.&#39;</span>
<span class="k">try</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">except</span> <span class="ne">KeyError</span><span class="p">:</span>
<span class="k">return</span> <span class="n">default</span>
<span class="k">def</span><span class="w"> </span><span class="fm">__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">try</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">except</span> <span class="ne">KeyError</span><span class="p">:</span>
<span class="k">return</span> <span class="kc">False</span>
<span class="k">else</span><span class="p">:</span>
<span class="k">return</span> <span class="kc">True</span>
<span class="k">def</span><span class="w"> </span><span class="nf">keys</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
<span class="s2">&quot;D.keys() -&gt; a set-like object providing a view on D&#39;s keys&quot;</span>
<span class="k">return</span> <span class="n">KeysView</span><span class="p">(</span><span class="bp">self</span><span class="p">)</span>
<span class="k">def</span><span class="w"> </span><span class="nf">items</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
<span class="s2">&quot;D.items() -&gt; a set-like object providing a view on D&#39;s items&quot;</span>
<span class="k">return</span> <span class="n">ItemsView</span><span class="p">(</span><span class="bp">self</span><span class="p">)</span>
<span class="k">def</span><span class="w"> </span><span class="nf">values</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
<span class="s2">&quot;D.values() -&gt; an object providing a view on D&#39;s values&quot;</span>
<span class="k">return</span> <span class="n">ValuesView</span><span class="p">(</span><span class="bp">self</span><span class="p">)</span>
<span class="k">def</span><span class="w"> </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">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">Mapping</span><span class="p">):</span>
<span class="k">return</span> <span class="bp">NotImplemented</span>
<span class="k">return</span> <span class="nb">dict</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">items</span><span class="p">())</span> <span class="o">==</span> <span class="nb">dict</span><span class="p">(</span><span class="n">other</span><span class="o">.</span><span class="n">items</span><span class="p">())</span>
<span class="fm">__reversed__</span> <span class="o">=</span> <span class="kc">None</span>
<span class="n">Mapping</span><span class="o">.</span><span class="n">register</span><span class="p">(</span><span class="n">mappingproxy</span><span class="p">)</span>
<span class="n">Mapping</span><span class="o">.</span><span class="n">register</span><span class="p">(</span><span class="n">framelocalsproxy</span><span class="p">)</span>
<span class="k">class</span><span class="w"> </span><span class="nc">MappingView</span><span class="p">(</span><span class="n">Sized</span><span class="p">):</span>
<span class="vm">__slots__</span> <span class="o">=</span> <span class="s1">&#39;_mapping&#39;</span><span class="p">,</span>
<span class="k">def</span><span class="w"> </span><span class="fm">__init__</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="bp">self</span><span class="o">.</span><span class="n">_mapping</span> <span class="o">=</span> <span class="n">mapping</span>
<span class="k">def</span><span class="w"> </span><span class="fm">__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">_mapping</span><span class="p">)</span>
<span class="k">def</span><span class="w"> </span><span class="fm">__repr__</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
<span class="k">return</span> <span class="s1">&#39;</span><span class="si">{0.__class__.__name__}</span><span class="s1">(</span><span class="si">{0._mapping!r}</span><span class="s1">)&#39;</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="n">__class_getitem__</span> <span class="o">=</span> <span class="nb">classmethod</span><span class="p">(</span><span class="n">GenericAlias</span><span class="p">)</span>
<span class="k">class</span><span class="w"> </span><span class="nc">KeysView</span><span class="p">(</span><span class="n">MappingView</span><span class="p">,</span> <span class="n">Set</span><span class="p">):</span>
<span class="vm">__slots__</span> <span class="o">=</span> <span class="p">()</span>
<span class="nd">@classmethod</span>
<span class="k">def</span><span class="w"> </span><span class="nf">_from_iterable</span><span class="p">(</span><span class="bp">cls</span><span class="p">,</span> <span class="n">it</span><span class="p">):</span>
<span class="k">return</span> <span class="nb">set</span><span class="p">(</span><span class="n">it</span><span class="p">)</span>
<span class="k">def</span><span class="w"> </span><span class="fm">__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">_mapping</span>
<span class="k">def</span><span class="w"> </span><span class="fm">__iter__</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
<span class="k">yield from</span> <span class="bp">self</span><span class="o">.</span><span class="n">_mapping</span>
<span class="n">KeysView</span><span class="o">.</span><span class="n">register</span><span class="p">(</span><span class="n">dict_keys</span><span class="p">)</span>
<span class="k">class</span><span class="w"> </span><span class="nc">ItemsView</span><span class="p">(</span><span class="n">MappingView</span><span class="p">,</span> <span class="n">Set</span><span class="p">):</span>
<span class="vm">__slots__</span> <span class="o">=</span> <span class="p">()</span>
<span class="nd">@classmethod</span>
<span class="k">def</span><span class="w"> </span><span class="nf">_from_iterable</span><span class="p">(</span><span class="bp">cls</span><span class="p">,</span> <span class="n">it</span><span class="p">):</span>
<span class="k">return</span> <span class="nb">set</span><span class="p">(</span><span class="n">it</span><span class="p">)</span>
<span class="k">def</span><span class="w"> </span><span class="fm">__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="n">key</span><span class="p">,</span> <span class="n">value</span> <span class="o">=</span> <span class="n">item</span>
<span class="k">try</span><span class="p">:</span>
<span class="n">v</span> <span class="o">=</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">except</span> <span class="ne">KeyError</span><span class="p">:</span>
<span class="k">return</span> <span class="kc">False</span>
<span class="k">else</span><span class="p">:</span>
<span class="k">return</span> <span class="n">v</span> <span class="ow">is</span> <span class="n">value</span> <span class="ow">or</span> <span class="n">v</span> <span class="o">==</span> <span class="n">value</span>
<span class="k">def</span><span class="w"> </span><span class="fm">__iter__</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="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="n">ItemsView</span><span class="o">.</span><span class="n">register</span><span class="p">(</span><span class="n">dict_items</span><span class="p">)</span>
<span class="k">class</span><span class="w"> </span><span class="nc">ValuesView</span><span class="p">(</span><span class="n">MappingView</span><span class="p">,</span> <span class="n">Collection</span><span class="p">):</span>
<span class="vm">__slots__</span> <span class="o">=</span> <span class="p">()</span>
<span class="k">def</span><span class="w"> </span><span class="fm">__contains__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">value</span><span class="p">):</span>
<span class="k">for</span> <span class="n">key</span> <span class="ow">in</span> <span class="bp">self</span><span class="o">.</span><span class="n">_mapping</span><span class="p">:</span>
<span class="n">v</span> <span class="o">=</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">if</span> <span class="n">v</span> <span class="ow">is</span> <span class="n">value</span> <span class="ow">or</span> <span class="n">v</span> <span class="o">==</span> <span class="n">value</span><span class="p">:</span>
<span class="k">return</span> <span class="kc">True</span>
<span class="k">return</span> <span class="kc">False</span>
<span class="k">def</span><span class="w"> </span><span class="fm">__iter__</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="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="n">ValuesView</span><span class="o">.</span><span class="n">register</span><span class="p">(</span><span class="n">dict_values</span><span class="p">)</span>
<div class="viewcode-block" id="MutableMapping">
<a class="viewcode-back" href="../../api/evennia.utils.dbserialize.html#evennia.utils.dbserialize.MutableMapping">[docs]</a>
<span class="k">class</span><span class="w"> </span><span class="nc">MutableMapping</span><span class="p">(</span><span class="n">Mapping</span><span class="p">):</span>
<span class="w"> </span><span class="sd">&quot;&quot;&quot;A MutableMapping is a generic container for associating</span>
<span class="sd"> key/value pairs.</span>
<span class="sd"> This class provides concrete generic implementations of all</span>
<span class="sd"> methods except for __getitem__, __setitem__, __delitem__,</span>
<span class="sd"> __iter__, and __len__.</span>
<span class="sd"> &quot;&quot;&quot;</span>
<span class="vm">__slots__</span> <span class="o">=</span> <span class="p">()</span>
<span class="nd">@abstractmethod</span>
<span class="k">def</span><span class="w"> </span><span class="fm">__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">raise</span> <span class="ne">KeyError</span>
<span class="nd">@abstractmethod</span>
<span class="k">def</span><span class="w"> </span><span class="fm">__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">raise</span> <span class="ne">KeyError</span>
<span class="n">__marker</span> <span class="o">=</span> <span class="nb">object</span><span class="p">()</span>
<div class="viewcode-block" id="MutableMapping.pop">
<a class="viewcode-back" href="../../api/evennia.utils.dbserialize.html#evennia.utils.dbserialize.MutableMapping.pop">[docs]</a>
<span class="k">def</span><span class="w"> </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="w"> </span><span class="sd">&#39;&#39;&#39;D.pop(k[,d]) -&gt; v, remove specified key and return the corresponding value.</span>
<span class="sd"> If key is not found, d is returned if given, otherwise KeyError is raised.</span>
<span class="sd"> &#39;&#39;&#39;</span>
<span class="k">try</span><span class="p">:</span>
<span class="n">value</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">except</span> <span class="ne">KeyError</span><span class="p">:</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="k">return</span> <span class="n">default</span>
<span class="k">else</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">value</span></div>
<div class="viewcode-block" id="MutableMapping.popitem">
<a class="viewcode-back" href="../../api/evennia.utils.dbserialize.html#evennia.utils.dbserialize.MutableMapping.popitem">[docs]</a>
<span class="k">def</span><span class="w"> </span><span class="nf">popitem</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
<span class="w"> </span><span class="sd">&#39;&#39;&#39;D.popitem() -&gt; (k, v), remove and return some (key, value) pair</span>
<span class="sd"> as a 2-tuple; but raise KeyError if D is empty.</span>
<span class="sd"> &#39;&#39;&#39;</span>
<span class="k">try</span><span class="p">:</span>
<span class="n">key</span> <span class="o">=</span> <span class="nb">next</span><span class="p">(</span><span class="nb">iter</span><span class="p">(</span><span class="bp">self</span><span class="p">))</span>
<span class="k">except</span> <span class="ne">StopIteration</span><span class="p">:</span>
<span class="k">raise</span> <span class="ne">KeyError</span> <span class="kn">from</span><span class="w"> </span><span class="kc">None</span>
<span class="n">value</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">key</span><span class="p">,</span> <span class="n">value</span></div>
<div class="viewcode-block" id="MutableMapping.clear">
<a class="viewcode-back" href="../../api/evennia.utils.dbserialize.html#evennia.utils.dbserialize.MutableMapping.clear">[docs]</a>
<span class="k">def</span><span class="w"> </span><span class="nf">clear</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
<span class="s1">&#39;D.clear() -&gt; None. Remove all items from D.&#39;</span>
<span class="k">try</span><span class="p">:</span>
<span class="k">while</span> <span class="kc">True</span><span class="p">:</span>
<span class="bp">self</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">pass</span></div>
<div class="viewcode-block" id="MutableMapping.update">
<a class="viewcode-back" href="../../api/evennia.utils.dbserialize.html#evennia.utils.dbserialize.MutableMapping.update">[docs]</a>
<span class="k">def</span><span class="w"> </span><span class="nf">update</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">other</span><span class="o">=</span><span class="p">(),</span> <span class="o">/</span><span class="p">,</span> <span class="o">**</span><span class="n">kwds</span><span class="p">):</span>
<span class="w"> </span><span class="sd">&#39;&#39;&#39; D.update([E, ]**F) -&gt; None. Update D from mapping/iterable E and F.</span>
<span class="sd"> If E present and has a .keys() method, does: for k in E.keys(): D[k] = E[k]</span>
<span class="sd"> If E present and lacks .keys() method, does: for (k, v) in E: D[k] = v</span>
<span class="sd"> In either case, this is followed by: for k, v in F.items(): D[k] = v</span>
<span class="sd"> &#39;&#39;&#39;</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">Mapping</span><span class="p">):</span>
<span class="k">for</span> <span class="n">key</span> <span class="ow">in</span> <span class="n">other</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">other</span><span class="p">[</span><span class="n">key</span><span class="p">]</span>
<span class="k">elif</span> <span class="nb">hasattr</span><span class="p">(</span><span class="n">other</span><span class="p">,</span> <span class="s2">&quot;keys&quot;</span><span class="p">):</span>
<span class="k">for</span> <span class="n">key</span> <span class="ow">in</span> <span class="n">other</span><span class="o">.</span><span class="n">keys</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">other</span><span class="p">[</span><span class="n">key</span><span class="p">]</span>
<span class="k">else</span><span class="p">:</span>
<span class="k">for</span> <span class="n">key</span><span class="p">,</span> <span class="n">value</span> <span class="ow">in</span> <span class="n">other</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">for</span> <span class="n">key</span><span class="p">,</span> <span class="n">value</span> <span class="ow">in</span> <span class="n">kwds</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">key</span><span class="p">]</span> <span class="o">=</span> <span class="n">value</span></div>
<div class="viewcode-block" id="MutableMapping.setdefault">
<a class="viewcode-back" href="../../api/evennia.utils.dbserialize.html#evennia.utils.dbserialize.MutableMapping.setdefault">[docs]</a>
<span class="k">def</span><span class="w"> </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="s1">&#39;D.setdefault(k[,d]) -&gt; D.get(k,d), also set D[k]=d if k not in D&#39;</span>
<span class="k">try</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">except</span> <span class="ne">KeyError</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></div>
</div>
<span class="n">MutableMapping</span><span class="o">.</span><span class="n">register</span><span class="p">(</span><span class="nb">dict</span><span class="p">)</span>
<span class="c1">### SEQUENCES ###</span>
<span class="k">class</span><span class="w"> </span><span class="nc">Sequence</span><span class="p">(</span><span class="n">Reversible</span><span class="p">,</span> <span class="n">Collection</span><span class="p">):</span>
<span class="w"> </span><span class="sd">&quot;&quot;&quot;All the operations on a read-only sequence.</span>
<span class="sd"> Concrete subclasses must override __new__ or __init__,</span>
<span class="sd"> __getitem__, and __len__.</span>
<span class="sd"> &quot;&quot;&quot;</span>
<span class="vm">__slots__</span> <span class="o">=</span> <span class="p">()</span>
<span class="c1"># Tell ABCMeta.__new__ that this class should have TPFLAGS_SEQUENCE set.</span>
<span class="n">__abc_tpflags__</span> <span class="o">=</span> <span class="mi">1</span> <span class="o">&lt;&lt;</span> <span class="mi">5</span> <span class="c1"># Py_TPFLAGS_SEQUENCE</span>
<span class="nd">@abstractmethod</span>
<span class="k">def</span><span class="w"> </span><span class="fm">__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">raise</span> <span class="ne">IndexError</span>
<span class="k">def</span><span class="w"> </span><span class="fm">__iter__</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">0</span>
<span class="k">try</span><span class="p">:</span>
<span class="k">while</span> <span class="kc">True</span><span class="p">:</span>
<span class="n">v</span> <span class="o">=</span> <span class="bp">self</span><span class="p">[</span><span class="n">i</span><span class="p">]</span>
<span class="k">yield</span> <span class="n">v</span>
<span class="n">i</span> <span class="o">+=</span> <span class="mi">1</span>
<span class="k">except</span> <span class="ne">IndexError</span><span class="p">:</span>
<span class="k">return</span>
<span class="k">def</span><span class="w"> </span><span class="fm">__contains__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">value</span><span class="p">):</span>
<span class="k">for</span> <span class="n">v</span> <span class="ow">in</span> <span class="bp">self</span><span class="p">:</span>
<span class="k">if</span> <span class="n">v</span> <span class="ow">is</span> <span class="n">value</span> <span class="ow">or</span> <span class="n">v</span> <span class="o">==</span> <span class="n">value</span><span class="p">:</span>
<span class="k">return</span> <span class="kc">True</span>
<span class="k">return</span> <span class="kc">False</span>
<span class="k">def</span><span class="w"> </span><span class="fm">__reversed__</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
<span class="k">for</span> <span class="n">i</span> <span class="ow">in</span> <span class="nb">reversed</span><span class="p">(</span><span class="nb">range</span><span class="p">(</span><span class="nb">len</span><span class="p">(</span><span class="bp">self</span><span class="p">))):</span>
<span class="k">yield</span> <span class="bp">self</span><span class="p">[</span><span class="n">i</span><span class="p">]</span>
<span class="k">def</span><span class="w"> </span><span class="nf">index</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">value</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">stop</span><span class="o">=</span><span class="kc">None</span><span class="p">):</span>
<span class="w"> </span><span class="sd">&#39;&#39;&#39;S.index(value, [start, [stop]]) -&gt; integer -- return first index of value.</span>
<span class="sd"> Raises ValueError if the value is not present.</span>
<span class="sd"> Supporting start and stop arguments is optional, but</span>
<span class="sd"> recommended.</span>
<span class="sd"> &#39;&#39;&#39;</span>
<span class="k">if</span> <span class="n">start</span> <span class="ow">is</span> <span class="ow">not</span> <span class="kc">None</span> <span class="ow">and</span> <span class="n">start</span> <span class="o">&lt;</span> <span class="mi">0</span><span class="p">:</span>
<span class="n">start</span> <span class="o">=</span> <span class="nb">max</span><span class="p">(</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="n">start</span><span class="p">,</span> <span class="mi">0</span><span class="p">)</span>
<span class="k">if</span> <span class="n">stop</span> <span class="ow">is</span> <span class="ow">not</span> <span class="kc">None</span> <span class="ow">and</span> <span class="n">stop</span> <span class="o">&lt;</span> <span class="mi">0</span><span class="p">:</span>
<span class="n">stop</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="n">i</span> <span class="o">=</span> <span class="n">start</span>
<span class="k">while</span> <span class="n">stop</span> <span class="ow">is</span> <span class="kc">None</span> <span class="ow">or</span> <span class="n">i</span> <span class="o">&lt;</span> <span class="n">stop</span><span class="p">:</span>
<span class="k">try</span><span class="p">:</span>
<span class="n">v</span> <span class="o">=</span> <span class="bp">self</span><span class="p">[</span><span class="n">i</span><span class="p">]</span>
<span class="k">except</span> <span class="ne">IndexError</span><span class="p">:</span>
<span class="k">break</span>
<span class="k">if</span> <span class="n">v</span> <span class="ow">is</span> <span class="n">value</span> <span class="ow">or</span> <span class="n">v</span> <span class="o">==</span> <span class="n">value</span><span class="p">:</span>
<span class="k">return</span> <span class="n">i</span>
<span class="n">i</span> <span class="o">+=</span> <span class="mi">1</span>
<span class="k">raise</span> <span class="ne">ValueError</span>
<span class="k">def</span><span class="w"> </span><span class="nf">count</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">value</span><span class="p">):</span>
<span class="s1">&#39;S.count(value) -&gt; integer -- return number of occurrences of value&#39;</span>
<span class="k">return</span> <span class="nb">sum</span><span class="p">(</span><span class="mi">1</span> <span class="k">for</span> <span class="n">v</span> <span class="ow">in</span> <span class="bp">self</span> <span class="k">if</span> <span class="n">v</span> <span class="ow">is</span> <span class="n">value</span> <span class="ow">or</span> <span class="n">v</span> <span class="o">==</span> <span class="n">value</span><span class="p">)</span>
<span class="n">Sequence</span><span class="o">.</span><span class="n">register</span><span class="p">(</span><span class="nb">tuple</span><span class="p">)</span>
<span class="n">Sequence</span><span class="o">.</span><span class="n">register</span><span class="p">(</span><span class="nb">str</span><span class="p">)</span>
<span class="n">Sequence</span><span class="o">.</span><span class="n">register</span><span class="p">(</span><span class="nb">range</span><span class="p">)</span>
<span class="n">Sequence</span><span class="o">.</span><span class="n">register</span><span class="p">(</span><span class="nb">memoryview</span><span class="p">)</span>
<span class="k">class</span><span class="w"> </span><span class="nc">_DeprecateByteStringMeta</span><span class="p">(</span><span class="n">ABCMeta</span><span class="p">):</span>
<span class="k">def</span><span class="w"> </span><span class="fm">__new__</span><span class="p">(</span><span class="bp">cls</span><span class="p">,</span> <span class="n">name</span><span class="p">,</span> <span class="n">bases</span><span class="p">,</span> <span class="n">namespace</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="n">name</span> <span class="o">!=</span> <span class="s2">&quot;ByteString&quot;</span><span class="p">:</span>
<span class="kn">import</span><span class="w"> </span><span class="nn">warnings</span>
<span class="n">warnings</span><span class="o">.</span><span class="n">_deprecated</span><span class="p">(</span>
<span class="s2">&quot;collections.abc.ByteString&quot;</span><span class="p">,</span>
<span class="n">remove</span><span class="o">=</span><span class="p">(</span><span class="mi">3</span><span class="p">,</span> <span class="mi">14</span><span class="p">),</span>
<span class="p">)</span>
<span class="k">return</span> <span class="nb">super</span><span class="p">()</span><span class="o">.</span><span class="fm">__new__</span><span class="p">(</span><span class="bp">cls</span><span class="p">,</span> <span class="n">name</span><span class="p">,</span> <span class="n">bases</span><span class="p">,</span> <span class="n">namespace</span><span class="p">,</span> <span class="o">**</span><span class="n">kwargs</span><span class="p">)</span>
<span class="k">def</span><span class="w"> </span><span class="fm">__instancecheck__</span><span class="p">(</span><span class="bp">cls</span><span class="p">,</span> <span class="n">instance</span><span class="p">):</span>
<span class="kn">import</span><span class="w"> </span><span class="nn">warnings</span>
<span class="n">warnings</span><span class="o">.</span><span class="n">_deprecated</span><span class="p">(</span>
<span class="s2">&quot;collections.abc.ByteString&quot;</span><span class="p">,</span>
<span class="n">remove</span><span class="o">=</span><span class="p">(</span><span class="mi">3</span><span class="p">,</span> <span class="mi">14</span><span class="p">),</span>
<span class="p">)</span>
<span class="k">return</span> <span class="nb">super</span><span class="p">()</span><span class="o">.</span><span class="fm">__instancecheck__</span><span class="p">(</span><span class="n">instance</span><span class="p">)</span>
<span class="k">class</span><span class="w"> </span><span class="nc">ByteString</span><span class="p">(</span><span class="n">Sequence</span><span class="p">,</span> <span class="n">metaclass</span><span class="o">=</span><span class="n">_DeprecateByteStringMeta</span><span class="p">):</span>
<span class="w"> </span><span class="sd">&quot;&quot;&quot;This unifies bytes and bytearray.</span>
<span class="sd"> XXX Should add all their methods.</span>
<span class="sd"> &quot;&quot;&quot;</span>
<span class="vm">__slots__</span> <span class="o">=</span> <span class="p">()</span>
<span class="n">ByteString</span><span class="o">.</span><span class="n">register</span><span class="p">(</span><span class="nb">bytes</span><span class="p">)</span>
<span class="n">ByteString</span><span class="o">.</span><span class="n">register</span><span class="p">(</span><span class="nb">bytearray</span><span class="p">)</span>
<div class="viewcode-block" id="MutableSequence">
<a class="viewcode-back" href="../../api/evennia.utils.dbserialize.html#evennia.utils.dbserialize.MutableSequence">[docs]</a>
<span class="k">class</span><span class="w"> </span><span class="nc">MutableSequence</span><span class="p">(</span><span class="n">Sequence</span><span class="p">):</span>
<span class="w"> </span><span class="sd">&quot;&quot;&quot;All the operations on a read-write sequence.</span>
<span class="sd"> Concrete subclasses must provide __new__ or __init__,</span>
<span class="sd"> __getitem__, __setitem__, __delitem__, __len__, and insert().</span>
<span class="sd"> &quot;&quot;&quot;</span>
<span class="vm">__slots__</span> <span class="o">=</span> <span class="p">()</span>
<span class="nd">@abstractmethod</span>
<span class="k">def</span><span class="w"> </span><span class="fm">__setitem__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">index</span><span class="p">,</span> <span class="n">value</span><span class="p">):</span>
<span class="k">raise</span> <span class="ne">IndexError</span>
<span class="nd">@abstractmethod</span>
<span class="k">def</span><span class="w"> </span><span class="fm">__delitem__</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">raise</span> <span class="ne">IndexError</span>
<div class="viewcode-block" id="MutableSequence.insert">
<a class="viewcode-back" href="../../api/evennia.utils.dbserialize.html#evennia.utils.dbserialize.MutableSequence.insert">[docs]</a>
<span class="nd">@abstractmethod</span>
<span class="k">def</span><span class="w"> </span><span class="nf">insert</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">index</span><span class="p">,</span> <span class="n">value</span><span class="p">):</span>
<span class="s1">&#39;S.insert(index, value) -- insert value before index&#39;</span>
<span class="k">raise</span> <span class="ne">IndexError</span></div>
<div class="viewcode-block" id="MutableSequence.append">
<a class="viewcode-back" href="../../api/evennia.utils.dbserialize.html#evennia.utils.dbserialize.MutableSequence.append">[docs]</a>
<span class="k">def</span><span class="w"> </span><span class="nf">append</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">value</span><span class="p">):</span>
<span class="s1">&#39;S.append(value) -- append value to the end of the sequence&#39;</span>
<span class="bp">self</span><span class="o">.</span><span class="n">insert</span><span class="p">(</span><span class="nb">len</span><span class="p">(</span><span class="bp">self</span><span class="p">),</span> <span class="n">value</span><span class="p">)</span></div>
<div class="viewcode-block" id="MutableSequence.clear">
<a class="viewcode-back" href="../../api/evennia.utils.dbserialize.html#evennia.utils.dbserialize.MutableSequence.clear">[docs]</a>
<span class="k">def</span><span class="w"> </span><span class="nf">clear</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
<span class="s1">&#39;S.clear() -&gt; None -- remove all items from S&#39;</span>
<span class="k">try</span><span class="p">:</span>
<span class="k">while</span> <span class="kc">True</span><span class="p">:</span>
<span class="bp">self</span><span class="o">.</span><span class="n">pop</span><span class="p">()</span>
<span class="k">except</span> <span class="ne">IndexError</span><span class="p">:</span>
<span class="k">pass</span></div>
<div class="viewcode-block" id="MutableSequence.reverse">
<a class="viewcode-back" href="../../api/evennia.utils.dbserialize.html#evennia.utils.dbserialize.MutableSequence.reverse">[docs]</a>
<span class="k">def</span><span class="w"> </span><span class="nf">reverse</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
<span class="s1">&#39;S.reverse() -- reverse *IN PLACE*&#39;</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="k">for</span> <span class="n">i</span> <span class="ow">in</span> <span class="nb">range</span><span class="p">(</span><span class="n">n</span><span class="o">//</span><span class="mi">2</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="bp">self</span><span class="p">[</span><span class="n">n</span><span class="o">-</span><span class="n">i</span><span class="o">-</span><span class="mi">1</span><span class="p">]</span> <span class="o">=</span> <span class="bp">self</span><span class="p">[</span><span class="n">n</span><span class="o">-</span><span class="n">i</span><span class="o">-</span><span class="mi">1</span><span class="p">],</span> <span class="bp">self</span><span class="p">[</span><span class="n">i</span><span class="p">]</span></div>
<div class="viewcode-block" id="MutableSequence.extend">
<a class="viewcode-back" href="../../api/evennia.utils.dbserialize.html#evennia.utils.dbserialize.MutableSequence.extend">[docs]</a>
<span class="k">def</span><span class="w"> </span><span class="nf">extend</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">values</span><span class="p">):</span>
<span class="s1">&#39;S.extend(iterable) -- extend sequence by appending elements from the iterable&#39;</span>
<span class="k">if</span> <span class="n">values</span> <span class="ow">is</span> <span class="bp">self</span><span class="p">:</span>
<span class="n">values</span> <span class="o">=</span> <span class="nb">list</span><span class="p">(</span><span class="n">values</span><span class="p">)</span>
<span class="k">for</span> <span class="n">v</span> <span class="ow">in</span> <span class="n">values</span><span class="p">:</span>
<span class="bp">self</span><span class="o">.</span><span class="n">append</span><span class="p">(</span><span class="n">v</span><span class="p">)</span></div>
<div class="viewcode-block" id="MutableSequence.pop">
<a class="viewcode-back" href="../../api/evennia.utils.dbserialize.html#evennia.utils.dbserialize.MutableSequence.pop">[docs]</a>
<span class="k">def</span><span class="w"> </span><span class="nf">pop</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">index</span><span class="o">=-</span><span class="mi">1</span><span class="p">):</span>
<span class="w"> </span><span class="sd">&#39;&#39;&#39;S.pop([index]) -&gt; item -- remove and return item at index (default last).</span>
<span class="sd"> Raise IndexError if list is empty or index is out of range.</span>
<span class="sd"> &#39;&#39;&#39;</span>
<span class="n">v</span> <span class="o">=</span> <span class="bp">self</span><span class="p">[</span><span class="n">index</span><span class="p">]</span>
<span class="k">del</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="n">v</span></div>
<div class="viewcode-block" id="MutableSequence.remove">
<a class="viewcode-back" href="../../api/evennia.utils.dbserialize.html#evennia.utils.dbserialize.MutableSequence.remove">[docs]</a>
<span class="k">def</span><span class="w"> </span><span class="nf">remove</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">value</span><span class="p">):</span>
<span class="w"> </span><span class="sd">&#39;&#39;&#39;S.remove(value) -- remove first occurrence of value.</span>
<span class="sd"> Raise ValueError if the value is not present.</span>
<span class="sd"> &#39;&#39;&#39;</span>
<span class="k">del</span> <span class="bp">self</span><span class="p">[</span><span class="bp">self</span><span class="o">.</span><span class="n">index</span><span class="p">(</span><span class="n">value</span><span class="p">)]</span></div>
<span class="k">def</span><span class="w"> </span><span class="fm">__iadd__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">values</span><span class="p">):</span>
<span class="bp">self</span><span class="o">.</span><span class="n">extend</span><span class="p">(</span><span class="n">values</span><span class="p">)</span>
<span class="k">return</span> <span class="bp">self</span></div>
<span class="n">MutableSequence</span><span class="o">.</span><span class="n">register</span><span class="p">(</span><span class="nb">list</span><span class="p">)</span>
<span class="n">MutableSequence</span><span class="o">.</span><span class="n">register</span><span class="p">(</span><span class="nb">bytearray</span><span class="p">)</span> <span class="c1"># Multiply inheriting, see ByteString</span>
</pre></div>
</div>
</div>
</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 latest</a> &#187;</li>
<li class="nav-item nav-item-1"><a href="../index.html" >Module code</a> &#187;</li>
<li class="nav-item nav-item-2"><a href="../collections.html" >collections</a> &#187;</li>
<li class="nav-item nav-item-this"><a href="">collections.abc</a></li>
</ul>
</div>
<div class="footer" role="contentinfo">
&#169; Copyright 2024, The Evennia developer community.
Created using <a href="https://www.sphinx-doc.org/">Sphinx</a> 8.2.3.
</div>
</body>
</html>
Reference in a new issue View git blame Copy permalink