python3-postgresql 1.1.0-2+b3 / usr / share / doc / python3-postgresql / html / _modules / abc.html

This file is indexed.

/usr/share/doc/python3-postgresql/html/_modules/abc.html is in python3-postgresql 1.1.0-2+b3.

This file is owned by root:root, with mode 0o644.

The actual contents of the file can be viewed below. 

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
  "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">


<html xmlns="http://www.w3.org/1999/xhtml">
  <head>
    <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
    
    <title>abc &mdash; py-postgresql 1.1.0 documentation</title>
    
    <link rel="stylesheet" href="../_static/default.css" type="text/css" />
    <link rel="stylesheet" href="../_static/pygments.css" type="text/css" />
    
    <script type="text/javascript">
      var DOCUMENTATION_OPTIONS = {
        URL_ROOT:    '../',
        VERSION:     '1.1.0',
        COLLAPSE_INDEX: false,
        FILE_SUFFIX: '.html',
        HAS_SOURCE:  true
      };
    </script>
    <script type="text/javascript" src="../_static/jquery.js"></script>
    <script type="text/javascript" src="../_static/underscore.js"></script>
    <script type="text/javascript" src="../_static/doctools.js"></script>
    <link rel="top" title="py-postgresql 1.1.0 documentation" href="../index.html" />
    <link rel="up" title="Module code" href="index.html" />

   
  
  <meta name="viewport" content="width=device-width, initial-scale=0.9, maximum-scale=0.9">

<link rel="stylesheet" href="_static/unsuck.css" type="text/css" />

  </head>
  <body role="document">  

    <div class="document">
      <div class="documentwrapper">
        <div class="bodywrapper">
          <div class="body" role="main">
            
  <h1>Source code for abc</h1><div class="highlight"><pre>
<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) according to PEP 3119.&quot;&quot;&quot;</span>

<span class="kn">from</span> <span class="nn">_weakrefset</span> <span class="kn">import</span> <span class="n">WeakSet</span>


<span class="k">def</span> <span class="nf">abstractmethod</span><span class="p">(</span><span class="n">funcobj</span><span class="p">):</span>
    <span class="sd">&quot;&quot;&quot;A decorator indicating abstract methods.</span>

<span class="sd">    Requires that the metaclass is ABCMeta or derived from it.  A</span>
<span class="sd">    class that has a metaclass derived from ABCMeta cannot be</span>
<span class="sd">    instantiated unless all of its abstract methods are overridden.</span>
<span class="sd">    The abstract methods can be called using any of the normal</span>
<span class="sd">    &#39;super&#39; call mechanisms.</span>

<span class="sd">    Usage:</span>

<span class="sd">        class C(metaclass=ABCMeta):</span>
<span class="sd">            @abstractmethod</span>
<span class="sd">            def my_abstract_method(self, ...):</span>
<span class="sd">                ...</span>
<span class="sd">    &quot;&quot;&quot;</span>
    <span class="n">funcobj</span><span class="o">.</span><span class="n">__isabstractmethod__</span> <span class="o">=</span> <span class="bp">True</span>
    <span class="k">return</span> <span class="n">funcobj</span>


<span class="k">class</span> <span class="nc">abstractclassmethod</span><span class="p">(</span><span class="nb">classmethod</span><span class="p">):</span>
    <span class="sd">&quot;&quot;&quot;</span>
<span class="sd">    A decorator indicating abstract classmethods.</span>

<span class="sd">    Similar to abstractmethod.</span>

<span class="sd">    Usage:</span>

<span class="sd">        class C(metaclass=ABCMeta):</span>
<span class="sd">            @abstractclassmethod</span>
<span class="sd">            def my_abstract_classmethod(cls, ...):</span>
<span class="sd">                ...</span>

<span class="sd">    &#39;abstractclassmethod&#39; is deprecated. Use &#39;classmethod&#39; with</span>
<span class="sd">    &#39;abstractmethod&#39; instead.</span>
<span class="sd">    &quot;&quot;&quot;</span>

    <span class="n">__isabstractmethod__</span> <span class="o">=</span> <span class="bp">True</span>

    <span class="k">def</span> <span class="nf">__init__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="nb">callable</span><span class="p">):</span>
        <span class="nb">callable</span><span class="o">.</span><span class="n">__isabstractmethod__</span> <span class="o">=</span> <span class="bp">True</span>
        <span class="nb">super</span><span class="p">()</span><span class="o">.</span><span class="n">__init__</span><span class="p">(</span><span class="nb">callable</span><span class="p">)</span>


<span class="k">class</span> <span class="nc">abstractstaticmethod</span><span class="p">(</span><span class="nb">staticmethod</span><span class="p">):</span>
    <span class="sd">&quot;&quot;&quot;</span>
<span class="sd">    A decorator indicating abstract staticmethods.</span>

<span class="sd">    Similar to abstractmethod.</span>

<span class="sd">    Usage:</span>

<span class="sd">        class C(metaclass=ABCMeta):</span>
<span class="sd">            @abstractstaticmethod</span>
<span class="sd">            def my_abstract_staticmethod(...):</span>
<span class="sd">                ...</span>

<span class="sd">    &#39;abstractstaticmethod&#39; is deprecated. Use &#39;staticmethod&#39; with</span>
<span class="sd">    &#39;abstractmethod&#39; instead.</span>
<span class="sd">    &quot;&quot;&quot;</span>

    <span class="n">__isabstractmethod__</span> <span class="o">=</span> <span class="bp">True</span>

    <span class="k">def</span> <span class="nf">__init__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="nb">callable</span><span class="p">):</span>
        <span class="nb">callable</span><span class="o">.</span><span class="n">__isabstractmethod__</span> <span class="o">=</span> <span class="bp">True</span>
        <span class="nb">super</span><span class="p">()</span><span class="o">.</span><span class="n">__init__</span><span class="p">(</span><span class="nb">callable</span><span class="p">)</span>


<span class="k">class</span> <span class="nc">abstractproperty</span><span class="p">(</span><span class="nb">property</span><span class="p">):</span>
    <span class="sd">&quot;&quot;&quot;</span>
<span class="sd">    A decorator indicating abstract properties.</span>

<span class="sd">    Requires that the metaclass is ABCMeta or derived from it.  A</span>
<span class="sd">    class that has a metaclass derived from ABCMeta cannot be</span>
<span class="sd">    instantiated unless all of its abstract properties are overridden.</span>
<span class="sd">    The abstract properties can be called using any of the normal</span>
<span class="sd">    &#39;super&#39; call mechanisms.</span>

<span class="sd">    Usage:</span>

<span class="sd">        class C(metaclass=ABCMeta):</span>
<span class="sd">            @abstractproperty</span>
<span class="sd">            def my_abstract_property(self):</span>
<span class="sd">                ...</span>

<span class="sd">    This defines a read-only property; you can also define a read-write</span>
<span class="sd">    abstract property using the &#39;long&#39; form of property declaration:</span>

<span class="sd">        class C(metaclass=ABCMeta):</span>
<span class="sd">            def getx(self): ...</span>
<span class="sd">            def setx(self, value): ...</span>
<span class="sd">            x = abstractproperty(getx, setx)</span>

<span class="sd">    &#39;abstractproperty&#39; is deprecated. Use &#39;property&#39; with &#39;abstractmethod&#39;</span>
<span class="sd">    instead.</span>
<span class="sd">    &quot;&quot;&quot;</span>

    <span class="n">__isabstractmethod__</span> <span class="o">=</span> <span class="bp">True</span>


<span class="k">class</span> <span class="nc">ABCMeta</span><span class="p">(</span><span class="nb">type</span><span class="p">):</span>

    <span class="sd">&quot;&quot;&quot;Metaclass for defining Abstract Base Classes (ABCs).</span>

<span class="sd">    Use this metaclass to create an ABC.  An ABC can be subclassed</span>
<span class="sd">    directly, and then acts as a mix-in class.  You can also register</span>
<span class="sd">    unrelated concrete classes (even built-in classes) and unrelated</span>
<span class="sd">    ABCs as &#39;virtual subclasses&#39; -- these and their descendants will</span>
<span class="sd">    be considered subclasses of the registering ABC by the built-in</span>
<span class="sd">    issubclass() function, but the registering ABC won&#39;t show up in</span>
<span class="sd">    their MRO (Method Resolution Order) nor will method</span>
<span class="sd">    implementations defined by the registering ABC be callable (not</span>
<span class="sd">    even via super()).</span>

<span class="sd">    &quot;&quot;&quot;</span>

    <span class="c1"># A global counter that is incremented each time a class is</span>
    <span class="c1"># registered as a virtual subclass of anything.  It forces the</span>
    <span class="c1"># negative cache to be cleared before its next use.</span>
    <span class="c1"># Note: this counter is private. Use `abc.get_cache_token()` for</span>
    <span class="c1">#       external code.</span>
    <span class="n">_abc_invalidation_counter</span> <span class="o">=</span> <span class="mi">0</span>

    <span class="k">def</span> <span class="nf">__new__</span><span class="p">(</span><span class="n">mcls</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="n">cls</span> <span class="o">=</span> <span class="nb">super</span><span class="p">()</span><span class="o">.</span><span class="n">__new__</span><span class="p">(</span><span class="n">mcls</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="c1"># Compute set of abstract method names</span>
        <span class="n">abstracts</span> <span class="o">=</span> <span class="p">{</span><span class="n">name</span>
                     <span class="k">for</span> <span class="n">name</span><span class="p">,</span> <span class="n">value</span> <span class="ow">in</span> <span class="n">namespace</span><span class="o">.</span><span class="n">items</span><span class="p">()</span>
                     <span class="k">if</span> <span class="nb">getattr</span><span class="p">(</span><span class="n">value</span><span class="p">,</span> <span class="s2">&quot;__isabstractmethod__&quot;</span><span class="p">,</span> <span class="bp">False</span><span class="p">)}</span>
        <span class="k">for</span> <span class="n">base</span> <span class="ow">in</span> <span class="n">bases</span><span class="p">:</span>
            <span class="k">for</span> <span class="n">name</span> <span class="ow">in</span> <span class="nb">getattr</span><span class="p">(</span><span class="n">base</span><span class="p">,</span> <span class="s2">&quot;__abstractmethods__&quot;</span><span class="p">,</span> <span class="nb">set</span><span class="p">()):</span>
                <span class="n">value</span> <span class="o">=</span> <span class="nb">getattr</span><span class="p">(</span><span class="n">cls</span><span class="p">,</span> <span class="n">name</span><span class="p">,</span> <span class="bp">None</span><span class="p">)</span>
                <span class="k">if</span> <span class="nb">getattr</span><span class="p">(</span><span class="n">value</span><span class="p">,</span> <span class="s2">&quot;__isabstractmethod__&quot;</span><span class="p">,</span> <span class="bp">False</span><span class="p">):</span>
                    <span class="n">abstracts</span><span class="o">.</span><span class="n">add</span><span class="p">(</span><span class="n">name</span><span class="p">)</span>
        <span class="n">cls</span><span class="o">.</span><span class="n">__abstractmethods__</span> <span class="o">=</span> <span class="nb">frozenset</span><span class="p">(</span><span class="n">abstracts</span><span class="p">)</span>
        <span class="c1"># Set up inheritance registry</span>
        <span class="n">cls</span><span class="o">.</span><span class="n">_abc_registry</span> <span class="o">=</span> <span class="n">WeakSet</span><span class="p">()</span>
        <span class="n">cls</span><span class="o">.</span><span class="n">_abc_cache</span> <span class="o">=</span> <span class="n">WeakSet</span><span class="p">()</span>
        <span class="n">cls</span><span class="o">.</span><span class="n">_abc_negative_cache</span> <span class="o">=</span> <span class="n">WeakSet</span><span class="p">()</span>
        <span class="n">cls</span><span class="o">.</span><span class="n">_abc_negative_cache_version</span> <span class="o">=</span> <span class="n">ABCMeta</span><span class="o">.</span><span class="n">_abc_invalidation_counter</span>
        <span class="k">return</span> <span class="n">cls</span>

    <span class="k">def</span> <span class="nf">register</span><span class="p">(</span><span class="n">cls</span><span class="p">,</span> <span class="n">subclass</span><span class="p">):</span>
        <span class="sd">&quot;&quot;&quot;Register a virtual subclass of an ABC.</span>

<span class="sd">        Returns the subclass, to allow usage as a class decorator.</span>
<span class="sd">        &quot;&quot;&quot;</span>
        <span class="k">if</span> <span class="ow">not</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">subclass</span><span class="p">,</span> <span class="nb">type</span><span class="p">):</span>
            <span class="k">raise</span> <span class="ne">TypeError</span><span class="p">(</span><span class="s2">&quot;Can only register classes&quot;</span><span class="p">)</span>
        <span class="k">if</span> <span class="nb">issubclass</span><span class="p">(</span><span class="n">subclass</span><span class="p">,</span> <span class="n">cls</span><span class="p">):</span>
            <span class="k">return</span> <span class="n">subclass</span>  <span class="c1"># Already a subclass</span>
        <span class="c1"># Subtle: test for cycles *after* testing for &quot;already a subclass&quot;;</span>
        <span class="c1"># this means we allow X.register(X) and interpret it as a no-op.</span>
        <span class="k">if</span> <span class="nb">issubclass</span><span class="p">(</span><span class="n">cls</span><span class="p">,</span> <span class="n">subclass</span><span class="p">):</span>
            <span class="c1"># This would create a cycle, which is bad for the algorithm below</span>
            <span class="k">raise</span> <span class="ne">RuntimeError</span><span class="p">(</span><span class="s2">&quot;Refusing to create an inheritance cycle&quot;</span><span class="p">)</span>
        <span class="n">cls</span><span class="o">.</span><span class="n">_abc_registry</span><span class="o">.</span><span class="n">add</span><span class="p">(</span><span class="n">subclass</span><span class="p">)</span>
        <span class="n">ABCMeta</span><span class="o">.</span><span class="n">_abc_invalidation_counter</span> <span class="o">+=</span> <span class="mi">1</span>  <span class="c1"># Invalidate negative cache</span>
        <span class="k">return</span> <span class="n">subclass</span>

    <span class="k">def</span> <span class="nf">_dump_registry</span><span class="p">(</span><span class="n">cls</span><span class="p">,</span> <span class="nb">file</span><span class="o">=</span><span class="bp">None</span><span class="p">):</span>
        <span class="sd">&quot;&quot;&quot;Debug helper to print the ABC registry.&quot;&quot;&quot;</span>
        <span class="k">print</span><span class="p">(</span><span class="s2">&quot;Class: </span><span class="si">%s</span><span class="s2">.</span><span class="si">%s</span><span class="s2">&quot;</span> <span class="o">%</span> <span class="p">(</span><span class="n">cls</span><span class="o">.</span><span class="n">__module__</span><span class="p">,</span> <span class="n">cls</span><span class="o">.</span><span class="n">__qualname__</span><span class="p">),</span> <span class="nb">file</span><span class="o">=</span><span class="nb">file</span><span class="p">)</span>
        <span class="k">print</span><span class="p">(</span><span class="s2">&quot;Inv.counter: </span><span class="si">%s</span><span class="s2">&quot;</span> <span class="o">%</span> <span class="n">ABCMeta</span><span class="o">.</span><span class="n">_abc_invalidation_counter</span><span class="p">,</span> <span class="nb">file</span><span class="o">=</span><span class="nb">file</span><span class="p">)</span>
        <span class="k">for</span> <span class="n">name</span> <span class="ow">in</span> <span class="nb">sorted</span><span class="p">(</span><span class="n">cls</span><span class="o">.</span><span class="n">__dict__</span><span class="o">.</span><span class="n">keys</span><span class="p">()):</span>
            <span class="k">if</span> <span class="n">name</span><span class="o">.</span><span class="n">startswith</span><span class="p">(</span><span class="s2">&quot;_abc_&quot;</span><span class="p">):</span>
                <span class="n">value</span> <span class="o">=</span> <span class="nb">getattr</span><span class="p">(</span><span class="n">cls</span><span class="p">,</span> <span class="n">name</span><span class="p">)</span>
                <span class="k">print</span><span class="p">(</span><span class="s2">&quot;</span><span class="si">%s</span><span class="s2">: </span><span class="si">%r</span><span class="s2">&quot;</span> <span class="o">%</span> <span class="p">(</span><span class="n">name</span><span class="p">,</span> <span class="n">value</span><span class="p">),</span> <span class="nb">file</span><span class="o">=</span><span class="nb">file</span><span class="p">)</span>

    <span class="k">def</span> <span class="nf">__instancecheck__</span><span class="p">(</span><span class="n">cls</span><span class="p">,</span> <span class="n">instance</span><span class="p">):</span>
        <span class="sd">&quot;&quot;&quot;Override for isinstance(instance, cls).&quot;&quot;&quot;</span>
        <span class="c1"># Inline the cache checking</span>
        <span class="n">subclass</span> <span class="o">=</span> <span class="n">instance</span><span class="o">.</span><span class="n">__class__</span>
        <span class="k">if</span> <span class="n">subclass</span> <span class="ow">in</span> <span class="n">cls</span><span class="o">.</span><span class="n">_abc_cache</span><span class="p">:</span>
            <span class="k">return</span> <span class="bp">True</span>
        <span class="n">subtype</span> <span class="o">=</span> <span class="nb">type</span><span class="p">(</span><span class="n">instance</span><span class="p">)</span>
        <span class="k">if</span> <span class="n">subtype</span> <span class="ow">is</span> <span class="n">subclass</span><span class="p">:</span>
            <span class="k">if</span> <span class="p">(</span><span class="n">cls</span><span class="o">.</span><span class="n">_abc_negative_cache_version</span> <span class="o">==</span>
                <span class="n">ABCMeta</span><span class="o">.</span><span class="n">_abc_invalidation_counter</span> <span class="ow">and</span>
                <span class="n">subclass</span> <span class="ow">in</span> <span class="n">cls</span><span class="o">.</span><span class="n">_abc_negative_cache</span><span class="p">):</span>
                <span class="k">return</span> <span class="bp">False</span>
            <span class="c1"># Fall back to the subclass check.</span>
            <span class="k">return</span> <span class="n">cls</span><span class="o">.</span><span class="n">__subclasscheck__</span><span class="p">(</span><span class="n">subclass</span><span class="p">)</span>
        <span class="k">return</span> <span class="nb">any</span><span class="p">(</span><span class="n">cls</span><span class="o">.</span><span class="n">__subclasscheck__</span><span class="p">(</span><span class="n">c</span><span class="p">)</span> <span class="k">for</span> <span class="n">c</span> <span class="ow">in</span> <span class="p">{</span><span class="n">subclass</span><span class="p">,</span> <span class="n">subtype</span><span class="p">})</span>

    <span class="k">def</span> <span class="nf">__subclasscheck__</span><span class="p">(</span><span class="n">cls</span><span class="p">,</span> <span class="n">subclass</span><span class="p">):</span>
        <span class="sd">&quot;&quot;&quot;Override for issubclass(subclass, cls).&quot;&quot;&quot;</span>
        <span class="c1"># Check cache</span>
        <span class="k">if</span> <span class="n">subclass</span> <span class="ow">in</span> <span class="n">cls</span><span class="o">.</span><span class="n">_abc_cache</span><span class="p">:</span>
            <span class="k">return</span> <span class="bp">True</span>
        <span class="c1"># Check negative cache; may have to invalidate</span>
        <span class="k">if</span> <span class="n">cls</span><span class="o">.</span><span class="n">_abc_negative_cache_version</span> <span class="o">&lt;</span> <span class="n">ABCMeta</span><span class="o">.</span><span class="n">_abc_invalidation_counter</span><span class="p">:</span>
            <span class="c1"># Invalidate the negative cache</span>
            <span class="n">cls</span><span class="o">.</span><span class="n">_abc_negative_cache</span> <span class="o">=</span> <span class="n">WeakSet</span><span class="p">()</span>
            <span class="n">cls</span><span class="o">.</span><span class="n">_abc_negative_cache_version</span> <span class="o">=</span> <span class="n">ABCMeta</span><span class="o">.</span><span class="n">_abc_invalidation_counter</span>
        <span class="k">elif</span> <span class="n">subclass</span> <span class="ow">in</span> <span class="n">cls</span><span class="o">.</span><span class="n">_abc_negative_cache</span><span class="p">:</span>
            <span class="k">return</span> <span class="bp">False</span>
        <span class="c1"># Check the subclass hook</span>
        <span class="n">ok</span> <span class="o">=</span> <span class="n">cls</span><span class="o">.</span><span class="n">__subclasshook__</span><span class="p">(</span><span class="n">subclass</span><span class="p">)</span>
        <span class="k">if</span> <span class="n">ok</span> <span class="ow">is</span> <span class="ow">not</span> <span class="bp">NotImplemented</span><span class="p">:</span>
            <span class="k">assert</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">ok</span><span class="p">,</span> <span class="nb">bool</span><span class="p">)</span>
            <span class="k">if</span> <span class="n">ok</span><span class="p">:</span>
                <span class="n">cls</span><span class="o">.</span><span class="n">_abc_cache</span><span class="o">.</span><span class="n">add</span><span class="p">(</span><span class="n">subclass</span><span class="p">)</span>
            <span class="k">else</span><span class="p">:</span>
                <span class="n">cls</span><span class="o">.</span><span class="n">_abc_negative_cache</span><span class="o">.</span><span class="n">add</span><span class="p">(</span><span class="n">subclass</span><span class="p">)</span>
            <span class="k">return</span> <span class="n">ok</span>
        <span class="c1"># Check if it&#39;s a direct subclass</span>
        <span class="k">if</span> <span class="n">cls</span> <span class="ow">in</span> <span class="nb">getattr</span><span class="p">(</span><span class="n">subclass</span><span class="p">,</span> <span class="s1">&#39;__mro__&#39;</span><span class="p">,</span> <span class="p">()):</span>
            <span class="n">cls</span><span class="o">.</span><span class="n">_abc_cache</span><span class="o">.</span><span class="n">add</span><span class="p">(</span><span class="n">subclass</span><span class="p">)</span>
            <span class="k">return</span> <span class="bp">True</span>
        <span class="c1"># Check if it&#39;s a subclass of a registered class (recursive)</span>
        <span class="k">for</span> <span class="n">rcls</span> <span class="ow">in</span> <span class="n">cls</span><span class="o">.</span><span class="n">_abc_registry</span><span class="p">:</span>
            <span class="k">if</span> <span class="nb">issubclass</span><span class="p">(</span><span class="n">subclass</span><span class="p">,</span> <span class="n">rcls</span><span class="p">):</span>
                <span class="n">cls</span><span class="o">.</span><span class="n">_abc_cache</span><span class="o">.</span><span class="n">add</span><span class="p">(</span><span class="n">subclass</span><span class="p">)</span>
                <span class="k">return</span> <span class="bp">True</span>
        <span class="c1"># Check if it&#39;s a subclass of a subclass (recursive)</span>
        <span class="k">for</span> <span class="n">scls</span> <span class="ow">in</span> <span class="n">cls</span><span class="o">.</span><span class="n">__subclasses__</span><span class="p">():</span>
            <span class="k">if</span> <span class="nb">issubclass</span><span class="p">(</span><span class="n">subclass</span><span class="p">,</span> <span class="n">scls</span><span class="p">):</span>
                <span class="n">cls</span><span class="o">.</span><span class="n">_abc_cache</span><span class="o">.</span><span class="n">add</span><span class="p">(</span><span class="n">subclass</span><span class="p">)</span>
                <span class="k">return</span> <span class="bp">True</span>
        <span class="c1"># No dice; update negative cache</span>
        <span class="n">cls</span><span class="o">.</span><span class="n">_abc_negative_cache</span><span class="o">.</span><span class="n">add</span><span class="p">(</span><span class="n">subclass</span><span class="p">)</span>
        <span class="k">return</span> <span class="bp">False</span>


<span class="k">class</span> <span class="nc">ABC</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="sd">&quot;&quot;&quot;Helper class that provides a standard way to create an ABC using</span>
<span class="sd">    inheritance.</span>
<span class="sd">    &quot;&quot;&quot;</span>
    <span class="k">pass</span>


<span class="k">def</span> <span class="nf">get_cache_token</span><span class="p">():</span>
    <span class="sd">&quot;&quot;&quot;Returns the current ABC cache token.</span>

<span class="sd">    The token is an opaque object (supporting equality testing) identifying the</span>
<span class="sd">    current version of the ABC cache for virtual subclasses. The token changes</span>
<span class="sd">    with every call to ``register()`` on any ABC.</span>
<span class="sd">    &quot;&quot;&quot;</span>
    <span class="k">return</span> <span class="n">ABCMeta</span><span class="o">.</span><span class="n">_abc_invalidation_counter</span>
</pre></div>

          </div>
        </div>
      </div>
      <div class="sphinxsidebar" role="navigation" aria-label="main navigation">
        <div class="sphinxsidebarwrapper"><div class="relations">
<h3>Related Topics</h3>
<ul>
  <li><a href="../index.html">Documentation overview</a><ul>
  <li><a href="index.html">Module code</a><ul>
  </ul></li>
  </ul></li>
</ul>
</div>
<div id="searchbox" style="display: none" role="search">
  <h3>Quick search</h3>
    <form class="search" action="../search.html" method="get">
      <input type="text" name="q" />
      <input type="submit" value="Go" />
      <input type="hidden" name="check_keywords" value="yes" />
      <input type="hidden" name="area" value="default" />
    </form>
    <p class="searchtip" style="font-size: 90%">
    Enter search terms or a module, class or function name.
    </p>
</div>
<script type="text/javascript">$('#searchbox').show(0);</script>
        </div>
      </div>
      <div class="clearer"></div>
    </div>
    <div class="footer">
      &copy;Python+Postgres.
      
      |
      Powered by <a href="http://sphinx-doc.org/">Sphinx 1.3.5</a>
      &amp; <a href="https://github.com/bitprophet/alabaster">Alabaster 0.7.6</a>
      
    </div>

    

    
  </body>
</html>

APT Browse - Built by Thomas Orozco.