Merge pull request #1 from micheles/3.4.1

Initial work for release 3.4.1
author: Michele Simionato <michele.simionato@gmail.com> 2015-03-16 13:32:00 +0100
committer: Michele Simionato <michele.simionato@gmail.com> 2015-03-16 13:32:00 +0100
commit: 8bf5f43efca4654409b76200e6a59c3a539532ad (patch)
tree: 42e586ddbb42b8980709d8e4ad49e01162d33448
parent: 6faf8468c33457ce2e7f215bfc54c66b467ef899 (diff)
parent: d7d4bac90419a049165da9f29e2b8fef18fa7f33 (diff)
download: python-decorator-git-8bf5f43efca4654409b76200e6a59c3a539532ad.tar.gz
14 files changed, 11548 insertions, 6224 deletions
diff --git a/CHANGES.txt b/CHANGES.txt
index bb093fa..41a2610 100644
--- a/CHANGES.txt
+++ b/CHANGES.txt
@@ -1,6 +1,8 @@
 HISTORY
 ----------
 
+3.4.1 Ported the repository from GoogleCode to GitHub.
+     setuptools is made mandatory in Python 3.
 3.4.0 Added the ability to use classes and generic callables as callers and
      implemented a signature-preserving contexmanager decorator. Fixed a bug
      with the signature f(**kw) in Python 3 and fixed a couple of doctests
diff --git a/LICENSE.txt b/LICENSE.txt
new file mode 100644
index 0000000..88e0bcc
--- /dev/null
+++ b/LICENSE.txt
@@ -0,0 +1,26 @@
+Copyright (c) 2005-2015, Michele Simionato
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are
+met:
+
+  Redistributions of source code must retain the above copyright
+  notice, this list of conditions and the following disclaimer.
+  Redistributions in bytecode form must reproduce the above copyright
+  notice, this list of conditions and the following disclaimer in
+  the documentation and/or other materials provided with the
+  distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
+OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
+TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
+USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
+DAMAGE.
diff --git a/Makefile b/Makefile
index a5c0b86..7e90baf 100644
--- a/Makefile
+++ b/Makefile
@@ -1,18 +1,18 @@
 RST=python $(S)/ms/tools/rst.py
 
 rst: documentation.py documentation3.py
-	python $(S)/ms/tools/minidoc.py -d documentation.py
-	python3.3 $(S)/minidoc3.py -d documentation3.py
+	PYTHONPATH=src:$(S) python $(S)/ms/tools/minidoc.py -d documentation.py
+	python3 $(S)/minidoc3.py -d documentation3.py
+	cp /tmp/documentation.rst /tmp/documentation3.rst .
 
 html: /tmp/documentation.rst /tmp/documentation3.rst
 	$(RST) /tmp/documentation.rst
 	$(RST) /tmp/documentation3.rst
-	rst2html README.txt index.html
+	rst2html README.rst index.html
 
 pdf: /tmp/documentation.rst /tmp/documentation3.rst
 	rst2pdf /tmp/documentation.rst -o documentation.pdf
 	rst2pdf /tmp/documentation3.rst -o documentation3.pdf
-	cp /tmp/documentation.html /tmp/documentation3.html .
 
 upload: documentation.pdf documentation3.pdf
-	python3.3 setup.py register sdist upload 
+	python3 setup.py register sdist upload 
diff --git a/README.txt b/README.rst
index 50b39c1..3a15f82 100644
--- a/README.txt
+++ b/README.rst
@@ -1,7 +1,6 @@
 Decorator module
 =================
 
-
 :Author: Michele Simionato
 :E-mail: michele.simionato@gmail.com
 :Requires: Python 2.4+
@@ -14,10 +13,9 @@ Installation
 
 If you are lazy, just perform
 
-$ easy_install decorator
+$ pip install decorator
 
-which will install just the module on your system. Notice that
-Python 3 requires the easy_install version of the distribute_ project.
+which will install just the module on your system.
 
 If you prefer to install the full distribution from source, including
 the documentation, download the tarball_, unpack it and run
@@ -38,7 +36,7 @@ $ python documentation.py
 
 for Python 3.X run
 
-$ python documentation3.py
+$ python3 documentation3.py
 
 You will see a few innocuous errors with Python 2.5, because some
 inner details such as the introduction of the ArgSpec namedtuple and
@@ -66,15 +64,14 @@ There are various versions of the documentation:
 -  `HTML version (Python 3)`_ 
 -  `PDF version (Python 3)`_ 
 
-.. _HTML version (Python 2): http://micheles.googlecode.com/hg/decorator/documentation.html
-.. _PDF version (Python 2): http://micheles.googlecode.com/hg/decorator/documentation.pdf
-.. _HTML version (Python 3): http://micheles.googlecode.com/hg/decorator/documentation3.html
-.. _PDF version (Python 3): http://micheles.googlecode.com/hg/decorator/documentation3.pdf
+.. _HTML version (Python 2): https://github.com/micheles/decorator/blob/3.4.1/documentation.rst
+.. _PDF version (Python 2): https://github.com/micheles/decorator/blob/3.4.1/documentation.pdf
+.. _HTML version (Python 3): https://github.com/micheles/decorator/blob/3.4.1/documentation3.rst
+.. _PDF version (Python 3): https://github.com/micheles/decorator/blob/3.4.1/documentation3.pdf
 
 Repository
 ---------------
 
-The project is hosted on GoogleCode as a Mercurial repository. You
-can look at the source here:
+The project is hosted on GitHub. You can look at the source here:
 
- http://code.google.com/p/micheles/source/browse/#hg%2Fdecorator
+ https://github.com/micheles/decorator
diff --git a/documentation.html b/documentation.html
deleted file mode 100644
index 25a5709..0000000
--- a/documentation.html
+++ /dev/null
@@ -1,1102 +0,0 @@
-<?xml version="1.0" encoding="utf-8" ?>
-<!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" xml:lang="en" lang="en">
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
-<meta name="generator" content="Docutils 0.8.1: http://docutils.sourceforge.net/" />
-<title>The decorator module</title>
-<meta name="author" content="Michele Simionato" />
-<style type="text/css">
-
-.highlight  { background: #f8f8f8; }
-.highlight .c { color: #408080; font-style: italic } /* Comment */
-.highlight .err { border: 1px solid #FF0000 } /* Error */
-.highlight .k { color: #008000; font-weight: bold } /* Keyword */
-.highlight .o { color: #666666 } /* Operator */
-.highlight .cm { color: #408080; font-style: italic } /* Comment.Multiline */
-.highlight .cp { color: #BC7A00 } /* Comment.Preproc */
-.highlight .c1 { color: #408080; font-style: italic } /* Comment.Single */
-.highlight .cs { color: #408080; font-style: italic } /* Comment.Special */
-.highlight .gd { color: #A00000 } /* Generic.Deleted */
-.highlight .ge { font-style: italic } /* Generic.Emph */
-.highlight .gr { color: #FF0000 } /* Generic.Error */
-.highlight .gh { color: #000080; font-weight: bold } /* Generic.Heading */
-.highlight .gi { color: #00A000 } /* Generic.Inserted */
-.highlight .go { color: #808080 } /* Generic.Output */
-.highlight .gp { color: #000080; font-weight: bold } /* Generic.Prompt */
-.highlight .gs { font-weight: bold } /* Generic.Strong */
-.highlight .gu { color: #800080; font-weight: bold } /* Generic.Subheading */
-.highlight .gt { color: #0040D0 } /* Generic.Traceback */
-.highlight .kc { color: #008000; font-weight: bold } /* Keyword.Constant */
-.highlight .kd { color: #008000; font-weight: bold } /* Keyword.Declaration */
-.highlight .kp { color: #008000 } /* Keyword.Pseudo */
-.highlight .kr { color: #008000; font-weight: bold } /* Keyword.Reserved */
-.highlight .kt { color: #008000; font-weight: bold } /* Keyword.Type */
-.highlight .m { color: #666666 } /* Literal.Number */
-.highlight .s { color: #BA2121 } /* Literal.String */
-.highlight .na { color: #7D9029 } /* Name.Attribute */
-.highlight .nb { color: #008000 } /* Name.Builtin */
-.highlight .nc { color: #0000FF; font-weight: bold } /* Name.Class */
-.highlight .no { color: #880000 } /* Name.Constant */
-.highlight .nd { color: #AA22FF } /* Name.Decorator */
-.highlight .ni { color: #999999; font-weight: bold } /* Name.Entity */
-.highlight .ne { color: #D2413A; font-weight: bold } /* Name.Exception */
-.highlight .nf { color: #0000FF } /* Name.Function */
-.highlight .nl { color: #A0A000 } /* Name.Label */
-.highlight .nn { color: #0000FF; font-weight: bold } /* Name.Namespace */
-.highlight .nt { color: #008000; font-weight: bold } /* Name.Tag */
-.highlight .nv { color: #19177C } /* Name.Variable */
-.highlight .ow { color: #AA22FF; font-weight: bold } /* Operator.Word */
-.highlight .w { color: #bbbbbb } /* Text.Whitespace */
-.highlight .mf { color: #666666 } /* Literal.Number.Float */
-.highlight .mh { color: #666666 } /* Literal.Number.Hex */
-.highlight .mi { color: #666666 } /* Literal.Number.Integer */
-.highlight .mo { color: #666666 } /* Literal.Number.Oct */
-.highlight .sb { color: #BA2121 } /* Literal.String.Backtick */
-.highlight .sc { color: #BA2121 } /* Literal.String.Char */
-.highlight .sd { color: #BA2121; font-style: italic } /* Literal.String.Doc */
-.highlight .s2 { color: #BA2121 } /* Literal.String.Double */
-.highlight .se { color: #BB6622; font-weight: bold } /* Literal.String.Escape */
-.highlight .sh { color: #BA2121 } /* Literal.String.Heredoc */
-.highlight .si { color: #BB6688; font-weight: bold } /* Literal.String.Interpol */
-.highlight .sx { color: #008000 } /* Literal.String.Other */
-.highlight .sr { color: #BB6688 } /* Literal.String.Regex */
-.highlight .s1 { color: #BA2121 } /* Literal.String.Single */
-.highlight .ss { color: #19177C } /* Literal.String.Symbol */
-.highlight .bp { color: #008000 } /* Name.Builtin.Pseudo */
-.highlight .vc { color: #19177C } /* Name.Variable.Class */
-.highlight .vg { color: #19177C } /* Name.Variable.Global */
-.highlight .vi { color: #19177C } /* Name.Variable.Instance */
-.highlight .il { color: #666666 } /* Literal.Number.Integer.Long */
-
-</style>
-</head>
-<body>
-<div class="document" id="the-decorator-module">
-<h1 class="title">The <tt class="docutils literal">decorator</tt> module</h1>
-<table class="docinfo" frame="void" rules="none">
-<col class="docinfo-name" />
-<col class="docinfo-content" />
-<tbody valign="top">
-<tr><th class="docinfo-name">Author:</th>
-<td>Michele Simionato</td></tr>
-<tr class="field"><th class="docinfo-name">E-mail:</th><td class="field-body"><a class="reference external" href="mailto:michele.simionato&#64;gmail.com">michele.simionato&#64;gmail.com</a></td>
-</tr>
-<tr><th class="docinfo-name">Version:</th>
-<td>3.4.0 (2012-10-18)</td></tr>
-<tr class="field"><th class="docinfo-name">Requires:</th><td class="field-body">Python 2.4+</td>
-</tr>
-<tr class="field"><th class="docinfo-name">Download page:</th><td class="field-body"><a class="reference external" href="http://pypi.python.org/pypi/decorator/3.4.0">http://pypi.python.org/pypi/decorator/3.4.0</a></td>
-</tr>
-<tr class="field"><th class="docinfo-name">Installation:</th><td class="field-body"><tt class="docutils literal">easy_install decorator</tt></td>
-</tr>
-<tr class="field"><th class="docinfo-name">License:</th><td class="field-body">BSD license</td>
-</tr>
-</tbody>
-</table>
-<div class="contents topic" id="contents">
-<p class="topic-title first">Contents</p>
-<ul class="simple">
-<li><a class="reference internal" href="#introduction" id="id3">Introduction</a></li>
-<li><a class="reference internal" href="#definitions" id="id4">Definitions</a></li>
-<li><a class="reference internal" href="#statement-of-the-problem" id="id5">Statement of the problem</a></li>
-<li><a class="reference internal" href="#the-solution" id="id6">The solution</a></li>
-<li><a class="reference internal" href="#a-trace-decorator" id="id7">A <tt class="docutils literal">trace</tt> decorator</a></li>
-<li><a class="reference internal" href="#decorator-is-a-decorator" id="id8"><tt class="docutils literal">decorator</tt> is a decorator</a></li>
-<li><a class="reference internal" href="#blocking" id="id9"><tt class="docutils literal">blocking</tt></a></li>
-<li><a class="reference internal" href="#async" id="id10"><tt class="docutils literal">async</tt></a></li>
-<li><a class="reference internal" href="#contextmanager" id="id11">contextmanager</a></li>
-<li><a class="reference internal" href="#the-functionmaker-class" id="id12">The <tt class="docutils literal">FunctionMaker</tt> class</a></li>
-<li><a class="reference internal" href="#getting-the-source-code" id="id13">Getting the source code</a></li>
-<li><a class="reference internal" href="#dealing-with-third-party-decorators" id="id14">Dealing with third party decorators</a></li>
-<li><a class="reference internal" href="#caveats-and-limitations" id="id15">Caveats and limitations</a></li>
-<li><a class="reference internal" href="#compatibility-notes" id="id16">Compatibility notes</a></li>
-<li><a class="reference internal" href="#licence" id="id17">LICENCE</a></li>
-</ul>
-</div>
-<div class="section" id="introduction">
-<h1><a class="toc-backref" href="#id3">Introduction</a></h1>
-<p>Python decorators are an interesting example of why syntactic sugar
-matters. In principle, their introduction in Python 2.4 changed
-nothing, since they do not provide any new functionality which was not
-already present in the language. In practice, their introduction has
-significantly changed the way we structure our programs in Python. I
-believe the change is for the best, and that decorators are a great
-idea since:</p>
-<ul class="simple">
-<li>decorators help reducing boilerplate code;</li>
-<li>decorators help separation of concerns;</li>
-<li>decorators enhance readability and maintenability;</li>
-<li>decorators are explicit.</li>
-</ul>
-<p>Still, as of now, writing custom decorators correctly requires
-some experience and it is not as easy as it could be. For instance,
-typical implementations of decorators involve nested functions, and
-we all know that flat is better than nested.</p>
-<p>The aim of the <tt class="docutils literal">decorator</tt> module it to simplify the usage of
-decorators for the average programmer, and to popularize decorators by
-showing various non-trivial examples. Of course, as all techniques,
-decorators can be abused (I have seen that) and you should not try to
-solve every problem with a decorator, just because you can.</p>
-<p>You may find the source code for all the examples
-discussed here in the <tt class="docutils literal">documentation.py</tt> file, which contains
-this documentation in the form of doctests.</p>
-</div>
-<div class="section" id="definitions">
-<h1><a class="toc-backref" href="#id4">Definitions</a></h1>
-<p>Technically speaking, any Python object which can be called with one argument
-can be used as  a decorator. However, this definition is somewhat too large
-to be really useful. It is more convenient to split the generic class of
-decorators in two subclasses:</p>
-<ul class="simple">
-<li><em>signature-preserving</em> decorators, i.e. callable objects taking a
-function as input and returning a function <em>with the same
-signature</em> as output;</li>
-<li><em>signature-changing</em> decorators, i.e. decorators that change
-the signature of their input function, or decorators returning
-non-callable objects.</li>
-</ul>
-<p>Signature-changing decorators have their use: for instance the
-builtin classes <tt class="docutils literal">staticmethod</tt> and <tt class="docutils literal">classmethod</tt> are in this
-group, since they take functions and return descriptor objects which
-are not functions, nor callables.</p>
-<p>However, signature-preserving decorators are more common and easier to
-reason about; in particular signature-preserving decorators can be
-composed together whereas other decorators in general cannot.</p>
-<p>Writing signature-preserving decorators from scratch is not that
-obvious, especially if one wants to define proper decorators that
-can accept functions with any signature. A simple example will clarify
-the issue.</p>
-</div>
-<div class="section" id="statement-of-the-problem">
-<h1><a class="toc-backref" href="#id5">Statement of the problem</a></h1>
-<p>A very common use case for decorators is the memoization of functions.
-A <tt class="docutils literal">memoize</tt> decorator works by caching
-the result of the function call in a dictionary, so that the next time
-the function is called with the same input parameters the result is retrieved
-from the cache and not recomputed. There are many implementations of
-<tt class="docutils literal">memoize</tt> in <a class="reference external" href="http://www.python.org/moin/PythonDecoratorLibrary">http://www.python.org/moin/PythonDecoratorLibrary</a>,
-but they do not preserve the signature.
-A simple implementation could be the following (notice
-that in general it is impossible to memoize correctly something
-that depends on non-hashable arguments):</p>
-<div class="codeblock python">
-<div class="highlight"><pre><span class="k">def</span> <span class="nf">memoize_uw</span><span class="p">(</span><span class="n">func</span><span class="p">):</span>
-    <span class="n">func</span><span class="o">.</span><span class="n">cache</span> <span class="o">=</span> <span class="p">{}</span>
-    <span class="k">def</span> <span class="nf">memoize</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">kw</span><span class="p">):</span>
-        <span class="k">if</span> <span class="n">kw</span><span class="p">:</span> <span class="c"># frozenset is used to ensure hashability</span>
-            <span class="n">key</span> <span class="o">=</span> <span class="n">args</span><span class="p">,</span> <span class="nb">frozenset</span><span class="p">(</span><span class="n">kw</span><span class="o">.</span><span class="n">iteritems</span><span class="p">())</span>
-        <span class="k">else</span><span class="p">:</span>
-            <span class="n">key</span> <span class="o">=</span> <span class="n">args</span>
-        <span class="n">cache</span> <span class="o">=</span> <span class="n">func</span><span class="o">.</span><span class="n">cache</span>
-        <span class="k">if</span> <span class="n">key</span> <span class="ow">in</span> <span class="n">cache</span><span class="p">:</span>
-            <span class="k">return</span> <span class="n">cache</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="n">cache</span><span class="p">[</span><span class="n">key</span><span class="p">]</span> <span class="o">=</span> <span class="n">result</span> <span class="o">=</span> <span class="n">func</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">kw</span><span class="p">)</span>
-            <span class="k">return</span> <span class="n">result</span>
-    <span class="k">return</span> <span class="n">functools</span><span class="o">.</span><span class="n">update_wrapper</span><span class="p">(</span><span class="n">memoize</span><span class="p">,</span> <span class="n">func</span><span class="p">)</span>
-</pre></div>
-
-</div>
-<p>Here we used the <a class="reference external" href="http://www.python.org/doc/2.5.2/lib/module-functools.html">functools.update_wrapper</a> utility, which has
-been added in Python 2.5 expressly to simplify the definition of decorators
-(in older versions of Python you need to copy the function attributes
-<tt class="docutils literal">__name__</tt>, <tt class="docutils literal">__doc__</tt>, <tt class="docutils literal">__module__</tt> and <tt class="docutils literal">__dict__</tt>
-from the original function to the decorated function by hand).</p>
-<p>The implementation above works in the sense that the decorator
-can accept functions with generic signatures; unfortunately this
-implementation does <em>not</em> define a signature-preserving decorator, since in
-general <tt class="docutils literal">memoize_uw</tt> returns a function with a
-<em>different signature</em> from the original function.</p>
-<p>Consider for instance the following case:</p>
-<div class="codeblock python">
-<div class="highlight"><pre><span class="o">&gt;&gt;&gt;</span> <span class="nd">@memoize_uw</span>
-<span class="o">...</span> <span class="k">def</span> <span class="nf">f1</span><span class="p">(</span><span class="n">x</span><span class="p">):</span>
-<span class="o">...</span>     <span class="n">time</span><span class="o">.</span><span class="n">sleep</span><span class="p">(</span><span class="mi">1</span><span class="p">)</span> <span class="c"># simulate some long computation</span>
-<span class="o">...</span>     <span class="k">return</span> <span class="n">x</span>
-</pre></div>
-
-</div>
-<p>Here the original function takes a single argument named <tt class="docutils literal">x</tt>,
-but the decorated function takes any number of arguments and
-keyword arguments:</p>
-<div class="codeblock python">
-<div class="highlight"><pre><span class="o">&gt;&gt;&gt;</span> <span class="kn">from</span> <span class="nn">inspect</span> <span class="kn">import</span> <span class="n">getargspec</span>
-<span class="o">&gt;&gt;&gt;</span> <span class="k">print</span> <span class="n">getargspec</span><span class="p">(</span><span class="n">f1</span><span class="p">)</span> <span class="c"># I am using Python 2.6+ here</span>
-<span class="n">ArgSpec</span><span class="p">(</span><span class="n">args</span><span class="o">=</span><span class="p">[],</span> <span class="n">varargs</span><span class="o">=</span><span class="s">&#39;args&#39;</span><span class="p">,</span> <span class="n">keywords</span><span class="o">=</span><span class="s">&#39;kw&#39;</span><span class="p">,</span> <span class="n">defaults</span><span class="o">=</span><span class="bp">None</span><span class="p">)</span>
-</pre></div>
-
-</div>
-<p>This means that introspection tools such as pydoc will give
-wrong informations about the signature of <tt class="docutils literal">f1</tt>. This is pretty bad:
-pydoc will tell you that the function accepts a generic signature
-<tt class="docutils literal">*args</tt>, <tt class="docutils literal">**kw</tt>, but when you try to call the function with more than an
-argument, you will get an error:</p>
-<div class="codeblock python">
-<div class="highlight"><pre><span class="o">&gt;&gt;&gt;</span> <span class="n">f1</span><span class="p">(</span><span class="mi">0</span><span class="p">,</span> <span class="mi">1</span><span class="p">)</span>
-<span class="n">Traceback</span> <span class="p">(</span><span class="n">most</span> <span class="n">recent</span> <span class="n">call</span> <span class="n">last</span><span class="p">):</span>
-   <span class="o">...</span>
-<span class="ne">TypeError</span><span class="p">:</span> <span class="n">f1</span><span class="p">()</span> <span class="n">takes</span> <span class="n">exactly</span> <span class="mi">1</span> <span class="n">argument</span> <span class="p">(</span><span class="mi">2</span> <span class="n">given</span><span class="p">)</span>
-</pre></div>
-
-</div>
-</div>
-<div class="section" id="the-solution">
-<h1><a class="toc-backref" href="#id6">The solution</a></h1>
-<p>The solution is to provide a generic factory of generators, which
-hides the complexity of making signature-preserving decorators
-from the application programmer. The <tt class="docutils literal">decorator</tt> function in
-the <tt class="docutils literal">decorator</tt> module is such a factory:</p>
-<div class="codeblock python">
-<div class="highlight"><pre><span class="o">&gt;&gt;&gt;</span> <span class="kn">from</span> <span class="nn">decorator</span> <span class="kn">import</span> <span class="n">decorator</span>
-</pre></div>
-
-</div>
-<p><tt class="docutils literal">decorator</tt> takes two arguments, a caller function describing the
-functionality of the decorator and a function to be decorated; it
-returns the decorated function. The caller function must have
-signature <tt class="docutils literal">(f, *args, **kw)</tt> and it must call the original function <tt class="docutils literal">f</tt>
-with arguments <tt class="docutils literal">args</tt> and <tt class="docutils literal">kw</tt>, implementing the wanted capability,
-i.e. memoization in this case:</p>
-<div class="codeblock python">
-<div class="highlight"><pre><span class="k">def</span> <span class="nf">_memoize</span><span class="p">(</span><span class="n">func</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">kw</span><span class="p">):</span>
-    <span class="k">if</span> <span class="n">kw</span><span class="p">:</span> <span class="c"># frozenset is used to ensure hashability</span>
-        <span class="n">key</span> <span class="o">=</span> <span class="n">args</span><span class="p">,</span> <span class="nb">frozenset</span><span class="p">(</span><span class="n">kw</span><span class="o">.</span><span class="n">iteritems</span><span class="p">())</span>
-    <span class="k">else</span><span class="p">:</span>
-        <span class="n">key</span> <span class="o">=</span> <span class="n">args</span>
-    <span class="n">cache</span> <span class="o">=</span> <span class="n">func</span><span class="o">.</span><span class="n">cache</span> <span class="c"># attributed added by memoize</span>
-    <span class="k">if</span> <span class="n">key</span> <span class="ow">in</span> <span class="n">cache</span><span class="p">:</span>
-        <span class="k">return</span> <span class="n">cache</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="n">cache</span><span class="p">[</span><span class="n">key</span><span class="p">]</span> <span class="o">=</span> <span class="n">result</span> <span class="o">=</span> <span class="n">func</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">kw</span><span class="p">)</span>
-        <span class="k">return</span> <span class="n">result</span>
-</pre></div>
-
-</div>
-<p>At this point you can define your decorator as follows:</p>
-<div class="codeblock python">
-<div class="highlight"><pre><span class="k">def</span> <span class="nf">memoize</span><span class="p">(</span><span class="n">f</span><span class="p">):</span>
-    <span class="n">f</span><span class="o">.</span><span class="n">cache</span> <span class="o">=</span> <span class="p">{}</span>
-    <span class="k">return</span> <span class="n">decorator</span><span class="p">(</span><span class="n">_memoize</span><span class="p">,</span> <span class="n">f</span><span class="p">)</span>
-</pre></div>
-
-</div>
-<p>The difference with respect to the <tt class="docutils literal">memoize_uw</tt> approach, which is based
-on nested functions, is that the decorator module forces you to lift
-the inner function at the outer level (<em>flat is better than nested</em>).
-Moreover, you are forced to pass explicitly the function you want to
-decorate to the caller function.</p>
-<p>Here is a test of usage:</p>
-<div class="codeblock python">
-<div class="highlight"><pre><span class="o">&gt;&gt;&gt;</span> <span class="nd">@memoize</span>
-<span class="o">...</span> <span class="k">def</span> <span class="nf">heavy_computation</span><span class="p">():</span>
-<span class="o">...</span>     <span class="n">time</span><span class="o">.</span><span class="n">sleep</span><span class="p">(</span><span class="mi">2</span><span class="p">)</span>
-<span class="o">...</span>     <span class="k">return</span> <span class="s">&quot;done&quot;</span>
-
-<span class="o">&gt;&gt;&gt;</span> <span class="k">print</span> <span class="n">heavy_computation</span><span class="p">()</span> <span class="c"># the first time it will take 2 seconds</span>
-<span class="n">done</span>
-
-<span class="o">&gt;&gt;&gt;</span> <span class="k">print</span> <span class="n">heavy_computation</span><span class="p">()</span> <span class="c"># the second time it will be instantaneous</span>
-<span class="n">done</span>
-</pre></div>
-
-</div>
-<p>The signature of <tt class="docutils literal">heavy_computation</tt> is the one you would expect:</p>
-<div class="codeblock python">
-<div class="highlight"><pre><span class="o">&gt;&gt;&gt;</span> <span class="k">print</span> <span class="n">getargspec</span><span class="p">(</span><span class="n">heavy_computation</span><span class="p">)</span>
-<span class="n">ArgSpec</span><span class="p">(</span><span class="n">args</span><span class="o">=</span><span class="p">[],</span> <span class="n">varargs</span><span class="o">=</span><span class="bp">None</span><span class="p">,</span> <span class="n">keywords</span><span class="o">=</span><span class="bp">None</span><span class="p">,</span> <span class="n">defaults</span><span class="o">=</span><span class="bp">None</span><span class="p">)</span>
-</pre></div>
-
-</div>
-</div>
-<div class="section" id="a-trace-decorator">
-<h1><a class="toc-backref" href="#id7">A <tt class="docutils literal">trace</tt> decorator</a></h1>
-<p>As an additional example, here is how you can define a trivial
-<tt class="docutils literal">trace</tt> decorator, which prints a message everytime the traced
-function is called:</p>
-<div class="codeblock python">
-<div class="highlight"><pre><span class="k">def</span> <span class="nf">_trace</span><span class="p">(</span><span class="n">f</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">kw</span><span class="p">):</span>
-    <span class="k">print</span> <span class="s">&quot;calling </span><span class="si">%s</span><span class="s"> with args </span><span class="si">%s</span><span class="s">, </span><span class="si">%s</span><span class="s">&quot;</span> <span class="o">%</span> <span class="p">(</span><span class="n">f</span><span class="o">.</span><span class="n">__name__</span><span class="p">,</span> <span class="n">args</span><span class="p">,</span> <span class="n">kw</span><span class="p">)</span>
-    <span class="k">return</span> <span class="n">f</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">kw</span><span class="p">)</span>
-</pre></div>
-
-</div>
-<div class="codeblock python">
-<div class="highlight"><pre><span class="k">def</span> <span class="nf">trace</span><span class="p">(</span><span class="n">f</span><span class="p">):</span>
-    <span class="k">return</span> <span class="n">decorator</span><span class="p">(</span><span class="n">_trace</span><span class="p">,</span> <span class="n">f</span><span class="p">)</span>
-</pre></div>
-
-</div>
-<p>Here is an example of usage:</p>
-<div class="codeblock python">
-<div class="highlight"><pre><span class="o">&gt;&gt;&gt;</span> <span class="nd">@trace</span>
-<span class="o">...</span> <span class="k">def</span> <span class="nf">f1</span><span class="p">(</span><span class="n">x</span><span class="p">):</span>
-<span class="o">...</span>     <span class="k">pass</span>
-</pre></div>
-
-</div>
-<p>It is immediate to verify that <tt class="docutils literal">f1</tt> works</p>
-<div class="codeblock python">
-<div class="highlight"><pre><span class="o">&gt;&gt;&gt;</span> <span class="n">f1</span><span class="p">(</span><span class="mi">0</span><span class="p">)</span>
-<span class="n">calling</span> <span class="n">f1</span> <span class="k">with</span> <span class="n">args</span> <span class="p">(</span><span class="mi">0</span><span class="p">,),</span> <span class="p">{}</span>
-</pre></div>
-
-</div>
-<p>and it that it has the correct signature:</p>
-<div class="codeblock python">
-<div class="highlight"><pre><span class="o">&gt;&gt;&gt;</span> <span class="k">print</span> <span class="n">getargspec</span><span class="p">(</span><span class="n">f1</span><span class="p">)</span>
-<span class="n">ArgSpec</span><span class="p">(</span><span class="n">args</span><span class="o">=</span><span class="p">[</span><span class="s">&#39;x&#39;</span><span class="p">],</span> <span class="n">varargs</span><span class="o">=</span><span class="bp">None</span><span class="p">,</span> <span class="n">keywords</span><span class="o">=</span><span class="bp">None</span><span class="p">,</span> <span class="n">defaults</span><span class="o">=</span><span class="bp">None</span><span class="p">)</span>
-</pre></div>
-
-</div>
-<p>The same decorator works with functions of any signature:</p>
-<div class="codeblock python">
-<div class="highlight"><pre><span class="o">&gt;&gt;&gt;</span> <span class="nd">@trace</span>
-<span class="o">...</span> <span class="k">def</span> <span class="nf">f</span><span class="p">(</span><span class="n">x</span><span class="p">,</span> <span class="n">y</span><span class="o">=</span><span class="mi">1</span><span class="p">,</span> <span class="n">z</span><span class="o">=</span><span class="mi">2</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">kw</span><span class="p">):</span>
-<span class="o">...</span>     <span class="k">pass</span>
-
-<span class="o">&gt;&gt;&gt;</span> <span class="n">f</span><span class="p">(</span><span class="mi">0</span><span class="p">,</span> <span class="mi">3</span><span class="p">)</span>
-<span class="n">calling</span> <span class="n">f</span> <span class="k">with</span> <span class="n">args</span> <span class="p">(</span><span class="mi">0</span><span class="p">,</span> <span class="mi">3</span><span class="p">,</span> <span class="mi">2</span><span class="p">),</span> <span class="p">{}</span>
-
-<span class="o">&gt;&gt;&gt;</span> <span class="k">print</span> <span class="n">getargspec</span><span class="p">(</span><span class="n">f</span><span class="p">)</span>
-<span class="n">ArgSpec</span><span class="p">(</span><span class="n">args</span><span class="o">=</span><span class="p">[</span><span class="s">&#39;x&#39;</span><span class="p">,</span> <span class="s">&#39;y&#39;</span><span class="p">,</span> <span class="s">&#39;z&#39;</span><span class="p">],</span> <span class="n">varargs</span><span class="o">=</span><span class="s">&#39;args&#39;</span><span class="p">,</span> <span class="n">keywords</span><span class="o">=</span><span class="s">&#39;kw&#39;</span><span class="p">,</span> <span class="n">defaults</span><span class="o">=</span><span class="p">(</span><span class="mi">1</span><span class="p">,</span> <span class="mi">2</span><span class="p">))</span>
-</pre></div>
-
-</div>
-<p>That includes even functions with exotic signatures like the following:</p>
-<div class="codeblock python">
-<div class="highlight"><pre><span class="o">&gt;&gt;&gt;</span> <span class="nd">@trace</span>
-<span class="o">...</span> <span class="k">def</span> <span class="nf">exotic_signature</span><span class="p">((</span><span class="n">x</span><span class="p">,</span> <span class="n">y</span><span class="p">)</span><span class="o">=</span><span class="p">(</span><span class="mi">1</span><span class="p">,</span><span class="mi">2</span><span class="p">)):</span> <span class="k">return</span> <span class="n">x</span><span class="o">+</span><span class="n">y</span>
-
-<span class="o">&gt;&gt;&gt;</span> <span class="k">print</span> <span class="n">getargspec</span><span class="p">(</span><span class="n">exotic_signature</span><span class="p">)</span>
-<span class="n">ArgSpec</span><span class="p">(</span><span class="n">args</span><span class="o">=</span><span class="p">[[</span><span class="s">&#39;x&#39;</span><span class="p">,</span> <span class="s">&#39;y&#39;</span><span class="p">]],</span> <span class="n">varargs</span><span class="o">=</span><span class="bp">None</span><span class="p">,</span> <span class="n">keywords</span><span class="o">=</span><span class="bp">None</span><span class="p">,</span> <span class="n">defaults</span><span class="o">=</span><span class="p">((</span><span class="mi">1</span><span class="p">,</span> <span class="mi">2</span><span class="p">),))</span>
-<span class="o">&gt;&gt;&gt;</span> <span class="n">exotic_signature</span><span class="p">()</span>
-<span class="n">calling</span> <span class="n">exotic_signature</span> <span class="k">with</span> <span class="n">args</span> <span class="p">((</span><span class="mi">1</span><span class="p">,</span> <span class="mi">2</span><span class="p">),),</span> <span class="p">{}</span>
-<span class="mi">3</span>
-</pre></div>
-
-</div>
-<p>Notice that the support for exotic signatures has been deprecated
-in Python 2.6 and removed in Python 3.0.</p>
-</div>
-<div class="section" id="decorator-is-a-decorator">
-<h1><a class="toc-backref" href="#id8"><tt class="docutils literal">decorator</tt> is a decorator</a></h1>
-<p>It may be annoying to write a caller function (like the <tt class="docutils literal">_trace</tt>
-function above) and then a trivial wrapper
-(<tt class="docutils literal">def trace(f): return decorator(_trace, f)</tt>) every time. For this reason,
-the <tt class="docutils literal">decorator</tt> module provides an easy shortcut to convert
-the caller function into a signature-preserving decorator:
-you can just call <tt class="docutils literal">decorator</tt> with a single argument.
-In our example you can just write <tt class="docutils literal">trace = decorator(_trace)</tt>.
-The <tt class="docutils literal">decorator</tt> function can also be used as a signature-changing
-decorator, just as <tt class="docutils literal">classmethod</tt> and <tt class="docutils literal">staticmethod</tt>.
-However, <tt class="docutils literal">classmethod</tt> and <tt class="docutils literal">staticmethod</tt> return generic
-objects which are not callable, while <tt class="docutils literal">decorator</tt> returns
-signature-preserving decorators, i.e. functions of a single argument.
-For instance, you can write directly</p>
-<div class="codeblock python">
-<div class="highlight"><pre><span class="o">&gt;&gt;&gt;</span> <span class="nd">@decorator</span>
-<span class="o">...</span> <span class="k">def</span> <span class="nf">trace</span><span class="p">(</span><span class="n">f</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">kw</span><span class="p">):</span>
-<span class="o">...</span>     <span class="k">print</span> <span class="s">&quot;calling </span><span class="si">%s</span><span class="s"> with args </span><span class="si">%s</span><span class="s">, </span><span class="si">%s</span><span class="s">&quot;</span> <span class="o">%</span> <span class="p">(</span><span class="n">f</span><span class="o">.</span><span class="n">func_name</span><span class="p">,</span> <span class="n">args</span><span class="p">,</span> <span class="n">kw</span><span class="p">)</span>
-<span class="o">...</span>     <span class="k">return</span> <span class="n">f</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">kw</span><span class="p">)</span>
-</pre></div>
-
-</div>
-<p>and now <tt class="docutils literal">trace</tt> will be a decorator. Actually <tt class="docutils literal">trace</tt> is a <tt class="docutils literal">partial</tt>
-object which can be used as a decorator:</p>
-<div class="codeblock python">
-<div class="highlight"><pre><span class="o">&gt;&gt;&gt;</span> <span class="n">trace</span>
-<span class="o">&lt;</span><span class="n">function</span> <span class="n">trace</span> <span class="n">at</span> <span class="mi">0</span><span class="n">x</span><span class="o">...&gt;</span>
-</pre></div>
-
-</div>
-<p>Here is an example of usage:</p>
-<div class="codeblock python">
-<div class="highlight"><pre><span class="o">&gt;&gt;&gt;</span> <span class="nd">@trace</span>
-<span class="o">...</span> <span class="k">def</span> <span class="nf">func</span><span class="p">():</span> <span class="k">pass</span>
-
-<span class="o">&gt;&gt;&gt;</span> <span class="n">func</span><span class="p">()</span>
-<span class="n">calling</span> <span class="n">func</span> <span class="k">with</span> <span class="n">args</span> <span class="p">(),</span> <span class="p">{}</span>
-</pre></div>
-
-</div>
-<p>If you are using an old Python version (Python 2.4) the
-<tt class="docutils literal">decorator</tt> module provides a poor man replacement for
-<tt class="docutils literal">functools.partial</tt>.</p>
-</div>
-<div class="section" id="blocking">
-<h1><a class="toc-backref" href="#id9"><tt class="docutils literal">blocking</tt></a></h1>
-<p>Sometimes one has to deal with blocking resources, such as <tt class="docutils literal">stdin</tt>, and
-sometimes it is best to have back a &quot;busy&quot; message than to block everything.
-This behavior can be implemented with a suitable family of decorators,
-where the parameter is the busy message:</p>
-<div class="codeblock python">
-<div class="highlight"><pre><span class="k">def</span> <span class="nf">blocking</span><span class="p">(</span><span class="n">not_avail</span><span class="p">):</span>
-    <span class="k">def</span> <span class="nf">blocking</span><span class="p">(</span><span class="n">f</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">kw</span><span class="p">):</span>
-        <span class="k">if</span> <span class="ow">not</span> <span class="nb">hasattr</span><span class="p">(</span><span class="n">f</span><span class="p">,</span> <span class="s">&quot;thread&quot;</span><span class="p">):</span> <span class="c"># no thread running</span>
-            <span class="k">def</span> <span class="nf">set_result</span><span class="p">():</span> <span class="n">f</span><span class="o">.</span><span class="n">result</span> <span class="o">=</span> <span class="n">f</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">kw</span><span class="p">)</span>
-            <span class="n">f</span><span class="o">.</span><span class="n">thread</span> <span class="o">=</span> <span class="n">threading</span><span class="o">.</span><span class="n">Thread</span><span class="p">(</span><span class="bp">None</span><span class="p">,</span> <span class="n">set_result</span><span class="p">)</span>
-            <span class="n">f</span><span class="o">.</span><span class="n">thread</span><span class="o">.</span><span class="n">start</span><span class="p">()</span>
-            <span class="k">return</span> <span class="n">not_avail</span>
-        <span class="k">elif</span> <span class="n">f</span><span class="o">.</span><span class="n">thread</span><span class="o">.</span><span class="n">isAlive</span><span class="p">():</span>
-            <span class="k">return</span> <span class="n">not_avail</span>
-        <span class="k">else</span><span class="p">:</span> <span class="c"># the thread is ended, return the stored result</span>
-            <span class="k">del</span> <span class="n">f</span><span class="o">.</span><span class="n">thread</span>
-            <span class="k">return</span> <span class="n">f</span><span class="o">.</span><span class="n">result</span>
-    <span class="k">return</span> <span class="n">decorator</span><span class="p">(</span><span class="n">blocking</span><span class="p">)</span>
-</pre></div>
-
-</div>
-<p>Functions decorated with <tt class="docutils literal">blocking</tt> will return a busy message if
-the resource is unavailable, and the intended result if the resource is
-available. For instance:</p>
-<div class="codeblock python">
-<div class="highlight"><pre><span class="o">&gt;&gt;&gt;</span> <span class="nd">@blocking</span><span class="p">(</span><span class="s">&quot;Please wait ...&quot;</span><span class="p">)</span>
-<span class="o">...</span> <span class="k">def</span> <span class="nf">read_data</span><span class="p">():</span>
-<span class="o">...</span>     <span class="n">time</span><span class="o">.</span><span class="n">sleep</span><span class="p">(</span><span class="mi">3</span><span class="p">)</span> <span class="c"># simulate a blocking resource</span>
-<span class="o">...</span>     <span class="k">return</span> <span class="s">&quot;some data&quot;</span>
-
-<span class="o">&gt;&gt;&gt;</span> <span class="k">print</span> <span class="n">read_data</span><span class="p">()</span> <span class="c"># data is not available yet</span>
-<span class="n">Please</span> <span class="n">wait</span> <span class="o">...</span>
-
-<span class="o">&gt;&gt;&gt;</span> <span class="n">time</span><span class="o">.</span><span class="n">sleep</span><span class="p">(</span><span class="mi">1</span><span class="p">)</span>
-<span class="o">&gt;&gt;&gt;</span> <span class="k">print</span> <span class="n">read_data</span><span class="p">()</span> <span class="c"># data is not available yet</span>
-<span class="n">Please</span> <span class="n">wait</span> <span class="o">...</span>
-
-<span class="o">&gt;&gt;&gt;</span> <span class="n">time</span><span class="o">.</span><span class="n">sleep</span><span class="p">(</span><span class="mi">1</span><span class="p">)</span>
-<span class="o">&gt;&gt;&gt;</span> <span class="k">print</span> <span class="n">read_data</span><span class="p">()</span> <span class="c"># data is not available yet</span>
-<span class="n">Please</span> <span class="n">wait</span> <span class="o">...</span>
-
-<span class="o">&gt;&gt;&gt;</span> <span class="n">time</span><span class="o">.</span><span class="n">sleep</span><span class="p">(</span><span class="mf">1.1</span><span class="p">)</span> <span class="c"># after 3.1 seconds, data is available</span>
-<span class="o">&gt;&gt;&gt;</span> <span class="k">print</span> <span class="n">read_data</span><span class="p">()</span>
-<span class="n">some</span> <span class="n">data</span>
-</pre></div>
-
-</div>
-</div>
-<div class="section" id="async">
-<h1><a class="toc-backref" href="#id10"><tt class="docutils literal">async</tt></a></h1>
-<p>We have just seen an examples of a simple decorator factory,
-implemented as a function returning a decorator.
-For more complex situations, it is more
-convenient to implement decorator factories as classes returning
-callable objects that can be converted into decorators.</p>
-<p>As an example, here will I show a decorator
-which is able to convert a blocking function into an asynchronous
-function. The function, when called,
-is executed in a separate thread. Moreover, it is possible to set
-three callbacks <tt class="docutils literal">on_success</tt>, <tt class="docutils literal">on_failure</tt> and <tt class="docutils literal">on_closing</tt>,
-to specify how to manage the function call (of course the code here
-is just an example, it is not a recommended way of doing multi-threaded
-programming). The implementation is the following:</p>
-<div class="codeblock python">
-<div class="highlight"><pre><span class="k">def</span> <span class="nf">on_success</span><span class="p">(</span><span class="n">result</span><span class="p">):</span> <span class="c"># default implementation</span>
-    <span class="s">&quot;Called on the result of the function&quot;</span>
-    <span class="k">return</span> <span class="n">result</span>
-</pre></div>
-
-</div>
-<div class="codeblock python">
-<div class="highlight"><pre><span class="k">def</span> <span class="nf">on_failure</span><span class="p">(</span><span class="n">exc_info</span><span class="p">):</span> <span class="c"># default implementation</span>
-    <span class="s">&quot;Called if the function fails&quot;</span>
-    <span class="k">pass</span>
-</pre></div>
-
-</div>
-<div class="codeblock python">
-<div class="highlight"><pre><span class="k">def</span> <span class="nf">on_closing</span><span class="p">():</span> <span class="c"># default implementation</span>
-    <span class="s">&quot;Called at the end, both in case of success and failure&quot;</span>
-    <span class="k">pass</span>
-</pre></div>
-
-</div>
-<div class="codeblock python">
-<div class="highlight"><pre><span class="k">class</span> <span class="nc">Async</span><span class="p">(</span><span class="nb">object</span><span class="p">):</span>
-    <span class="sd">&quot;&quot;&quot;</span>
-<span class="sd">    A decorator converting blocking functions into asynchronous</span>
-<span class="sd">    functions, by using threads or processes. Examples:</span>
-
-<span class="sd">    async_with_threads =  Async(threading.Thread)</span>
-<span class="sd">    async_with_processes =  Async(multiprocessing.Process)</span>
-<span class="sd">    &quot;&quot;&quot;</span>
-
-    <span class="k">def</span> <span class="nf">__init__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">threadfactory</span><span class="p">,</span> <span class="n">on_success</span><span class="o">=</span><span class="n">on_success</span><span class="p">,</span>
-                 <span class="n">on_failure</span><span class="o">=</span><span class="n">on_failure</span><span class="p">,</span> <span class="n">on_closing</span><span class="o">=</span><span class="n">on_closing</span><span class="p">):</span>
-        <span class="bp">self</span><span class="o">.</span><span class="n">threadfactory</span> <span class="o">=</span> <span class="n">threadfactory</span>
-        <span class="bp">self</span><span class="o">.</span><span class="n">on_success</span> <span class="o">=</span> <span class="n">on_success</span>
-        <span class="bp">self</span><span class="o">.</span><span class="n">on_failure</span> <span class="o">=</span> <span class="n">on_failure</span>
-        <span class="bp">self</span><span class="o">.</span><span class="n">on_closing</span> <span class="o">=</span> <span class="n">on_closing</span>
-
-    <span class="k">def</span> <span class="nf">__call__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">func</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">kw</span><span class="p">):</span>
-        <span class="k">try</span><span class="p">:</span>
-            <span class="n">counter</span> <span class="o">=</span> <span class="n">func</span><span class="o">.</span><span class="n">counter</span>
-        <span class="k">except</span> <span class="ne">AttributeError</span><span class="p">:</span> <span class="c"># instantiate the counter at the first call</span>
-            <span class="n">counter</span> <span class="o">=</span> <span class="n">func</span><span class="o">.</span><span class="n">counter</span> <span class="o">=</span> <span class="n">itertools</span><span class="o">.</span><span class="n">count</span><span class="p">(</span><span class="mi">1</span><span class="p">)</span>
-        <span class="n">name</span> <span class="o">=</span> <span class="s">&#39;</span><span class="si">%s</span><span class="s">-</span><span class="si">%s</span><span class="s">&#39;</span> <span class="o">%</span> <span class="p">(</span><span class="n">func</span><span class="o">.</span><span class="n">__name__</span><span class="p">,</span> <span class="n">counter</span><span class="o">.</span><span class="n">next</span><span class="p">())</span>
-        <span class="k">def</span> <span class="nf">func_wrapper</span><span class="p">():</span>
-            <span class="k">try</span><span class="p">:</span>
-                <span class="n">result</span> <span class="o">=</span> <span class="n">func</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">kw</span><span class="p">)</span>
-            <span class="k">except</span><span class="p">:</span>
-                <span class="bp">self</span><span class="o">.</span><span class="n">on_failure</span><span class="p">(</span><span class="n">sys</span><span class="o">.</span><span class="n">exc_info</span><span class="p">())</span>
-            <span class="k">else</span><span class="p">:</span>
-                <span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="n">on_success</span><span class="p">(</span><span class="n">result</span><span class="p">)</span>
-            <span class="k">finally</span><span class="p">:</span>
-                <span class="bp">self</span><span class="o">.</span><span class="n">on_closing</span><span class="p">()</span>
-        <span class="n">thread</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="n">threadfactory</span><span class="p">(</span><span class="bp">None</span><span class="p">,</span> <span class="n">func_wrapper</span><span class="p">,</span> <span class="n">name</span><span class="p">)</span>
-        <span class="n">thread</span><span class="o">.</span><span class="n">start</span><span class="p">()</span>
-        <span class="k">return</span> <span class="n">thread</span>
-</pre></div>
-
-</div>
-<p>The decorated function returns
-the current execution thread, which can be stored and checked later, for
-instance to verify that the thread <tt class="docutils literal">.isAlive()</tt>.</p>
-<p>Here is an example of usage. Suppose one wants to write some data to
-an external resource which can be accessed by a single user at once
-(for instance a printer). Then the access to the writing function must
-be locked. Here is a minimalistic example:</p>
-<div class="codeblock python">
-<div class="highlight"><pre><span class="o">&gt;&gt;&gt;</span> <span class="n">async</span> <span class="o">=</span> <span class="n">decorator</span><span class="p">(</span><span class="n">Async</span><span class="p">(</span><span class="n">threading</span><span class="o">.</span><span class="n">Thread</span><span class="p">))</span>
-
-<span class="o">&gt;&gt;&gt;</span> <span class="n">datalist</span> <span class="o">=</span> <span class="p">[]</span> <span class="c"># for simplicity the written data are stored into a list.</span>
-
-<span class="o">&gt;&gt;&gt;</span> <span class="nd">@async</span>
-<span class="o">...</span> <span class="k">def</span> <span class="nf">write</span><span class="p">(</span><span class="n">data</span><span class="p">):</span>
-<span class="o">...</span>     <span class="c"># append data to the datalist by locking</span>
-<span class="o">...</span>     <span class="k">with</span> <span class="n">threading</span><span class="o">.</span><span class="n">Lock</span><span class="p">():</span>
-<span class="o">...</span>         <span class="n">time</span><span class="o">.</span><span class="n">sleep</span><span class="p">(</span><span class="mi">1</span><span class="p">)</span> <span class="c"># emulate some long running operation</span>
-<span class="o">...</span>         <span class="n">datalist</span><span class="o">.</span><span class="n">append</span><span class="p">(</span><span class="n">data</span><span class="p">)</span>
-<span class="o">...</span>     <span class="c"># other operations not requiring a lock here</span>
-</pre></div>
-
-</div>
-<p>Each call to <tt class="docutils literal">write</tt> will create a new writer thread, but there will
-be no synchronization problems since <tt class="docutils literal">write</tt> is locked.</p>
-<div class="codeblock python">
-<div class="highlight"><pre><span class="o">&gt;&gt;&gt;</span> <span class="n">write</span><span class="p">(</span><span class="s">&quot;data1&quot;</span><span class="p">)</span>
-<span class="o">&lt;</span><span class="n">Thread</span><span class="p">(</span><span class="n">write</span><span class="o">-</span><span class="mi">1</span><span class="p">,</span> <span class="n">started</span><span class="o">...</span><span class="p">)</span><span class="o">&gt;</span>
-
-<span class="o">&gt;&gt;&gt;</span> <span class="n">time</span><span class="o">.</span><span class="n">sleep</span><span class="p">(</span><span class="o">.</span><span class="mi">1</span><span class="p">)</span> <span class="c"># wait a bit, so we are sure data2 is written after data1</span>
-
-<span class="o">&gt;&gt;&gt;</span> <span class="n">write</span><span class="p">(</span><span class="s">&quot;data2&quot;</span><span class="p">)</span>
-<span class="o">&lt;</span><span class="n">Thread</span><span class="p">(</span><span class="n">write</span><span class="o">-</span><span class="mi">2</span><span class="p">,</span> <span class="n">started</span><span class="o">...</span><span class="p">)</span><span class="o">&gt;</span>
-
-<span class="o">&gt;&gt;&gt;</span> <span class="n">time</span><span class="o">.</span><span class="n">sleep</span><span class="p">(</span><span class="mi">2</span><span class="p">)</span> <span class="c"># wait for the writers to complete</span>
-
-<span class="o">&gt;&gt;&gt;</span> <span class="k">print</span> <span class="n">datalist</span>
-<span class="p">[</span><span class="s">&#39;data1&#39;</span><span class="p">,</span> <span class="s">&#39;data2&#39;</span><span class="p">]</span>
-</pre></div>
-
-</div>
-</div>
-<div class="section" id="contextmanager">
-<h1><a class="toc-backref" href="#id11">contextmanager</a></h1>
-<p>For a long time Python had in its standard library a <tt class="docutils literal">contextmanager</tt>
-decorator, able to convert generator functions into <tt class="docutils literal">GeneratorContextManager</tt>
-factories. For instance if you write</p>
-<div class="codeblock python">
-<div class="highlight"><pre><span class="o">&gt;&gt;&gt;</span> <span class="kn">from</span> <span class="nn">contextlib</span> <span class="kn">import</span> <span class="n">contextmanager</span>
-<span class="o">&gt;&gt;&gt;</span> <span class="nd">@contextmanager</span>
-<span class="o">...</span> <span class="k">def</span> <span class="nf">before_after</span><span class="p">(</span><span class="n">before</span><span class="p">,</span> <span class="n">after</span><span class="p">):</span>
-<span class="o">...</span>     <span class="k">print</span><span class="p">(</span><span class="n">before</span><span class="p">)</span>
-<span class="o">...</span>     <span class="k">yield</span>
-<span class="o">...</span>     <span class="k">print</span><span class="p">(</span><span class="n">after</span><span class="p">)</span>
-</pre></div>
-
-</div>
-<p>then <tt class="docutils literal">before_after</tt> is a factory function returning
-<tt class="docutils literal">GeneratorContextManager</tt> objects which can be used with
-the <tt class="docutils literal">with</tt> statement:</p>
-<div class="codeblock python">
-<div class="highlight"><pre><span class="o">&gt;&gt;&gt;</span> <span class="n">ba</span> <span class="o">=</span> <span class="n">before_after</span><span class="p">(</span><span class="s">&#39;BEFORE&#39;</span><span class="p">,</span> <span class="s">&#39;AFTER&#39;</span><span class="p">)</span>
-<span class="o">&gt;&gt;&gt;</span> <span class="nb">type</span><span class="p">(</span><span class="n">ba</span><span class="p">)</span>
-<span class="o">&lt;</span><span class="k">class</span> <span class="err">&#39;</span><span class="nc">contextlib</span><span class="o">.</span><span class="n">GeneratorContextManager</span><span class="s">&#39;&gt;</span>
-<span class="o">&gt;&gt;&gt;</span> <span class="k">with</span> <span class="n">ba</span><span class="p">:</span>
-<span class="o">...</span>     <span class="k">print</span> <span class="s">&#39;hello&#39;</span>
-<span class="n">BEFORE</span>
-<span class="n">hello</span>
-<span class="n">AFTER</span>
-</pre></div>
-
-</div>
-<p>Basically, it is as if the content of the <tt class="docutils literal">with</tt> block was executed
-in the place of the <tt class="docutils literal">yield</tt> expression in the generator function.
-In Python 3.2 <tt class="docutils literal">GeneratorContextManager</tt>
-objects were enhanced with a <tt class="docutils literal">__call__</tt>
-method, so that they can be used as decorators as in this example:</p>
-<div class="codeblock python">
-<div class="highlight"><pre><span class="o">&gt;&gt;&gt;</span> <span class="nd">@ba</span>
-<span class="o">...</span> <span class="k">def</span> <span class="nf">hello</span><span class="p">():</span>
-<span class="o">...</span>     <span class="k">print</span> <span class="s">&#39;hello&#39;</span>
-<span class="o">...</span>
-<span class="o">&gt;&gt;&gt;</span> <span class="n">hello</span><span class="p">()</span>
-<span class="n">BEFORE</span>
-<span class="n">hello</span>
-<span class="n">AFTER</span>
-</pre></div>
-
-</div>
-<p>The <tt class="docutils literal">ba</tt> decorator is basically inserting a <tt class="docutils literal">with ba:</tt>
-block inside the function.
-However there two issues: the first is that <tt class="docutils literal">GeneratorContextManager</tt>
-objects are callable only in Python 3.2, so the previous example will break
-in older versions of Python; the second is that
-<tt class="docutils literal">GeneratorContextManager</tt> objects do not preserve the signature
-of the decorated functions: the decorated <tt class="docutils literal">hello</tt> function here will have
-a generic signature <tt class="docutils literal"><span class="pre">hello(*args,</span> **kwargs)</tt> but will break when
-called with more than zero arguments. For such reasons the decorator
-module, starting with release 3.4, offers a <tt class="docutils literal">decorator.contextmanager</tt>
-decorator that solves both problems and works even in Python 2.5.
-The usage is the same and factories decorated with <tt class="docutils literal">decorator.contextmanager</tt>
-will returns instances of <tt class="docutils literal">ContextManager</tt>, a subclass of
-<tt class="docutils literal">contextlib.GeneratorContextManager</tt> with a <tt class="docutils literal">__call__</tt> method
-acting as a signature-preserving decorator.</p>
-</div>
-<div class="section" id="the-functionmaker-class">
-<h1><a class="toc-backref" href="#id12">The <tt class="docutils literal">FunctionMaker</tt> class</a></h1>
-<p>You may wonder about how the functionality of the <tt class="docutils literal">decorator</tt> module
-is implemented. The basic building block is
-a <tt class="docutils literal">FunctionMaker</tt> class which is able to generate on the fly
-functions with a given name and signature from a function template
-passed as a string. Generally speaking, you should not need to
-resort to <tt class="docutils literal">FunctionMaker</tt> when writing ordinary decorators, but
-it is handy in some circumstances. You will see an example shortly, in
-the implementation of a cool decorator utility (<tt class="docutils literal">decorator_apply</tt>).</p>
-<p><tt class="docutils literal">FunctionMaker</tt> provides a <tt class="docutils literal">.create</tt> classmethod which
-takes as input the name, signature, and body of the function
-we want to generate as well as the execution environment
-were the function is generated by <tt class="docutils literal">exec</tt>. Here is an example:</p>
-<div class="codeblock python">
-<div class="highlight"><pre><span class="o">&gt;&gt;&gt;</span> <span class="k">def</span> <span class="nf">f</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">kw</span><span class="p">):</span> <span class="c"># a function with a generic signature</span>
-<span class="o">...</span>     <span class="k">print</span> <span class="n">args</span><span class="p">,</span> <span class="n">kw</span>
-
-<span class="o">&gt;&gt;&gt;</span> <span class="n">f1</span> <span class="o">=</span> <span class="n">FunctionMaker</span><span class="o">.</span><span class="n">create</span><span class="p">(</span><span class="s">&#39;f1(a, b)&#39;</span><span class="p">,</span> <span class="s">&#39;f(a, b)&#39;</span><span class="p">,</span> <span class="nb">dict</span><span class="p">(</span><span class="n">f</span><span class="o">=</span><span class="n">f</span><span class="p">))</span>
-<span class="o">&gt;&gt;&gt;</span> <span class="n">f1</span><span class="p">(</span><span class="mi">1</span><span class="p">,</span><span class="mi">2</span><span class="p">)</span>
-<span class="p">(</span><span class="mi">1</span><span class="p">,</span> <span class="mi">2</span><span class="p">)</span> <span class="p">{}</span>
-</pre></div>
-
-</div>
-<p>It is important to notice that the function body is interpolated
-before being executed, so be careful with the <tt class="docutils literal">%</tt> sign!</p>
-<p><tt class="docutils literal">FunctionMaker.create</tt> also accepts keyword arguments and such
-arguments are attached to the resulting function. This is useful
-if you want to set some function attributes, for instance the
-docstring <tt class="docutils literal">__doc__</tt>.</p>
-<p>For debugging/introspection purposes it may be useful to see
-the source code of the generated function; to do that, just
-pass the flag <tt class="docutils literal">addsource=True</tt> and a <tt class="docutils literal">__source__</tt> attribute will
-be added to the generated function:</p>
-<div class="codeblock python">
-<div class="highlight"><pre><span class="o">&gt;&gt;&gt;</span> <span class="n">f1</span> <span class="o">=</span> <span class="n">FunctionMaker</span><span class="o">.</span><span class="n">create</span><span class="p">(</span>
-<span class="o">...</span>     <span class="s">&#39;f1(a, b)&#39;</span><span class="p">,</span> <span class="s">&#39;f(a, b)&#39;</span><span class="p">,</span> <span class="nb">dict</span><span class="p">(</span><span class="n">f</span><span class="o">=</span><span class="n">f</span><span class="p">),</span> <span class="n">addsource</span><span class="o">=</span><span class="bp">True</span><span class="p">)</span>
-<span class="o">&gt;&gt;&gt;</span> <span class="k">print</span> <span class="n">f1</span><span class="o">.</span><span class="n">__source__</span>
-<span class="k">def</span> <span class="nf">f1</span><span class="p">(</span><span class="n">a</span><span class="p">,</span> <span class="n">b</span><span class="p">):</span>
-    <span class="n">f</span><span class="p">(</span><span class="n">a</span><span class="p">,</span> <span class="n">b</span><span class="p">)</span>
-<span class="o">&lt;</span><span class="n">BLANKLINE</span><span class="o">&gt;</span>
-</pre></div>
-
-</div>
-<p><tt class="docutils literal">FunctionMaker.create</tt> can take as first argument a string,
-as in the examples before, or a function. This is the most common
-usage, since typically you want to decorate a pre-existing
-function. A framework author may want to use directly <tt class="docutils literal">FunctionMaker.create</tt>
-instead of <tt class="docutils literal">decorator</tt>, since it gives you direct access to the body
-of the generated function. For instance, suppose you want to instrument
-the <tt class="docutils literal">__init__</tt> methods of a set of classes, by preserving their
-signature (such use case is not made up; this is done in SQAlchemy
-and in other frameworks). When the first argument of <tt class="docutils literal">FunctionMaker.create</tt>
-is a function, a <tt class="docutils literal">FunctionMaker</tt> object is instantiated internally,
-with attributes <tt class="docutils literal">args</tt>, <tt class="docutils literal">varargs</tt>,
-<tt class="docutils literal">keywords</tt> and <tt class="docutils literal">defaults</tt> which are the
-the return values of the standard library function <tt class="docutils literal">inspect.getargspec</tt>.
-For each argument in the <tt class="docutils literal">args</tt> (which is a list of strings containing
-the names of the mandatory arguments) an attribute <tt class="docutils literal">arg0</tt>, <tt class="docutils literal">arg1</tt>,
-..., <tt class="docutils literal">argN</tt> is also generated. Finally, there is a <tt class="docutils literal">signature</tt>
-attribute, a string with the signature of the original function.</p>
-<p>Notice that while I do not have plans
-to change or remove the functionality provided in the
-<tt class="docutils literal">FunctionMaker</tt> class, I do not guarantee that it will stay
-unchanged forever. For instance, right now I am using the traditional
-string interpolation syntax for function templates, but Python 2.6
-and Python 3.0 provide a newer interpolation syntax and I may use
-the new syntax in the future.
-On the other hand, the functionality provided by
-<tt class="docutils literal">decorator</tt> has been there from version 0.1 and it is guaranteed to
-stay there forever.</p>
-</div>
-<div class="section" id="getting-the-source-code">
-<h1><a class="toc-backref" href="#id13">Getting the source code</a></h1>
-<p>Internally <tt class="docutils literal">FunctionMaker.create</tt> uses <tt class="docutils literal">exec</tt> to generate the
-decorated function. Therefore
-<tt class="docutils literal">inspect.getsource</tt> will not work for decorated functions. That
-means that the usual '??' trick in IPython will give you the (right on
-the spot) message <tt class="docutils literal">Dynamically generated function. No source code
-available</tt>.  In the past I have considered this acceptable, since
-<tt class="docutils literal">inspect.getsource</tt> does not really work even with regular
-decorators. In that case <tt class="docutils literal">inspect.getsource</tt> gives you the wrapper
-source code which is probably not what you want:</p>
-<div class="codeblock python">
-<div class="highlight"><pre><span class="k">def</span> <span class="nf">identity_dec</span><span class="p">(</span><span class="n">func</span><span class="p">):</span>
-    <span class="k">def</span> <span class="nf">wrapper</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">kw</span><span class="p">):</span>
-        <span class="k">return</span> <span class="n">func</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">kw</span><span class="p">)</span>
-    <span class="k">return</span> <span class="n">wrapper</span>
-</pre></div>
-
-</div>
-<div class="codeblock python">
-<div class="highlight"><pre><span class="nd">@identity_dec</span>
-<span class="k">def</span> <span class="nf">example</span><span class="p">():</span> <span class="k">pass</span>
-
-<span class="o">&gt;&gt;&gt;</span> <span class="k">print</span> <span class="n">inspect</span><span class="o">.</span><span class="n">getsource</span><span class="p">(</span><span class="n">example</span><span class="p">)</span>
-    <span class="k">def</span> <span class="nf">wrapper</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">kw</span><span class="p">):</span>
-        <span class="k">return</span> <span class="n">func</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">kw</span><span class="p">)</span>
-<span class="o">&lt;</span><span class="n">BLANKLINE</span><span class="o">&gt;</span>
-</pre></div>
-
-</div>
-<p>(see bug report <a class="reference external" href="http://bugs.python.org/issue1764286">1764286</a> for an explanation of what is happening).
-Unfortunately the bug is still there, even in Python 2.7 and 3.1.
-There is however a workaround. The decorator module adds an
-attribute <tt class="docutils literal">.__wrapped__</tt> to the decorated function, containing
-a reference to the original function. The easy way to get
-the source code is to call <tt class="docutils literal">inspect.getsource</tt> on the
-undecorated function:</p>
-<div class="codeblock python">
-<div class="highlight"><pre><span class="o">&gt;&gt;&gt;</span> <span class="k">print</span> <span class="n">inspect</span><span class="o">.</span><span class="n">getsource</span><span class="p">(</span><span class="n">factorial</span><span class="o">.</span><span class="n">__wrapped__</span><span class="p">)</span>
-<span class="nd">@tail_recursive</span>
-<span class="k">def</span> <span class="nf">factorial</span><span class="p">(</span><span class="n">n</span><span class="p">,</span> <span class="n">acc</span><span class="o">=</span><span class="mi">1</span><span class="p">):</span>
-    <span class="s">&quot;The good old factorial&quot;</span>
-    <span class="k">if</span> <span class="n">n</span> <span class="o">==</span> <span class="mi">0</span><span class="p">:</span> <span class="k">return</span> <span class="n">acc</span>
-    <span class="k">return</span> <span class="n">factorial</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">n</span><span class="o">*</span><span class="n">acc</span><span class="p">)</span>
-<span class="o">&lt;</span><span class="n">BLANKLINE</span><span class="o">&gt;</span>
-</pre></div>
-
-</div>
-</div>
-<div class="section" id="dealing-with-third-party-decorators">
-<h1><a class="toc-backref" href="#id14">Dealing with third party decorators</a></h1>
-<p>Sometimes you find on the net some cool decorator that you would
-like to include in your code. However, more often than not the cool
-decorator is not signature-preserving. Therefore you may want an easy way to
-upgrade third party decorators to signature-preserving decorators without
-having to rewrite them in terms of <tt class="docutils literal">decorator</tt>. You can use a
-<tt class="docutils literal">FunctionMaker</tt> to implement that functionality as follows:</p>
-<div class="codeblock python">
-<div class="highlight"><pre><span class="k">def</span> <span class="nf">decorator_apply</span><span class="p">(</span><span class="n">dec</span><span class="p">,</span> <span class="n">func</span><span class="p">):</span>
-    <span class="sd">&quot;&quot;&quot;</span>
-<span class="sd">    Decorate a function by preserving the signature even if dec</span>
-<span class="sd">    is not a signature-preserving decorator.</span>
-<span class="sd">    &quot;&quot;&quot;</span>
-    <span class="k">return</span> <span class="n">FunctionMaker</span><span class="o">.</span><span class="n">create</span><span class="p">(</span>
-        <span class="n">func</span><span class="p">,</span> <span class="s">&#39;return decorated(</span><span class="si">%(signature)s</span><span class="s">)&#39;</span><span class="p">,</span>
-        <span class="nb">dict</span><span class="p">(</span><span class="n">decorated</span><span class="o">=</span><span class="n">dec</span><span class="p">(</span><span class="n">func</span><span class="p">)),</span> <span class="n">__wrapped__</span><span class="o">=</span><span class="n">func</span><span class="p">)</span>
-</pre></div>
-
-</div>
-<p><tt class="docutils literal">decorator_apply</tt> sets the attribute <tt class="docutils literal">.__wrapped__</tt> of the generated
-function to the original function, so that you can get the right
-source code.</p>
-<p>Notice that I am not providing this functionality in the <tt class="docutils literal">decorator</tt>
-module directly since I think it is best to rewrite the decorator rather
-than adding an additional level of indirection. However, practicality
-beats purity, so you can add <tt class="docutils literal">decorator_apply</tt> to your toolbox and
-use it if you need to.</p>
-<p>In order to give an example of usage of <tt class="docutils literal">decorator_apply</tt>, I will show a
-pretty slick decorator that converts a tail-recursive function in an iterative
-function. I have shamelessly stolen the basic idea from Kay Schluehr's recipe
-in the Python Cookbook,
-<a class="reference external" href="http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/496691">http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/496691</a>.</p>
-<div class="codeblock python">
-<div class="highlight"><pre><span class="k">class</span> <span class="nc">TailRecursive</span><span class="p">(</span><span class="nb">object</span><span class="p">):</span>
-    <span class="sd">&quot;&quot;&quot;</span>
-<span class="sd">    tail_recursive decorator based on Kay Schluehr&#39;s recipe</span>
-<span class="sd">    http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/496691</span>
-<span class="sd">    with improvements by me and George Sakkis.</span>
-<span class="sd">    &quot;&quot;&quot;</span>
-
-    <span class="k">def</span> <span class="nf">__init__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">func</span><span class="p">):</span>
-        <span class="bp">self</span><span class="o">.</span><span class="n">func</span> <span class="o">=</span> <span class="n">func</span>
-        <span class="bp">self</span><span class="o">.</span><span class="n">firstcall</span> <span class="o">=</span> <span class="bp">True</span>
-        <span class="bp">self</span><span class="o">.</span><span class="n">CONTINUE</span> <span class="o">=</span> <span class="nb">object</span><span class="p">()</span> <span class="c"># sentinel</span>
-
-    <span class="k">def</span> <span class="nf">__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">kwd</span><span class="p">):</span>
-        <span class="n">CONTINUE</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="n">CONTINUE</span>
-        <span class="k">if</span> <span class="bp">self</span><span class="o">.</span><span class="n">firstcall</span><span class="p">:</span>
-            <span class="n">func</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="n">func</span>
-            <span class="bp">self</span><span class="o">.</span><span class="n">firstcall</span> <span class="o">=</span> <span class="bp">False</span>
-            <span class="k">try</span><span class="p">:</span>
-                <span class="k">while</span> <span class="bp">True</span><span class="p">:</span>
-                    <span class="n">result</span> <span class="o">=</span> <span class="n">func</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">kwd</span><span class="p">)</span>
-                    <span class="k">if</span> <span class="n">result</span> <span class="ow">is</span> <span class="n">CONTINUE</span><span class="p">:</span> <span class="c"># update arguments</span>
-                        <span class="n">args</span><span class="p">,</span> <span class="n">kwd</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="n">argskwd</span>
-                    <span class="k">else</span><span class="p">:</span> <span class="c"># last call</span>
-                        <span class="k">return</span> <span class="n">result</span>
-            <span class="k">finally</span><span class="p">:</span>
-                <span class="bp">self</span><span class="o">.</span><span class="n">firstcall</span> <span class="o">=</span> <span class="bp">True</span>
-        <span class="k">else</span><span class="p">:</span> <span class="c"># return the arguments of the tail call</span>
-            <span class="bp">self</span><span class="o">.</span><span class="n">argskwd</span> <span class="o">=</span> <span class="n">args</span><span class="p">,</span> <span class="n">kwd</span>
-            <span class="k">return</span> <span class="n">CONTINUE</span>
-</pre></div>
-
-</div>
-<p>Here the decorator is implemented as a class returning callable
-objects.</p>
-<div class="codeblock python">
-<div class="highlight"><pre><span class="k">def</span> <span class="nf">tail_recursive</span><span class="p">(</span><span class="n">func</span><span class="p">):</span>
-    <span class="k">return</span> <span class="n">decorator_apply</span><span class="p">(</span><span class="n">TailRecursive</span><span class="p">,</span> <span class="n">func</span><span class="p">)</span>
-</pre></div>
-
-</div>
-<p>Here is how you apply the upgraded decorator to the good old factorial:</p>
-<div class="codeblock python">
-<div class="highlight"><pre><span class="nd">@tail_recursive</span>
-<span class="k">def</span> <span class="nf">factorial</span><span class="p">(</span><span class="n">n</span><span class="p">,</span> <span class="n">acc</span><span class="o">=</span><span class="mi">1</span><span class="p">):</span>
-    <span class="s">&quot;The good old factorial&quot;</span>
-    <span class="k">if</span> <span class="n">n</span> <span class="o">==</span> <span class="mi">0</span><span class="p">:</span> <span class="k">return</span> <span class="n">acc</span>
-    <span class="k">return</span> <span class="n">factorial</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">n</span><span class="o">*</span><span class="n">acc</span><span class="p">)</span>
-</pre></div>
-
-</div>
-<div class="codeblock python">
-<div class="highlight"><pre><span class="o">&gt;&gt;&gt;</span> <span class="k">print</span> <span class="n">factorial</span><span class="p">(</span><span class="mi">4</span><span class="p">)</span>
-<span class="mi">24</span>
-</pre></div>
-
-</div>
-<p>This decorator is pretty impressive, and should give you some food for
-your mind ;) Notice that there is no recursion limit now, and you can
-easily compute <tt class="docutils literal">factorial(1001)</tt> or larger without filling the stack
-frame. Notice also that the decorator will not work on functions which
-are not tail recursive, such as the following</p>
-<div class="codeblock python">
-<div class="highlight"><pre><span class="k">def</span> <span class="nf">fact</span><span class="p">(</span><span class="n">n</span><span class="p">):</span> <span class="c"># this is not tail-recursive</span>
-    <span class="k">if</span> <span class="n">n</span> <span class="o">==</span> <span class="mi">0</span><span class="p">:</span> <span class="k">return</span> <span class="mi">1</span>
-    <span class="k">return</span> <span class="n">n</span> <span class="o">*</span> <span class="n">fact</span><span class="p">(</span><span class="n">n</span><span class="o">-</span><span class="mi">1</span><span class="p">)</span>
-</pre></div>
-
-</div>
-<p>(reminder: a function is tail recursive if it either returns a value without
-making a recursive call, or returns directly the result of a recursive
-call).</p>
-</div>
-<div class="section" id="caveats-and-limitations">
-<h1><a class="toc-backref" href="#id15">Caveats and limitations</a></h1>
-<p>The first thing you should be aware of, it the fact that decorators
-have a performance penalty.
-The worse case is shown by the following example:</p>
-<pre class="literal-block">
-$ cat performance.sh
-python -m timeit -s &quot;
-from decorator import decorator
-
-&#64;decorator
-def do_nothing(func, *args, **kw):
-    return func(*args, **kw)
-
-&#64;do_nothing
-def f():
-    pass
-&quot; &quot;f()&quot;
-
-python -m timeit -s &quot;
-def f():
-    pass
-&quot; &quot;f()&quot;
-</pre>
-<p>On my MacBook, using the <tt class="docutils literal">do_nothing</tt> decorator instead of the
-plain function is more than three times slower:</p>
-<pre class="literal-block">
-$ bash performance.sh
-1000000 loops, best of 3: 0.995 usec per loop
-1000000 loops, best of 3: 0.273 usec per loop
-</pre>
-<p>It should be noted that a real life function would probably do
-something more useful than <tt class="docutils literal">f</tt> here, and therefore in real life the
-performance penalty could be completely negligible.  As always, the
-only way to know if there is
-a penalty in your specific use case is to measure it.</p>
-<p>You should be aware that decorators will make your tracebacks
-longer and more difficult to understand. Consider this example:</p>
-<div class="codeblock python">
-<div class="highlight"><pre><span class="o">&gt;&gt;&gt;</span> <span class="nd">@trace</span>
-<span class="o">...</span> <span class="k">def</span> <span class="nf">f</span><span class="p">():</span>
-<span class="o">...</span>     <span class="mi">1</span><span class="o">/</span><span class="mi">0</span>
-</pre></div>
-
-</div>
-<p>Calling <tt class="docutils literal">f()</tt> will give you a <tt class="docutils literal">ZeroDivisionError</tt>, but since the
-function is decorated the traceback will be longer:</p>
-<div class="codeblock python">
-<div class="highlight"><pre><span class="o">&gt;&gt;&gt;</span> <span class="n">f</span><span class="p">()</span>
-<span class="n">Traceback</span> <span class="p">(</span><span class="n">most</span> <span class="n">recent</span> <span class="n">call</span> <span class="n">last</span><span class="p">):</span>
-  <span class="o">...</span>
-     <span class="n">File</span> <span class="s">&quot;&lt;string&gt;&quot;</span><span class="p">,</span> <span class="n">line</span> <span class="mi">2</span><span class="p">,</span> <span class="ow">in</span> <span class="n">f</span>
-     <span class="n">File</span> <span class="s">&quot;&lt;doctest __main__[18]&gt;&quot;</span><span class="p">,</span> <span class="n">line</span> <span class="mi">4</span><span class="p">,</span> <span class="ow">in</span> <span class="n">trace</span>
-       <span class="k">return</span> <span class="n">f</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">kw</span><span class="p">)</span>
-     <span class="n">File</span> <span class="s">&quot;&lt;doctest __main__[47]&gt;&quot;</span><span class="p">,</span> <span class="n">line</span> <span class="mi">3</span><span class="p">,</span> <span class="ow">in</span> <span class="n">f</span>
-       <span class="mi">1</span><span class="o">/</span><span class="mi">0</span>
-<span class="ne">ZeroDivisionError</span><span class="p">:</span> <span class="n">integer</span> <span class="n">division</span> <span class="ow">or</span> <span class="n">modulo</span> <span class="n">by</span> <span class="n">zero</span>
-</pre></div>
-
-</div>
-<p>You see here the inner call to the decorator <tt class="docutils literal">trace</tt>, which calls
-<tt class="docutils literal"><span class="pre">f(*args,</span> **kw)</tt>, and a reference to  <tt class="docutils literal">File <span class="pre">&quot;&lt;string&gt;&quot;,</span> line 2, in f</tt>.
-This latter reference is due to the fact that internally the decorator
-module uses <tt class="docutils literal">exec</tt> to generate the decorated function. Notice that
-<tt class="docutils literal">exec</tt> is <em>not</em> responsibile for the performance penalty, since is the
-called <em>only once</em> at function decoration time, and not every time
-the decorated function is called.</p>
-<p>At present, there is no clean way to avoid <tt class="docutils literal">exec</tt>. A clean solution
-would require to change the CPython implementation of functions and
-add an hook to make it possible to change their signature directly.
-That could happen in future versions of Python (see PEP <a class="reference external" href="http://www.python.org/dev/peps/pep-0362">362</a>) and
-then the decorator module would become obsolete. However, at present,
-even in Python 3.1 it is impossible to change the function signature
-directly, therefore the <tt class="docutils literal">decorator</tt> module is still useful.
-Actually, this is one of the main reasons why I keep maintaining
-the module and releasing new versions.</p>
-<p>In the present implementation, decorators generated by <tt class="docutils literal">decorator</tt>
-can only be used on user-defined Python functions or methods, not on generic
-callable objects, nor on built-in functions, due to limitations of the
-<tt class="docutils literal">inspect</tt> module in the standard library. Moreover, notice
-that you can decorate a method, but only before if becomes a bound or unbound
-method, i.e. inside the class.
-Here is an example of valid decoration:</p>
-<div class="codeblock python">
-<div class="highlight"><pre><span class="o">&gt;&gt;&gt;</span> <span class="k">class</span> <span class="nc">C</span><span class="p">(</span><span class="nb">object</span><span class="p">):</span>
-<span class="o">...</span>      <span class="nd">@trace</span>
-<span class="o">...</span>      <span class="k">def</span> <span class="nf">meth</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
-<span class="o">...</span>          <span class="k">pass</span>
-</pre></div>
-
-</div>
-<p>Here is an example of invalid decoration, when the decorator in
-called too late:</p>
-<div class="codeblock python">
-<div class="highlight"><pre><span class="o">&gt;&gt;&gt;</span> <span class="k">class</span> <span class="nc">C</span><span class="p">(</span><span class="nb">object</span><span class="p">):</span>
-<span class="o">...</span>      <span class="k">def</span> <span class="nf">meth</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
-<span class="o">...</span>          <span class="k">pass</span>
-<span class="o">...</span>
-<span class="o">&gt;&gt;&gt;</span> <span class="n">trace</span><span class="p">(</span><span class="n">C</span><span class="o">.</span><span class="n">meth</span><span class="p">)</span>
-<span class="n">Traceback</span> <span class="p">(</span><span class="n">most</span> <span class="n">recent</span> <span class="n">call</span> <span class="n">last</span><span class="p">):</span>
-  <span class="o">...</span>
-<span class="ne">TypeError</span><span class="p">:</span> <span class="n">You</span> <span class="n">are</span> <span class="n">decorating</span> <span class="n">a</span> <span class="n">non</span> <span class="n">function</span><span class="p">:</span> <span class="o">&lt;</span><span class="n">unbound</span> <span class="n">method</span> <span class="n">C</span><span class="o">.</span><span class="n">meth</span><span class="o">&gt;</span>
-</pre></div>
-
-</div>
-<p>The solution is to extract the inner function from the unbound method:</p>
-<div class="codeblock python">
-<div class="highlight"><pre><span class="o">&gt;&gt;&gt;</span> <span class="n">trace</span><span class="p">(</span><span class="n">C</span><span class="o">.</span><span class="n">meth</span><span class="o">.</span><span class="n">im_func</span><span class="p">)</span>
-<span class="o">&lt;</span><span class="n">function</span> <span class="n">meth</span> <span class="n">at</span> <span class="mi">0</span><span class="n">x</span><span class="o">...&gt;</span>
-</pre></div>
-
-</div>
-<p>There is a restriction on the names of the arguments: for instance,
-if try to call an argument <tt class="docutils literal">_call_</tt> or <tt class="docutils literal">_func_</tt>
-you will get a <tt class="docutils literal">NameError</tt>:</p>
-<div class="codeblock python">
-<div class="highlight"><pre><span class="o">&gt;&gt;&gt;</span> <span class="nd">@trace</span>
-<span class="o">...</span> <span class="k">def</span> <span class="nf">f</span><span class="p">(</span><span class="n">_func_</span><span class="p">):</span> <span class="k">print</span> <span class="n">f</span>
-<span class="o">...</span>
-<span class="n">Traceback</span> <span class="p">(</span><span class="n">most</span> <span class="n">recent</span> <span class="n">call</span> <span class="n">last</span><span class="p">):</span>
-  <span class="o">...</span>
-<span class="ne">NameError</span><span class="p">:</span> <span class="n">_func_</span> <span class="ow">is</span> <span class="n">overridden</span> <span class="ow">in</span>
-<span class="k">def</span> <span class="nf">f</span><span class="p">(</span><span class="n">_func_</span><span class="p">):</span>
-    <span class="k">return</span> <span class="n">_call_</span><span class="p">(</span><span class="n">_func_</span><span class="p">,</span> <span class="n">_func_</span><span class="p">)</span>
-</pre></div>
-
-</div>
-<p>Finally, the implementation is such that the decorated function
-attribute <tt class="docutils literal">.func_globals</tt> is a <em>copy</em> of the original function
-attribute. Moreover the decorated function contains
-a <em>copy</em> of the original function dictionary
-(<tt class="docutils literal">vars(decorated_f) is not vars(f)</tt>):</p>
-<div class="codeblock python">
-<div class="highlight"><pre><span class="o">&gt;&gt;&gt;</span> <span class="k">def</span> <span class="nf">f</span><span class="p">():</span> <span class="k">pass</span> <span class="c"># the original function</span>
-<span class="o">&gt;&gt;&gt;</span> <span class="n">f</span><span class="o">.</span><span class="n">attr1</span> <span class="o">=</span> <span class="s">&quot;something&quot;</span> <span class="c"># setting an attribute</span>
-<span class="o">&gt;&gt;&gt;</span> <span class="n">f</span><span class="o">.</span><span class="n">attr2</span> <span class="o">=</span> <span class="s">&quot;something else&quot;</span> <span class="c"># setting another attribute</span>
-
-<span class="o">&gt;&gt;&gt;</span> <span class="n">traced_f</span> <span class="o">=</span> <span class="n">trace</span><span class="p">(</span><span class="n">f</span><span class="p">)</span> <span class="c"># the decorated function</span>
-
-<span class="o">&gt;&gt;&gt;</span> <span class="n">traced_f</span><span class="o">.</span><span class="n">attr1</span>
-<span class="s">&#39;something&#39;</span>
-<span class="o">&gt;&gt;&gt;</span> <span class="n">traced_f</span><span class="o">.</span><span class="n">attr2</span> <span class="o">=</span> <span class="s">&quot;something different&quot;</span> <span class="c"># setting attr</span>
-<span class="o">&gt;&gt;&gt;</span> <span class="n">f</span><span class="o">.</span><span class="n">attr2</span> <span class="c"># the original attribute did not change</span>
-<span class="s">&#39;something else&#39;</span>
-</pre></div>
-
-</div>
-</div>
-<div class="section" id="compatibility-notes">
-<h1><a class="toc-backref" href="#id16">Compatibility notes</a></h1>
-<p>Version 3.3 is the first version of the <tt class="docutils literal">decorator</tt> module to fully
-support Python 3, including <a class="reference external" href="http://www.python.org/dev/peps/pep-3107/">function annotations</a>. Version 3.2 was the
-first version to support Python 3 via the <tt class="docutils literal">2to3</tt> conversion tool
-invoked in the build process by the <a class="reference external" href="http://packages.python.org/distribute/">distribute</a> project, the Python
-3-compatible replacement of easy_install.  The hard work (for me) has
-been converting the documentation and the doctests.  This has been
-possible only after that <a class="reference external" href="http://docutils.sourceforge.net/">docutils</a> and <a class="reference external" href="http://pygments.org/">pygments</a> have been ported to
-Python 3.</p>
-<p>Version 3 of the <tt class="docutils literal">decorator</tt> module do not contain any backward
-incompatible change, apart from the removal of the functions
-<tt class="docutils literal">get_info</tt> and <tt class="docutils literal">new_wrapper</tt>, which have been deprecated for
-years. <tt class="docutils literal">get_info</tt> has been removed since it was little used and
-since it had to be changed anyway to work with Python 3.0;
-<tt class="docutils literal">new_wrapper</tt> has been removed since it was useless: its major use
-case (converting signature changing decorators to signature preserving
-decorators) has been subsumed by <tt class="docutils literal">decorator_apply</tt>, whereas the other use
-case can be managed with the <tt class="docutils literal">FunctionMaker</tt>.</p>
-<p>There are a few changes in the documentation: I removed the
-<tt class="docutils literal">decorator_factory</tt> example, which was confusing some of my users,
-and I removed the part about exotic signatures in the Python 3
-documentation, since Python 3 does not support them.</p>
-<p>Finally <tt class="docutils literal">decorator</tt> cannot be used as a class decorator and the
-<a class="reference external" href="http://www.phyast.pitt.edu/~micheles/python/documentation.html#class-decorators-and-decorator-factories">functionality introduced in version 2.3</a> has been removed. That
-means that in order to define decorator factories with classes you
-need to define the <tt class="docutils literal">__call__</tt> method explicitly (no magic anymore).
-All these changes should not cause any trouble, since they were
-all rarely used features. Should you have any trouble, you can always
-downgrade to the 2.3 version.</p>
-<p>The examples shown here have been tested with Python 2.6. Python 2.4
-is also supported - of course the examples requiring the <tt class="docutils literal">with</tt>
-statement will not work there. Python 2.5 works fine, but if you
-run the examples in the interactive interpreter
-you will notice a few differences since
-<tt class="docutils literal">getargspec</tt> returns an <tt class="docutils literal">ArgSpec</tt> namedtuple instead of a regular
-tuple. That means that running the file
-<tt class="docutils literal">documentation.py</tt> under Python 2.5 will print a few errors, but
-they are not serious.</p>
-</div>
-<div class="section" id="licence">
-<h1><a class="toc-backref" href="#id17">LICENCE</a></h1>
-<p>Copyright (c) 2005-2012, Michele Simionato
-All rights reserved.</p>
-<p>Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are
-met:</p>
-<blockquote>
-Redistributions of source code must retain the above copyright
-notice, this list of conditions and the following disclaimer.
-Redistributions in bytecode form must reproduce the above copyright
-notice, this list of conditions and the following disclaimer in
-the documentation and/or other materials provided with the
-distribution.</blockquote>
-<p>THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-&quot;AS IS&quot; AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
-INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
-BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
-OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
-TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
-USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
-DAMAGE.</p>
-<p>If you use this software and you are happy with it, consider sending me a
-note, just to gratify my ego. On the other hand, if you use this software and
-you are unhappy with it, send me a patch!</p>
-</div>
-</div>
-</body>
-</html>
diff --git a/documentation.pdf b/documentation.pdf
index 611972e..66bf009 100644
--- a/documentation.pdf
+++ b/documentation.pdf
@@ -1,1367 +1,285 @@
 %PDF-1.4
-%���� ReportLab Generated PDF document http://www.reportlab.com
-% 'BasicFonts': class PDFDictionary 
+%���� ReportLab Generated PDF document http://www.reportlab.com
 1 0 obj
-% The standard fonts dictionary
-<< /F1 2 0 R
- /F2 3 0 R
- /F3 4 0 R
- /F4 7 0 R
- /F5 39 0 R
- /F6 41 0 R >>
-endobj
-% 'F1': class PDFType1Font 
+<< /F1 2 0 R /F2 3 0 R /F3 4 0 R /F4 7 0 R /F5 44 0 R /F6 46 0 R >>
+endobj
 2 0 obj
-% Font Helvetica
-<< /BaseFont /Helvetica
- /Encoding /WinAnsiEncoding
- /Name /F1
- /Subtype /Type1
- /Type /Font >>
-endobj
-% 'F2': class PDFType1Font 
+<< /BaseFont /Helvetica /Encoding /WinAnsiEncoding /Name /F1 /Subtype /Type1 /Type /Font >>
+endobj
 3 0 obj
-% Font Helvetica-Bold
-<< /BaseFont /Helvetica-Bold
- /Encoding /WinAnsiEncoding
- /Name /F2
- /Subtype /Type1
- /Type /Font >>
-endobj
-% 'F3': class PDFType1Font 
+<< /BaseFont /Helvetica-Bold /Encoding /WinAnsiEncoding /Name /F2 /Subtype /Type1 /Type /Font >>
+endobj
 4 0 obj
-% Font Courier-Bold
-<< /BaseFont /Courier-Bold
- /Encoding /WinAnsiEncoding
- /Name /F3
- /Subtype /Type1
- /Type /Font >>
-endobj
-% 'Annot.NUMBER1': class PDFDictionary 
+<< /BaseFont /Courier-Bold /Encoding /WinAnsiEncoding /Name /F3 /Subtype /Type1 /Type /Font >>
+endobj
 5 0 obj
-<< /A << /S /URI
- /Type /Action
- /URI (mailto:michele.simionato@gmail.com) >>
- /Border [ 0
- 0
- 0 ]
- /Rect [ 153.7323
- 704.7736
- 289.4623
- 716.7736 ]
- /Subtype /Link
- /Type /Annot >>
-endobj
-% 'Annot.NUMBER2': class PDFDictionary 
+<< /A << /S /URI /Type /Action /URI (mailto:michele.simionato@gmail.com) >> /Border [ 0 0 0 ] /Rect [ 153.7323 704.7736 289.4623 716.7736 ] /Subtype /Link /Type /Annot >>
+endobj
 6 0 obj
-<< /A << /S /URI
- /Type /Action
- /URI (http://pypi.python.org/pypi/decorator/3.4.0) >>
- /Border [ 0
- 0
- 0 ]
- /Rect [ 153.7323
- 659.7736
- 526.5827
- 671.7736 ]
- /Subtype /Link
- /Type /Annot >>
-endobj
-% 'F4': class PDFType1Font 
+<< /A << /S /URI /Type /Action /URI (http://pypi.python.org/pypi/decorator/3.4.1) >> /Border [ 0 0 0 ] /Rect [ 153.7323 659.7736 526.5827 671.7736 ] /Subtype /Link /Type /Annot >>
+endobj
 7 0 obj
-% Font Courier
-<< /BaseFont /Courier
- /Encoding /WinAnsiEncoding
- /Name /F4
- /Subtype /Type1
- /Type /Font >>
-endobj
-% 'Annot.NUMBER3': class LinkAnnotation 
+<< /BaseFont /Courier /Encoding /WinAnsiEncoding /Name /F4 /Subtype /Type1 /Type /Font >>
+endobj
 8 0 obj
-<< /Border [ 0
- 0
- 0 ]
- /Contents ()
- /Dest [ 38 0 R
- /XYZ
- 62.69291
- 293.0236
- 0 ]
- /Rect [ 62.69291
- 560.7736
- 121.0229
- 572.7736 ]
- /Subtype /Link
- /Type /Annot >>
-endobj
-% 'Annot.NUMBER4': class LinkAnnotation 
+<< /Border [ 0 0 0 ] /Contents () /Dest [ 43 0 R /XYZ 62.69291 293.0236 0 ] /Rect [ 62.69291 560.7736 121.0229 572.7736 ] /Subtype /Link /Type /Annot >>
+endobj
 9 0 obj
-<< /Border [ 0
- 0
- 0 ]
- /Contents ()
- /Dest [ 38 0 R
- /XYZ
- 62.69291
- 293.0236
- 0 ]
- /Rect [ 527.0227
- 560.7736
- 532.5827
- 572.7736 ]
- /Subtype /Link
- /Type /Annot >>
-endobj
-% 'Annot.NUMBER5': class LinkAnnotation 
+<< /Border [ 0 0 0 ] /Contents () /Dest [ 43 0 R /XYZ 62.69291 293.0236 0 ] /Rect [ 527.0227 560.7736 532.5827 572.7736 ] /Subtype /Link /Type /Annot >>
+endobj
 10 0 obj
-<< /Border [ 0
- 0
- 0 ]
- /Contents ()
- /Dest [ 43 0 R
- /XYZ
- 62.69291
- 675.0236
- 0 ]
- /Rect [ 62.69291
- 542.7736
- 114.3629
- 554.7736 ]
- /Subtype /Link
- /Type /Annot >>
-endobj
-% 'Annot.NUMBER6': class LinkAnnotation 
+<< /Border [ 0 0 0 ] /Contents () /Dest [ 48 0 R /XYZ 62.69291 675.0236 0 ] /Rect [ 62.69291 542.7736 114.3629 554.7736 ] /Subtype /Link /Type /Annot >>
+endobj
 11 0 obj
-<< /Border [ 0
- 0
- 0 ]
- /Contents ()
- /Dest [ 43 0 R
- /XYZ
- 62.69291
- 675.0236
- 0 ]
- /Rect [ 527.0227
- 542.7736
- 532.5827
- 554.7736 ]
- /Subtype /Link
- /Type /Annot >>
-endobj
-% 'Annot.NUMBER7': class LinkAnnotation 
+<< /Border [ 0 0 0 ] /Contents () /Dest [ 48 0 R /XYZ 62.69291 675.0236 0 ] /Rect [ 527.0227 542.7736 532.5827 554.7736 ] /Subtype /Link /Type /Annot >>
+endobj
 12 0 obj
-<< /Border [ 0
- 0
- 0 ]
- /Contents ()
- /Dest [ 43 0 R
- /XYZ
- 62.69291
- 438.0236
- 0 ]
- /Rect [ 62.69291
- 524.7736
- 183.2629
- 536.7736 ]
- /Subtype /Link
- /Type /Annot >>
-endobj
-% 'Annot.NUMBER8': class LinkAnnotation 
+<< /Border [ 0 0 0 ] /Contents () /Dest [ 48 0 R /XYZ 62.69291 438.0236 0 ] /Rect [ 62.69291 524.7736 183.2629 536.7736 ] /Subtype /Link /Type /Annot >>
+endobj
 13 0 obj
-<< /Border [ 0
- 0
- 0 ]
- /Contents ()
- /Dest [ 43 0 R
- /XYZ
- 62.69291
- 438.0236
- 0 ]
- /Rect [ 527.0227
- 524.7736
- 532.5827
- 536.7736 ]
- /Subtype /Link
- /Type /Annot >>
-endobj
-% 'Annot.NUMBER9': class LinkAnnotation 
+<< /Border [ 0 0 0 ] /Contents () /Dest [ 48 0 R /XYZ 62.69291 438.0236 0 ] /Rect [ 527.0227 524.7736 532.5827 536.7736 ] /Subtype /Link /Type /Annot >>
+endobj
 14 0 obj
-<< /Border [ 0
- 0
- 0 ]
- /Contents ()
- /Dest [ 44 0 R
- /XYZ
- 62.69291
- 427.4236
- 0 ]
- /Rect [ 62.69291
- 506.7736
- 122.1429
- 518.7736 ]
- /Subtype /Link
- /Type /Annot >>
-endobj
-% 'Annot.NUMBER10': class LinkAnnotation 
+<< /Border [ 0 0 0 ] /Contents () /Dest [ 49 0 R /XYZ 62.69291 427.4236 0 ] /Rect [ 62.69291 506.7736 122.1429 518.7736 ] /Subtype /Link /Type /Annot >>
+endobj
 15 0 obj
-<< /Border [ 0
- 0
- 0 ]
- /Contents ()
- /Dest [ 44 0 R
- /XYZ
- 62.69291
- 427.4236
- 0 ]
- /Rect [ 527.0227
- 506.7736
- 532.5827
- 518.7736 ]
- /Subtype /Link
- /Type /Annot >>
-endobj
-% 'Annot.NUMBER11': class LinkAnnotation 
+<< /Border [ 0 0 0 ] /Contents () /Dest [ 49 0 R /XYZ 62.69291 427.4236 0 ] /Rect [ 527.0227 506.7736 532.5827 518.7736 ] /Subtype /Link /Type /Annot >>
+endobj
 16 0 obj
-<< /Border [ 0
- 0
- 0 ]
- /Contents ()
- /Dest [ 45 0 R
- /XYZ
- 62.69291
- 435.4236
- 0 ]
- /Rect [ 62.69291
- 488.7736
- 154.8129
- 500.7736 ]
- /Subtype /Link
- /Type /Annot >>
-endobj
-% 'Annot.NUMBER12': class LinkAnnotation 
+<< /Border [ 0 0 0 ] /Contents () /Dest [ 50 0 R /XYZ 62.69291 435.4236 0 ] /Rect [ 62.69291 488.7736 72.69291 500.7736 ] /Subtype /Link /Type /Annot >>
+endobj
 17 0 obj
-<< /Border [ 0
- 0
- 0 ]
- /Contents ()
- /Dest [ 45 0 R
- /XYZ
- 62.69291
- 435.4236
- 0 ]
- /Rect [ 527.0227
- 488.7736
- 532.5827
- 500.7736 ]
- /Subtype /Link
- /Type /Annot >>
-endobj
-% 'Annot.NUMBER13': class LinkAnnotation 
+<< /Border [ 0 0 0 ] /Contents () /Dest [ 50 0 R /XYZ 62.69291 435.4236 0 ] /Rect [ 72.69291 488.7736 108.6929 500.7736 ] /Subtype /Link /Type /Annot >>
+endobj
 18 0 obj
-<< /Border [ 0
- 0
- 0 ]
- /Contents ()
- /Dest [ 46 0 R
- /XYZ
- 62.69291
- 398.778
- 0 ]
- /Rect [ 62.69291
- 470.7736
- 188.2729
- 482.7736 ]
- /Subtype /Link
- /Type /Annot >>
-endobj
-% 'Annot.NUMBER14': class LinkAnnotation 
+<< /Border [ 0 0 0 ] /Contents () /Dest [ 50 0 R /XYZ 62.69291 435.4236 0 ] /Rect [ 108.6929 488.7736 154.8129 500.7736 ] /Subtype /Link /Type /Annot >>
+endobj
 19 0 obj
-<< /Border [ 0
- 0
- 0 ]
- /Contents ()
- /Dest [ 46 0 R
- /XYZ
- 62.69291
- 398.778
- 0 ]
- /Rect [ 527.0227
- 470.7736
- 532.5827
- 482.7736 ]
- /Subtype /Link
- /Type /Annot >>
-endobj
-% 'Annot.NUMBER15': class LinkAnnotation 
+<< /Border [ 0 0 0 ] /Contents () /Dest [ 50 0 R /XYZ 62.69291 435.4236 0 ] /Rect [ 527.0227 488.7736 532.5827 500.7736 ] /Subtype /Link /Type /Annot >>
+endobj
 20 0 obj
-<< /Border [ 0
- 0
- 0 ]
- /Contents ()
- /Dest [ 47 0 R
- /XYZ
- 62.69291
- 647.8236
- 0 ]
- /Rect [ 62.69291
- 452.7736
- 110.6929
- 464.7736 ]
- /Subtype /Link
- /Type /Annot >>
-endobj
-% 'Annot.NUMBER16': class LinkAnnotation 
+<< /Border [ 0 0 0 ] /Contents () /Dest [ 51 0 R /XYZ 62.69291 397.4236 0 ] /Rect [ 62.69291 470.7736 122.6929 482.7736 ] /Subtype /Link /Type /Annot >>
+endobj
 21 0 obj
-<< /Border [ 0
- 0
- 0 ]
- /Contents ()
- /Dest [ 47 0 R
- /XYZ
- 62.69291
- 647.8236
- 0 ]
- /Rect [ 527.0227
- 452.7736
- 532.5827
- 464.7736 ]
- /Subtype /Link
- /Type /Annot >>
-endobj
-% 'Annot.NUMBER17': class LinkAnnotation 
+<< /Border [ 0 0 0 ] /Contents () /Dest [ 51 0 R /XYZ 62.69291 397.4236 0 ] /Rect [ 122.6929 470.7736 188.2729 482.7736 ] /Subtype /Link /Type /Annot >>
+endobj
 22 0 obj
-<< /Border [ 0
- 0
- 0 ]
- /Contents ()
- /Dest [ 48 0 R
- /XYZ
- 62.69291
- 765.0236
- 0 ]
- /Rect [ 62.69291
- 434.7736
- 92.69291
- 446.7736 ]
- /Subtype /Link
- /Type /Annot >>
-endobj
-% 'Annot.NUMBER18': class LinkAnnotation 
+<< /Border [ 0 0 0 ] /Contents () /Dest [ 51 0 R /XYZ 62.69291 397.4236 0 ] /Rect [ 527.0227 470.7736 532.5827 482.7736 ] /Subtype /Link /Type /Annot >>
+endobj
 23 0 obj
-<< /Border [ 0
- 0
- 0 ]
- /Contents ()
- /Dest [ 48 0 R
- /XYZ
- 62.69291
- 765.0236
- 0 ]
- /Rect [ 527.0227
- 434.7736
- 532.5827
- 446.7736 ]
- /Subtype /Link
- /Type /Annot >>
-endobj
-% 'Annot.NUMBER19': class LinkAnnotation 
+<< /Border [ 0 0 0 ] /Contents () /Dest [ 52 0 R /XYZ 62.69291 647.8236 0 ] /Rect [ 62.69291 452.7736 110.6929 464.7736 ] /Subtype /Link /Type /Annot >>
+endobj
 24 0 obj
-<< /Border [ 0
- 0
- 0 ]
- /Contents ()
- /Dest [ 49 0 R
- /XYZ
- 62.69291
- 267.4236
- 0 ]
- /Rect [ 62.69291
- 416.7736
- 139.9329
- 428.7736 ]
- /Subtype /Link
- /Type /Annot >>
-endobj
-% 'Annot.NUMBER20': class LinkAnnotation 
+<< /Border [ 0 0 0 ] /Contents () /Dest [ 52 0 R /XYZ 62.69291 647.8236 0 ] /Rect [ 527.0227 452.7736 532.5827 464.7736 ] /Subtype /Link /Type /Annot >>
+endobj
 25 0 obj
-<< /Border [ 0
- 0
- 0 ]
- /Contents ()
- /Dest [ 49 0 R
- /XYZ
- 62.69291
- 267.4236
- 0 ]
- /Rect [ 527.0227
- 416.7736
- 532.5827
- 428.7736 ]
- /Subtype /Link
- /Type /Annot >>
-endobj
-% 'Annot.NUMBER21': class LinkAnnotation 
+<< /Border [ 0 0 0 ] /Contents () /Dest [ 53 0 R /XYZ 62.69291 765.0236 0 ] /Rect [ 62.69291 434.7736 92.69291 446.7736 ] /Subtype /Link /Type /Annot >>
+endobj
 26 0 obj
-<< /Border [ 0
- 0
- 0 ]
- /Contents ()
- /Dest [ 50 0 R
- /XYZ
- 62.69291
- 354.6236
- 0 ]
- /Rect [ 62.69291
- 398.7736
- 192.2729
- 410.7736 ]
- /Subtype /Link
- /Type /Annot >>
-endobj
-% 'Annot.NUMBER22': class LinkAnnotation 
+<< /Border [ 0 0 0 ] /Contents () /Dest [ 53 0 R /XYZ 62.69291 765.0236 0 ] /Rect [ 527.0227 434.7736 532.5827 446.7736 ] /Subtype /Link /Type /Annot >>
+endobj
 27 0 obj
-<< /Border [ 0
- 0
- 0 ]
- /Contents ()
- /Dest [ 50 0 R
- /XYZ
- 62.69291
- 354.6236
- 0 ]
- /Rect [ 527.0227
- 398.7736
- 532.5827
- 410.7736 ]
- /Subtype /Link
- /Type /Annot >>
-endobj
-% 'Annot.NUMBER23': class LinkAnnotation 
+<< /Border [ 0 0 0 ] /Contents () /Dest [ 54 0 R /XYZ 62.69291 255.4236 0 ] /Rect [ 62.69291 416.7736 139.9329 428.7736 ] /Subtype /Link /Type /Annot >>
+endobj
 28 0 obj
-<< /Border [ 0
- 0
- 0 ]
- /Contents ()
- /Dest [ 51 0 R
- /XYZ
- 62.69291
- 363.8236
- 0 ]
- /Rect [ 62.69291
- 380.7736
- 177.1629
- 392.7736 ]
- /Subtype /Link
- /Type /Annot >>
-endobj
-% 'Annot.NUMBER24': class LinkAnnotation 
+<< /Border [ 0 0 0 ] /Contents () /Dest [ 54 0 R /XYZ 62.69291 255.4236 0 ] /Rect [ 527.0227 416.7736 532.5827 428.7736 ] /Subtype /Link /Type /Annot >>
+endobj
 29 0 obj
-<< /Border [ 0
- 0
- 0 ]
- /Contents ()
- /Dest [ 51 0 R
- /XYZ
- 62.69291
- 363.8236
- 0 ]
- /Rect [ 521.4627
- 380.7736
- 532.5827
- 392.7736 ]
- /Subtype /Link
- /Type /Annot >>
-endobj
-% 'Annot.NUMBER25': class LinkAnnotation 
+<< /Border [ 0 0 0 ] /Contents () /Dest [ 55 0 R /XYZ 62.69291 324.6236 0 ] /Rect [ 62.69291 398.7736 83.25291 410.7736 ] /Subtype /Link /Type /Annot >>
+endobj
 30 0 obj
-<< /Border [ 0
- 0
- 0 ]
- /Contents ()
- /Dest [ 54 0 R
- /XYZ
- 62.69291
- 599.8236
- 0 ]
- /Rect [ 62.69291
- 362.7736
- 228.2829
- 374.7736 ]
- /Subtype /Link
- /Type /Annot >>
-endobj
-% 'Annot.NUMBER26': class LinkAnnotation 
+<< /Border [ 0 0 0 ] /Contents () /Dest [ 55 0 R /XYZ 62.69291 324.6236 0 ] /Rect [ 83.25291 398.7736 167.2529 410.7736 ] /Subtype /Link /Type /Annot >>
+endobj
 31 0 obj
-<< /Border [ 0
- 0
- 0 ]
- /Contents ()
- /Dest [ 54 0 R
- /XYZ
- 62.69291
- 599.8236
- 0 ]
- /Rect [ 521.4627
- 362.7736
- 532.5827
- 374.7736 ]
- /Subtype /Link
- /Type /Annot >>
-endobj
-% 'Annot.NUMBER27': class LinkAnnotation 
+<< /Border [ 0 0 0 ] /Contents () /Dest [ 55 0 R /XYZ 62.69291 324.6236 0 ] /Rect [ 167.2529 398.7736 192.2729 410.7736 ] /Subtype /Link /Type /Annot >>
+endobj
 32 0 obj
-<< /Border [ 0
- 0
- 0 ]
- /Contents ()
- /Dest [ 55 0 R
- /XYZ
- 62.69291
- 215.0236
- 0 ]
- /Rect [ 62.69291
- 344.7736
- 174.3929
- 356.7736 ]
- /Subtype /Link
- /Type /Annot >>
-endobj
-% 'Annot.NUMBER28': class LinkAnnotation 
+<< /Border [ 0 0 0 ] /Contents () /Dest [ 55 0 R /XYZ 62.69291 324.6236 0 ] /Rect [ 527.0227 398.7736 532.5827 410.7736 ] /Subtype /Link /Type /Annot >>
+endobj
 33 0 obj
-<< /Border [ 0
- 0
- 0 ]
- /Contents ()
- /Dest [ 55 0 R
- /XYZ
- 62.69291
- 215.0236
- 0 ]
- /Rect [ 521.4627
- 344.7736
- 532.5827
- 356.7736 ]
- /Subtype /Link
- /Type /Annot >>
-endobj
-% 'Annot.NUMBER29': class LinkAnnotation 
+<< /Border [ 0 0 0 ] /Contents () /Dest [ 56 0 R /XYZ 62.69291 333.8236 0 ] /Rect [ 62.69291 380.7736 177.1629 392.7736 ] /Subtype /Link /Type /Annot >>
+endobj
 34 0 obj
-<< /Border [ 0
- 0
- 0 ]
- /Contents ()
- /Dest [ 65 0 R
- /XYZ
- 62.69291
- 765.0236
- 0 ]
- /Rect [ 62.69291
- 326.7736
- 155.4829
- 338.7736 ]
- /Subtype /Link
- /Type /Annot >>
-endobj
-% 'Annot.NUMBER30': class LinkAnnotation 
+<< /Border [ 0 0 0 ] /Contents () /Dest [ 56 0 R /XYZ 62.69291 333.8236 0 ] /Rect [ 521.4627 380.7736 532.5827 392.7736 ] /Subtype /Link /Type /Annot >>
+endobj
 35 0 obj
-<< /Border [ 0
- 0
- 0 ]
- /Contents ()
- /Dest [ 65 0 R
- /XYZ
- 62.69291
- 765.0236
- 0 ]
- /Rect [ 521.4627
- 326.7736
- 532.5827
- 338.7736 ]
- /Subtype /Link
- /Type /Annot >>
-endobj
-% 'Annot.NUMBER31': class LinkAnnotation 
+<< /Border [ 0 0 0 ] /Contents () /Dest [ 59 0 R /XYZ 62.69291 542.6236 0 ] /Rect [ 62.69291 362.7736 228.2829 374.7736 ] /Subtype /Link /Type /Annot >>
+endobj
 36 0 obj
-<< /Border [ 0
- 0
- 0 ]
- /Contents ()
- /Dest [ 65 0 R
- /XYZ
- 62.69291
- 414.0236
- 0 ]
- /Rect [ 62.69291
- 308.7736
- 106.5829
- 320.7736 ]
- /Subtype /Link
- /Type /Annot >>
-endobj
-% 'Annot.NUMBER32': class LinkAnnotation 
+<< /Border [ 0 0 0 ] /Contents () /Dest [ 59 0 R /XYZ 62.69291 542.6236 0 ] /Rect [ 521.4627 362.7736 532.5827 374.7736 ] /Subtype /Link /Type /Annot >>
+endobj
 37 0 obj
-<< /Border [ 0
- 0
- 0 ]
- /Contents ()
- /Dest [ 65 0 R
- /XYZ
- 62.69291
- 414.0236
- 0 ]
- /Rect [ 521.4627
- 308.7736
- 532.5827
- 320.7736 ]
- /Subtype /Link
- /Type /Annot >>
-endobj
-% 'Page1': class PDFPage 
+<< /Border [ 0 0 0 ] /Contents () /Dest [ 60 0 R /XYZ 62.69291 131.0236 0 ] /Rect [ 62.69291 344.7736 174.3929 356.7736 ] /Subtype /Link /Type /Annot >>
+endobj
 38 0 obj
-% Page dictionary
-<< /Annots [ 5 0 R
- 6 0 R
- 8 0 R
- 9 0 R
- 10 0 R
- 11 0 R
- 12 0 R
- 13 0 R
- 14 0 R
- 15 0 R
- 16 0 R
- 17 0 R
- 18 0 R
- 19 0 R
- 20 0 R
- 21 0 R
- 22 0 R
- 23 0 R
- 24 0 R
- 25 0 R
- 26 0 R
- 27 0 R
- 28 0 R
- 29 0 R
- 30 0 R
- 31 0 R
- 32 0 R
- 33 0 R
- 34 0 R
- 35 0 R
- 36 0 R
- 37 0 R ]
- /Contents 85 0 R
- /MediaBox [ 0
- 0
- 595.2756
- 841.8898 ]
- /Parent 84 0 R
- /Resources << /Font 1 0 R
- /ProcSet [ /PDF
- /Text
- /ImageB
- /ImageC
- /ImageI ] >>
- /Rotate 0
- /Trans <<  >>
- /Type /Page >>
-endobj
-% 'F5': class PDFType1Font 
+<< /Border [ 0 0 0 ] /Contents () /Dest [ 60 0 R /XYZ 62.69291 131.0236 0 ] /Rect [ 521.4627 344.7736 532.5827 356.7736 ] /Subtype /Link /Type /Annot >>
+endobj
 39 0 obj
-% Font Helvetica-Oblique
-<< /BaseFont /Helvetica-Oblique
- /Encoding /WinAnsiEncoding
- /Name /F5
- /Subtype /Type1
- /Type /Font >>
-endobj
-% 'Annot.NUMBER33': class PDFDictionary 
+<< /Border [ 0 0 0 ] /Contents () /Dest [ 65 0 R /XYZ 62.69291 667.8236 0 ] /Rect [ 62.69291 326.7736 155.4829 338.7736 ] /Subtype /Link /Type /Annot >>
+endobj
 40 0 obj
-<< /A << /S /URI
- /Type /Action
- /URI (http://www.python.org/moin/PythonDecoratorLibrary) >>
- /Border [ 0
- 0
- 0 ]
- /Rect [ 219.6428
- 363.7736
- 449.1728
- 375.7736 ]
- /Subtype /Link
- /Type /Annot >>
-endobj
-% 'F6': class PDFType1Font 
+<< /Border [ 0 0 0 ] /Contents () /Dest [ 65 0 R /XYZ 62.69291 667.8236 0 ] /Rect [ 521.4627 326.7736 532.5827 338.7736 ] /Subtype /Link /Type /Annot >>
+endobj
 41 0 obj
-% Font Courier-Oblique
-<< /BaseFont /Courier-Oblique
- /Encoding /WinAnsiEncoding
- /Name /F6
- /Subtype /Type1
- /Type /Font >>
-endobj
-% 'Annot.NUMBER34': class PDFDictionary 
+<< /Border [ 0 0 0 ] /Contents () /Dest [ 65 0 R /XYZ 62.69291 514.8236 0 ] /Rect [ 62.69291 308.7736 106.5829 320.7736 ] /Subtype /Link /Type /Annot >>
+endobj
 42 0 obj
-<< /A << /S /URI
- /Type /Action
- /URI (http://www.python.org/doc/2.5.2/lib/module-functools.html) >>
- /Border [ 0
- 0
- 0 ]
- /Rect [ 151.0486
- 130.5736
- 270.69
- 142.5736 ]
- /Subtype /Link
- /Type /Annot >>
-endobj
-% 'Page2': class PDFPage 
+<< /Border [ 0 0 0 ] /Contents () /Dest [ 65 0 R /XYZ 62.69291 514.8236 0 ] /Rect [ 521.4627 308.7736 532.5827 320.7736 ] /Subtype /Link /Type /Annot >>
+endobj
 43 0 obj
-% Page dictionary
-<< /Annots [ 40 0 R
- 42 0 R ]
- /Contents 86 0 R
- /MediaBox [ 0
- 0
- 595.2756
- 841.8898 ]
- /Parent 84 0 R
- /Resources << /Font 1 0 R
- /ProcSet [ /PDF
- /Text
- /ImageB
- /ImageC
- /ImageI ] >>
- /Rotate 0
- /Trans <<  >>
- /Type /Page >>
-endobj
-% 'Page3': class PDFPage 
+<< /Annots [ 5 0 R 6 0 R 8 0 R 9 0 R 10 0 R 11 0 R 12 0 R 13 0 R 14 0 R 15 0 R 
+  16 0 R 17 0 R 18 0 R 19 0 R 20 0 R 21 0 R 22 0 R 23 0 R 24 0 R 25 0 R 
+  26 0 R 27 0 R 28 0 R 29 0 R 30 0 R 31 0 R 32 0 R 33 0 R 34 0 R 35 0 R 
+  36 0 R 37 0 R 38 0 R 39 0 R 40 0 R 41 0 R 42 0 R ] /Contents 85 0 R /MediaBox [ 0 0 595.2756 841.8898 ] /Parent 84 0 R /Resources << /Font 1 0 R /ProcSet [ /PDF /Text /ImageB /ImageC /ImageI ] >> /Rotate 0 
+  /Trans <<  >> /Type /Page >>
+endobj
 44 0 obj
-% Page dictionary
-<< /Contents 87 0 R
- /MediaBox [ 0
- 0
- 595.2756
- 841.8898 ]
- /Parent 84 0 R
- /Resources << /Font 1 0 R
- /ProcSet [ /PDF
- /Text
- /ImageB
- /ImageC
- /ImageI ] >>
- /Rotate 0
- /Trans <<  >>
- /Type /Page >>
-endobj
-% 'Page4': class PDFPage 
+<< /BaseFont /Helvetica-Oblique /Encoding /WinAnsiEncoding /Name /F5 /Subtype /Type1 /Type /Font >>
+endobj
 45 0 obj
-% Page dictionary
-<< /Contents 88 0 R
- /MediaBox [ 0
- 0
- 595.2756
- 841.8898 ]
- /Parent 84 0 R
- /Resources << /Font 1 0 R
- /ProcSet [ /PDF
- /Text
- /ImageB
- /ImageC
- /ImageI ] >>
- /Rotate 0
- /Trans <<  >>
- /Type /Page >>
-endobj
-% 'Page5': class PDFPage 
+<< /A << /S /URI /Type /Action /URI (http://www.python.org/moin/PythonDecoratorLibrary) >> /Border [ 0 0 0 ] /Rect [ 219.6428 363.7736 449.1728 375.7736 ] /Subtype /Link /Type /Annot >>
+endobj
 46 0 obj
-% Page dictionary
-<< /Contents 89 0 R
- /MediaBox [ 0
- 0
- 595.2756
- 841.8898 ]
- /Parent 84 0 R
- /Resources << /Font 1 0 R
- /ProcSet [ /PDF
- /Text
- /ImageB
- /ImageC
- /ImageI ] >>
- /Rotate 0
- /Trans <<  >>
- /Type /Page >>
-endobj
-% 'Page6': class PDFPage 
+<< /BaseFont /Courier-Oblique /Encoding /WinAnsiEncoding /Name /F6 /Subtype /Type1 /Type /Font >>
+endobj
 47 0 obj
-% Page dictionary
-<< /Contents 90 0 R
- /MediaBox [ 0
- 0
- 595.2756
- 841.8898 ]
- /Parent 84 0 R
- /Resources << /Font 1 0 R
- /ProcSet [ /PDF
- /Text
- /ImageB
- /ImageC
- /ImageI ] >>
- /Rotate 0
- /Trans <<  >>
- /Type /Page >>
-endobj
-% 'Page7': class PDFPage 
+<< /A << /S /URI /Type /Action /URI (https://docs.python.org/2/library/functools.html#functools.update_wrapper) >> /Border [ 0 0 0 ] /Rect [ 151.0486 118.5736 270.69 130.5736 ] /Subtype /Link /Type /Annot >>
+endobj
 48 0 obj
-% Page dictionary
-<< /Contents 91 0 R
- /MediaBox [ 0
- 0
- 595.2756
- 841.8898 ]
- /Parent 84 0 R
- /Resources << /Font 1 0 R
- /ProcSet [ /PDF
- /Text
- /ImageB
- /ImageC
- /ImageI ] >>
- /Rotate 0
- /Trans <<  >>
- /Type /Page >>
-endobj
-% 'Page8': class PDFPage 
+<< /Annots [ 45 0 R 47 0 R ] /Contents 86 0 R /MediaBox [ 0 0 595.2756 841.8898 ] /Parent 84 0 R /Resources << /Font 1 0 R /ProcSet [ /PDF /Text /ImageB /ImageC /ImageI ] >> /Rotate 0 
+  /Trans <<  >> /Type /Page >>
+endobj
 49 0 obj
-% Page dictionary
-<< /Contents 92 0 R
- /MediaBox [ 0
- 0
- 595.2756
- 841.8898 ]
- /Parent 84 0 R
- /Resources << /Font 1 0 R
- /ProcSet [ /PDF
- /Text
- /ImageB
- /ImageC
- /ImageI ] >>
- /Rotate 0
- /Trans <<  >>
- /Type /Page >>
-endobj
-% 'Page9': class PDFPage 
+<< /Contents 87 0 R /MediaBox [ 0 0 595.2756 841.8898 ] /Parent 84 0 R /Resources << /Font 1 0 R /ProcSet [ /PDF /Text /ImageB /ImageC /ImageI ] >> /Rotate 0 /Trans <<  >> 
+  /Type /Page >>
+endobj
 50 0 obj
-% Page dictionary
-<< /Contents 93 0 R
- /MediaBox [ 0
- 0
- 595.2756
- 841.8898 ]
- /Parent 84 0 R
- /Resources << /Font 1 0 R
- /ProcSet [ /PDF
- /Text
- /ImageB
- /ImageC
- /ImageI ] >>
- /Rotate 0
- /Trans <<  >>
- /Type /Page >>
-endobj
-% 'Page10': class PDFPage 
+<< /Contents 88 0 R /MediaBox [ 0 0 595.2756 841.8898 ] /Parent 84 0 R /Resources << /Font 1 0 R /ProcSet [ /PDF /Text /ImageB /ImageC /ImageI ] >> /Rotate 0 /Trans <<  >> 
+  /Type /Page >>
+endobj
 51 0 obj
-% Page dictionary
-<< /Contents 94 0 R
- /MediaBox [ 0
- 0
- 595.2756
- 841.8898 ]
- /Parent 84 0 R
- /Resources << /Font 1 0 R
- /ProcSet [ /PDF
- /Text
- /ImageB
- /ImageC
- /ImageI ] >>
- /Rotate 0
- /Trans <<  >>
- /Type /Page >>
-endobj
-% 'Annot.NUMBER35': class PDFDictionary 
+<< /Contents 89 0 R /MediaBox [ 0 0 595.2756 841.8898 ] /Parent 84 0 R /Resources << /Font 1 0 R /ProcSet [ /PDF /Text /ImageB /ImageC /ImageI ] >> /Rotate 0 /Trans <<  >> 
+  /Type /Page >>
+endobj
 52 0 obj
-<< /A << /S /URI
- /Type /Action
- /URI (http://bugs.python.org/issue1764286) >>
- /Border [ 0
- 0
- 0 ]
- /Rect [ 137.6966
- 753.7736
- 180.8679
- 765.7736 ]
- /Subtype /Link
- /Type /Annot >>
-endobj
-% 'Annot.NUMBER36': class PDFDictionary 
+<< /Contents 90 0 R /MediaBox [ 0 0 595.2756 841.8898 ] /Parent 84 0 R /Resources << /Font 1 0 R /ProcSet [ /PDF /Text /ImageB /ImageC /ImageI ] >> /Rotate 0 /Trans <<  >> 
+  /Type /Page >>
+endobj
 53 0 obj
-<< /A << /S /URI
- /Type /Action
- /URI (http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/496691) >>
- /Border [ 0
- 0
- 0 ]
- /Rect [ 62.69291
- 280.3736
- 363.4029
- 292.3736 ]
- /Subtype /Link
- /Type /Annot >>
-endobj
-% 'Page11': class PDFPage 
+<< /Contents 91 0 R /MediaBox [ 0 0 595.2756 841.8898 ] /Parent 84 0 R /Resources << /Font 1 0 R /ProcSet [ /PDF /Text /ImageB /ImageC /ImageI ] >> /Rotate 0 /Trans <<  >> 
+  /Type /Page >>
+endobj
 54 0 obj
-% Page dictionary
-<< /Annots [ 52 0 R
- 53 0 R ]
- /Contents 95 0 R
- /MediaBox [ 0
- 0
- 595.2756
- 841.8898 ]
- /Parent 84 0 R
- /Resources << /Font 1 0 R
- /ProcSet [ /PDF
- /Text
- /ImageB
- /ImageC
- /ImageI ] >>
- /Rotate 0
- /Trans <<  >>
- /Type /Page >>
-endobj
-% 'Page12': class PDFPage 
+<< /Contents 92 0 R /MediaBox [ 0 0 595.2756 841.8898 ] /Parent 84 0 R /Resources << /Font 1 0 R /ProcSet [ /PDF /Text /ImageB /ImageC /ImageI ] >> /Rotate 0 /Trans <<  >> 
+  /Type /Page >>
+endobj
 55 0 obj
-% Page dictionary
-<< /Contents 96 0 R
- /MediaBox [ 0
- 0
- 595.2756
- 841.8898 ]
- /Parent 84 0 R
- /Resources << /Font 1 0 R
- /ProcSet [ /PDF
- /Text
- /ImageB
- /ImageC
- /ImageI ] >>
- /Rotate 0
- /Trans <<  >>
- /Type /Page >>
-endobj
-% 'Annot.NUMBER37': class PDFDictionary 
+<< /Contents 93 0 R /MediaBox [ 0 0 595.2756 841.8898 ] /Parent 84 0 R /Resources << /Font 1 0 R /ProcSet [ /PDF /Text /ImageB /ImageC /ImageI ] >> /Rotate 0 /Trans <<  >> 
+  /Type /Page >>
+endobj
 56 0 obj
-<< /A << /S /URI
- /Type /Action
- /URI (http://www.python.org/dev/peps/pep-0362) >>
- /Border [ 0
- 0
- 0 ]
- /Rect [ 301.1597
- 116.9736
- 317.8397
- 128.9736 ]
- /Subtype /Link
- /Type /Annot >>
-endobj
-% 'Page13': class PDFPage 
+<< /Contents 94 0 R /MediaBox [ 0 0 595.2756 841.8898 ] /Parent 84 0 R /Resources << /Font 1 0 R /ProcSet [ /PDF /Text /ImageB /ImageC /ImageI ] >> /Rotate 0 /Trans <<  >> 
+  /Type /Page >>
+endobj
 57 0 obj
-% Page dictionary
-<< /Annots [ 56 0 R ]
- /Contents 97 0 R
- /MediaBox [ 0
- 0
- 595.2756
- 841.8898 ]
- /Parent 84 0 R
- /Resources << /Font 1 0 R
- /ProcSet [ /PDF
- /Text
- /ImageB
- /ImageC
- /ImageI ] >>
- /Rotate 0
- /Trans <<  >>
- /Type /Page >>
-endobj
-% 'Page14': class PDFPage 
+<< /A << /S /URI /Type /Action /URI (http://bugs.python.org/issue1764286) >> /Border [ 0 0 0 ] /Rect [ 137.6966 708.5736 180.8679 720.5736 ] /Subtype /Link /Type /Annot >>
+endobj
 58 0 obj
-% Page dictionary
-<< /Contents 98 0 R
- /MediaBox [ 0
- 0
- 595.2756
- 841.8898 ]
- /Parent 84 0 R
- /Resources << /Font 1 0 R
- /ProcSet [ /PDF
- /Text
- /ImageB
- /ImageC
- /ImageI ] >>
- /Rotate 0
- /Trans <<  >>
- /Type /Page >>
-endobj
-% 'Annot.NUMBER38': class PDFDictionary 
+<< /A << /S /URI /Type /Action /URI (http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/496691) >> /Border [ 0 0 0 ] /Rect [ 62.69291 223.1736 363.4029 235.1736 ] /Subtype /Link /Type /Annot >>
+endobj
 59 0 obj
-<< /A << /S /URI
- /Type /Action
- /URI (http://www.python.org/dev/peps/pep-3107/) >>
- /Border [ 0
- 0
- 0 ]
- /Rect [ 497.5627
- 726.7736
- 531.1777
- 738.7736 ]
- /Subtype /Link
- /Type /Annot >>
-endobj
-% 'Annot.NUMBER39': class PDFDictionary 
+<< /Annots [ 57 0 R 58 0 R ] /Contents 95 0 R /MediaBox [ 0 0 595.2756 841.8898 ] /Parent 84 0 R /Resources << /Font 1 0 R /ProcSet [ /PDF /Text /ImageB /ImageC /ImageI ] >> /Rotate 0 
+  /Trans <<  >> /Type /Page >>
+endobj
 60 0 obj
-<< /A << /S /URI
- /Type /Action
- /URI (http://www.python.org/dev/peps/pep-3107/) >>
- /Border [ 0
- 0
- 0 ]
- /Rect [ 62.69291
- 714.7736
- 114.3929
- 726.7736 ]
- /Subtype /Link
- /Type /Annot >>
-endobj
-% 'Annot.NUMBER40': class PDFDictionary 
+<< /Contents 96 0 R /MediaBox [ 0 0 595.2756 841.8898 ] /Parent 84 0 R /Resources << /Font 1 0 R /ProcSet [ /PDF /Text /ImageB /ImageC /ImageI ] >> /Rotate 0 /Trans <<  >> 
+  /Type /Page >>
+endobj
 61 0 obj
-<< /A << /S /URI
- /Type /Action
- /URI (http://packages.python.org/distribute/) >>
- /Border [ 0
- 0
- 0 ]
- /Rect [ 172.9507
- 702.7736
- 216.6742
- 714.7736 ]
- /Subtype /Link
- /Type /Annot >>
-endobj
-% 'Annot.NUMBER41': class PDFDictionary 
+<< /Contents 97 0 R /MediaBox [ 0 0 595.2756 841.8898 ] /Parent 84 0 R /Resources << /Font 1 0 R /ProcSet [ /PDF /Text /ImageB /ImageC /ImageI ] >> /Rotate 0 /Trans <<  >> 
+  /Type /Page >>
+endobj
 62 0 obj
-<< /A << /S /URI
- /Type /Action
- /URI (http://docutils.sourceforge.net/) >>
- /Border [ 0
- 0
- 0 ]
- /Rect [ 82.15291
- 678.7736
- 118.8329
- 690.7736 ]
- /Subtype /Link
- /Type /Annot >>
-endobj
-% 'Annot.NUMBER42': class PDFDictionary 
+<< /A << /S /URI /Type /Action /URI (http://www.python.org/dev/peps/pep-0362) >> /Border [ 0 0 0 ] /Rect [ 301.1597 729.7736 317.8397 741.7736 ] /Subtype /Link /Type /Annot >>
+endobj
 63 0 obj
-<< /A << /S /URI
- /Type /Action
- /URI (http://pygments.org/) >>
- /Border [ 0
- 0
- 0 ]
- /Rect [ 138.2929
- 678.7736
- 184.4229
- 690.7736 ]
- /Subtype /Link
- /Type /Annot >>
-endobj
-% 'Annot.NUMBER43': class PDFDictionary 
+<< /Annots [ 62 0 R ] /Contents 98 0 R /MediaBox [ 0 0 595.2756 841.8898 ] /Parent 84 0 R /Resources << /Font 1 0 R /ProcSet [ /PDF /Text /ImageB /ImageC /ImageI ] >> /Rotate 0 
+  /Trans <<  >> /Type /Page >>
+endobj
 64 0 obj
-<< /A << /S /URI
- /Type /Action
- /URI (http://www.phyast.pitt.edu/~micheles/python/documentation.html#class-decorators-and-decorator-factories) >>
- /Border [ 0
- 0
- 0 ]
- /Rect [ 364.2921
- 540.7736
- 531.64
- 552.7736 ]
- /Subtype /Link
- /Type /Annot >>
-endobj
-% 'Page15': class PDFPage 
+<< /A << /S /URI /Type /Action /URI (http://www.python.org/dev/peps/pep-3107/) >> /Border [ 0 0 0 ] /Rect [ 281.1568 629.5736 372.4888 641.5736 ] /Subtype /Link /Type /Annot >>
+endobj
 65 0 obj
-% Page dictionary
-<< /Annots [ 59 0 R
- 60 0 R
- 61 0 R
- 62 0 R
- 63 0 R
- 64 0 R ]
- /Contents 99 0 R
- /MediaBox [ 0
- 0
- 595.2756
- 841.8898 ]
- /Parent 84 0 R
- /Resources << /Font 1 0 R
- /ProcSet [ /PDF
- /Text
- /ImageB
- /ImageC
- /ImageI ] >>
- /Rotate 0
- /Trans <<  >>
- /Type /Page >>
-endobj
-% 'R66': class PDFCatalog 
+<< /Annots [ 64 0 R ] /Contents 99 0 R /MediaBox [ 0 0 595.2756 841.8898 ] /Parent 84 0 R /Resources << /Font 1 0 R /ProcSet [ /PDF /Text /ImageB /ImageC /ImageI ] >> /Rotate 0 
+  /Trans <<  >> /Type /Page >>
+endobj
 66 0 obj
-% Document Root
-<< /Outlines 68 0 R
- /PageLabels 100 0 R
- /PageMode /UseNone
- /Pages 84 0 R
- /Type /Catalog >>
-endobj
-% 'R67': class PDFInfo 
+<< /Outlines 68 0 R /PageLabels 100 0 R /PageMode /UseNone /Pages 84 0 R /Type /Catalog >>
+endobj
 67 0 obj
-<< /Author (Michele Simionato)
- /CreationDate (D:20121018102559-01'00')
- /Creator (\(unspecified\))
- /Keywords ()
- /Producer (ReportLab PDF Library - www.reportlab.com)
- /Subject (\(unspecified\))
- /Title (The decorator module) >>
-endobj
-% 'R68': class PDFOutlines 
+<< /Author (Michele Simionato) /CreationDate (D:20150316121851-01'00') /Creator (\(unspecified\)) /Keywords () /Producer (ReportLab PDF Library - www.reportlab.com) /Subject (\(unspecified\)) 
+  /Title (The decorator module) >>
+endobj
 68 0 obj
-<< /Count 15
- /First 69 0 R
- /Last 83 0 R
- /Type /Outlines >>
+<< /Count 15 /First 69 0 R /Last 83 0 R /Type /Outlines >>
 endobj
-% 'Outline.0': class OutlineEntryObject 
 69 0 obj
-<< /Dest [ 38 0 R
- /XYZ
- 62.69291
- 293.0236
- 0 ]
- /Next 70 0 R
- /Parent 68 0 R
- /Title (Introduction) >>
-endobj
-% 'Outline.1': class OutlineEntryObject 
+<< /Dest [ 43 0 R /XYZ 62.69291 293.0236 0 ] /Next 70 0 R /Parent 68 0 R /Title (Introduction) >>
+endobj
 70 0 obj
-<< /Dest [ 43 0 R
- /XYZ
- 62.69291
- 675.0236
- 0 ]
- /Next 71 0 R
- /Parent 68 0 R
- /Prev 69 0 R
- /Title (Definitions) >>
-endobj
-% 'Outline.2': class OutlineEntryObject 
+<< /Dest [ 48 0 R /XYZ 62.69291 675.0236 0 ] /Next 71 0 R /Parent 68 0 R /Prev 69 0 R /Title (Definitions) >>
+endobj
 71 0 obj
-<< /Dest [ 43 0 R
- /XYZ
- 62.69291
- 438.0236
- 0 ]
- /Next 72 0 R
- /Parent 68 0 R
- /Prev 70 0 R
- /Title (Statement of the problem) >>
-endobj
-% 'Outline.3': class OutlineEntryObject 
+<< /Dest [ 48 0 R /XYZ 62.69291 438.0236 0 ] /Next 72 0 R /Parent 68 0 R /Prev 70 0 R /Title (Statement of the problem) >>
+endobj
 72 0 obj
-<< /Dest [ 44 0 R
- /XYZ
- 62.69291
- 427.4236
- 0 ]
- /Next 73 0 R
- /Parent 68 0 R
- /Prev 71 0 R
- /Title (The solution) >>
-endobj
-% 'Outline.4': class OutlineEntryObject 
+<< /Dest [ 49 0 R /XYZ 62.69291 427.4236 0 ] /Next 73 0 R /Parent 68 0 R /Prev 71 0 R /Title (The solution) >>
+endobj
 73 0 obj
-<< /Dest [ 45 0 R
- /XYZ
- 62.69291
- 435.4236
- 0 ]
- /Next 74 0 R
- /Parent 68 0 R
- /Prev 72 0 R
- /Title (A trace decorator) >>
-endobj
-% 'Outline.5': class OutlineEntryObject 
+<< /Dest [ 50 0 R /XYZ 62.69291 435.4236 0 ] /Next 74 0 R /Parent 68 0 R /Prev 72 0 R /Title (A trace decorator) >>
+endobj
 74 0 obj
-<< /Dest [ 46 0 R
- /XYZ
- 62.69291
- 398.778
- 0 ]
- /Next 75 0 R
- /Parent 68 0 R
- /Prev 73 0 R
- /Title (decorator is a decorator) >>
-endobj
-% 'Outline.6': class OutlineEntryObject 
+<< /Dest [ 51 0 R /XYZ 62.69291 397.4236 0 ] /Next 75 0 R /Parent 68 0 R /Prev 73 0 R /Title (decorator is a decorator) >>
+endobj
 75 0 obj
-<< /Dest [ 47 0 R
- /XYZ
- 62.69291
- 647.8236
- 0 ]
- /Next 76 0 R
- /Parent 68 0 R
- /Prev 74 0 R
- /Title (blocking) >>
-endobj
-% 'Outline.7': class OutlineEntryObject 
+<< /Dest [ 52 0 R /XYZ 62.69291 647.8236 0 ] /Next 76 0 R /Parent 68 0 R /Prev 74 0 R /Title (blocking) >>
+endobj
 76 0 obj
-<< /Dest [ 48 0 R
- /XYZ
- 62.69291
- 765.0236
- 0 ]
- /Next 77 0 R
- /Parent 68 0 R
- /Prev 75 0 R
- /Title (async) >>
-endobj
-% 'Outline.8': class OutlineEntryObject 
+<< /Dest [ 53 0 R /XYZ 62.69291 765.0236 0 ] /Next 77 0 R /Parent 68 0 R /Prev 75 0 R /Title (async) >>
+endobj
 77 0 obj
-<< /Dest [ 49 0 R
- /XYZ
- 62.69291
- 267.4236
- 0 ]
- /Next 78 0 R
- /Parent 68 0 R
- /Prev 76 0 R
- /Title (contextmanager) >>
-endobj
-% 'Outline.9': class OutlineEntryObject 
+<< /Dest [ 54 0 R /XYZ 62.69291 255.4236 0 ] /Next 78 0 R /Parent 68 0 R /Prev 76 0 R /Title (contextmanager) >>
+endobj
 78 0 obj
-<< /Dest [ 50 0 R
- /XYZ
- 62.69291
- 354.6236
- 0 ]
- /Next 79 0 R
- /Parent 68 0 R
- /Prev 77 0 R
- /Title (The FunctionMaker class) >>
-endobj
-% 'Outline.10': class OutlineEntryObject 
+<< /Dest [ 55 0 R /XYZ 62.69291 324.6236 0 ] /Next 79 0 R /Parent 68 0 R /Prev 77 0 R /Title (The FunctionMaker class) >>
+endobj
 79 0 obj
-<< /Dest [ 51 0 R
- /XYZ
- 62.69291
- 363.8236
- 0 ]
- /Next 80 0 R
- /Parent 68 0 R
- /Prev 78 0 R
- /Title (Getting the source code) >>
-endobj
-% 'Outline.11': class OutlineEntryObject 
+<< /Dest [ 56 0 R /XYZ 62.69291 333.8236 0 ] /Next 80 0 R /Parent 68 0 R /Prev 78 0 R /Title (Getting the source code) >>
+endobj
 80 0 obj
-<< /Dest [ 54 0 R
- /XYZ
- 62.69291
- 599.8236
- 0 ]
- /Next 81 0 R
- /Parent 68 0 R
- /Prev 79 0 R
- /Title (Dealing with third party decorators) >>
-endobj
-% 'Outline.12': class OutlineEntryObject 
+<< /Dest [ 59 0 R /XYZ 62.69291 542.6236 0 ] /Next 81 0 R /Parent 68 0 R /Prev 79 0 R /Title (Dealing with third party decorators) >>
+endobj
 81 0 obj
-<< /Dest [ 55 0 R
- /XYZ
- 62.69291
- 215.0236
- 0 ]
- /Next 82 0 R
- /Parent 68 0 R
- /Prev 80 0 R
- /Title (Caveats and limitations) >>
-endobj
-% 'Outline.13': class OutlineEntryObject 
+<< /Dest [ 60 0 R /XYZ 62.69291 131.0236 0 ] /Next 82 0 R /Parent 68 0 R /Prev 80 0 R /Title (Caveats and limitations) >>
+endobj
 82 0 obj
-<< /Dest [ 65 0 R
- /XYZ
- 62.69291
- 765.0236
- 0 ]
- /Next 83 0 R
- /Parent 68 0 R
- /Prev 81 0 R
- /Title (Compatibility notes) >>
-endobj
-% 'Outline.14': class OutlineEntryObject 
+<< /Dest [ 65 0 R /XYZ 62.69291 667.8236 0 ] /Next 83 0 R /Parent 68 0 R /Prev 81 0 R /Title (Compatibility notes) >>
+endobj
 83 0 obj
-<< /Dest [ 65 0 R
- /XYZ
- 62.69291
- 414.0236
- 0 ]
- /Parent 68 0 R
- /Prev 82 0 R
- /Title (LICENCE) >>
-endobj
-% 'R84': class PDFPages 
+<< /Dest [ 65 0 R /XYZ 62.69291 514.8236 0 ] /Parent 68 0 R /Prev 82 0 R /Title (LICENCE) >>
+endobj
 84 0 obj
-% page tree
-<< /Count 15
- /Kids [ 38 0 R
- 43 0 R
- 44 0 R
- 45 0 R
- 46 0 R
- 47 0 R
- 48 0 R
- 49 0 R
- 50 0 R
- 51 0 R
- 54 0 R
- 55 0 R
- 57 0 R
- 58 0 R
- 65 0 R ]
- /Type /Pages >>
-endobj
-% 'R85': class PDFStream 
+<< /Count 15 /Kids [ 43 0 R 48 0 R 49 0 R 50 0 R 51 0 R 52 0 R 53 0 R 54 0 R 55 0 R 56 0 R 
+  59 0 R 60 0 R 61 0 R 63 0 R 65 0 R ] /Type /Pages >>
+endobj
 85 0 obj
-% page stream
-<< /Length 9046 >>
+<< /Length 9109 >>
 stream
 1 0 0 1 0 0 cm  BT /F1 12 Tf 14.4 TL ET
 q
 1 0 0 1 62.69291 741.0236 cm
 q
-BT 1 0 0 1 0 4 Tm 118.8249 0 Td 24 TL /F2 20 Tf 0 0 0 rg (The ) Tj /F3 20 Tf (decorator ) Tj /F2 20 Tf (module) Tj T* -118.8249 0 Td ET
+BT 1 0 0 1 0 4 Tm 118.8249 0 Td 24 TL /F2 20 Tf 0 0 0 rg (The ) Tj /F3 20 Tf 0 0 0 rg (decorator ) Tj /F2 20 Tf 0 0 0 rg (module) Tj T* -118.8249 0 Td ET
 Q
 Q
 q
@@ -1420,7 +338,7 @@ q
 1 0 0 1 91.03937 3 cm
 q
 0 0 0 rg
-BT 1 0 0 1 0 2 Tm /F1 10 Tf 12 TL (3.4.0 \(2012-10-18\)) Tj T* ET
+BT 1 0 0 1 0 2 Tm /F1 10 Tf 12 TL (3.4.1 \(2015-03-16\)) Tj T* ET
 Q
 Q
 q
@@ -1463,7 +381,7 @@ q
 q
 0 0 .501961 rg
 0 0 .501961 RG
-BT 1 0 0 1 0 2 Tm /F1 10 Tf 12 TL (http://pypi.python.org/pypi/decorator/3.4.0) Tj T* ET
+BT 1 0 0 1 0 2 Tm /F1 10 Tf 12 TL (http://pypi.python.org/pypi/decorator/3.4.1) Tj T* ET
 Q
 Q
 q
@@ -1579,7 +497,7 @@ Q
 q
 1 0 0 1 0 183 cm
 q
-BT 1 0 0 1 0 2 Tm 12 TL /F2 10 Tf 0 0 .501961 rg (A ) Tj /F3 10 Tf (trace ) Tj /F2 10 Tf (decorator) Tj T* ET
+BT 1 0 0 1 0 2 Tm 12 TL /F2 10 Tf 0 0 .501961 rg (A ) Tj /F3 10 Tf 0 0 0 rg (trace ) Tj /F2 10 Tf 0 0 .501961 rg (decorator) Tj T* ET
 Q
 Q
 q
@@ -1593,7 +511,7 @@ Q
 q
 1 0 0 1 0 165 cm
 q
-BT 1 0 0 1 0 2 Tm 12 TL /F3 10 Tf 0 0 .501961 rg (decorator ) Tj /F2 10 Tf (is a decorator) Tj T* ET
+BT 1 0 0 1 0 2 Tm 12 TL /F3 10 Tf 0 0 0 rg (decorator ) Tj /F2 10 Tf 0 0 .501961 rg (is a decorator) Tj T* ET
 Q
 Q
 q
@@ -1607,7 +525,7 @@ Q
 q
 1 0 0 1 0 147 cm
 q
-BT 1 0 0 1 0 2 Tm 12 TL /F3 10 Tf 0 0 .501961 rg (blocking) Tj T* ET
+BT 1 0 0 1 0 2 Tm 12 TL /F3 10 Tf 0 0 0 rg (blocking) Tj T* ET
 Q
 Q
 q
@@ -1621,7 +539,7 @@ Q
 q
 1 0 0 1 0 129 cm
 q
-BT 1 0 0 1 0 2 Tm 12 TL /F3 10 Tf 0 0 .501961 rg (async) Tj T* ET
+BT 1 0 0 1 0 2 Tm 12 TL /F3 10 Tf 0 0 0 rg (async) Tj T* ET
 Q
 Q
 q
@@ -1649,7 +567,7 @@ Q
 q
 1 0 0 1 0 93 cm
 q
-BT 1 0 0 1 0 2 Tm 12 TL /F2 10 Tf 0 0 .501961 rg (The ) Tj /F3 10 Tf (FunctionMaker ) Tj /F2 10 Tf (class) Tj T* ET
+BT 1 0 0 1 0 2 Tm 12 TL /F2 10 Tf 0 0 .501961 rg (The ) Tj /F3 10 Tf 0 0 0 rg (FunctionMaker ) Tj /F2 10 Tf 0 0 .501961 rg (class) Tj T* ET
 Q
 Q
 q
@@ -1858,22 +776,20 @@ Q
  
 endstream
 endobj
-% 'R86': class PDFStream 
 86 0 obj
-% page stream
-<< /Length 7546 >>
+<< /Length 12549 >>
 stream
 1 0 0 1 0 0 cm  BT /F1 12 Tf 14.4 TL ET
 q
 1 0 0 1 62.69291 717.0236 cm
 q
-BT 1 0 0 1 0 38 Tm 1.093735 Tw 12 TL /F1 10 Tf 0 0 0 rg (The aim of the ) Tj /F4 10 Tf (decorator ) Tj /F1 10 Tf (module it to simplify the usage of decorators for the average programmer,) Tj T* 0 Tw 2.456136 Tw (and to popularize decorators by showing various non-trivial examples. Of course, as all techniques,) Tj T* 0 Tw 2.234987 Tw (decorators can be abused \(I have seen that\) and you should not try to solve every problem with a) Tj T* 0 Tw (decorator, just because you can.) Tj T* ET
+BT 1 0 0 1 0 38 Tm 1.093735 Tw 12 TL /F1 10 Tf 0 0 0 rg (The aim of the ) Tj /F4 10 Tf 0 0 0 rg (decorator ) Tj /F1 10 Tf 0 0 0 rg (module it to simplify the usage of decorators for the average programmer,) Tj T* 0 Tw 2.456136 Tw (and to popularize decorators by showing various non-trivial examples. Of course, as all techniques,) Tj T* 0 Tw 2.234987 Tw (decorators can be abused \(I have seen that\) and you should not try to solve every problem with a) Tj T* 0 Tw (decorator, just because you can.) Tj T* ET
 Q
 Q
 q
 1 0 0 1 62.69291 687.0236 cm
 q
-BT 1 0 0 1 0 14 Tm .13561 Tw 12 TL /F1 10 Tf 0 0 0 rg (You may find the source code for all the examples discussed here in the ) Tj /F4 10 Tf (documentation.py ) Tj /F1 10 Tf (file, which) Tj T* 0 Tw (contains this documentation in the form of doctests.) Tj T* ET
+BT 1 0 0 1 0 14 Tm .13561 Tw 12 TL /F1 10 Tf 0 0 0 rg (You may find the source code for all the examples discussed here in the ) Tj /F4 10 Tf 0 0 0 rg (documentation.py ) Tj /F1 10 Tf 0 0 0 rg (file, which) Tj T* 0 Tw (contains this documentation in the form of doctests.) Tj T* ET
 Q
 Q
 q
@@ -1944,7 +860,7 @@ Q
 q
 1 0 0 1 62.69291 510.0236 cm
 q
-BT 1 0 0 1 0 26 Tm 2.832706 Tw 12 TL /F1 10 Tf 0 0 0 rg (Signature-changing decorators have their use: for instance the builtin classes ) Tj /F4 10 Tf (staticmethod ) Tj /F1 10 Tf (and) Tj T* 0 Tw 1.506651 Tw /F4 10 Tf (classmethod ) Tj /F1 10 Tf (are in this group, since they take functions and return descriptor objects which are not) Tj T* 0 Tw (functions, nor callables.) Tj T* ET
+BT 1 0 0 1 0 26 Tm 2.832706 Tw 12 TL /F1 10 Tf 0 0 0 rg (Signature-changing decorators have their use: for instance the builtin classes ) Tj /F4 10 Tf 0 0 0 rg (staticmethod ) Tj /F1 10 Tf 0 0 0 rg (and) Tj T* 0 Tw 1.506651 Tw /F4 10 Tf 0 0 0 rg (classmethod ) Tj /F1 10 Tf 0 0 0 rg (are in this group, since they take functions and return descriptor objects which are not) Tj T* 0 Tw (functions, nor callables.) Tj T* ET
 Q
 Q
 q
@@ -1970,11 +886,11 @@ Q
 q
 1 0 0 1 62.69291 339.0236 cm
 q
-BT 1 0 0 1 0 62 Tm .351235 Tw 12 TL /F1 10 Tf 0 0 0 rg (A very common use case for decorators is the memoization of functions. A ) Tj /F4 10 Tf (memoize ) Tj /F1 10 Tf (decorator works by) Tj T* 0 Tw .871988 Tw (caching the result of the function call in a dictionary, so that the next time the function is called with the) Tj T* 0 Tw 2.350651 Tw (same input parameters the result is retrieved from the cache and not recomputed. There are many) Tj T* 0 Tw 2.92247 Tw (implementations of ) Tj /F4 10 Tf (memoize ) Tj /F1 10 Tf (in ) Tj 0 0 .501961 rg (http://www.python.org/moin/PythonDecoratorLibrary) Tj 0 0 0 rg (, but they do not) Tj T* 0 Tw 2.683984 Tw (preserve the signature. A simple implementation could be the following \(notice that in general it is) Tj T* 0 Tw (impossible to memoize correctly something that depends on non-hashable arguments\):) Tj T* ET
+BT 1 0 0 1 0 62 Tm .351235 Tw 12 TL /F1 10 Tf 0 0 0 rg (A very common use case for decorators is the memoization of functions. A ) Tj /F4 10 Tf 0 0 0 rg (memoize ) Tj /F1 10 Tf 0 0 0 rg (decorator works by) Tj T* 0 Tw .871988 Tw (caching the result of the function call in a dictionary, so that the next time the function is called with the) Tj T* 0 Tw 2.350651 Tw (same input parameters the result is retrieved from the cache and not recomputed. There are many) Tj T* 0 Tw 2.92247 Tw (implementations of ) Tj /F4 10 Tf 0 0 0 rg (memoize ) Tj /F1 10 Tf 0 0 0 rg (in ) Tj 0 0 .501961 rg (http://www.python.org/moin/PythonDecoratorLibrary) Tj 0 0 0 rg (, but they do not) Tj T* 0 Tw 2.683984 Tw (preserve the signature. A simple implementation could be the following \(notice that in general it is) Tj T* 0 Tw (impossible to memoize correctly something that depends on non-hashable arguments\):) Tj T* ET
 Q
 Q
 q
-1 0 0 1 62.69291 149.8236 cm
+1 0 0 1 62.69291 137.8236 cm
 q
 q
 1 0 0 1 0 0 cm
@@ -1984,34 +900,194 @@ q
 .662745 .662745 .662745 RG
 .5 w
 .960784 .960784 .862745 rg
-n -6 -6 468.6898 180 re B*
+n -6 -6 468.6898 192 re B*
 Q
 q
-BT 1 0 0 1 0 158 Tm 12 TL /F3 10 Tf 0 .501961 0 rg (def) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 1 rg (memoize_uw) Tj 0 0 0 rg (\() Tj (func) Tj (\):) Tj  T* (    ) Tj (func) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (cache) Tj ( ) Tj .4 .4 .4 rg (=) Tj 0 0 0 rg ( ) Tj ({}) Tj  T* (    ) Tj /F3 10 Tf 0 .501961 0 rg (def) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 1 rg (memoize) Tj 0 0 0 rg (\() Tj .4 .4 .4 rg (*) Tj 0 0 0 rg (args) Tj (,) Tj ( ) Tj .4 .4 .4 rg (**) Tj 0 0 0 rg (kw) Tj (\):) Tj  T* (        ) Tj /F3 10 Tf 0 .501961 0 rg (if) Tj /F4 10 Tf 0 0 0 rg ( ) Tj (kw) Tj (:) Tj ( ) Tj /F6 10 Tf .25098 .501961 .501961 rg (# frozenset is used to ensure hashability) Tj /F4 10 Tf 0 0 0 rg  T* (            ) Tj (key) Tj ( ) Tj .4 .4 .4 rg (=) Tj 0 0 0 rg ( ) Tj (args) Tj (,) Tj ( ) Tj 0 .501961 0 rg (frozenset) Tj 0 0 0 rg (\() Tj (kw) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (iteritems) Tj (\(\)\)) Tj  T* (        ) Tj /F3 10 Tf 0 .501961 0 rg (else) Tj /F4 10 Tf 0 0 0 rg (:) Tj  T* (            ) Tj (key) Tj ( ) Tj .4 .4 .4 rg (=) Tj 0 0 0 rg ( ) Tj (args) Tj  T* (        ) Tj (cache) Tj ( ) Tj .4 .4 .4 rg (=) Tj 0 0 0 rg ( ) Tj (func) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (cache) Tj  T* (        ) Tj /F3 10 Tf 0 .501961 0 rg (if) Tj /F4 10 Tf 0 0 0 rg ( ) Tj (key) Tj ( ) Tj /F3 10 Tf .666667 .133333 1 rg (in) Tj /F4 10 Tf 0 0 0 rg ( ) Tj (cache) Tj (:) Tj  T* (            ) Tj /F3 10 Tf 0 .501961 0 rg (return) Tj /F4 10 Tf 0 0 0 rg ( ) Tj (cache) Tj ([) Tj (key) Tj (]) Tj  T* (        ) Tj /F3 10 Tf 0 .501961 0 rg (else) Tj /F4 10 Tf 0 0 0 rg (:) Tj  T* (            ) Tj (cache) Tj ([) Tj (key) Tj (]) Tj ( ) Tj .4 .4 .4 rg (=) Tj 0 0 0 rg ( ) Tj (result) Tj ( ) Tj .4 .4 .4 rg (=) Tj 0 0 0 rg ( ) Tj (func) Tj (\() Tj .4 .4 .4 rg (*) Tj 0 0 0 rg (args) Tj (,) Tj ( ) Tj .4 .4 .4 rg (**) Tj 0 0 0 rg (kw) Tj (\)) Tj  T* (            ) Tj /F3 10 Tf 0 .501961 0 rg (return) Tj /F4 10 Tf 0 0 0 rg ( ) Tj (result) Tj  T* (    ) Tj /F3 10 Tf 0 .501961 0 rg (return) Tj /F4 10 Tf 0 0 0 rg ( ) Tj (functools) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (update_wrapper) Tj (\() Tj (memoize) Tj (,) Tj ( ) Tj (func) Tj (\)) Tj T* ET
+.960784 .960784 .862745 rg
+n 0 168.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 24 168.75 60 12 re f*
+.960784 .960784 .862745 rg
+n 84 168.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 90 168.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 114 168.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 24 156.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 48 156.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 54 156.75 30 12 re f*
+.960784 .960784 .862745 rg
+n 90 156.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 102 156.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 24 132.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 48 132.75 42 12 re f*
+.960784 .960784 .862745 rg
+n 90 132.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 96 132.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 102 132.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 126 132.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 138 132.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 150 132.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 162 132.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 48 120.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 66 120.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 78 120.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 96 120.75 246 12 re f*
+.960784 .960784 .862745 rg
+n 72 108.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 96 108.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 108 108.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 132 108.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 144 108.75 54 12 re f*
+.960784 .960784 .862745 rg
+n 198 108.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 204 108.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 216 108.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 222 108.75 54 12 re f*
+.960784 .960784 .862745 rg
+n 276 108.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 48 96.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 72 96.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 72 84.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 96 84.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 108 84.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 48 72.75 30 12 re f*
+.960784 .960784 .862745 rg
+n 84 72.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 96 72.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 120 72.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 126 72.75 30 12 re f*
+.960784 .960784 .862745 rg
+n 48 60.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 66 60.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 90 60.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 108 60.75 30 12 re f*
+.960784 .960784 .862745 rg
+n 138 60.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 72 48.75 36 12 re f*
+.960784 .960784 .862745 rg
+n 114 48.75 30 12 re f*
+.960784 .960784 .862745 rg
+n 144 48.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 150 48.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 168 48.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 48 36.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 72 36.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 72 24.75 30 12 re f*
+.960784 .960784 .862745 rg
+n 102 24.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 108 24.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 126 24.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 138 24.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 150 24.75 36 12 re f*
+.960784 .960784 .862745 rg
+n 192 24.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 204 24.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 228 24.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 234 24.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 240 24.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 264 24.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 276 24.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 288 24.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 300 24.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 72 12.75 36 12 re f*
+.960784 .960784 .862745 rg
+n 114 12.75 36 12 re f*
+.960784 .960784 .862745 rg
+n 24 .75 36 12 re f*
+.960784 .960784 .862745 rg
+n 66 .75 54 12 re f*
+.960784 .960784 .862745 rg
+n 120 .75 6 12 re f*
+.960784 .960784 .862745 rg
+n 126 .75 84 12 re f*
+.960784 .960784 .862745 rg
+n 210 .75 6 12 re f*
+.960784 .960784 .862745 rg
+n 216 .75 42 12 re f*
+.960784 .960784 .862745 rg
+n 258 .75 6 12 re f*
+.960784 .960784 .862745 rg
+n 270 .75 24 12 re f*
+.960784 .960784 .862745 rg
+n 294 .75 6 12 re f*
+BT 1 0 0 1 0 170 Tm 12 TL /F3 10 Tf 0 .501961 0 rg (def) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 1 rg (memoize_uw) Tj 0 0 0 rg (\() Tj 0 0 0 rg (func) Tj 0 0 0 rg (\):) Tj 0 0 0 rg  T* (    ) Tj 0 0 0 rg (func) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (cache) Tj 0 0 0 rg ( ) Tj .4 .4 .4 rg (=) Tj 0 0 0 rg ( ) Tj 0 0 0 rg ({}) Tj 0 0 0 rg  T*  T* (    ) Tj /F3 10 Tf 0 .501961 0 rg (def) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 1 rg (memoize) Tj 0 0 0 rg (\() Tj .4 .4 .4 rg (*) Tj 0 0 0 rg (args) Tj 0 0 0 rg (,) Tj 0 0 0 rg ( ) Tj .4 .4 .4 rg (**) Tj 0 0 0 rg (kw) Tj 0 0 0 rg (\):) Tj 0 0 0 rg  T* (        ) Tj /F3 10 Tf 0 .501961 0 rg (if) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 0 rg (kw) Tj 0 0 0 rg (:) Tj 0 0 0 rg (  ) Tj /F6 10 Tf .25098 .501961 .501961 rg (# frozenset is used to ensure hashability) Tj /F4 10 Tf 0 0 0 rg  T* (            ) Tj 0 0 0 rg (key) Tj 0 0 0 rg ( ) Tj .4 .4 .4 rg (=) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (args) Tj 0 0 0 rg (,) Tj 0 0 0 rg ( ) Tj 0 .501961 0 rg (frozenset) Tj 0 0 0 rg (\() Tj 0 0 0 rg (kw) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (iteritems) Tj 0 0 0 rg (\(\)\)) Tj 0 0 0 rg  T* (        ) Tj /F3 10 Tf 0 .501961 0 rg (else) Tj /F4 10 Tf 0 0 0 rg (:) Tj 0 0 0 rg  T* (            ) Tj 0 0 0 rg (key) Tj 0 0 0 rg ( ) Tj .4 .4 .4 rg (=) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (args) Tj 0 0 0 rg  T* (        ) Tj 0 0 0 rg (cache) Tj 0 0 0 rg ( ) Tj .4 .4 .4 rg (=) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (func) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (cache) Tj 0 0 0 rg  T* (        ) Tj /F3 10 Tf 0 .501961 0 rg (if) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 0 rg (key) Tj 0 0 0 rg ( ) Tj /F3 10 Tf .666667 .133333 1 rg (in) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 0 rg (cache) Tj 0 0 0 rg (:) Tj 0 0 0 rg  T* (            ) Tj /F3 10 Tf 0 .501961 0 rg (return) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 0 rg (cache) Tj 0 0 0 rg ([) Tj 0 0 0 rg (key) Tj 0 0 0 rg (]) Tj 0 0 0 rg  T* (        ) Tj /F3 10 Tf 0 .501961 0 rg (else) Tj /F4 10 Tf 0 0 0 rg (:) Tj 0 0 0 rg  T* (            ) Tj 0 0 0 rg (cache) Tj 0 0 0 rg ([) Tj 0 0 0 rg (key) Tj 0 0 0 rg (]) Tj 0 0 0 rg ( ) Tj .4 .4 .4 rg (=) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (result) Tj 0 0 0 rg ( ) Tj .4 .4 .4 rg (=) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (func) Tj 0 0 0 rg (\() Tj .4 .4 .4 rg (*) Tj 0 0 0 rg (args) Tj 0 0 0 rg (,) Tj 0 0 0 rg ( ) Tj .4 .4 .4 rg (**) Tj 0 0 0 rg (kw) Tj 0 0 0 rg (\)) Tj 0 0 0 rg  T* (            ) Tj /F3 10 Tf 0 .501961 0 rg (return) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 0 rg (result) Tj 0 0 0 rg  T* (    ) Tj /F3 10 Tf 0 .501961 0 rg (return) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 0 rg (functools) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (update_wrapper) Tj 0 0 0 rg (\() Tj 0 0 0 rg (memoize) Tj 0 0 0 rg (,) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (func) Tj 0 0 0 rg (\)) Tj T* ET
 Q
 Q
 Q
 Q
 Q
 q
-1 0 0 1 62.69291 93.82362 cm
+1 0 0 1 62.69291 81.82362 cm
 q
-BT 1 0 0 1 0 38 Tm 1.801412 Tw 12 TL /F1 10 Tf 0 0 0 rg (Here we used the ) Tj 0 0 .501961 rg (functools.update_wrapper ) Tj 0 0 0 rg (utility, which has been added in Python 2.5 expressly to) Tj T* 0 Tw .91686 Tw (simplify the definition of decorators \(in older versions of Python you need to copy the function attributes) Tj T* 0 Tw .580814 Tw /F4 10 Tf (__name__) Tj /F1 10 Tf (, ) Tj /F4 10 Tf (__doc__) Tj /F1 10 Tf (, ) Tj /F4 10 Tf (__module__ ) Tj /F1 10 Tf (and ) Tj /F4 10 Tf (__dict__ ) Tj /F1 10 Tf (from the original function to the decorated function) Tj T* 0 Tw (by hand\).) Tj T* ET
+BT 1 0 0 1 0 38 Tm 1.801412 Tw 12 TL /F1 10 Tf 0 0 0 rg (Here we used the ) Tj 0 0 .501961 rg (functools.update_wrapper ) Tj 0 0 0 rg (utility, which has been added in Python 2.5 expressly to) Tj T* 0 Tw .91686 Tw (simplify the definition of decorators \(in older versions of Python you need to copy the function attributes) Tj T* 0 Tw .580814 Tw /F4 10 Tf 0 0 0 rg (__name__) Tj /F1 10 Tf 0 0 0 rg (, ) Tj /F4 10 Tf 0 0 0 rg (__doc__) Tj /F1 10 Tf 0 0 0 rg (, ) Tj /F4 10 Tf 0 0 0 rg (__module__ ) Tj /F1 10 Tf 0 0 0 rg (and ) Tj /F4 10 Tf 0 0 0 rg (__dict__ ) Tj /F1 10 Tf 0 0 0 rg (from the original function to the decorated function) Tj T* 0 Tw (by hand\).) Tj T* ET
 Q
 Q
  
 endstream
 endobj
-% 'R87': class PDFStream 
 87 0 obj
-% page stream
-<< /Length 8057 >>
+<< /Length 17189 >>
 stream
 1 0 0 1 0 0 cm  BT /F1 12 Tf 14.4 TL ET
 q
 1 0 0 1 62.69291 729.0236 cm
 q
-BT 1 0 0 1 0 26 Tm 2.517126 Tw 12 TL /F1 10 Tf 0 0 0 rg (The implementation above works in the sense that the decorator can accept functions with generic) Tj T* 0 Tw 1.233615 Tw (signatures; unfortunately this implementation does ) Tj /F5 10 Tf (not ) Tj /F1 10 Tf (define a signature-preserving decorator, since in) Tj T* 0 Tw (general ) Tj /F4 10 Tf (memoize_uw ) Tj /F1 10 Tf (returns a function with a ) Tj /F5 10 Tf (different signature ) Tj /F1 10 Tf (from the original function.) Tj T* ET
+BT 1 0 0 1 0 26 Tm 2.517126 Tw 12 TL /F1 10 Tf 0 0 0 rg (The implementation above works in the sense that the decorator can accept functions with generic) Tj T* 0 Tw 1.233615 Tw (signatures; unfortunately this implementation does ) Tj /F5 10 Tf (not ) Tj /F1 10 Tf (define a signature-preserving decorator, since in) Tj T* 0 Tw (general ) Tj /F4 10 Tf 0 0 0 rg (memoize_uw ) Tj /F1 10 Tf 0 0 0 rg (returns a function with a ) Tj /F5 10 Tf (different signature ) Tj /F1 10 Tf (from the original function.) Tj T* ET
 Q
 Q
 q
@@ -2035,7 +1111,49 @@ q
 n -6 -6 468.6898 60 re B*
 Q
 q
-BT 1 0 0 1 0 38 Tm 12 TL /F4 10 Tf .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj .666667 .133333 1 rg (@memoize_uw) Tj 0 0 0 rg  T* .4 .4 .4 rg (...) Tj 0 0 0 rg ( ) Tj /F3 10 Tf 0 .501961 0 rg (def) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 1 rg (f1) Tj 0 0 0 rg (\() Tj (x) Tj (\):) Tj  T* .4 .4 .4 rg (...) Tj 0 0 0 rg (     ) Tj (time) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (sleep) Tj (\() Tj .4 .4 .4 rg (1) Tj 0 0 0 rg (\)) Tj ( ) Tj /F6 10 Tf .25098 .501961 .501961 rg (# simulate some long computation) Tj /F4 10 Tf 0 0 0 rg  T* .4 .4 .4 rg (...) Tj 0 0 0 rg (     ) Tj /F3 10 Tf 0 .501961 0 rg (return) Tj /F4 10 Tf 0 0 0 rg ( ) Tj (x) Tj T* ET
+.960784 .960784 .862745 rg
+n 0 36.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 6 36.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 12 36.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 24 36.75 66 12 re f*
+.960784 .960784 .862745 rg
+n 0 24.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 24 24.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 48 24.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 60 24.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 66 24.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 72 24.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 0 12.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 48 12.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 72 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 78 12.75 30 12 re f*
+.960784 .960784 .862745 rg
+n 108 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 114 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 120 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 132 12.75 192 12 re f*
+.960784 .960784 .862745 rg
+n 0 .75 18 12 re f*
+.960784 .960784 .862745 rg
+n 48 .75 36 12 re f*
+.960784 .960784 .862745 rg
+n 90 .75 6 12 re f*
+BT 1 0 0 1 0 38 Tm 12 TL /F4 10 Tf .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj .666667 .133333 1 rg (@memoize_uw) Tj 0 0 0 rg  T* .4 .4 .4 rg (...) Tj 0 0 0 rg ( ) Tj /F3 10 Tf 0 .501961 0 rg (def) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 1 rg (f1) Tj 0 0 0 rg (\() Tj 0 0 0 rg (x) Tj 0 0 0 rg (\):) Tj 0 0 0 rg  T* .4 .4 .4 rg (...) Tj 0 0 0 rg (     ) Tj 0 0 0 rg (time) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (sleep) Tj 0 0 0 rg (\() Tj .4 .4 .4 rg (1) Tj 0 0 0 rg (\)) Tj 0 0 0 rg ( ) Tj /F6 10 Tf .25098 .501961 .501961 rg (# simulate some long computation) Tj /F4 10 Tf 0 0 0 rg  T* .4 .4 .4 rg (...) Tj 0 0 0 rg (     ) Tj /F3 10 Tf 0 .501961 0 rg (return) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 0 rg (x) Tj T* ET
 Q
 Q
 Q
@@ -2044,7 +1162,7 @@ Q
 q
 1 0 0 1 62.69291 609.8236 cm
 q
-BT 1 0 0 1 0 14 Tm .26311 Tw 12 TL /F1 10 Tf 0 0 0 rg (Here the original function takes a single argument named ) Tj /F4 10 Tf (x) Tj /F1 10 Tf (, but the decorated function takes any number) Tj T* 0 Tw (of arguments and keyword arguments:) Tj T* ET
+BT 1 0 0 1 0 14 Tm .26311 Tw 12 TL /F1 10 Tf 0 0 0 rg (Here the original function takes a single argument named ) Tj /F4 10 Tf 0 0 0 rg (x) Tj /F1 10 Tf 0 0 0 rg (, but the decorated function takes any number) Tj T* 0 Tw (of arguments and keyword arguments:) Tj T* ET
 Q
 Q
 q
@@ -2061,7 +1179,73 @@ q
 n -6 -6 468.6898 48 re B*
 Q
 q
-BT 1 0 0 1 0 26 Tm 12 TL /F4 10 Tf .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj /F3 10 Tf 0 .501961 0 rg (from) Tj /F4 10 Tf 0 0 0 rg ( ) Tj /F3 10 Tf 0 0 1 rg (inspect) Tj /F4 10 Tf 0 0 0 rg ( ) Tj /F3 10 Tf 0 .501961 0 rg (import) Tj /F4 10 Tf 0 0 0 rg ( ) Tj (getargspec) Tj  T* .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj /F3 10 Tf 0 .501961 0 rg (print) Tj /F4 10 Tf 0 0 0 rg ( ) Tj (getargspec) Tj (\() Tj (f1) Tj (\)) Tj ( ) Tj /F6 10 Tf .25098 .501961 .501961 rg (# I am using Python 2.6+ here) Tj /F4 10 Tf 0 0 0 rg  T* (ArgSpec) Tj (\() Tj (args) Tj .4 .4 .4 rg (=) Tj 0 0 0 rg ([],) Tj ( ) Tj (varargs) Tj .4 .4 .4 rg (=) Tj .729412 .129412 .129412 rg ('args') Tj 0 0 0 rg (,) Tj ( ) Tj (keywords) Tj .4 .4 .4 rg (=) Tj .729412 .129412 .129412 rg ('kw') Tj 0 0 0 rg (,) Tj ( ) Tj (defaults) Tj .4 .4 .4 rg (=) Tj 0 .501961 0 rg (None) Tj 0 0 0 rg (\)) Tj T* ET
+.960784 .960784 .862745 rg
+n 0 24.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 6 24.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 12 24.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 24 24.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 54 24.75 42 12 re f*
+.960784 .960784 .862745 rg
+n 102 24.75 36 12 re f*
+.960784 .960784 .862745 rg
+n 144 24.75 60 12 re f*
+.960784 .960784 .862745 rg
+n 0 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 6 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 12 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 24 12.75 30 12 re f*
+.960784 .960784 .862745 rg
+n 60 12.75 60 12 re f*
+.960784 .960784 .862745 rg
+n 120 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 126 12.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 138 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 150 12.75 174 12 re f*
+.960784 .960784 .862745 rg
+n 0 .75 42 12 re f*
+.960784 .960784 .862745 rg
+n 42 .75 6 12 re f*
+.960784 .960784 .862745 rg
+n 48 .75 24 12 re f*
+.960784 .960784 .862745 rg
+n 72 .75 6 12 re f*
+.960784 .960784 .862745 rg
+n 78 .75 18 12 re f*
+.960784 .960784 .862745 rg
+n 102 .75 42 12 re f*
+.960784 .960784 .862745 rg
+n 144 .75 6 12 re f*
+.960784 .960784 .862745 rg
+n 150 .75 36 12 re f*
+.960784 .960784 .862745 rg
+n 186 .75 6 12 re f*
+.960784 .960784 .862745 rg
+n 198 .75 48 12 re f*
+.960784 .960784 .862745 rg
+n 246 .75 6 12 re f*
+.960784 .960784 .862745 rg
+n 252 .75 24 12 re f*
+.960784 .960784 .862745 rg
+n 276 .75 6 12 re f*
+.960784 .960784 .862745 rg
+n 288 .75 48 12 re f*
+.960784 .960784 .862745 rg
+n 336 .75 6 12 re f*
+.960784 .960784 .862745 rg
+n 342 .75 24 12 re f*
+.960784 .960784 .862745 rg
+n 366 .75 6 12 re f*
+BT 1 0 0 1 0 26 Tm 12 TL /F4 10 Tf .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj /F3 10 Tf 0 .501961 0 rg (from) Tj /F4 10 Tf 0 0 0 rg ( ) Tj /F3 10 Tf 0 0 1 rg (inspect) Tj /F4 10 Tf 0 0 0 rg ( ) Tj /F3 10 Tf 0 .501961 0 rg (import) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 0 rg (getargspec) Tj 0 0 0 rg  T* .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj /F3 10 Tf 0 .501961 0 rg (print) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 0 rg (getargspec) Tj 0 0 0 rg (\() Tj 0 0 0 rg (f1) Tj 0 0 0 rg (\)) Tj 0 0 0 rg ( ) Tj /F6 10 Tf .25098 .501961 .501961 rg (# I am using Python 2.6+ here) Tj /F4 10 Tf 0 0 0 rg  T* 0 0 0 rg (ArgSpec) Tj 0 0 0 rg (\() Tj 0 0 0 rg (args) Tj .4 .4 .4 rg (=) Tj 0 0 0 rg ([],) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (varargs) Tj .4 .4 .4 rg (=) Tj .729412 .129412 .129412 rg ('args') Tj 0 0 0 rg (,) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (keywords) Tj .4 .4 .4 rg (=) Tj .729412 .129412 .129412 rg ('kw') Tj 0 0 0 rg (,) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (defaults) Tj .4 .4 .4 rg (=) Tj 0 .501961 0 rg (None) Tj 0 0 0 rg (\)) Tj T* ET
 Q
 Q
 Q
@@ -2070,7 +1254,7 @@ Q
 q
 1 0 0 1 62.69291 508.6236 cm
 q
-BT 1 0 0 1 0 26 Tm .411235 Tw 12 TL /F1 10 Tf 0 0 0 rg (This means that introspection tools such as pydoc will give wrong informations about the signature of ) Tj /F4 10 Tf (f1) Tj /F1 10 Tf (.) Tj T* 0 Tw .161654 Tw (This is pretty bad: pydoc will tell you that the function accepts a generic signature ) Tj /F4 10 Tf (*args) Tj /F1 10 Tf (, ) Tj /F4 10 Tf (**kw) Tj /F1 10 Tf (, but when) Tj T* 0 Tw (you try to call the function with more than an argument, you will get an error:) Tj T* ET
+BT 1 0 0 1 0 26 Tm .411235 Tw 12 TL /F1 10 Tf 0 0 0 rg (This means that introspection tools such as pydoc will give wrong informations about the signature of ) Tj /F4 10 Tf 0 0 0 rg (f1) Tj /F1 10 Tf 0 0 0 rg (.) Tj T* 0 Tw .161654 Tw (This is pretty bad: pydoc will tell you that the function accepts a generic signature ) Tj /F4 10 Tf 0 0 0 rg (*args) Tj /F1 10 Tf 0 0 0 rg (, ) Tj /F4 10 Tf 0 0 0 rg (**kw) Tj /F1 10 Tf 0 0 0 rg (, but when) Tj T* 0 Tw (you try to call the function with more than an argument, you will get an error:) Tj T* ET
 Q
 Q
 q
@@ -2087,7 +1271,65 @@ q
 n -6 -6 468.6898 60 re B*
 Q
 q
-BT 1 0 0 1 0 38 Tm 12 TL /F4 10 Tf .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj (f1) Tj (\() Tj .4 .4 .4 rg (0) Tj 0 0 0 rg (,) Tj ( ) Tj .4 .4 .4 rg (1) Tj 0 0 0 rg (\)) Tj  T* (Traceback) Tj ( ) Tj (\() Tj (most) Tj ( ) Tj (recent) Tj ( ) Tj (call) Tj ( ) Tj (last) Tj (\):) Tj  T* (   ) Tj .4 .4 .4 rg (...) Tj 0 0 0 rg  T* /F3 10 Tf .823529 .254902 .227451 rg (TypeError) Tj /F4 10 Tf 0 0 0 rg (:) Tj ( ) Tj (f1) Tj (\(\)) Tj ( ) Tj (takes) Tj ( ) Tj (exactly) Tj ( ) Tj .4 .4 .4 rg (1) Tj 0 0 0 rg ( ) Tj (argument) Tj ( ) Tj (\() Tj .4 .4 .4 rg (2) Tj 0 0 0 rg ( ) Tj (given) Tj (\)) Tj T* ET
+.960784 .960784 .862745 rg
+n 0 36.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 6 36.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 12 36.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 24 36.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 36 36.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 42 36.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 48 36.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 60 36.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 66 36.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 0 24.75 54 12 re f*
+.960784 .960784 .862745 rg
+n 60 24.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 66 24.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 96 24.75 36 12 re f*
+.960784 .960784 .862745 rg
+n 138 24.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 168 24.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 192 24.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 18 12.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 0 .75 54 12 re f*
+.960784 .960784 .862745 rg
+n 54 .75 6 12 re f*
+.960784 .960784 .862745 rg
+n 66 .75 12 12 re f*
+.960784 .960784 .862745 rg
+n 78 .75 12 12 re f*
+.960784 .960784 .862745 rg
+n 96 .75 30 12 re f*
+.960784 .960784 .862745 rg
+n 132 .75 42 12 re f*
+.960784 .960784 .862745 rg
+n 180 .75 6 12 re f*
+.960784 .960784 .862745 rg
+n 192 .75 48 12 re f*
+.960784 .960784 .862745 rg
+n 246 .75 6 12 re f*
+.960784 .960784 .862745 rg
+n 252 .75 6 12 re f*
+.960784 .960784 .862745 rg
+n 264 .75 30 12 re f*
+.960784 .960784 .862745 rg
+n 294 .75 6 12 re f*
+BT 1 0 0 1 0 38 Tm 12 TL /F4 10 Tf .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (f1) Tj 0 0 0 rg (\() Tj .4 .4 .4 rg (0) Tj 0 0 0 rg (,) Tj 0 0 0 rg ( ) Tj .4 .4 .4 rg (1) Tj 0 0 0 rg (\)) Tj 0 0 0 rg  T* 0 0 0 rg (Traceback) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (\() Tj 0 0 0 rg (most) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (recent) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (call) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (last) Tj 0 0 0 rg (\):) Tj 0 0 0 rg  T* (   ) Tj .4 .4 .4 rg (...) Tj 0 0 0 rg  T* /F3 10 Tf .823529 .254902 .227451 rg (TypeError) Tj /F4 10 Tf 0 0 0 rg (:) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (f1) Tj 0 0 0 rg (\(\)) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (takes) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (exactly) Tj 0 0 0 rg ( ) Tj .4 .4 .4 rg (1) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (argument) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (\() Tj .4 .4 .4 rg (2) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (given) Tj 0 0 0 rg (\)) Tj T* ET
 Q
 Q
 Q
@@ -2102,7 +1344,7 @@ Q
 q
 1 0 0 1 62.69291 364.4236 cm
 q
-BT 1 0 0 1 0 26 Tm 3.313984 Tw 12 TL /F1 10 Tf 0 0 0 rg (The solution is to provide a generic factory of generators, which hides the complexity of making) Tj T* 0 Tw 3.362976 Tw (signature-preserving decorators from the application programmer. The ) Tj /F4 10 Tf (decorator ) Tj /F1 10 Tf (function in the) Tj T* 0 Tw /F4 10 Tf (decorator ) Tj /F1 10 Tf (module is such a factory:) Tj T* ET
+BT 1 0 0 1 0 26 Tm 3.313984 Tw 12 TL /F1 10 Tf 0 0 0 rg (The solution is to provide a generic factory of generators, which hides the complexity of making) Tj T* 0 Tw 3.362976 Tw (signature-preserving decorators from the application programmer. The ) Tj /F4 10 Tf 0 0 0 rg (decorator ) Tj /F1 10 Tf 0 0 0 rg (function in the) Tj T* 0 Tw /F4 10 Tf 0 0 0 rg (decorator ) Tj /F1 10 Tf 0 0 0 rg (module is such a factory:) Tj T* ET
 Q
 Q
 q
@@ -2119,7 +1361,21 @@ q
 n -6 -6 468.6898 24 re B*
 Q
 q
-BT 1 0 0 1 0 2 Tm 12 TL /F4 10 Tf .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj /F3 10 Tf 0 .501961 0 rg (from) Tj /F4 10 Tf 0 0 0 rg ( ) Tj /F3 10 Tf 0 0 1 rg (decorator) Tj /F4 10 Tf 0 0 0 rg ( ) Tj /F3 10 Tf 0 .501961 0 rg (import) Tj /F4 10 Tf 0 0 0 rg ( ) Tj (decorator) Tj T* ET
+.960784 .960784 .862745 rg
+n 0 .75 6 12 re f*
+.960784 .960784 .862745 rg
+n 6 .75 6 12 re f*
+.960784 .960784 .862745 rg
+n 12 .75 6 12 re f*
+.960784 .960784 .862745 rg
+n 24 .75 24 12 re f*
+.960784 .960784 .862745 rg
+n 54 .75 54 12 re f*
+.960784 .960784 .862745 rg
+n 114 .75 36 12 re f*
+.960784 .960784 .862745 rg
+n 156 .75 54 12 re f*
+BT 1 0 0 1 0 2 Tm 12 TL /F4 10 Tf .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj /F3 10 Tf 0 .501961 0 rg (from) Tj /F4 10 Tf 0 0 0 rg ( ) Tj /F3 10 Tf 0 0 1 rg (decorator) Tj /F4 10 Tf 0 0 0 rg ( ) Tj /F3 10 Tf 0 .501961 0 rg (import) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 0 rg (decorator) Tj T* ET
 Q
 Q
 Q
@@ -2128,7 +1384,7 @@ Q
 q
 1 0 0 1 62.69291 275.2236 cm
 q
-BT 1 0 0 1 0 38 Tm 1.716412 Tw 12 TL /F4 10 Tf 0 0 0 rg (decorator ) Tj /F1 10 Tf (takes two arguments, a caller function describing the functionality of the decorator and a) Tj T* 0 Tw 2.594983 Tw (function to be decorated; it returns the decorated function. The caller function must have signature) Tj T* 0 Tw .19311 Tw /F4 10 Tf (\(f,) Tj ( ) Tj (*args,) Tj ( ) Tj (**kw\) ) Tj /F1 10 Tf (and it must call the original function ) Tj /F4 10 Tf (f ) Tj /F1 10 Tf (with arguments ) Tj /F4 10 Tf (args ) Tj /F1 10 Tf (and ) Tj /F4 10 Tf (kw) Tj /F1 10 Tf (, implementing) Tj T* 0 Tw (the wanted capability, i.e. memoization in this case:) Tj T* ET
+BT 1 0 0 1 0 38 Tm 1.716412 Tw 12 TL /F4 10 Tf 0 0 0 rg (decorator ) Tj /F1 10 Tf 0 0 0 rg (takes two arguments, a caller function describing the functionality of the decorator and a) Tj T* 0 Tw 2.594983 Tw (function to be decorated; it returns the decorated function. The caller function must have signature) Tj T* 0 Tw .19311 Tw /F4 10 Tf 0 0 0 rg (\(f,) Tj ( ) Tj (*args,) Tj ( ) Tj (**kw\) ) Tj /F1 10 Tf 0 0 0 rg (and it must call the original function ) Tj /F4 10 Tf 0 0 0 rg (f ) Tj /F1 10 Tf 0 0 0 rg (with arguments ) Tj /F4 10 Tf 0 0 0 rg (args ) Tj /F1 10 Tf 0 0 0 rg (and ) Tj /F4 10 Tf 0 0 0 rg (kw) Tj /F1 10 Tf 0 0 0 rg (, implementing) Tj T* 0 Tw (the wanted capability, i.e. memoization in this case:) Tj T* ET
 Q
 Q
 q
@@ -2145,7 +1401,137 @@ q
 n -6 -6 468.6898 144 re B*
 Q
 q
-BT 1 0 0 1 0 122 Tm 12 TL /F3 10 Tf 0 .501961 0 rg (def) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 1 rg (_memoize) Tj 0 0 0 rg (\() Tj (func) Tj (,) Tj ( ) Tj .4 .4 .4 rg (*) Tj 0 0 0 rg (args) Tj (,) Tj ( ) Tj .4 .4 .4 rg (**) Tj 0 0 0 rg (kw) Tj (\):) Tj  T* (    ) Tj /F3 10 Tf 0 .501961 0 rg (if) Tj /F4 10 Tf 0 0 0 rg ( ) Tj (kw) Tj (:) Tj ( ) Tj /F6 10 Tf .25098 .501961 .501961 rg (# frozenset is used to ensure hashability) Tj /F4 10 Tf 0 0 0 rg  T* (        ) Tj (key) Tj ( ) Tj .4 .4 .4 rg (=) Tj 0 0 0 rg ( ) Tj (args) Tj (,) Tj ( ) Tj 0 .501961 0 rg (frozenset) Tj 0 0 0 rg (\() Tj (kw) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (iteritems) Tj (\(\)\)) Tj  T* (    ) Tj /F3 10 Tf 0 .501961 0 rg (else) Tj /F4 10 Tf 0 0 0 rg (:) Tj  T* (        ) Tj (key) Tj ( ) Tj .4 .4 .4 rg (=) Tj 0 0 0 rg ( ) Tj (args) Tj  T* (    ) Tj (cache) Tj ( ) Tj .4 .4 .4 rg (=) Tj 0 0 0 rg ( ) Tj (func) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (cache) Tj ( ) Tj /F6 10 Tf .25098 .501961 .501961 rg (# attributed added by memoize) Tj /F4 10 Tf 0 0 0 rg  T* (    ) Tj /F3 10 Tf 0 .501961 0 rg (if) Tj /F4 10 Tf 0 0 0 rg ( ) Tj (key) Tj ( ) Tj /F3 10 Tf .666667 .133333 1 rg (in) Tj /F4 10 Tf 0 0 0 rg ( ) Tj (cache) Tj (:) Tj  T* (        ) Tj /F3 10 Tf 0 .501961 0 rg (return) Tj /F4 10 Tf 0 0 0 rg ( ) Tj (cache) Tj ([) Tj (key) Tj (]) Tj  T* (    ) Tj /F3 10 Tf 0 .501961 0 rg (else) Tj /F4 10 Tf 0 0 0 rg (:) Tj  T* (        ) Tj (cache) Tj ([) Tj (key) Tj (]) Tj ( ) Tj .4 .4 .4 rg (=) Tj 0 0 0 rg ( ) Tj (result) Tj ( ) Tj .4 .4 .4 rg (=) Tj 0 0 0 rg ( ) Tj (func) Tj (\() Tj .4 .4 .4 rg (*) Tj 0 0 0 rg (args) Tj (,) Tj ( ) Tj .4 .4 .4 rg (**) Tj 0 0 0 rg (kw) Tj (\)) Tj  T* (        ) Tj /F3 10 Tf 0 .501961 0 rg (return) Tj /F4 10 Tf 0 0 0 rg ( ) Tj (result) Tj T* ET
+.960784 .960784 .862745 rg
+n 0 120.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 24 120.75 48 12 re f*
+.960784 .960784 .862745 rg
+n 72 120.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 78 120.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 102 120.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 114 120.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 120 120.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 144 120.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 156 120.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 168 120.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 180 120.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 24 108.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 42 108.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 54 108.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 72 108.75 246 12 re f*
+.960784 .960784 .862745 rg
+n 48 96.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 72 96.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 84 96.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 108 96.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 120 96.75 54 12 re f*
+.960784 .960784 .862745 rg
+n 174 96.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 180 96.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 192 96.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 198 96.75 54 12 re f*
+.960784 .960784 .862745 rg
+n 252 96.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 24 84.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 48 84.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 48 72.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 72 72.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 84 72.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 24 60.75 30 12 re f*
+.960784 .960784 .862745 rg
+n 60 60.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 72 60.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 96 60.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 102 60.75 30 12 re f*
+.960784 .960784 .862745 rg
+n 144 60.75 174 12 re f*
+.960784 .960784 .862745 rg
+n 24 48.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 42 48.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 66 48.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 84 48.75 30 12 re f*
+.960784 .960784 .862745 rg
+n 114 48.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 48 36.75 36 12 re f*
+.960784 .960784 .862745 rg
+n 90 36.75 30 12 re f*
+.960784 .960784 .862745 rg
+n 120 36.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 126 36.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 144 36.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 24 24.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 48 24.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 48 12.75 30 12 re f*
+.960784 .960784 .862745 rg
+n 78 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 84 12.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 102 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 114 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 126 12.75 36 12 re f*
+.960784 .960784 .862745 rg
+n 168 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 180 12.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 204 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 210 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 216 12.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 240 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 252 12.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 264 12.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 276 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 48 .75 36 12 re f*
+.960784 .960784 .862745 rg
+n 90 .75 36 12 re f*
+BT 1 0 0 1 0 122 Tm 12 TL /F3 10 Tf 0 .501961 0 rg (def) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 1 rg (_memoize) Tj 0 0 0 rg (\() Tj 0 0 0 rg (func) Tj 0 0 0 rg (,) Tj 0 0 0 rg ( ) Tj .4 .4 .4 rg (*) Tj 0 0 0 rg (args) Tj 0 0 0 rg (,) Tj 0 0 0 rg ( ) Tj .4 .4 .4 rg (**) Tj 0 0 0 rg (kw) Tj 0 0 0 rg (\):) Tj 0 0 0 rg  T* (    ) Tj /F3 10 Tf 0 .501961 0 rg (if) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 0 rg (kw) Tj 0 0 0 rg (:) Tj 0 0 0 rg (  ) Tj /F6 10 Tf .25098 .501961 .501961 rg (# frozenset is used to ensure hashability) Tj /F4 10 Tf 0 0 0 rg  T* (        ) Tj 0 0 0 rg (key) Tj 0 0 0 rg ( ) Tj .4 .4 .4 rg (=) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (args) Tj 0 0 0 rg (,) Tj 0 0 0 rg ( ) Tj 0 .501961 0 rg (frozenset) Tj 0 0 0 rg (\() Tj 0 0 0 rg (kw) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (iteritems) Tj 0 0 0 rg (\(\)\)) Tj 0 0 0 rg  T* (    ) Tj /F3 10 Tf 0 .501961 0 rg (else) Tj /F4 10 Tf 0 0 0 rg (:) Tj 0 0 0 rg  T* (        ) Tj 0 0 0 rg (key) Tj 0 0 0 rg ( ) Tj .4 .4 .4 rg (=) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (args) Tj 0 0 0 rg  T* (    ) Tj 0 0 0 rg (cache) Tj 0 0 0 rg ( ) Tj .4 .4 .4 rg (=) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (func) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (cache) Tj 0 0 0 rg (  ) Tj /F6 10 Tf .25098 .501961 .501961 rg (# attributed added by memoize) Tj /F4 10 Tf 0 0 0 rg  T* (    ) Tj /F3 10 Tf 0 .501961 0 rg (if) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 0 rg (key) Tj 0 0 0 rg ( ) Tj /F3 10 Tf .666667 .133333 1 rg (in) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 0 rg (cache) Tj 0 0 0 rg (:) Tj 0 0 0 rg  T* (        ) Tj /F3 10 Tf 0 .501961 0 rg (return) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 0 rg (cache) Tj 0 0 0 rg ([) Tj 0 0 0 rg (key) Tj 0 0 0 rg (]) Tj 0 0 0 rg  T* (    ) Tj /F3 10 Tf 0 .501961 0 rg (else) Tj /F4 10 Tf 0 0 0 rg (:) Tj 0 0 0 rg  T* (        ) Tj 0 0 0 rg (cache) Tj 0 0 0 rg ([) Tj 0 0 0 rg (key) Tj 0 0 0 rg (]) Tj 0 0 0 rg ( ) Tj .4 .4 .4 rg (=) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (result) Tj 0 0 0 rg ( ) Tj .4 .4 .4 rg (=) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (func) Tj 0 0 0 rg (\() Tj .4 .4 .4 rg (*) Tj 0 0 0 rg (args) Tj 0 0 0 rg (,) Tj 0 0 0 rg ( ) Tj .4 .4 .4 rg (**) Tj 0 0 0 rg (kw) Tj 0 0 0 rg (\)) Tj 0 0 0 rg  T* (        ) Tj /F3 10 Tf 0 .501961 0 rg (return) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 0 rg (result) Tj T* ET
 Q
 Q
 Q
@@ -2161,10 +1547,8 @@ Q
  
 endstream
 endobj
-% 'R88': class PDFStream 
 88 0 obj
-% page stream
-<< /Length 7115 >>
+<< /Length 15826 >>
 stream
 1 0 0 1 0 0 cm  BT /F1 12 Tf 14.4 TL ET
 q
@@ -2181,7 +1565,41 @@ q
 n -6 -6 468.6898 48 re B*
 Q
 q
-BT 1 0 0 1 0 26 Tm 12 TL /F3 10 Tf 0 .501961 0 rg (def) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 1 rg (memoize) Tj 0 0 0 rg (\() Tj (f) Tj (\):) Tj  T* (    ) Tj (f) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (cache) Tj ( ) Tj .4 .4 .4 rg (=) Tj 0 0 0 rg ( ) Tj ({}) Tj  T* (    ) Tj /F3 10 Tf 0 .501961 0 rg (return) Tj /F4 10 Tf 0 0 0 rg ( ) Tj (decorator) Tj (\() Tj (_memoize) Tj (,) Tj ( ) Tj (f) Tj (\)) Tj T* ET
+.960784 .960784 .862745 rg
+n 0 24.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 24 24.75 42 12 re f*
+.960784 .960784 .862745 rg
+n 66 24.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 72 24.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 78 24.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 24 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 30 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 36 12.75 30 12 re f*
+.960784 .960784 .862745 rg
+n 72 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 84 12.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 24 .75 36 12 re f*
+.960784 .960784 .862745 rg
+n 66 .75 54 12 re f*
+.960784 .960784 .862745 rg
+n 120 .75 6 12 re f*
+.960784 .960784 .862745 rg
+n 126 .75 48 12 re f*
+.960784 .960784 .862745 rg
+n 174 .75 6 12 re f*
+.960784 .960784 .862745 rg
+n 186 .75 6 12 re f*
+.960784 .960784 .862745 rg
+n 192 .75 6 12 re f*
+BT 1 0 0 1 0 26 Tm 12 TL /F3 10 Tf 0 .501961 0 rg (def) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 1 rg (memoize) Tj 0 0 0 rg (\() Tj 0 0 0 rg (f) Tj 0 0 0 rg (\):) Tj 0 0 0 rg  T* (    ) Tj 0 0 0 rg (f) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (cache) Tj 0 0 0 rg ( ) Tj .4 .4 .4 rg (=) Tj 0 0 0 rg ( ) Tj 0 0 0 rg ({}) Tj 0 0 0 rg  T* (    ) Tj /F3 10 Tf 0 .501961 0 rg (return) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 0 rg (decorator) Tj 0 0 0 rg (\() Tj 0 0 0 rg (_memoize) Tj 0 0 0 rg (,) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (f) Tj 0 0 0 rg (\)) Tj T* ET
 Q
 Q
 Q
@@ -2190,7 +1608,7 @@ Q
 q
 1 0 0 1 62.69291 671.8236 cm
 q
-BT 1 0 0 1 0 26 Tm .12561 Tw 12 TL /F1 10 Tf 0 0 0 rg (The difference with respect to the ) Tj /F4 10 Tf (memoize_uw ) Tj /F1 10 Tf (approach, which is based on nested functions, is that the) Tj T* 0 Tw 2.59528 Tw (decorator module forces you to lift the inner function at the outer level \() Tj /F5 10 Tf (flat is better than nested) Tj /F1 10 Tf (\).) Tj T* 0 Tw (Moreover, you are forced to pass explicitly the function you want to decorate to the caller function.) Tj T* ET
+BT 1 0 0 1 0 26 Tm .12561 Tw 12 TL /F1 10 Tf 0 0 0 rg (The difference with respect to the ) Tj /F4 10 Tf 0 0 0 rg (memoize_uw ) Tj /F1 10 Tf 0 0 0 rg (approach, which is based on nested functions, is that the) Tj T* 0 Tw 2.59528 Tw (decorator module forces you to lift the inner function at the outer level \() Tj /F5 10 Tf (flat is better than nested) Tj /F1 10 Tf (\).) Tj T* 0 Tw (Moreover, you are forced to pass explicitly the function you want to decorate to the caller function.) Tj T* ET
 Q
 Q
 q
@@ -2214,7 +1632,75 @@ q
 n -6 -6 468.6898 132 re B*
 Q
 q
-BT 1 0 0 1 0 110 Tm 12 TL /F4 10 Tf .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj .666667 .133333 1 rg (@memoize) Tj 0 0 0 rg  T* .4 .4 .4 rg (...) Tj 0 0 0 rg ( ) Tj /F3 10 Tf 0 .501961 0 rg (def) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 1 rg (heavy_computation) Tj 0 0 0 rg (\(\):) Tj  T* .4 .4 .4 rg (...) Tj 0 0 0 rg (     ) Tj (time) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (sleep) Tj (\() Tj .4 .4 .4 rg (2) Tj 0 0 0 rg (\)) Tj  T* .4 .4 .4 rg (...) Tj 0 0 0 rg (     ) Tj /F3 10 Tf 0 .501961 0 rg (return) Tj /F4 10 Tf 0 0 0 rg ( ) Tj .729412 .129412 .129412 rg ("done") Tj 0 0 0 rg  T*  T* .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj /F3 10 Tf 0 .501961 0 rg (print) Tj /F4 10 Tf 0 0 0 rg ( ) Tj (heavy_computation) Tj (\(\)) Tj ( ) Tj /F6 10 Tf .25098 .501961 .501961 rg (# the first time it will take 2 seconds) Tj /F4 10 Tf 0 0 0 rg  T* (done) Tj  T*  T* .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj /F3 10 Tf 0 .501961 0 rg (print) Tj /F4 10 Tf 0 0 0 rg ( ) Tj (heavy_computation) Tj (\(\)) Tj ( ) Tj /F6 10 Tf .25098 .501961 .501961 rg (# the second time it will be instantaneous) Tj /F4 10 Tf 0 0 0 rg  T* (done) Tj T* ET
+.960784 .960784 .862745 rg
+n 0 108.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 6 108.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 12 108.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 24 108.75 48 12 re f*
+.960784 .960784 .862745 rg
+n 0 96.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 24 96.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 48 96.75 102 12 re f*
+.960784 .960784 .862745 rg
+n 150 96.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 0 84.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 48 84.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 72 84.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 78 84.75 30 12 re f*
+.960784 .960784 .862745 rg
+n 108 84.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 114 84.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 120 84.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 0 72.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 48 72.75 36 12 re f*
+.960784 .960784 .862745 rg
+n 90 72.75 36 12 re f*
+.960784 .960784 .862745 rg
+n 0 48.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 6 48.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 12 48.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 24 48.75 30 12 re f*
+.960784 .960784 .862745 rg
+n 60 48.75 102 12 re f*
+.960784 .960784 .862745 rg
+n 162 48.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 180 48.75 234 12 re f*
+.960784 .960784 .862745 rg
+n 0 36.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 0 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 6 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 12 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 24 12.75 30 12 re f*
+.960784 .960784 .862745 rg
+n 60 12.75 102 12 re f*
+.960784 .960784 .862745 rg
+n 162 12.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 180 12.75 252 12 re f*
+.960784 .960784 .862745 rg
+n 0 .75 24 12 re f*
+BT 1 0 0 1 0 110 Tm 12 TL /F4 10 Tf .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj .666667 .133333 1 rg (@memoize) Tj 0 0 0 rg  T* .4 .4 .4 rg (...) Tj 0 0 0 rg ( ) Tj /F3 10 Tf 0 .501961 0 rg (def) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 1 rg (heavy_computation) Tj 0 0 0 rg (\(\):) Tj 0 0 0 rg  T* .4 .4 .4 rg (...) Tj 0 0 0 rg (     ) Tj 0 0 0 rg (time) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (sleep) Tj 0 0 0 rg (\() Tj .4 .4 .4 rg (2) Tj 0 0 0 rg (\)) Tj 0 0 0 rg  T* .4 .4 .4 rg (...) Tj 0 0 0 rg (     ) Tj /F3 10 Tf 0 .501961 0 rg (return) Tj /F4 10 Tf 0 0 0 rg ( ) Tj .729412 .129412 .129412 rg ("done") Tj 0 0 0 rg  T*  T* .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj /F3 10 Tf 0 .501961 0 rg (print) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 0 rg (heavy_computation) Tj 0 0 0 rg (\(\)) Tj 0 0 0 rg ( ) Tj /F6 10 Tf .25098 .501961 .501961 rg (# the first time it will take 2 seconds) Tj /F4 10 Tf 0 0 0 rg  T* 0 0 0 rg (done) Tj 0 0 0 rg  T*  T* .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj /F3 10 Tf 0 .501961 0 rg (print) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 0 rg (heavy_computation) Tj 0 0 0 rg (\(\)) Tj 0 0 0 rg ( ) Tj /F6 10 Tf .25098 .501961 .501961 rg (# the second time it will be instantaneous) Tj /F4 10 Tf 0 0 0 rg  T* 0 0 0 rg (done) Tj T* ET
 Q
 Q
 Q
@@ -2223,7 +1709,7 @@ Q
 q
 1 0 0 1 62.69291 492.6236 cm
 q
-BT 1 0 0 1 0 2 Tm 12 TL /F1 10 Tf 0 0 0 rg (The signature of ) Tj /F4 10 Tf (heavy_computation ) Tj /F1 10 Tf (is the one you would expect:) Tj T* ET
+BT 1 0 0 1 0 2 Tm 12 TL /F1 10 Tf 0 0 0 rg (The signature of ) Tj /F4 10 Tf 0 0 0 rg (heavy_computation ) Tj /F1 10 Tf 0 0 0 rg (is the one you would expect:) Tj T* ET
 Q
 Q
 q
@@ -2240,7 +1726,57 @@ q
 n -6 -6 468.6898 36 re B*
 Q
 q
-BT 1 0 0 1 0 14 Tm 12 TL /F4 10 Tf .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj /F3 10 Tf 0 .501961 0 rg (print) Tj /F4 10 Tf 0 0 0 rg ( ) Tj (getargspec) Tj (\() Tj (heavy_computation) Tj (\)) Tj  T* (ArgSpec) Tj (\() Tj (args) Tj .4 .4 .4 rg (=) Tj 0 0 0 rg ([],) Tj ( ) Tj (varargs) Tj .4 .4 .4 rg (=) Tj 0 .501961 0 rg (None) Tj 0 0 0 rg (,) Tj ( ) Tj (keywords) Tj .4 .4 .4 rg (=) Tj 0 .501961 0 rg (None) Tj 0 0 0 rg (,) Tj ( ) Tj (defaults) Tj .4 .4 .4 rg (=) Tj 0 .501961 0 rg (None) Tj 0 0 0 rg (\)) Tj T* ET
+.960784 .960784 .862745 rg
+n 0 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 6 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 12 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 24 12.75 30 12 re f*
+.960784 .960784 .862745 rg
+n 60 12.75 60 12 re f*
+.960784 .960784 .862745 rg
+n 120 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 126 12.75 102 12 re f*
+.960784 .960784 .862745 rg
+n 228 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 0 .75 42 12 re f*
+.960784 .960784 .862745 rg
+n 42 .75 6 12 re f*
+.960784 .960784 .862745 rg
+n 48 .75 24 12 re f*
+.960784 .960784 .862745 rg
+n 72 .75 6 12 re f*
+.960784 .960784 .862745 rg
+n 78 .75 18 12 re f*
+.960784 .960784 .862745 rg
+n 102 .75 42 12 re f*
+.960784 .960784 .862745 rg
+n 144 .75 6 12 re f*
+.960784 .960784 .862745 rg
+n 150 .75 24 12 re f*
+.960784 .960784 .862745 rg
+n 174 .75 6 12 re f*
+.960784 .960784 .862745 rg
+n 186 .75 48 12 re f*
+.960784 .960784 .862745 rg
+n 234 .75 6 12 re f*
+.960784 .960784 .862745 rg
+n 240 .75 24 12 re f*
+.960784 .960784 .862745 rg
+n 264 .75 6 12 re f*
+.960784 .960784 .862745 rg
+n 276 .75 48 12 re f*
+.960784 .960784 .862745 rg
+n 324 .75 6 12 re f*
+.960784 .960784 .862745 rg
+n 330 .75 24 12 re f*
+.960784 .960784 .862745 rg
+n 354 .75 6 12 re f*
+BT 1 0 0 1 0 14 Tm 12 TL /F4 10 Tf .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj /F3 10 Tf 0 .501961 0 rg (print) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 0 rg (getargspec) Tj 0 0 0 rg (\() Tj 0 0 0 rg (heavy_computation) Tj 0 0 0 rg (\)) Tj 0 0 0 rg  T* 0 0 0 rg (ArgSpec) Tj 0 0 0 rg (\() Tj 0 0 0 rg (args) Tj .4 .4 .4 rg (=) Tj 0 0 0 rg ([],) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (varargs) Tj .4 .4 .4 rg (=) Tj 0 .501961 0 rg (None) Tj 0 0 0 rg (,) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (keywords) Tj .4 .4 .4 rg (=) Tj 0 .501961 0 rg (None) Tj 0 0 0 rg (,) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (defaults) Tj .4 .4 .4 rg (=) Tj 0 .501961 0 rg (None) Tj 0 0 0 rg (\)) Tj T* ET
 Q
 Q
 Q
@@ -2249,13 +1785,13 @@ Q
 q
 1 0 0 1 62.69291 414.4236 cm
 q
-BT 1 0 0 1 0 3.5 Tm 21 TL /F2 17.5 Tf 0 0 0 rg (A ) Tj /F3 17.5 Tf (trace ) Tj /F2 17.5 Tf (decorator) Tj T* ET
+BT 1 0 0 1 0 3.5 Tm 21 TL /F2 17.5 Tf 0 0 0 rg (A ) Tj /F3 17.5 Tf 0 0 0 rg (trace ) Tj /F2 17.5 Tf 0 0 0 rg (decorator) Tj T* ET
 Q
 Q
 q
 1 0 0 1 62.69291 384.4236 cm
 q
-BT 1 0 0 1 0 14 Tm .479398 Tw 12 TL /F1 10 Tf 0 0 0 rg (As an additional example, here is how you can define a trivial ) Tj /F4 10 Tf (trace ) Tj /F1 10 Tf (decorator, which prints a message) Tj T* 0 Tw (everytime the traced function is called:) Tj T* ET
+BT 1 0 0 1 0 14 Tm .479398 Tw 12 TL /F1 10 Tf 0 0 0 rg (As an additional example, here is how you can define a trivial ) Tj /F4 10 Tf 0 0 0 rg (trace ) Tj /F1 10 Tf 0 0 0 rg (decorator, which prints a message) Tj T* 0 Tw (everytime the traced function is called:) Tj T* ET
 Q
 Q
 q
@@ -2272,7 +1808,83 @@ q
 n -6 -6 468.6898 48 re B*
 Q
 q
-BT 1 0 0 1 0 26 Tm 12 TL /F3 10 Tf 0 .501961 0 rg (def) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 1 rg (_trace) Tj 0 0 0 rg (\() Tj (f) Tj (,) Tj ( ) Tj .4 .4 .4 rg (*) Tj 0 0 0 rg (args) Tj (,) Tj ( ) Tj .4 .4 .4 rg (**) Tj 0 0 0 rg (kw) Tj (\):) Tj  T* (    ) Tj /F3 10 Tf 0 .501961 0 rg (print) Tj /F4 10 Tf 0 0 0 rg ( ) Tj .729412 .129412 .129412 rg ("calling ) Tj /F3 10 Tf .733333 .4 .533333 rg (%s) Tj /F4 10 Tf .729412 .129412 .129412 rg ( with args ) Tj /F3 10 Tf .733333 .4 .533333 rg (%s) Tj /F4 10 Tf .729412 .129412 .129412 rg (, ) Tj /F3 10 Tf .733333 .4 .533333 rg (%s) Tj /F4 10 Tf .729412 .129412 .129412 rg (") Tj 0 0 0 rg ( ) Tj .4 .4 .4 rg (%) Tj 0 0 0 rg ( ) Tj (\() Tj (f) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (__name__) Tj (,) Tj ( ) Tj (args) Tj (,) Tj ( ) Tj (kw) Tj (\)) Tj  T* (    ) Tj /F3 10 Tf 0 .501961 0 rg (return) Tj /F4 10 Tf 0 0 0 rg ( ) Tj (f) Tj (\() Tj .4 .4 .4 rg (*) Tj 0 0 0 rg (args) Tj (,) Tj ( ) Tj .4 .4 .4 rg (**) Tj 0 0 0 rg (kw) Tj (\)) Tj T* ET
+.960784 .960784 .862745 rg
+n 0 24.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 24 24.75 36 12 re f*
+.960784 .960784 .862745 rg
+n 60 24.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 66 24.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 72 24.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 84 24.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 90 24.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 114 24.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 126 24.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 138 24.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 150 24.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 24 12.75 30 12 re f*
+.960784 .960784 .862745 rg
+n 60 12.75 54 12 re f*
+.960784 .960784 .862745 rg
+n 114 12.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 126 12.75 66 12 re f*
+.960784 .960784 .862745 rg
+n 192 12.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 204 12.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 216 12.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 228 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 240 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 252 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 258 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 264 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 270 12.75 48 12 re f*
+.960784 .960784 .862745 rg
+n 318 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 330 12.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 354 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 366 12.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 378 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 24 .75 36 12 re f*
+.960784 .960784 .862745 rg
+n 66 .75 6 12 re f*
+.960784 .960784 .862745 rg
+n 72 .75 6 12 re f*
+.960784 .960784 .862745 rg
+n 78 .75 6 12 re f*
+.960784 .960784 .862745 rg
+n 84 .75 24 12 re f*
+.960784 .960784 .862745 rg
+n 108 .75 6 12 re f*
+.960784 .960784 .862745 rg
+n 120 .75 12 12 re f*
+.960784 .960784 .862745 rg
+n 132 .75 12 12 re f*
+.960784 .960784 .862745 rg
+n 144 .75 6 12 re f*
+BT 1 0 0 1 0 26 Tm 12 TL /F3 10 Tf 0 .501961 0 rg (def) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 1 rg (_trace) Tj 0 0 0 rg (\() Tj 0 0 0 rg (f) Tj 0 0 0 rg (,) Tj 0 0 0 rg ( ) Tj .4 .4 .4 rg (*) Tj 0 0 0 rg (args) Tj 0 0 0 rg (,) Tj 0 0 0 rg ( ) Tj .4 .4 .4 rg (**) Tj 0 0 0 rg (kw) Tj 0 0 0 rg (\):) Tj 0 0 0 rg  T* (    ) Tj /F3 10 Tf 0 .501961 0 rg (print) Tj /F4 10 Tf 0 0 0 rg ( ) Tj .729412 .129412 .129412 rg ("calling ) Tj /F3 10 Tf .733333 .4 .533333 rg (%s) Tj /F4 10 Tf .729412 .129412 .129412 rg ( with args ) Tj /F3 10 Tf .733333 .4 .533333 rg (%s) Tj /F4 10 Tf .729412 .129412 .129412 rg (, ) Tj /F3 10 Tf .733333 .4 .533333 rg (%s) Tj /F4 10 Tf .729412 .129412 .129412 rg (") Tj 0 0 0 rg ( ) Tj .4 .4 .4 rg (%) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (\() Tj 0 0 0 rg (f) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (__name__) Tj 0 0 0 rg (,) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (args) Tj 0 0 0 rg (,) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (kw) Tj 0 0 0 rg (\)) Tj 0 0 0 rg  T* (    ) Tj /F3 10 Tf 0 .501961 0 rg (return) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 0 rg (f) Tj 0 0 0 rg (\() Tj .4 .4 .4 rg (*) Tj 0 0 0 rg (args) Tj 0 0 0 rg (,) Tj 0 0 0 rg ( ) Tj .4 .4 .4 rg (**) Tj 0 0 0 rg (kw) Tj 0 0 0 rg (\)) Tj T* ET
 Q
 Q
 Q
@@ -2292,7 +1904,31 @@ q
 n -6 -6 468.6898 36 re B*
 Q
 q
-BT 1 0 0 1 0 14 Tm 12 TL /F3 10 Tf 0 .501961 0 rg (def) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 1 rg (trace) Tj 0 0 0 rg (\() Tj (f) Tj (\):) Tj  T* (    ) Tj /F3 10 Tf 0 .501961 0 rg (return) Tj /F4 10 Tf 0 0 0 rg ( ) Tj (decorator) Tj (\() Tj (_trace) Tj (,) Tj ( ) Tj (f) Tj (\)) Tj T* ET
+.960784 .960784 .862745 rg
+n 0 12.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 24 12.75 30 12 re f*
+.960784 .960784 .862745 rg
+n 54 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 60 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 66 12.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 24 .75 36 12 re f*
+.960784 .960784 .862745 rg
+n 66 .75 54 12 re f*
+.960784 .960784 .862745 rg
+n 120 .75 6 12 re f*
+.960784 .960784 .862745 rg
+n 126 .75 36 12 re f*
+.960784 .960784 .862745 rg
+n 162 .75 6 12 re f*
+.960784 .960784 .862745 rg
+n 174 .75 6 12 re f*
+.960784 .960784 .862745 rg
+n 180 .75 6 12 re f*
+BT 1 0 0 1 0 14 Tm 12 TL /F3 10 Tf 0 .501961 0 rg (def) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 1 rg (trace) Tj 0 0 0 rg (\() Tj 0 0 0 rg (f) Tj 0 0 0 rg (\):) Tj 0 0 0 rg  T* (    ) Tj /F3 10 Tf 0 .501961 0 rg (return) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 0 rg (decorator) Tj 0 0 0 rg (\() Tj 0 0 0 rg (_trace) Tj 0 0 0 rg (,) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (f) Tj 0 0 0 rg (\)) Tj T* ET
 Q
 Q
 Q
@@ -2319,7 +1955,31 @@ q
 n -6 -6 468.6898 48 re B*
 Q
 q
-BT 1 0 0 1 0 26 Tm 12 TL /F4 10 Tf .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj .666667 .133333 1 rg (@trace) Tj 0 0 0 rg  T* .4 .4 .4 rg (...) Tj 0 0 0 rg ( ) Tj /F3 10 Tf 0 .501961 0 rg (def) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 1 rg (f1) Tj 0 0 0 rg (\() Tj (x) Tj (\):) Tj  T* .4 .4 .4 rg (...) Tj 0 0 0 rg (     ) Tj /F3 10 Tf 0 .501961 0 rg (pass) Tj T* ET
+.960784 .960784 .862745 rg
+n 0 24.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 6 24.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 12 24.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 24 24.75 36 12 re f*
+.960784 .960784 .862745 rg
+n 0 12.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 24 12.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 48 12.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 60 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 66 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 72 12.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 0 .75 18 12 re f*
+.960784 .960784 .862745 rg
+n 48 .75 24 12 re f*
+BT 1 0 0 1 0 26 Tm 12 TL /F4 10 Tf .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj .666667 .133333 1 rg (@trace) Tj 0 0 0 rg  T* .4 .4 .4 rg (...) Tj 0 0 0 rg ( ) Tj /F3 10 Tf 0 .501961 0 rg (def) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 1 rg (f1) Tj 0 0 0 rg (\() Tj 0 0 0 rg (x) Tj 0 0 0 rg (\):) Tj 0 0 0 rg  T* .4 .4 .4 rg (...) Tj 0 0 0 rg (     ) Tj /F3 10 Tf 0 .501961 0 rg (pass) Tj T* ET
 Q
 Q
 Q
@@ -2328,7 +1988,7 @@ Q
 q
 1 0 0 1 62.69291 184.8236 cm
 q
-BT 1 0 0 1 0 2 Tm 12 TL /F1 10 Tf 0 0 0 rg (It is immediate to verify that ) Tj /F4 10 Tf (f1 ) Tj /F1 10 Tf (works) Tj T* ET
+BT 1 0 0 1 0 2 Tm 12 TL /F1 10 Tf 0 0 0 rg (It is immediate to verify that ) Tj /F4 10 Tf 0 0 0 rg (f1 ) Tj /F1 10 Tf 0 0 0 rg (works) Tj T* ET
 Q
 Q
 q
@@ -2345,7 +2005,37 @@ q
 n -6 -6 468.6898 36 re B*
 Q
 q
-BT 1 0 0 1 0 14 Tm 12 TL /F4 10 Tf .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj (f1) Tj (\() Tj .4 .4 .4 rg (0) Tj 0 0 0 rg (\)) Tj  T* (calling) Tj ( ) Tj (f1) Tj ( ) Tj /F3 10 Tf 0 .501961 0 rg (with) Tj /F4 10 Tf 0 0 0 rg ( ) Tj (args) Tj ( ) Tj (\() Tj .4 .4 .4 rg (0) Tj 0 0 0 rg (,\),) Tj ( ) Tj ({}) Tj T* ET
+.960784 .960784 .862745 rg
+n 0 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 6 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 12 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 24 12.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 36 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 42 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 48 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 0 .75 42 12 re f*
+.960784 .960784 .862745 rg
+n 48 .75 12 12 re f*
+.960784 .960784 .862745 rg
+n 66 .75 24 12 re f*
+.960784 .960784 .862745 rg
+n 96 .75 24 12 re f*
+.960784 .960784 .862745 rg
+n 126 .75 6 12 re f*
+.960784 .960784 .862745 rg
+n 132 .75 6 12 re f*
+.960784 .960784 .862745 rg
+n 138 .75 18 12 re f*
+.960784 .960784 .862745 rg
+n 162 .75 12 12 re f*
+BT 1 0 0 1 0 14 Tm 12 TL /F4 10 Tf .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (f1) Tj 0 0 0 rg (\() Tj .4 .4 .4 rg (0) Tj 0 0 0 rg (\)) Tj 0 0 0 rg  T* 0 0 0 rg (calling) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (f1) Tj 0 0 0 rg ( ) Tj /F3 10 Tf 0 .501961 0 rg (with) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 0 rg (args) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (\() Tj .4 .4 .4 rg (0) Tj 0 0 0 rg (,\),) Tj 0 0 0 rg ( ) Tj 0 0 0 rg ({}) Tj T* ET
 Q
 Q
 Q
@@ -2361,10 +2051,8 @@ Q
  
 endstream
 endobj
-% 'R89': class PDFStream 
 89 0 obj
-% page stream
-<< /Length 8852 >>
+<< /Length 22325 >>
 stream
 1 0 0 1 0 0 cm  BT /F1 12 Tf 14.4 TL ET
 q
@@ -2381,7 +2069,61 @@ q
 n -6 -6 468.6898 36 re B*
 Q
 q
-BT 1 0 0 1 0 14 Tm 12 TL /F4 10 Tf .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj /F3 10 Tf 0 .501961 0 rg (print) Tj /F4 10 Tf 0 0 0 rg ( ) Tj (getargspec) Tj (\() Tj (f1) Tj (\)) Tj  T* (ArgSpec) Tj (\() Tj (args) Tj .4 .4 .4 rg (=) Tj 0 0 0 rg ([) Tj .729412 .129412 .129412 rg ('x') Tj 0 0 0 rg (],) Tj ( ) Tj (varargs) Tj .4 .4 .4 rg (=) Tj 0 .501961 0 rg (None) Tj 0 0 0 rg (,) Tj ( ) Tj (keywords) Tj .4 .4 .4 rg (=) Tj 0 .501961 0 rg (None) Tj 0 0 0 rg (,) Tj ( ) Tj (defaults) Tj .4 .4 .4 rg (=) Tj 0 .501961 0 rg (None) Tj 0 0 0 rg (\)) Tj T* ET
+.960784 .960784 .862745 rg
+n 0 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 6 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 12 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 24 12.75 30 12 re f*
+.960784 .960784 .862745 rg
+n 60 12.75 60 12 re f*
+.960784 .960784 .862745 rg
+n 120 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 126 12.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 138 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 0 .75 42 12 re f*
+.960784 .960784 .862745 rg
+n 42 .75 6 12 re f*
+.960784 .960784 .862745 rg
+n 48 .75 24 12 re f*
+.960784 .960784 .862745 rg
+n 72 .75 6 12 re f*
+.960784 .960784 .862745 rg
+n 78 .75 6 12 re f*
+.960784 .960784 .862745 rg
+n 84 .75 18 12 re f*
+.960784 .960784 .862745 rg
+n 102 .75 12 12 re f*
+.960784 .960784 .862745 rg
+n 120 .75 42 12 re f*
+.960784 .960784 .862745 rg
+n 162 .75 6 12 re f*
+.960784 .960784 .862745 rg
+n 168 .75 24 12 re f*
+.960784 .960784 .862745 rg
+n 192 .75 6 12 re f*
+.960784 .960784 .862745 rg
+n 204 .75 48 12 re f*
+.960784 .960784 .862745 rg
+n 252 .75 6 12 re f*
+.960784 .960784 .862745 rg
+n 258 .75 24 12 re f*
+.960784 .960784 .862745 rg
+n 282 .75 6 12 re f*
+.960784 .960784 .862745 rg
+n 294 .75 48 12 re f*
+.960784 .960784 .862745 rg
+n 342 .75 6 12 re f*
+.960784 .960784 .862745 rg
+n 348 .75 24 12 re f*
+.960784 .960784 .862745 rg
+n 372 .75 6 12 re f*
+BT 1 0 0 1 0 14 Tm 12 TL /F4 10 Tf .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj /F3 10 Tf 0 .501961 0 rg (print) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 0 rg (getargspec) Tj 0 0 0 rg (\() Tj 0 0 0 rg (f1) Tj 0 0 0 rg (\)) Tj 0 0 0 rg  T* 0 0 0 rg (ArgSpec) Tj 0 0 0 rg (\() Tj 0 0 0 rg (args) Tj .4 .4 .4 rg (=) Tj 0 0 0 rg ([) Tj .729412 .129412 .129412 rg ('x') Tj 0 0 0 rg (],) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (varargs) Tj .4 .4 .4 rg (=) Tj 0 .501961 0 rg (None) Tj 0 0 0 rg (,) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (keywords) Tj .4 .4 .4 rg (=) Tj 0 .501961 0 rg (None) Tj 0 0 0 rg (,) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (defaults) Tj .4 .4 .4 rg (=) Tj 0 .501961 0 rg (None) Tj 0 0 0 rg (\)) Tj T* ET
 Q
 Q
 Q
@@ -2395,12 +2137,12 @@ BT 1 0 0 1 0 2 Tm /F1 10 Tf 12 TL (The same decorator works with functions of an
 Q
 Q
 q
-1 0 0 1 62.69291 579.978 cm
+1 0 0 1 62.69291 578.6236 cm
 q
 q
-.988825 0 0 .988825 0 0 cm
+1 0 0 1 0 0 cm
 q
-1 0 0 1 6.6 6.674587 cm
+1 0 0 1 6.6 6.6 cm
 q
 .662745 .662745 .662745 RG
 .5 w
@@ -2408,21 +2150,183 @@ q
 n -6 -6 474 120 re B*
 Q
 q
-BT 1 0 0 1 0 98 Tm 12 TL /F4 10 Tf .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj .666667 .133333 1 rg (@trace) Tj 0 0 0 rg  T* .4 .4 .4 rg (...) Tj 0 0 0 rg ( ) Tj /F3 10 Tf 0 .501961 0 rg (def) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 1 rg (f) Tj 0 0 0 rg (\() Tj (x) Tj (,) Tj ( ) Tj (y) Tj .4 .4 .4 rg (=) Tj (1) Tj 0 0 0 rg (,) Tj ( ) Tj (z) Tj .4 .4 .4 rg (=) Tj (2) Tj 0 0 0 rg (,) Tj ( ) Tj .4 .4 .4 rg (*) Tj 0 0 0 rg (args) Tj (,) Tj ( ) Tj .4 .4 .4 rg (**) Tj 0 0 0 rg (kw) Tj (\):) Tj  T* .4 .4 .4 rg (...) Tj 0 0 0 rg (     ) Tj /F3 10 Tf 0 .501961 0 rg (pass) Tj /F4 10 Tf 0 0 0 rg  T*  T* .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj (f) Tj (\() Tj .4 .4 .4 rg (0) Tj 0 0 0 rg (,) Tj ( ) Tj .4 .4 .4 rg (3) Tj 0 0 0 rg (\)) Tj  T* (calling) Tj ( ) Tj (f) Tj ( ) Tj /F3 10 Tf 0 .501961 0 rg (with) Tj /F4 10 Tf 0 0 0 rg ( ) Tj (args) Tj ( ) Tj (\() Tj .4 .4 .4 rg (0) Tj 0 0 0 rg (,) Tj ( ) Tj .4 .4 .4 rg (3) Tj 0 0 0 rg (,) Tj ( ) Tj .4 .4 .4 rg (2) Tj 0 0 0 rg (\),) Tj ( ) Tj ({}) Tj  T*  T* .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj /F3 10 Tf 0 .501961 0 rg (print) Tj /F4 10 Tf 0 0 0 rg ( ) Tj (getargspec) Tj (\() Tj (f) Tj (\)) Tj  T* (ArgSpec) Tj (\() Tj (args) Tj .4 .4 .4 rg (=) Tj 0 0 0 rg ([) Tj .729412 .129412 .129412 rg ('x') Tj 0 0 0 rg (,) Tj ( ) Tj .729412 .129412 .129412 rg ('y') Tj 0 0 0 rg (,) Tj ( ) Tj .729412 .129412 .129412 rg ('z') Tj 0 0 0 rg (],) Tj ( ) Tj (varargs) Tj .4 .4 .4 rg (=) Tj .729412 .129412 .129412 rg ('args') Tj 0 0 0 rg (,) Tj ( ) Tj (keywords) Tj .4 .4 .4 rg (=) Tj .729412 .129412 .129412 rg ('kw') Tj 0 0 0 rg (,) Tj ( ) Tj (defaults) Tj .4 .4 .4 rg (=) Tj 0 0 0 rg (\() Tj .4 .4 .4 rg (1) Tj 0 0 0 rg (,) Tj ( ) Tj .4 .4 .4 rg (2) Tj 0 0 0 rg (\)\)) Tj T* ET
+.960784 .960784 .862745 rg
+n 0 96.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 6 96.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 12 96.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 24 96.75 36 12 re f*
+.960784 .960784 .862745 rg
+n 0 84.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 24 84.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 48 84.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 54 84.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 60 84.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 66 84.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 78 84.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 84 84.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 90 84.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 96 84.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 108 84.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 114 84.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 120 84.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 126 84.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 138 84.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 144 84.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 168 84.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 180 84.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 192 84.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 204 84.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 0 72.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 48 72.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 0 48.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 6 48.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 12 48.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 24 48.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 30 48.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 36 48.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 42 48.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 54 48.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 60 48.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 0 36.75 42 12 re f*
+.960784 .960784 .862745 rg
+n 48 36.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 60 36.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 90 36.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 120 36.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 126 36.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 132 36.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 144 36.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 150 36.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 162 36.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 168 36.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 186 36.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 0 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 6 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 12 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 24 12.75 30 12 re f*
+.960784 .960784 .862745 rg
+n 60 12.75 60 12 re f*
+.960784 .960784 .862745 rg
+n 120 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 126 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 132 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 0 .75 42 12 re f*
+.960784 .960784 .862745 rg
+n 42 .75 6 12 re f*
+.960784 .960784 .862745 rg
+n 48 .75 24 12 re f*
+.960784 .960784 .862745 rg
+n 72 .75 6 12 re f*
+.960784 .960784 .862745 rg
+n 78 .75 6 12 re f*
+.960784 .960784 .862745 rg
+n 84 .75 18 12 re f*
+.960784 .960784 .862745 rg
+n 102 .75 6 12 re f*
+.960784 .960784 .862745 rg
+n 114 .75 18 12 re f*
+.960784 .960784 .862745 rg
+n 132 .75 6 12 re f*
+.960784 .960784 .862745 rg
+n 144 .75 18 12 re f*
+.960784 .960784 .862745 rg
+n 162 .75 12 12 re f*
+.960784 .960784 .862745 rg
+n 180 .75 42 12 re f*
+.960784 .960784 .862745 rg
+n 222 .75 6 12 re f*
+.960784 .960784 .862745 rg
+n 228 .75 36 12 re f*
+.960784 .960784 .862745 rg
+n 264 .75 6 12 re f*
+.960784 .960784 .862745 rg
+n 276 .75 48 12 re f*
+.960784 .960784 .862745 rg
+n 324 .75 6 12 re f*
+.960784 .960784 .862745 rg
+n 330 .75 24 12 re f*
+.960784 .960784 .862745 rg
+n 354 .75 6 12 re f*
+.960784 .960784 .862745 rg
+n 366 .75 48 12 re f*
+.960784 .960784 .862745 rg
+n 414 .75 6 12 re f*
+.960784 .960784 .862745 rg
+n 420 .75 6 12 re f*
+.960784 .960784 .862745 rg
+n 426 .75 6 12 re f*
+.960784 .960784 .862745 rg
+n 432 .75 6 12 re f*
+.960784 .960784 .862745 rg
+n 444 .75 6 12 re f*
+.960784 .960784 .862745 rg
+n 450 .75 12 12 re f*
+BT 1 0 0 1 0 98 Tm 12 TL /F4 10 Tf .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj .666667 .133333 1 rg (@trace) Tj 0 0 0 rg  T* .4 .4 .4 rg (...) Tj 0 0 0 rg ( ) Tj /F3 10 Tf 0 .501961 0 rg (def) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 1 rg (f) Tj 0 0 0 rg (\() Tj 0 0 0 rg (x) Tj 0 0 0 rg (,) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (y) Tj .4 .4 .4 rg (=) Tj .4 .4 .4 rg (1) Tj 0 0 0 rg (,) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (z) Tj .4 .4 .4 rg (=) Tj .4 .4 .4 rg (2) Tj 0 0 0 rg (,) Tj 0 0 0 rg ( ) Tj .4 .4 .4 rg (*) Tj 0 0 0 rg (args) Tj 0 0 0 rg (,) Tj 0 0 0 rg ( ) Tj .4 .4 .4 rg (**) Tj 0 0 0 rg (kw) Tj 0 0 0 rg (\):) Tj 0 0 0 rg  T* .4 .4 .4 rg (...) Tj 0 0 0 rg (     ) Tj /F3 10 Tf 0 .501961 0 rg (pass) Tj /F4 10 Tf 0 0 0 rg  T*  T* .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (f) Tj 0 0 0 rg (\() Tj .4 .4 .4 rg (0) Tj 0 0 0 rg (,) Tj 0 0 0 rg ( ) Tj .4 .4 .4 rg (3) Tj 0 0 0 rg (\)) Tj 0 0 0 rg  T* 0 0 0 rg (calling) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (f) Tj 0 0 0 rg ( ) Tj /F3 10 Tf 0 .501961 0 rg (with) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 0 rg (args) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (\() Tj .4 .4 .4 rg (0) Tj 0 0 0 rg (,) Tj 0 0 0 rg ( ) Tj .4 .4 .4 rg (3) Tj 0 0 0 rg (,) Tj 0 0 0 rg ( ) Tj .4 .4 .4 rg (2) Tj 0 0 0 rg (\),) Tj 0 0 0 rg ( ) Tj 0 0 0 rg ({}) Tj 0 0 0 rg  T*  T* .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj /F3 10 Tf 0 .501961 0 rg (print) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 0 rg (getargspec) Tj 0 0 0 rg (\() Tj 0 0 0 rg (f) Tj 0 0 0 rg (\)) Tj 0 0 0 rg  T* 0 0 0 rg (ArgSpec) Tj 0 0 0 rg (\() Tj 0 0 0 rg (args) Tj .4 .4 .4 rg (=) Tj 0 0 0 rg ([) Tj .729412 .129412 .129412 rg ('x') Tj 0 0 0 rg (,) Tj 0 0 0 rg ( ) Tj .729412 .129412 .129412 rg ('y') Tj 0 0 0 rg (,) Tj 0 0 0 rg ( ) Tj .729412 .129412 .129412 rg ('z') Tj 0 0 0 rg (],) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (varargs) Tj .4 .4 .4 rg (=) Tj .729412 .129412 .129412 rg ('args') Tj 0 0 0 rg (,) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (keywords) Tj .4 .4 .4 rg (=) Tj .729412 .129412 .129412 rg ('kw') Tj 0 0 0 rg (,) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (defaults) Tj .4 .4 .4 rg (=) Tj 0 0 0 rg (\() Tj .4 .4 .4 rg (1) Tj 0 0 0 rg (,) Tj 0 0 0 rg ( ) Tj .4 .4 .4 rg (2) Tj 0 0 0 rg (\)\)) Tj T* ET
 Q
 Q
 Q
 Q
 Q
 q
-1 0 0 1 62.69291 559.978 cm
+1 0 0 1 62.69291 558.6236 cm
 q
 0 0 0 rg
 BT 1 0 0 1 0 2 Tm /F1 10 Tf 12 TL (That includes even functions with exotic signatures like the following:) Tj T* ET
 Q
 Q
 q
-1 0 0 1 62.69291 442.778 cm
+1 0 0 1 62.69291 441.4236 cm
 q
 q
 1 0 0 1 0 0 cm
@@ -2435,33 +2339,173 @@ q
 n -6 -6 468.6898 108 re B*
 Q
 q
-BT 1 0 0 1 0 86 Tm 12 TL /F4 10 Tf .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj .666667 .133333 1 rg (@trace) Tj 0 0 0 rg  T* .4 .4 .4 rg (...) Tj 0 0 0 rg ( ) Tj /F3 10 Tf 0 .501961 0 rg (def) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 1 rg (exotic_signature) Tj 0 0 0 rg (\(\() Tj (x) Tj (,) Tj ( ) Tj (y) Tj (\)) Tj .4 .4 .4 rg (=) Tj 0 0 0 rg (\() Tj .4 .4 .4 rg (1) Tj 0 0 0 rg (,) Tj .4 .4 .4 rg (2) Tj 0 0 0 rg (\)\):) Tj ( ) Tj /F3 10 Tf 0 .501961 0 rg (return) Tj /F4 10 Tf 0 0 0 rg ( ) Tj (x) Tj .4 .4 .4 rg (+) Tj 0 0 0 rg (y) Tj  T*  T* .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj /F3 10 Tf 0 .501961 0 rg (print) Tj /F4 10 Tf 0 0 0 rg ( ) Tj (getargspec) Tj (\() Tj (exotic_signature) Tj (\)) Tj  T* (ArgSpec) Tj (\() Tj (args) Tj .4 .4 .4 rg (=) Tj 0 0 0 rg ([[) Tj .729412 .129412 .129412 rg ('x') Tj 0 0 0 rg (,) Tj ( ) Tj .729412 .129412 .129412 rg ('y') Tj 0 0 0 rg (]],) Tj ( ) Tj (varargs) Tj .4 .4 .4 rg (=) Tj 0 .501961 0 rg (None) Tj 0 0 0 rg (,) Tj ( ) Tj (keywords) Tj .4 .4 .4 rg (=) Tj 0 .501961 0 rg (None) Tj 0 0 0 rg (,) Tj ( ) Tj (defaults) Tj .4 .4 .4 rg (=) Tj 0 0 0 rg (\(\() Tj .4 .4 .4 rg (1) Tj 0 0 0 rg (,) Tj ( ) Tj .4 .4 .4 rg (2) Tj 0 0 0 rg (\),\)\)) Tj  T* .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj (exotic_signature) Tj (\(\)) Tj  T* (calling) Tj ( ) Tj (exotic_signature) Tj ( ) Tj /F3 10 Tf 0 .501961 0 rg (with) Tj /F4 10 Tf 0 0 0 rg ( ) Tj (args) Tj ( ) Tj (\(\() Tj .4 .4 .4 rg (1) Tj 0 0 0 rg (,) Tj ( ) Tj .4 .4 .4 rg (2) Tj 0 0 0 rg (\),\),) Tj ( ) Tj ({}) Tj  T* .4 .4 .4 rg (3) Tj T* ET
+.960784 .960784 .862745 rg
+n 0 84.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 6 84.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 12 84.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 24 84.75 36 12 re f*
+.960784 .960784 .862745 rg
+n 0 72.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 24 72.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 48 72.75 96 12 re f*
+.960784 .960784 .862745 rg
+n 144 72.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 156 72.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 162 72.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 174 72.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 180 72.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 186 72.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 192 72.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 198 72.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 204 72.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 210 72.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 216 72.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 240 72.75 36 12 re f*
+.960784 .960784 .862745 rg
+n 282 72.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 288 72.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 294 72.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 0 48.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 6 48.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 12 48.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 24 48.75 30 12 re f*
+.960784 .960784 .862745 rg
+n 60 48.75 60 12 re f*
+.960784 .960784 .862745 rg
+n 120 48.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 126 48.75 96 12 re f*
+.960784 .960784 .862745 rg
+n 222 48.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 0 36.75 42 12 re f*
+.960784 .960784 .862745 rg
+n 42 36.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 48 36.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 72 36.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 78 36.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 90 36.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 108 36.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 120 36.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 138 36.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 162 36.75 42 12 re f*
+.960784 .960784 .862745 rg
+n 204 36.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 210 36.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 234 36.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 246 36.75 48 12 re f*
+.960784 .960784 .862745 rg
+n 294 36.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 300 36.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 324 36.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 336 36.75 48 12 re f*
+.960784 .960784 .862745 rg
+n 384 36.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 390 36.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 402 36.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 408 36.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 420 36.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 426 36.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 0 24.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 6 24.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 12 24.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 24 24.75 96 12 re f*
+.960784 .960784 .862745 rg
+n 120 24.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 0 12.75 42 12 re f*
+.960784 .960784 .862745 rg
+n 48 12.75 96 12 re f*
+.960784 .960784 .862745 rg
+n 150 12.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 180 12.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 210 12.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 222 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 228 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 240 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 246 12.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 276 12.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 0 .75 6 12 re f*
+BT 1 0 0 1 0 86 Tm 12 TL /F4 10 Tf .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj .666667 .133333 1 rg (@trace) Tj 0 0 0 rg  T* .4 .4 .4 rg (...) Tj 0 0 0 rg ( ) Tj /F3 10 Tf 0 .501961 0 rg (def) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 1 rg (exotic_signature) Tj 0 0 0 rg (\(\() Tj 0 0 0 rg (x) Tj 0 0 0 rg (,) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (y) Tj 0 0 0 rg (\)) Tj .4 .4 .4 rg (=) Tj 0 0 0 rg (\() Tj .4 .4 .4 rg (1) Tj 0 0 0 rg (,) Tj .4 .4 .4 rg (2) Tj 0 0 0 rg (\)\):) Tj 0 0 0 rg ( ) Tj /F3 10 Tf 0 .501961 0 rg (return) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 0 rg (x) Tj .4 .4 .4 rg (+) Tj 0 0 0 rg (y) Tj 0 0 0 rg  T*  T* .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj /F3 10 Tf 0 .501961 0 rg (print) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 0 rg (getargspec) Tj 0 0 0 rg (\() Tj 0 0 0 rg (exotic_signature) Tj 0 0 0 rg (\)) Tj 0 0 0 rg  T* 0 0 0 rg (ArgSpec) Tj 0 0 0 rg (\() Tj 0 0 0 rg (args) Tj .4 .4 .4 rg (=) Tj 0 0 0 rg ([[) Tj .729412 .129412 .129412 rg ('x') Tj 0 0 0 rg (,) Tj 0 0 0 rg ( ) Tj .729412 .129412 .129412 rg ('y') Tj 0 0 0 rg (]],) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (varargs) Tj .4 .4 .4 rg (=) Tj 0 .501961 0 rg (None) Tj 0 0 0 rg (,) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (keywords) Tj .4 .4 .4 rg (=) Tj 0 .501961 0 rg (None) Tj 0 0 0 rg (,) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (defaults) Tj .4 .4 .4 rg (=) Tj 0 0 0 rg (\(\() Tj .4 .4 .4 rg (1) Tj 0 0 0 rg (,) Tj 0 0 0 rg ( ) Tj .4 .4 .4 rg (2) Tj 0 0 0 rg (\),\)\)) Tj 0 0 0 rg  T* .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (exotic_signature) Tj 0 0 0 rg (\(\)) Tj 0 0 0 rg  T* 0 0 0 rg (calling) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (exotic_signature) Tj 0 0 0 rg ( ) Tj /F3 10 Tf 0 .501961 0 rg (with) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 0 rg (args) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (\(\() Tj .4 .4 .4 rg (1) Tj 0 0 0 rg (,) Tj 0 0 0 rg ( ) Tj .4 .4 .4 rg (2) Tj 0 0 0 rg (\),\),) Tj 0 0 0 rg ( ) Tj 0 0 0 rg ({}) Tj 0 0 0 rg  T* .4 .4 .4 rg (3) Tj T* ET
 Q
 Q
 Q
 Q
 Q
 q
-1 0 0 1 62.69291 410.778 cm
+1 0 0 1 62.69291 409.4236 cm
 q
 0 0 0 rg
 BT 1 0 0 1 0 14 Tm /F1 10 Tf 12 TL .84561 Tw (Notice that the support for exotic signatures has been deprecated in Python 2.6 and removed in Python) Tj T* 0 Tw (3.0.) Tj T* ET
 Q
 Q
 q
-1 0 0 1 62.69291 377.778 cm
+1 0 0 1 62.69291 376.4236 cm
 q
-BT 1 0 0 1 0 3.5 Tm 21 TL /F3 17.5 Tf 0 0 0 rg (decorator ) Tj /F2 17.5 Tf (is a decorator) Tj T* ET
+BT 1 0 0 1 0 3.5 Tm 21 TL /F3 17.5 Tf 0 0 0 rg (decorator ) Tj /F2 17.5 Tf 0 0 0 rg (is a decorator) Tj T* ET
 Q
 Q
 q
-1 0 0 1 62.69291 275.778 cm
+1 0 0 1 62.69291 274.4236 cm
 q
-BT 1 0 0 1 0 86 Tm .643876 Tw 12 TL /F1 10 Tf 0 0 0 rg (It may be annoying to write a caller function \(like the ) Tj /F4 10 Tf (_trace ) Tj /F1 10 Tf (function above\) and then a trivial wrapper) Tj T* 0 Tw 1.510888 Tw (\() Tj /F4 10 Tf (def) Tj ( ) Tj (trace\(f\):) Tj ( ) Tj (return) Tj ( ) Tj (decorator\(_trace,) Tj ( ) Tj (f\)) Tj /F1 10 Tf (\) every time. For this reason, the ) Tj /F4 10 Tf (decorator) Tj T* 0 Tw .334269 Tw /F1 10 Tf (module provides an easy shortcut to convert the caller function into a signature-preserving decorator: you) Tj T* 0 Tw 7.364269 Tw (can just call ) Tj /F4 10 Tf (decorator ) Tj /F1 10 Tf (with a single argument. In our example you can just write) Tj T* 0 Tw .951647 Tw /F4 10 Tf (trace) Tj ( ) Tj (=) Tj ( ) Tj (decorator\(_trace\)) Tj /F1 10 Tf (. The ) Tj /F4 10 Tf (decorator ) Tj /F1 10 Tf (function can also be used as a signature-changing) Tj T* 0 Tw 1.077752 Tw (decorator, just as ) Tj /F4 10 Tf (classmethod ) Tj /F1 10 Tf (and ) Tj /F4 10 Tf (staticmethod) Tj /F1 10 Tf (. However, ) Tj /F4 10 Tf (classmethod ) Tj /F1 10 Tf (and ) Tj /F4 10 Tf (staticmethod) Tj T* 0 Tw .531797 Tw /F1 10 Tf (return generic objects which are not callable, while ) Tj /F4 10 Tf (decorator ) Tj /F1 10 Tf (returns signature-preserving decorators,) Tj T* 0 Tw (i.e. functions of a single argument. For instance, you can write directly) Tj T* ET
+BT 1 0 0 1 0 86 Tm .643876 Tw 12 TL /F1 10 Tf 0 0 0 rg (It may be annoying to write a caller function \(like the ) Tj /F4 10 Tf 0 0 0 rg (_trace ) Tj /F1 10 Tf 0 0 0 rg (function above\) and then a trivial wrapper) Tj T* 0 Tw 1.510888 Tw (\() Tj /F4 10 Tf 0 0 0 rg (def) Tj ( ) Tj (trace\(f\):) Tj ( ) Tj (return) Tj ( ) Tj (decorator\(_trace,) Tj ( ) Tj (f\)) Tj /F1 10 Tf 0 0 0 rg (\) every time. For this reason, the ) Tj /F4 10 Tf 0 0 0 rg (decorator) Tj T* 0 Tw .334269 Tw /F1 10 Tf 0 0 0 rg (module provides an easy shortcut to convert the caller function into a signature-preserving decorator: you) Tj T* 0 Tw 7.364269 Tw (can just call ) Tj /F4 10 Tf 0 0 0 rg (decorator ) Tj /F1 10 Tf 0 0 0 rg (with a single argument. In our example you can just write) Tj T* 0 Tw .951647 Tw /F4 10 Tf 0 0 0 rg (trace) Tj ( ) Tj (=) Tj ( ) Tj (decorator\(_trace\)) Tj /F1 10 Tf 0 0 0 rg (. The ) Tj /F4 10 Tf 0 0 0 rg (decorator ) Tj /F1 10 Tf 0 0 0 rg (function can also be used as a signature-changing) Tj T* 0 Tw 1.077752 Tw (decorator, just as ) Tj /F4 10 Tf 0 0 0 rg (classmethod ) Tj /F1 10 Tf 0 0 0 rg (and ) Tj /F4 10 Tf 0 0 0 rg (staticmethod) Tj /F1 10 Tf 0 0 0 rg (. However, ) Tj /F4 10 Tf 0 0 0 rg (classmethod ) Tj /F1 10 Tf 0 0 0 rg (and ) Tj /F4 10 Tf 0 0 0 rg (staticmethod) Tj T* 0 Tw .531797 Tw /F1 10 Tf 0 0 0 rg (return generic objects which are not callable, while ) Tj /F4 10 Tf 0 0 0 rg (decorator ) Tj /F1 10 Tf 0 0 0 rg (returns signature-preserving decorators,) Tj T* 0 Tw (i.e. functions of a single argument. For instance, you can write directly) Tj T* ET
 Q
 Q
 q
-1 0 0 1 62.69291 206.578 cm
+1 0 0 1 62.69291 205.2236 cm
 q
 q
 1 0 0 1 0 0 cm
@@ -2474,20 +2518,110 @@ q
 n -6 -6 468.6898 60 re B*
 Q
 q
-BT 1 0 0 1 0 38 Tm 12 TL /F4 10 Tf .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj .666667 .133333 1 rg (@decorator) Tj 0 0 0 rg  T* .4 .4 .4 rg (...) Tj 0 0 0 rg ( ) Tj /F3 10 Tf 0 .501961 0 rg (def) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 1 rg (trace) Tj 0 0 0 rg (\() Tj (f) Tj (,) Tj ( ) Tj .4 .4 .4 rg (*) Tj 0 0 0 rg (args) Tj (,) Tj ( ) Tj .4 .4 .4 rg (**) Tj 0 0 0 rg (kw) Tj (\):) Tj  T* .4 .4 .4 rg (...) Tj 0 0 0 rg (     ) Tj /F3 10 Tf 0 .501961 0 rg (print) Tj /F4 10 Tf 0 0 0 rg ( ) Tj .729412 .129412 .129412 rg ("calling ) Tj /F3 10 Tf .733333 .4 .533333 rg (%s) Tj /F4 10 Tf .729412 .129412 .129412 rg ( with args ) Tj /F3 10 Tf .733333 .4 .533333 rg (%s) Tj /F4 10 Tf .729412 .129412 .129412 rg (, ) Tj /F3 10 Tf .733333 .4 .533333 rg (%s) Tj /F4 10 Tf .729412 .129412 .129412 rg (") Tj 0 0 0 rg ( ) Tj .4 .4 .4 rg (%) Tj 0 0 0 rg ( ) Tj (\() Tj (f) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (func_name) Tj (,) Tj ( ) Tj (args) Tj (,) Tj ( ) Tj (kw) Tj (\)) Tj  T* .4 .4 .4 rg (...) Tj 0 0 0 rg (     ) Tj /F3 10 Tf 0 .501961 0 rg (return) Tj /F4 10 Tf 0 0 0 rg ( ) Tj (f) Tj (\() Tj .4 .4 .4 rg (*) Tj 0 0 0 rg (args) Tj (,) Tj ( ) Tj .4 .4 .4 rg (**) Tj 0 0 0 rg (kw) Tj (\)) Tj T* ET
+.960784 .960784 .862745 rg
+n 0 36.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 6 36.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 12 36.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 24 36.75 60 12 re f*
+.960784 .960784 .862745 rg
+n 0 24.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 24 24.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 48 24.75 30 12 re f*
+.960784 .960784 .862745 rg
+n 78 24.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 84 24.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 90 24.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 102 24.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 108 24.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 132 24.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 144 24.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 156 24.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 168 24.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 0 12.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 48 12.75 30 12 re f*
+.960784 .960784 .862745 rg
+n 84 12.75 54 12 re f*
+.960784 .960784 .862745 rg
+n 138 12.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 150 12.75 66 12 re f*
+.960784 .960784 .862745 rg
+n 216 12.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 228 12.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 240 12.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 252 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 264 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 276 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 282 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 288 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 294 12.75 54 12 re f*
+.960784 .960784 .862745 rg
+n 348 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 360 12.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 384 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 396 12.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 408 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 0 .75 18 12 re f*
+.960784 .960784 .862745 rg
+n 48 .75 36 12 re f*
+.960784 .960784 .862745 rg
+n 90 .75 6 12 re f*
+.960784 .960784 .862745 rg
+n 96 .75 6 12 re f*
+.960784 .960784 .862745 rg
+n 102 .75 6 12 re f*
+.960784 .960784 .862745 rg
+n 108 .75 24 12 re f*
+.960784 .960784 .862745 rg
+n 132 .75 6 12 re f*
+.960784 .960784 .862745 rg
+n 144 .75 12 12 re f*
+.960784 .960784 .862745 rg
+n 156 .75 12 12 re f*
+.960784 .960784 .862745 rg
+n 168 .75 6 12 re f*
+BT 1 0 0 1 0 38 Tm 12 TL /F4 10 Tf .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj .666667 .133333 1 rg (@decorator) Tj 0 0 0 rg  T* .4 .4 .4 rg (...) Tj 0 0 0 rg ( ) Tj /F3 10 Tf 0 .501961 0 rg (def) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 1 rg (trace) Tj 0 0 0 rg (\() Tj 0 0 0 rg (f) Tj 0 0 0 rg (,) Tj 0 0 0 rg ( ) Tj .4 .4 .4 rg (*) Tj 0 0 0 rg (args) Tj 0 0 0 rg (,) Tj 0 0 0 rg ( ) Tj .4 .4 .4 rg (**) Tj 0 0 0 rg (kw) Tj 0 0 0 rg (\):) Tj 0 0 0 rg  T* .4 .4 .4 rg (...) Tj 0 0 0 rg (     ) Tj /F3 10 Tf 0 .501961 0 rg (print) Tj /F4 10 Tf 0 0 0 rg ( ) Tj .729412 .129412 .129412 rg ("calling ) Tj /F3 10 Tf .733333 .4 .533333 rg (%s) Tj /F4 10 Tf .729412 .129412 .129412 rg ( with args ) Tj /F3 10 Tf .733333 .4 .533333 rg (%s) Tj /F4 10 Tf .729412 .129412 .129412 rg (, ) Tj /F3 10 Tf .733333 .4 .533333 rg (%s) Tj /F4 10 Tf .729412 .129412 .129412 rg (") Tj 0 0 0 rg ( ) Tj .4 .4 .4 rg (%) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (\() Tj 0 0 0 rg (f) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (func_name) Tj 0 0 0 rg (,) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (args) Tj 0 0 0 rg (,) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (kw) Tj 0 0 0 rg (\)) Tj 0 0 0 rg  T* .4 .4 .4 rg (...) Tj 0 0 0 rg (     ) Tj /F3 10 Tf 0 .501961 0 rg (return) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 0 rg (f) Tj 0 0 0 rg (\() Tj .4 .4 .4 rg (*) Tj 0 0 0 rg (args) Tj 0 0 0 rg (,) Tj 0 0 0 rg ( ) Tj .4 .4 .4 rg (**) Tj 0 0 0 rg (kw) Tj 0 0 0 rg (\)) Tj T* ET
 Q
 Q
 Q
 Q
 Q
 q
-1 0 0 1 62.69291 174.578 cm
+1 0 0 1 62.69291 173.2236 cm
 q
-BT 1 0 0 1 0 14 Tm 1.806654 Tw 12 TL /F1 10 Tf 0 0 0 rg (and now ) Tj /F4 10 Tf (trace ) Tj /F1 10 Tf (will be a decorator. Actually ) Tj /F4 10 Tf (trace ) Tj /F1 10 Tf (is a ) Tj /F4 10 Tf (partial ) Tj /F1 10 Tf (object which can be used as a) Tj T* 0 Tw (decorator:) Tj T* ET
+BT 1 0 0 1 0 14 Tm 1.806654 Tw 12 TL /F1 10 Tf 0 0 0 rg (and now ) Tj /F4 10 Tf 0 0 0 rg (trace ) Tj /F1 10 Tf 0 0 0 rg (will be a decorator. Actually ) Tj /F4 10 Tf 0 0 0 rg (trace ) Tj /F1 10 Tf 0 0 0 rg (is a ) Tj /F4 10 Tf 0 0 0 rg (partial ) Tj /F1 10 Tf 0 0 0 rg (object which can be used as a) Tj T* 0 Tw (decorator:) Tj T* ET
 Q
 Q
 q
-1 0 0 1 62.69291 129.378 cm
+1 0 0 1 62.69291 128.0236 cm
 q
 q
 1 0 0 1 0 0 cm
@@ -2500,14 +2634,38 @@ q
 n -6 -6 468.6898 36 re B*
 Q
 q
-BT 1 0 0 1 0 14 Tm 12 TL /F4 10 Tf .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj (trace) Tj  T* .4 .4 .4 rg (<) Tj 0 0 0 rg (function) Tj ( ) Tj (trace) Tj ( ) Tj (at) Tj ( ) Tj .4 .4 .4 rg (0) Tj 0 0 0 rg (x) Tj .4 .4 .4 rg (...) Tj (>) Tj T* ET
+.960784 .960784 .862745 rg
+n 0 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 6 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 12 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 24 12.75 30 12 re f*
+.960784 .960784 .862745 rg
+n 0 .75 6 12 re f*
+.960784 .960784 .862745 rg
+n 6 .75 48 12 re f*
+.960784 .960784 .862745 rg
+n 60 .75 30 12 re f*
+.960784 .960784 .862745 rg
+n 96 .75 12 12 re f*
+.960784 .960784 .862745 rg
+n 114 .75 6 12 re f*
+.960784 .960784 .862745 rg
+n 120 .75 6 12 re f*
+.960784 .960784 .862745 rg
+n 126 .75 18 12 re f*
+.960784 .960784 .862745 rg
+n 144 .75 6 12 re f*
+BT 1 0 0 1 0 14 Tm 12 TL /F4 10 Tf .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (trace) Tj 0 0 0 rg  T* .4 .4 .4 rg (<) Tj 0 0 0 rg (function) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (trace) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (at) Tj 0 0 0 rg ( ) Tj .4 .4 .4 rg (0) Tj 0 0 0 rg (x) Tj .4 .4 .4 rg (...) Tj (>) Tj T* ET
 Q
 Q
 Q
 Q
 Q
 q
-1 0 0 1 62.69291 109.378 cm
+1 0 0 1 62.69291 108.0236 cm
 q
 0 0 0 rg
 BT 1 0 0 1 0 2 Tm /F1 10 Tf 12 TL (Here is an example of usage:) Tj T* ET
@@ -2516,10 +2674,8 @@ Q
  
 endstream
 endobj
-% 'R90': class PDFStream 
 90 0 obj
-% page stream
-<< /Length 7156 >>
+<< /Length 18247 >>
 stream
 1 0 0 1 0 0 cm  BT /F1 12 Tf 14.4 TL ET
 q
@@ -2536,7 +2692,47 @@ q
 n -6 -6 468.6898 72 re B*
 Q
 q
-BT 1 0 0 1 0 50 Tm 12 TL /F4 10 Tf .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj .666667 .133333 1 rg (@trace) Tj 0 0 0 rg  T* .4 .4 .4 rg (...) Tj 0 0 0 rg ( ) Tj /F3 10 Tf 0 .501961 0 rg (def) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 1 rg (func) Tj 0 0 0 rg (\(\):) Tj ( ) Tj /F3 10 Tf 0 .501961 0 rg (pass) Tj /F4 10 Tf 0 0 0 rg  T*  T* .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj (func) Tj (\(\)) Tj  T* (calling) Tj ( ) Tj (func) Tj ( ) Tj /F3 10 Tf 0 .501961 0 rg (with) Tj /F4 10 Tf 0 0 0 rg ( ) Tj (args) Tj ( ) Tj (\(\),) Tj ( ) Tj ({}) Tj T* ET
+.960784 .960784 .862745 rg
+n 0 48.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 6 48.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 12 48.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 24 48.75 36 12 re f*
+.960784 .960784 .862745 rg
+n 0 36.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 24 36.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 48 36.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 72 36.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 96 36.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 0 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 6 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 12 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 24 12.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 48 12.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 0 .75 42 12 re f*
+.960784 .960784 .862745 rg
+n 48 .75 24 12 re f*
+.960784 .960784 .862745 rg
+n 78 .75 24 12 re f*
+.960784 .960784 .862745 rg
+n 108 .75 24 12 re f*
+.960784 .960784 .862745 rg
+n 138 .75 18 12 re f*
+.960784 .960784 .862745 rg
+n 162 .75 12 12 re f*
+BT 1 0 0 1 0 50 Tm 12 TL /F4 10 Tf .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj .666667 .133333 1 rg (@trace) Tj 0 0 0 rg  T* .4 .4 .4 rg (...) Tj 0 0 0 rg ( ) Tj /F3 10 Tf 0 .501961 0 rg (def) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 1 rg (func) Tj 0 0 0 rg (\(\):) Tj 0 0 0 rg ( ) Tj /F3 10 Tf 0 .501961 0 rg (pass) Tj /F4 10 Tf 0 0 0 rg  T*  T* .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (func) Tj 0 0 0 rg (\(\)) Tj 0 0 0 rg  T* 0 0 0 rg (calling) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (func) Tj 0 0 0 rg ( ) Tj /F3 10 Tf 0 .501961 0 rg (with) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 0 rg (args) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (\(\),) Tj 0 0 0 rg ( ) Tj 0 0 0 rg ({}) Tj T* ET
 Q
 Q
 Q
@@ -2545,7 +2741,7 @@ Q
 q
 1 0 0 1 62.69291 659.8236 cm
 q
-BT 1 0 0 1 0 14 Tm 2.44686 Tw 12 TL /F1 10 Tf 0 0 0 rg (If you are using an old Python version \(Python 2.4\) the ) Tj /F4 10 Tf (decorator ) Tj /F1 10 Tf (module provides a poor man) Tj T* 0 Tw (replacement for ) Tj /F4 10 Tf (functools.partial) Tj /F1 10 Tf (.) Tj T* ET
+BT 1 0 0 1 0 14 Tm 2.44686 Tw 12 TL /F1 10 Tf 0 0 0 rg (If you are using an old Python version \(Python 2.4\) the ) Tj /F4 10 Tf 0 0 0 rg (decorator ) Tj /F1 10 Tf 0 0 0 rg (module provides a poor man) Tj T* 0 Tw (replacement for ) Tj /F4 10 Tf 0 0 0 rg (functools.partial) Tj /F1 10 Tf 0 0 0 rg (.) Tj T* ET
 Q
 Q
 q
@@ -2557,11 +2753,11 @@ Q
 q
 1 0 0 1 62.69291 584.8236 cm
 q
-BT 1 0 0 1 0 26 Tm 1.224692 Tw 12 TL /F1 10 Tf 0 0 0 rg (Sometimes one has to deal with blocking resources, such as ) Tj /F4 10 Tf (stdin) Tj /F1 10 Tf (, and sometimes it is best to have) Tj T* 0 Tw .266235 Tw (back a "busy" message than to block everything. This behavior can be implemented with a suitable family) Tj T* 0 Tw (of decorators, where the parameter is the busy message:) Tj T* ET
+BT 1 0 0 1 0 26 Tm 1.224692 Tw 12 TL /F1 10 Tf 0 0 0 rg (Sometimes one has to deal with blocking resources, such as ) Tj /F4 10 Tf 0 0 0 rg (stdin) Tj /F1 10 Tf 0 0 0 rg (, and sometimes it is best to have) Tj T* 0 Tw .266235 Tw (back a "busy" message than to block everything. This behavior can be implemented with a suitable family) Tj T* 0 Tw (of decorators, where the parameter is the busy message:) Tj T* ET
 Q
 Q
 q
-1 0 0 1 62.69291 407.6236 cm
+1 0 0 1 62.69291 395.6236 cm
 q
 q
 1 0 0 1 0 0 cm
@@ -2571,23 +2767,193 @@ q
 .662745 .662745 .662745 RG
 .5 w
 .960784 .960784 .862745 rg
-n -6 -6 468.6898 168 re B*
+n -6 -6 468.6898 180 re B*
 Q
 q
-BT 1 0 0 1 0 146 Tm 12 TL /F3 10 Tf 0 .501961 0 rg (def) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 1 rg (blocking) Tj 0 0 0 rg (\() Tj (not_avail) Tj (\):) Tj  T* (    ) Tj /F3 10 Tf 0 .501961 0 rg (def) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 1 rg (blocking) Tj 0 0 0 rg (\() Tj (f) Tj (,) Tj ( ) Tj .4 .4 .4 rg (*) Tj 0 0 0 rg (args) Tj (,) Tj ( ) Tj .4 .4 .4 rg (**) Tj 0 0 0 rg (kw) Tj (\):) Tj  T* (        ) Tj /F3 10 Tf 0 .501961 0 rg (if) Tj /F4 10 Tf 0 0 0 rg ( ) Tj /F3 10 Tf .666667 .133333 1 rg (not) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 .501961 0 rg (hasattr) Tj 0 0 0 rg (\() Tj (f) Tj (,) Tj ( ) Tj .729412 .129412 .129412 rg ("thread") Tj 0 0 0 rg (\):) Tj ( ) Tj /F6 10 Tf .25098 .501961 .501961 rg (# no thread running) Tj /F4 10 Tf 0 0 0 rg  T* (            ) Tj /F3 10 Tf 0 .501961 0 rg (def) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 1 rg (set_result) Tj 0 0 0 rg (\(\):) Tj ( ) Tj (f) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (result) Tj ( ) Tj .4 .4 .4 rg (=) Tj 0 0 0 rg ( ) Tj (f) Tj (\() Tj .4 .4 .4 rg (*) Tj 0 0 0 rg (args) Tj (,) Tj ( ) Tj .4 .4 .4 rg (**) Tj 0 0 0 rg (kw) Tj (\)) Tj  T* (            ) Tj (f) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (thread) Tj ( ) Tj .4 .4 .4 rg (=) Tj 0 0 0 rg ( ) Tj (threading) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (Thread) Tj (\() Tj 0 .501961 0 rg (None) Tj 0 0 0 rg (,) Tj ( ) Tj (set_result) Tj (\)) Tj  T* (            ) Tj (f) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (thread) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (start) Tj (\(\)) Tj  T* (            ) Tj /F3 10 Tf 0 .501961 0 rg (return) Tj /F4 10 Tf 0 0 0 rg ( ) Tj (not_avail) Tj  T* (        ) Tj /F3 10 Tf 0 .501961 0 rg (elif) Tj /F4 10 Tf 0 0 0 rg ( ) Tj (f) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (thread) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (isAlive) Tj (\(\):) Tj  T* (            ) Tj /F3 10 Tf 0 .501961 0 rg (return) Tj /F4 10 Tf 0 0 0 rg ( ) Tj (not_avail) Tj  T* (        ) Tj /F3 10 Tf 0 .501961 0 rg (else) Tj /F4 10 Tf 0 0 0 rg (:) Tj ( ) Tj /F6 10 Tf .25098 .501961 .501961 rg (# the thread is ended, return the stored result) Tj /F4 10 Tf 0 0 0 rg  T* (            ) Tj /F3 10 Tf 0 .501961 0 rg (del) Tj /F4 10 Tf 0 0 0 rg ( ) Tj (f) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (thread) Tj  T* (            ) Tj /F3 10 Tf 0 .501961 0 rg (return) Tj /F4 10 Tf 0 0 0 rg ( ) Tj (f) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (result) Tj  T* (    ) Tj /F3 10 Tf 0 .501961 0 rg (return) Tj /F4 10 Tf 0 0 0 rg ( ) Tj (decorator) Tj (\() Tj (blocking) Tj (\)) Tj T* ET
+.960784 .960784 .862745 rg
+n 0 156.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 24 156.75 48 12 re f*
+.960784 .960784 .862745 rg
+n 72 156.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 78 156.75 54 12 re f*
+.960784 .960784 .862745 rg
+n 132 156.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 24 144.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 48 144.75 48 12 re f*
+.960784 .960784 .862745 rg
+n 96 144.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 102 144.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 108 144.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 120 144.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 126 144.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 150 144.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 162 144.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 174 144.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 186 144.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 48 132.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 66 132.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 90 132.75 42 12 re f*
+.960784 .960784 .862745 rg
+n 132 132.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 138 132.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 144 132.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 156 132.75 48 12 re f*
+.960784 .960784 .862745 rg
+n 204 132.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 228 132.75 114 12 re f*
+.960784 .960784 .862745 rg
+n 72 120.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 96 120.75 60 12 re f*
+.960784 .960784 .862745 rg
+n 156 120.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 96 108.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 102 108.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 108 108.75 36 12 re f*
+.960784 .960784 .862745 rg
+n 150 108.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 162 108.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 168 108.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 174 108.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 180 108.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 204 108.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 216 108.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 228 108.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 240 108.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 72 96.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 78 96.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 84 96.75 36 12 re f*
+.960784 .960784 .862745 rg
+n 126 96.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 138 96.75 54 12 re f*
+.960784 .960784 .862745 rg
+n 192 96.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 198 96.75 36 12 re f*
+.960784 .960784 .862745 rg
+n 234 96.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 240 96.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 264 96.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 276 96.75 60 12 re f*
+.960784 .960784 .862745 rg
+n 336 96.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 72 84.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 78 84.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 84 84.75 36 12 re f*
+.960784 .960784 .862745 rg
+n 120 84.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 126 84.75 30 12 re f*
+.960784 .960784 .862745 rg
+n 156 84.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 72 72.75 36 12 re f*
+.960784 .960784 .862745 rg
+n 114 72.75 54 12 re f*
+.960784 .960784 .862745 rg
+n 48 60.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 78 60.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 84 60.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 90 60.75 36 12 re f*
+.960784 .960784 .862745 rg
+n 126 60.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 132 60.75 42 12 re f*
+.960784 .960784 .862745 rg
+n 174 60.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 72 48.75 36 12 re f*
+.960784 .960784 .862745 rg
+n 114 48.75 54 12 re f*
+.960784 .960784 .862745 rg
+n 48 36.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 72 36.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 90 36.75 282 12 re f*
+.960784 .960784 .862745 rg
+n 72 24.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 96 24.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 102 24.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 108 24.75 36 12 re f*
+.960784 .960784 .862745 rg
+n 72 12.75 36 12 re f*
+.960784 .960784 .862745 rg
+n 114 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 120 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 126 12.75 36 12 re f*
+.960784 .960784 .862745 rg
+n 24 .75 36 12 re f*
+.960784 .960784 .862745 rg
+n 66 .75 54 12 re f*
+.960784 .960784 .862745 rg
+n 120 .75 6 12 re f*
+.960784 .960784 .862745 rg
+n 126 .75 48 12 re f*
+.960784 .960784 .862745 rg
+n 174 .75 6 12 re f*
+BT 1 0 0 1 0 158 Tm 12 TL /F3 10 Tf 0 .501961 0 rg (def) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 1 rg (blocking) Tj 0 0 0 rg (\() Tj 0 0 0 rg (not_avail) Tj 0 0 0 rg (\):) Tj 0 0 0 rg  T* (    ) Tj /F3 10 Tf 0 .501961 0 rg (def) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 1 rg (blocking) Tj 0 0 0 rg (\() Tj 0 0 0 rg (f) Tj 0 0 0 rg (,) Tj 0 0 0 rg ( ) Tj .4 .4 .4 rg (*) Tj 0 0 0 rg (args) Tj 0 0 0 rg (,) Tj 0 0 0 rg ( ) Tj .4 .4 .4 rg (**) Tj 0 0 0 rg (kw) Tj 0 0 0 rg (\):) Tj 0 0 0 rg  T* (        ) Tj /F3 10 Tf 0 .501961 0 rg (if) Tj /F4 10 Tf 0 0 0 rg ( ) Tj /F3 10 Tf .666667 .133333 1 rg (not) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 .501961 0 rg (hasattr) Tj 0 0 0 rg (\() Tj 0 0 0 rg (f) Tj 0 0 0 rg (,) Tj 0 0 0 rg ( ) Tj .729412 .129412 .129412 rg ("thread") Tj 0 0 0 rg (\):) Tj 0 0 0 rg (  ) Tj /F6 10 Tf .25098 .501961 .501961 rg (# no thread running) Tj /F4 10 Tf 0 0 0 rg  T* (            ) Tj /F3 10 Tf 0 .501961 0 rg (def) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 1 rg (set_result) Tj 0 0 0 rg (\(\):) Tj 0 0 0 rg  T* (                ) Tj 0 0 0 rg (f) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (result) Tj 0 0 0 rg ( ) Tj .4 .4 .4 rg (=) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (f) Tj 0 0 0 rg (\() Tj .4 .4 .4 rg (*) Tj 0 0 0 rg (args) Tj 0 0 0 rg (,) Tj 0 0 0 rg ( ) Tj .4 .4 .4 rg (**) Tj 0 0 0 rg (kw) Tj 0 0 0 rg (\)) Tj 0 0 0 rg  T* (            ) Tj 0 0 0 rg (f) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (thread) Tj 0 0 0 rg ( ) Tj .4 .4 .4 rg (=) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (threading) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (Thread) Tj 0 0 0 rg (\() Tj 0 .501961 0 rg (None) Tj 0 0 0 rg (,) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (set_result) Tj 0 0 0 rg (\)) Tj 0 0 0 rg  T* (            ) Tj 0 0 0 rg (f) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (thread) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (start) Tj 0 0 0 rg (\(\)) Tj 0 0 0 rg  T* (            ) Tj /F3 10 Tf 0 .501961 0 rg (return) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 0 rg (not_avail) Tj 0 0 0 rg  T* (        ) Tj /F3 10 Tf 0 .501961 0 rg (elif) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 0 rg (f) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (thread) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (isAlive) Tj 0 0 0 rg (\(\):) Tj 0 0 0 rg  T* (            ) Tj /F3 10 Tf 0 .501961 0 rg (return) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 0 rg (not_avail) Tj 0 0 0 rg  T* (        ) Tj /F3 10 Tf 0 .501961 0 rg (else) Tj /F4 10 Tf 0 0 0 rg (:) Tj 0 0 0 rg (  ) Tj /F6 10 Tf .25098 .501961 .501961 rg (# the thread is ended, return the stored result) Tj /F4 10 Tf 0 0 0 rg  T* (            ) Tj /F3 10 Tf 0 .501961 0 rg (del) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 0 rg (f) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (thread) Tj 0 0 0 rg  T* (            ) Tj /F3 10 Tf 0 .501961 0 rg (return) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 0 rg (f) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (result) Tj 0 0 0 rg  T* (    ) Tj /F3 10 Tf 0 .501961 0 rg (return) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 0 rg (decorator) Tj 0 0 0 rg (\() Tj 0 0 0 rg (blocking) Tj 0 0 0 rg (\)) Tj T* ET
 Q
 Q
 Q
 Q
 Q
 q
-1 0 0 1 62.69291 375.6236 cm
+1 0 0 1 62.69291 363.6236 cm
 q
-BT 1 0 0 1 0 14 Tm 1.010651 Tw 12 TL /F1 10 Tf 0 0 0 rg (Functions decorated with ) Tj /F4 10 Tf (blocking ) Tj /F1 10 Tf (will return a busy message if the resource is unavailable, and the) Tj T* 0 Tw (intended result if the resource is available. For instance:) Tj T* ET
+BT 1 0 0 1 0 14 Tm 1.010651 Tw 12 TL /F1 10 Tf 0 0 0 rg (Functions decorated with ) Tj /F4 10 Tf 0 0 0 rg (blocking ) Tj /F1 10 Tf 0 0 0 rg (will return a busy message if the resource is unavailable, and the) Tj T* 0 Tw (intended result if the resource is available. For instance:) Tj T* ET
 Q
 Q
 q
-1 0 0 1 62.69291 126.4236 cm
+1 0 0 1 62.69291 114.4236 cm
 q
 q
 1 0 0 1 0 0 cm
@@ -2600,7 +2966,183 @@ q
 n -6 -6 468.6898 240 re B*
 Q
 q
-BT 1 0 0 1 0 218 Tm 12 TL /F4 10 Tf .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj .666667 .133333 1 rg (@blocking) Tj 0 0 0 rg (\() Tj .729412 .129412 .129412 rg ("Please wait ...") Tj 0 0 0 rg (\)) Tj  T* .4 .4 .4 rg (...) Tj 0 0 0 rg ( ) Tj /F3 10 Tf 0 .501961 0 rg (def) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 1 rg (read_data) Tj 0 0 0 rg (\(\):) Tj  T* .4 .4 .4 rg (...) Tj 0 0 0 rg (     ) Tj (time) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (sleep) Tj (\() Tj .4 .4 .4 rg (3) Tj 0 0 0 rg (\)) Tj ( ) Tj /F6 10 Tf .25098 .501961 .501961 rg (# simulate a blocking resource) Tj /F4 10 Tf 0 0 0 rg  T* .4 .4 .4 rg (...) Tj 0 0 0 rg (     ) Tj /F3 10 Tf 0 .501961 0 rg (return) Tj /F4 10 Tf 0 0 0 rg ( ) Tj .729412 .129412 .129412 rg ("some data") Tj 0 0 0 rg  T*  T* .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj /F3 10 Tf 0 .501961 0 rg (print) Tj /F4 10 Tf 0 0 0 rg ( ) Tj (read_data) Tj (\(\)) Tj ( ) Tj /F6 10 Tf .25098 .501961 .501961 rg (# data is not available yet) Tj /F4 10 Tf 0 0 0 rg  T* (Please) Tj ( ) Tj (wait) Tj ( ) Tj .4 .4 .4 rg (...) Tj 0 0 0 rg  T*  T* .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj (time) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (sleep) Tj (\() Tj .4 .4 .4 rg (1) Tj 0 0 0 rg (\)) Tj  T* .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj /F3 10 Tf 0 .501961 0 rg (print) Tj /F4 10 Tf 0 0 0 rg ( ) Tj (read_data) Tj (\(\)) Tj ( ) Tj /F6 10 Tf .25098 .501961 .501961 rg (# data is not available yet) Tj /F4 10 Tf 0 0 0 rg  T* (Please) Tj ( ) Tj (wait) Tj ( ) Tj .4 .4 .4 rg (...) Tj 0 0 0 rg  T*  T* .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj (time) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (sleep) Tj (\() Tj .4 .4 .4 rg (1) Tj 0 0 0 rg (\)) Tj  T* .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj /F3 10 Tf 0 .501961 0 rg (print) Tj /F4 10 Tf 0 0 0 rg ( ) Tj (read_data) Tj (\(\)) Tj ( ) Tj /F6 10 Tf .25098 .501961 .501961 rg (# data is not available yet) Tj /F4 10 Tf 0 0 0 rg  T* (Please) Tj ( ) Tj (wait) Tj ( ) Tj .4 .4 .4 rg (...) Tj 0 0 0 rg  T*  T* .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj (time) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (sleep) Tj (\() Tj .4 .4 .4 rg (1.1) Tj 0 0 0 rg (\)) Tj ( ) Tj /F6 10 Tf .25098 .501961 .501961 rg (# after 3.1 seconds, data is available) Tj /F4 10 Tf 0 0 0 rg  T* .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj /F3 10 Tf 0 .501961 0 rg (print) Tj /F4 10 Tf 0 0 0 rg ( ) Tj (read_data) Tj (\(\)) Tj  T* (some) Tj ( ) Tj (data) Tj T* ET
+.960784 .960784 .862745 rg
+n 0 216.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 6 216.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 12 216.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 24 216.75 54 12 re f*
+.960784 .960784 .862745 rg
+n 78 216.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 84 216.75 102 12 re f*
+.960784 .960784 .862745 rg
+n 186 216.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 0 204.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 24 204.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 48 204.75 54 12 re f*
+.960784 .960784 .862745 rg
+n 102 204.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 0 192.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 48 192.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 72 192.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 78 192.75 30 12 re f*
+.960784 .960784 .862745 rg
+n 108 192.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 114 192.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 120 192.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 132 192.75 180 12 re f*
+.960784 .960784 .862745 rg
+n 0 180.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 48 180.75 36 12 re f*
+.960784 .960784 .862745 rg
+n 90 180.75 66 12 re f*
+.960784 .960784 .862745 rg
+n 0 156.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 6 156.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 12 156.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 24 156.75 30 12 re f*
+.960784 .960784 .862745 rg
+n 60 156.75 54 12 re f*
+.960784 .960784 .862745 rg
+n 114 156.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 132 156.75 162 12 re f*
+.960784 .960784 .862745 rg
+n 0 144.75 36 12 re f*
+.960784 .960784 .862745 rg
+n 42 144.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 72 144.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 0 120.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 6 120.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 12 120.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 24 120.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 48 120.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 54 120.75 30 12 re f*
+.960784 .960784 .862745 rg
+n 84 120.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 90 120.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 96 120.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 0 108.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 6 108.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 12 108.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 24 108.75 30 12 re f*
+.960784 .960784 .862745 rg
+n 60 108.75 54 12 re f*
+.960784 .960784 .862745 rg
+n 114 108.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 132 108.75 162 12 re f*
+.960784 .960784 .862745 rg
+n 0 96.75 36 12 re f*
+.960784 .960784 .862745 rg
+n 42 96.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 72 96.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 0 72.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 6 72.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 12 72.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 24 72.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 48 72.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 54 72.75 30 12 re f*
+.960784 .960784 .862745 rg
+n 84 72.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 90 72.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 96 72.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 0 60.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 6 60.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 12 60.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 24 60.75 30 12 re f*
+.960784 .960784 .862745 rg
+n 60 60.75 54 12 re f*
+.960784 .960784 .862745 rg
+n 114 60.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 132 60.75 162 12 re f*
+.960784 .960784 .862745 rg
+n 0 48.75 36 12 re f*
+.960784 .960784 .862745 rg
+n 42 48.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 72 48.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 0 24.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 6 24.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 12 24.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 24 24.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 48 24.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 54 24.75 30 12 re f*
+.960784 .960784 .862745 rg
+n 84 24.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 90 24.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 108 24.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 120 24.75 228 12 re f*
+.960784 .960784 .862745 rg
+n 0 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 6 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 12 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 24 12.75 30 12 re f*
+.960784 .960784 .862745 rg
+n 60 12.75 54 12 re f*
+.960784 .960784 .862745 rg
+n 114 12.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 0 .75 24 12 re f*
+.960784 .960784 .862745 rg
+n 30 .75 24 12 re f*
+BT 1 0 0 1 0 218 Tm 12 TL /F4 10 Tf .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj .666667 .133333 1 rg (@blocking) Tj 0 0 0 rg (\() Tj .729412 .129412 .129412 rg ("Please wait ...") Tj 0 0 0 rg (\)) Tj 0 0 0 rg  T* .4 .4 .4 rg (...) Tj 0 0 0 rg ( ) Tj /F3 10 Tf 0 .501961 0 rg (def) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 1 rg (read_data) Tj 0 0 0 rg (\(\):) Tj 0 0 0 rg  T* .4 .4 .4 rg (...) Tj 0 0 0 rg (     ) Tj 0 0 0 rg (time) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (sleep) Tj 0 0 0 rg (\() Tj .4 .4 .4 rg (3) Tj 0 0 0 rg (\)) Tj 0 0 0 rg ( ) Tj /F6 10 Tf .25098 .501961 .501961 rg (# simulate a blocking resource) Tj /F4 10 Tf 0 0 0 rg  T* .4 .4 .4 rg (...) Tj 0 0 0 rg (     ) Tj /F3 10 Tf 0 .501961 0 rg (return) Tj /F4 10 Tf 0 0 0 rg ( ) Tj .729412 .129412 .129412 rg ("some data") Tj 0 0 0 rg  T*  T* .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj /F3 10 Tf 0 .501961 0 rg (print) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 0 rg (read_data) Tj 0 0 0 rg (\(\)) Tj 0 0 0 rg ( ) Tj /F6 10 Tf .25098 .501961 .501961 rg (# data is not available yet) Tj /F4 10 Tf 0 0 0 rg  T* 0 0 0 rg (Please) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (wait) Tj 0 0 0 rg ( ) Tj .4 .4 .4 rg (...) Tj 0 0 0 rg  T*  T* .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (time) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (sleep) Tj 0 0 0 rg (\() Tj .4 .4 .4 rg (1) Tj 0 0 0 rg (\)) Tj 0 0 0 rg  T* .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj /F3 10 Tf 0 .501961 0 rg (print) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 0 rg (read_data) Tj 0 0 0 rg (\(\)) Tj 0 0 0 rg ( ) Tj /F6 10 Tf .25098 .501961 .501961 rg (# data is not available yet) Tj /F4 10 Tf 0 0 0 rg  T* 0 0 0 rg (Please) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (wait) Tj 0 0 0 rg ( ) Tj .4 .4 .4 rg (...) Tj 0 0 0 rg  T*  T* .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (time) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (sleep) Tj 0 0 0 rg (\() Tj .4 .4 .4 rg (1) Tj 0 0 0 rg (\)) Tj 0 0 0 rg  T* .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj /F3 10 Tf 0 .501961 0 rg (print) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 0 rg (read_data) Tj 0 0 0 rg (\(\)) Tj 0 0 0 rg ( ) Tj /F6 10 Tf .25098 .501961 .501961 rg (# data is not available yet) Tj /F4 10 Tf 0 0 0 rg  T* 0 0 0 rg (Please) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (wait) Tj 0 0 0 rg ( ) Tj .4 .4 .4 rg (...) Tj 0 0 0 rg  T*  T* .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (time) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (sleep) Tj 0 0 0 rg (\() Tj .4 .4 .4 rg (1.1) Tj 0 0 0 rg (\)) Tj 0 0 0 rg ( ) Tj /F6 10 Tf .25098 .501961 .501961 rg (# after 3.1 seconds, data is available) Tj /F4 10 Tf 0 0 0 rg  T* .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj /F3 10 Tf 0 .501961 0 rg (print) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 0 rg (read_data) Tj 0 0 0 rg (\(\)) Tj 0 0 0 rg  T* 0 0 0 rg (some) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (data) Tj T* ET
 Q
 Q
 Q
@@ -2609,10 +3151,8 @@ Q
  
 endstream
 endobj
-% 'R91': class PDFStream 
 91 0 obj
-% page stream
-<< /Length 7381 >>
+<< /Length 16586 >>
 stream
 1 0 0 1 0 0 cm  BT /F1 12 Tf 14.4 TL ET
 q
@@ -2631,7 +3171,7 @@ Q
 q
 1 0 0 1 62.69291 636.0236 cm
 q
-BT 1 0 0 1 0 50 Tm 2.853876 Tw 12 TL /F1 10 Tf 0 0 0 rg (As an example, here will I show a decorator which is able to convert a blocking function into an) Tj T* 0 Tw 2.477126 Tw (asynchronous function. The function, when called, is executed in a separate thread. Moreover, it is) Tj T* 0 Tw .288443 Tw (possible to set three callbacks ) Tj /F4 10 Tf (on_success) Tj /F1 10 Tf (, ) Tj /F4 10 Tf (on_failure ) Tj /F1 10 Tf (and ) Tj /F4 10 Tf (on_closing) Tj /F1 10 Tf (, to specify how to manage) Tj T* 0 Tw 1.854724 Tw (the function call \(of course the code here is just an example, it is not a recommended way of doing) Tj T* 0 Tw (multi-threaded programming\). The implementation is the following:) Tj T* ET
+BT 1 0 0 1 0 50 Tm 2.853876 Tw 12 TL /F1 10 Tf 0 0 0 rg (As an example, here will I show a decorator which is able to convert a blocking function into an) Tj T* 0 Tw 2.477126 Tw (asynchronous function. The function, when called, is executed in a separate thread. Moreover, it is) Tj T* 0 Tw .288443 Tw (possible to set three callbacks ) Tj /F4 10 Tf 0 0 0 rg (on_success) Tj /F1 10 Tf 0 0 0 rg (, ) Tj /F4 10 Tf 0 0 0 rg (on_failure ) Tj /F1 10 Tf 0 0 0 rg (and ) Tj /F4 10 Tf 0 0 0 rg (on_closing) Tj /F1 10 Tf 0 0 0 rg (, to specify how to manage) Tj T* 0 Tw 1.854724 Tw (the function call \(of course the code here is just an example, it is not a recommended way of doing) Tj T* 0 Tw (multi-threaded programming\). The implementation is the following:) Tj T* ET
 Q
 Q
 q
@@ -2648,7 +3188,25 @@ q
 n -6 -6 468.6898 48 re B*
 Q
 q
-BT 1 0 0 1 0 26 Tm 12 TL /F3 10 Tf 0 .501961 0 rg (def) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 1 rg (on_success) Tj 0 0 0 rg (\() Tj (result) Tj (\):) Tj ( ) Tj /F6 10 Tf .25098 .501961 .501961 rg (# default implementation) Tj /F4 10 Tf 0 0 0 rg  T* (    ) Tj .729412 .129412 .129412 rg ("Called on the result of the function") Tj 0 0 0 rg  T* (    ) Tj /F3 10 Tf 0 .501961 0 rg (return) Tj /F4 10 Tf 0 0 0 rg ( ) Tj (result) Tj T* ET
+.960784 .960784 .862745 rg
+n 0 24.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 24 24.75 60 12 re f*
+.960784 .960784 .862745 rg
+n 84 24.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 90 24.75 36 12 re f*
+.960784 .960784 .862745 rg
+n 126 24.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 150 24.75 144 12 re f*
+.960784 .960784 .862745 rg
+n 24 12.75 228 12 re f*
+.960784 .960784 .862745 rg
+n 24 .75 36 12 re f*
+.960784 .960784 .862745 rg
+n 66 .75 36 12 re f*
+BT 1 0 0 1 0 26 Tm 12 TL /F3 10 Tf 0 .501961 0 rg (def) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 1 rg (on_success) Tj 0 0 0 rg (\() Tj 0 0 0 rg (result) Tj 0 0 0 rg (\):) Tj 0 0 0 rg (  ) Tj /F6 10 Tf .25098 .501961 .501961 rg (# default implementation) Tj /F4 10 Tf 0 0 0 rg  T* (    ) Tj .729412 .129412 .129412 rg ("Called on the result of the function") Tj 0 0 0 rg  T* (    ) Tj /F3 10 Tf 0 .501961 0 rg (return) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 0 rg (result) Tj T* ET
 Q
 Q
 Q
@@ -2668,7 +3226,23 @@ q
 n -6 -6 468.6898 48 re B*
 Q
 q
-BT 1 0 0 1 0 26 Tm 12 TL /F3 10 Tf 0 .501961 0 rg (def) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 1 rg (on_failure) Tj 0 0 0 rg (\() Tj (exc_info) Tj (\):) Tj ( ) Tj /F6 10 Tf .25098 .501961 .501961 rg (# default implementation) Tj /F4 10 Tf 0 0 0 rg  T* (    ) Tj .729412 .129412 .129412 rg ("Called if the function fails") Tj 0 0 0 rg  T* (    ) Tj /F3 10 Tf 0 .501961 0 rg (pass) Tj T* ET
+.960784 .960784 .862745 rg
+n 0 24.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 24 24.75 60 12 re f*
+.960784 .960784 .862745 rg
+n 84 24.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 90 24.75 48 12 re f*
+.960784 .960784 .862745 rg
+n 138 24.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 162 24.75 144 12 re f*
+.960784 .960784 .862745 rg
+n 24 12.75 180 12 re f*
+.960784 .960784 .862745 rg
+n 24 .75 24 12 re f*
+BT 1 0 0 1 0 26 Tm 12 TL /F3 10 Tf 0 .501961 0 rg (def) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 1 rg (on_failure) Tj 0 0 0 rg (\() Tj 0 0 0 rg (exc_info) Tj 0 0 0 rg (\):) Tj 0 0 0 rg (  ) Tj /F6 10 Tf .25098 .501961 .501961 rg (# default implementation) Tj /F4 10 Tf 0 0 0 rg  T* (    ) Tj .729412 .129412 .129412 rg ("Called if the function fails") Tj 0 0 0 rg  T* (    ) Tj /F3 10 Tf 0 .501961 0 rg (pass) Tj T* ET
 Q
 Q
 Q
@@ -2688,7 +3262,19 @@ q
 n -6 -6 468.6898 48 re B*
 Q
 q
-BT 1 0 0 1 0 26 Tm 12 TL /F3 10 Tf 0 .501961 0 rg (def) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 1 rg (on_closing) Tj 0 0 0 rg (\(\):) Tj ( ) Tj /F6 10 Tf .25098 .501961 .501961 rg (# default implementation) Tj /F4 10 Tf 0 0 0 rg  T* (    ) Tj .729412 .129412 .129412 rg ("Called at the end, both in case of success and failure") Tj 0 0 0 rg  T* (    ) Tj /F3 10 Tf 0 .501961 0 rg (pass) Tj T* ET
+.960784 .960784 .862745 rg
+n 0 24.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 24 24.75 60 12 re f*
+.960784 .960784 .862745 rg
+n 84 24.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 114 24.75 144 12 re f*
+.960784 .960784 .862745 rg
+n 24 12.75 336 12 re f*
+.960784 .960784 .862745 rg
+n 24 .75 24 12 re f*
+BT 1 0 0 1 0 26 Tm 12 TL /F3 10 Tf 0 .501961 0 rg (def) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 1 rg (on_closing) Tj 0 0 0 rg (\(\):) Tj 0 0 0 rg (  ) Tj /F6 10 Tf .25098 .501961 .501961 rg (# default implementation) Tj /F4 10 Tf 0 0 0 rg  T* (    ) Tj .729412 .129412 .129412 rg ("Called at the end, both in case of success and failure") Tj 0 0 0 rg  T* (    ) Tj /F3 10 Tf 0 .501961 0 rg (pass) Tj T* ET
 Q
 Q
 Q
@@ -2708,7 +3294,283 @@ q
 n -6 -6 468.6898 372 re B*
 Q
 q
-BT 1 0 0 1 0 350 Tm 12 TL /F3 10 Tf 0 .501961 0 rg (class) Tj /F4 10 Tf 0 0 0 rg ( ) Tj /F3 10 Tf 0 0 1 rg (Async) Tj /F4 10 Tf 0 0 0 rg (\() Tj 0 .501961 0 rg (object) Tj 0 0 0 rg (\):) Tj  T* (    ) Tj /F6 10 Tf .729412 .129412 .129412 rg (""") Tj T* (    A decorator converting blocking functions into asynchronous) Tj T* (    functions, by using threads or processes. Examples:) Tj T*  T* (    async_with_threads =  Async\(threading.Thread\)) Tj T* (    async_with_processes =  Async\(multiprocessing.Process\)) Tj T* (    """) Tj /F4 10 Tf 0 0 0 rg  T*  T* (    ) Tj /F3 10 Tf 0 .501961 0 rg (def) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 1 rg (__init__) Tj 0 0 0 rg (\() Tj 0 .501961 0 rg (self) Tj 0 0 0 rg (,) Tj ( ) Tj (threadfactory) Tj (,) Tj ( ) Tj (on_success) Tj .4 .4 .4 rg (=) Tj 0 0 0 rg (on_success) Tj (,) Tj  T* (                 ) Tj (on_failure) Tj .4 .4 .4 rg (=) Tj 0 0 0 rg (on_failure) Tj (,) Tj ( ) Tj (on_closing) Tj .4 .4 .4 rg (=) Tj 0 0 0 rg (on_closing) Tj (\):) Tj  T* (        ) Tj 0 .501961 0 rg (self) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (threadfactory) Tj ( ) Tj .4 .4 .4 rg (=) Tj 0 0 0 rg ( ) Tj (threadfactory) Tj  T* (        ) Tj 0 .501961 0 rg (self) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (on_success) Tj ( ) Tj .4 .4 .4 rg (=) Tj 0 0 0 rg ( ) Tj (on_success) Tj  T* (        ) Tj 0 .501961 0 rg (self) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (on_failure) Tj ( ) Tj .4 .4 .4 rg (=) Tj 0 0 0 rg ( ) Tj (on_failure) Tj  T* (        ) Tj 0 .501961 0 rg (self) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (on_closing) Tj ( ) Tj .4 .4 .4 rg (=) Tj 0 0 0 rg ( ) Tj (on_closing) Tj  T*  T* (    ) Tj /F3 10 Tf 0 .501961 0 rg (def) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 1 rg (__call__) Tj 0 0 0 rg (\() Tj 0 .501961 0 rg (self) Tj 0 0 0 rg (,) Tj ( ) Tj (func) Tj (,) Tj ( ) Tj .4 .4 .4 rg (*) Tj 0 0 0 rg (args) Tj (,) Tj ( ) Tj .4 .4 .4 rg (**) Tj 0 0 0 rg (kw) Tj (\):) Tj  T* (        ) Tj /F3 10 Tf 0 .501961 0 rg (try) Tj /F4 10 Tf 0 0 0 rg (:) Tj  T* (            ) Tj (counter) Tj ( ) Tj .4 .4 .4 rg (=) Tj 0 0 0 rg ( ) Tj (func) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (counter) Tj  T* (        ) Tj /F3 10 Tf 0 .501961 0 rg (except) Tj /F4 10 Tf 0 0 0 rg ( ) Tj /F3 10 Tf .823529 .254902 .227451 rg (AttributeError) Tj /F4 10 Tf 0 0 0 rg (:) Tj ( ) Tj /F6 10 Tf .25098 .501961 .501961 rg (# instantiate the counter at the first call) Tj /F4 10 Tf 0 0 0 rg  T* (            ) Tj (counter) Tj ( ) Tj .4 .4 .4 rg (=) Tj 0 0 0 rg ( ) Tj (func) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (counter) Tj ( ) Tj .4 .4 .4 rg (=) Tj 0 0 0 rg ( ) Tj (itertools) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (count) Tj (\() Tj .4 .4 .4 rg (1) Tj 0 0 0 rg (\)) Tj  T* (        ) Tj (name) Tj ( ) Tj .4 .4 .4 rg (=) Tj 0 0 0 rg ( ) Tj .729412 .129412 .129412 rg (') Tj /F3 10 Tf .733333 .4 .533333 rg (%s) Tj /F4 10 Tf .729412 .129412 .129412 rg (-) Tj /F3 10 Tf .733333 .4 .533333 rg (%s) Tj /F4 10 Tf .729412 .129412 .129412 rg (') Tj 0 0 0 rg ( ) Tj .4 .4 .4 rg (%) Tj 0 0 0 rg ( ) Tj (\() Tj (func) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (__name__) Tj (,) Tj ( ) Tj (counter) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (next) Tj (\(\)\)) Tj  T* (        ) Tj /F3 10 Tf 0 .501961 0 rg (def) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 1 rg (func_wrapper) Tj 0 0 0 rg (\(\):) Tj  T* (            ) Tj /F3 10 Tf 0 .501961 0 rg (try) Tj /F4 10 Tf 0 0 0 rg (:) Tj  T* (                ) Tj (result) Tj ( ) Tj .4 .4 .4 rg (=) Tj 0 0 0 rg ( ) Tj (func) Tj (\() Tj .4 .4 .4 rg (*) Tj 0 0 0 rg (args) Tj (,) Tj ( ) Tj .4 .4 .4 rg (**) Tj 0 0 0 rg (kw) Tj (\)) Tj  T* (            ) Tj /F3 10 Tf 0 .501961 0 rg (except) Tj /F4 10 Tf 0 0 0 rg (:) Tj  T* (                ) Tj 0 .501961 0 rg (self) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (on_failure) Tj (\() Tj (sys) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (exc_info) Tj (\(\)\)) Tj  T* (            ) Tj /F3 10 Tf 0 .501961 0 rg (else) Tj /F4 10 Tf 0 0 0 rg (:) Tj  T* (                ) Tj /F3 10 Tf 0 .501961 0 rg (return) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 .501961 0 rg (self) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (on_success) Tj (\() Tj (result) Tj (\)) Tj  T* (            ) Tj /F3 10 Tf 0 .501961 0 rg (finally) Tj /F4 10 Tf 0 0 0 rg (:) Tj  T* ET
+.960784 .960784 .862745 rg
+n 0 348.75 30 12 re f*
+.960784 .960784 .862745 rg
+n 36 348.75 30 12 re f*
+.960784 .960784 .862745 rg
+n 66 348.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 72 348.75 36 12 re f*
+.960784 .960784 .862745 rg
+n 108 348.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 24 336.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 0 324.75 378 12 re f*
+.960784 .960784 .862745 rg
+n 0 312.75 330 12 re f*
+.960784 .960784 .862745 rg
+n 0 300.75 0 12 re f*
+.960784 .960784 .862745 rg
+n 0 288.75 294 12 re f*
+.960784 .960784 .862745 rg
+n 0 276.75 348 12 re f*
+.960784 .960784 .862745 rg
+n 0 264.75 42 12 re f*
+.960784 .960784 .862745 rg
+n 24 240.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 48 240.75 48 12 re f*
+.960784 .960784 .862745 rg
+n 96 240.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 102 240.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 126 240.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 138 240.75 78 12 re f*
+.960784 .960784 .862745 rg
+n 216 240.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 228 240.75 60 12 re f*
+.960784 .960784 .862745 rg
+n 288 240.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 294 240.75 60 12 re f*
+.960784 .960784 .862745 rg
+n 354 240.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 102 228.75 60 12 re f*
+.960784 .960784 .862745 rg
+n 162 228.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 168 228.75 60 12 re f*
+.960784 .960784 .862745 rg
+n 228 228.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 240 228.75 60 12 re f*
+.960784 .960784 .862745 rg
+n 300 228.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 306 228.75 60 12 re f*
+.960784 .960784 .862745 rg
+n 366 228.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 48 216.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 72 216.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 78 216.75 78 12 re f*
+.960784 .960784 .862745 rg
+n 162 216.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 174 216.75 78 12 re f*
+.960784 .960784 .862745 rg
+n 48 204.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 72 204.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 78 204.75 60 12 re f*
+.960784 .960784 .862745 rg
+n 144 204.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 156 204.75 60 12 re f*
+.960784 .960784 .862745 rg
+n 48 192.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 72 192.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 78 192.75 60 12 re f*
+.960784 .960784 .862745 rg
+n 144 192.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 156 192.75 60 12 re f*
+.960784 .960784 .862745 rg
+n 48 180.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 72 180.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 78 180.75 60 12 re f*
+.960784 .960784 .862745 rg
+n 144 180.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 156 180.75 60 12 re f*
+.960784 .960784 .862745 rg
+n 24 156.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 48 156.75 48 12 re f*
+.960784 .960784 .862745 rg
+n 96 156.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 102 156.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 126 156.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 138 156.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 162 156.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 174 156.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 180 156.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 204 156.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 216 156.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 228 156.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 240 156.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 48 144.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 66 144.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 72 132.75 42 12 re f*
+.960784 .960784 .862745 rg
+n 120 132.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 132 132.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 156 132.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 162 132.75 42 12 re f*
+.960784 .960784 .862745 rg
+n 48 120.75 36 12 re f*
+.960784 .960784 .862745 rg
+n 90 120.75 84 12 re f*
+.960784 .960784 .862745 rg
+n 174 120.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 192 120.75 258 12 re f*
+.960784 .960784 .862745 rg
+n 72 108.75 42 12 re f*
+.960784 .960784 .862745 rg
+n 120 108.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 132 108.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 156 108.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 162 108.75 42 12 re f*
+.960784 .960784 .862745 rg
+n 210 108.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 222 108.75 54 12 re f*
+.960784 .960784 .862745 rg
+n 276 108.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 282 108.75 30 12 re f*
+.960784 .960784 .862745 rg
+n 312 108.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 318 108.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 324 108.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 48 96.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 78 96.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 90 96.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 96 96.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 108 96.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 114 96.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 126 96.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 138 96.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 150 96.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 156 96.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 180 96.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 186 96.75 48 12 re f*
+.960784 .960784 .862745 rg
+n 234 96.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 246 96.75 42 12 re f*
+.960784 .960784 .862745 rg
+n 288 96.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 294 96.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 318 96.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 48 72.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 72 72.75 72 12 re f*
+.960784 .960784 .862745 rg
+n 144 72.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 72 60.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 90 60.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 96 48.75 36 12 re f*
+.960784 .960784 .862745 rg
+n 138 48.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 150 48.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 174 48.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 180 48.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 186 48.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 210 48.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 222 48.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 234 48.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 246 48.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 72 36.75 36 12 re f*
+.960784 .960784 .862745 rg
+n 108 36.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 96 24.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 120 24.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 126 24.75 60 12 re f*
+.960784 .960784 .862745 rg
+n 186 24.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 192 24.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 210 24.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 216 24.75 48 12 re f*
+.960784 .960784 .862745 rg
+n 264 24.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 72 12.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 96 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 96 .75 36 12 re f*
+.960784 .960784 .862745 rg
+n 138 .75 24 12 re f*
+.960784 .960784 .862745 rg
+n 162 .75 6 12 re f*
+.960784 .960784 .862745 rg
+n 168 .75 60 12 re f*
+.960784 .960784 .862745 rg
+n 228 .75 6 12 re f*
+.960784 .960784 .862745 rg
+n 234 .75 36 12 re f*
+.960784 .960784 .862745 rg
+n 270 .75 6 12 re f*
+BT 1 0 0 1 0 350 Tm 12 TL /F3 10 Tf 0 .501961 0 rg (class) Tj /F4 10 Tf 0 0 0 rg ( ) Tj /F3 10 Tf 0 0 1 rg (Async) Tj /F4 10 Tf 0 0 0 rg (\() Tj 0 .501961 0 rg (object) Tj 0 0 0 rg (\):) Tj 0 0 0 rg  T* (    ) Tj /F6 10 Tf .729412 .129412 .129412 rg (""") Tj T* (    A decorator converting blocking functions into asynchronous) Tj T* (    functions, by using threads or processes. Examples:) Tj T*  T* (    async_with_threads =  Async\(threading.Thread\)) Tj T* (    async_with_processes =  Async\(multiprocessing.Process\)) Tj T* (    """) Tj /F4 10 Tf 0 0 0 rg  T*  T* (    ) Tj /F3 10 Tf 0 .501961 0 rg (def) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 1 rg (__init__) Tj 0 0 0 rg (\() Tj 0 .501961 0 rg (self) Tj 0 0 0 rg (,) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (threadfactory) Tj 0 0 0 rg (,) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (on_success) Tj .4 .4 .4 rg (=) Tj 0 0 0 rg (on_success) Tj 0 0 0 rg (,) Tj 0 0 0 rg  T* (                 ) Tj 0 0 0 rg (on_failure) Tj .4 .4 .4 rg (=) Tj 0 0 0 rg (on_failure) Tj 0 0 0 rg (,) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (on_closing) Tj .4 .4 .4 rg (=) Tj 0 0 0 rg (on_closing) Tj 0 0 0 rg (\):) Tj 0 0 0 rg  T* (        ) Tj 0 .501961 0 rg (self) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (threadfactory) Tj 0 0 0 rg ( ) Tj .4 .4 .4 rg (=) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (threadfactory) Tj 0 0 0 rg  T* (        ) Tj 0 .501961 0 rg (self) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (on_success) Tj 0 0 0 rg ( ) Tj .4 .4 .4 rg (=) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (on_success) Tj 0 0 0 rg  T* (        ) Tj 0 .501961 0 rg (self) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (on_failure) Tj 0 0 0 rg ( ) Tj .4 .4 .4 rg (=) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (on_failure) Tj 0 0 0 rg  T* (        ) Tj 0 .501961 0 rg (self) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (on_closing) Tj 0 0 0 rg ( ) Tj .4 .4 .4 rg (=) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (on_closing) Tj 0 0 0 rg  T*  T* (    ) Tj /F3 10 Tf 0 .501961 0 rg (def) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 1 rg (__call__) Tj 0 0 0 rg (\() Tj 0 .501961 0 rg (self) Tj 0 0 0 rg (,) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (func) Tj 0 0 0 rg (,) Tj 0 0 0 rg ( ) Tj .4 .4 .4 rg (*) Tj 0 0 0 rg (args) Tj 0 0 0 rg (,) Tj 0 0 0 rg ( ) Tj .4 .4 .4 rg (**) Tj 0 0 0 rg (kw) Tj 0 0 0 rg (\):) Tj 0 0 0 rg  T* (        ) Tj /F3 10 Tf 0 .501961 0 rg (try) Tj /F4 10 Tf 0 0 0 rg (:) Tj 0 0 0 rg  T* (            ) Tj 0 0 0 rg (counter) Tj 0 0 0 rg ( ) Tj .4 .4 .4 rg (=) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (func) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (counter) Tj 0 0 0 rg  T* (        ) Tj /F3 10 Tf 0 .501961 0 rg (except) Tj /F4 10 Tf 0 0 0 rg ( ) Tj /F3 10 Tf .823529 .254902 .227451 rg (AttributeError) Tj /F4 10 Tf 0 0 0 rg (:) Tj 0 0 0 rg (  ) Tj /F6 10 Tf .25098 .501961 .501961 rg (# instantiate the counter at the first call) Tj /F4 10 Tf 0 0 0 rg  T* (            ) Tj 0 0 0 rg (counter) Tj 0 0 0 rg ( ) Tj .4 .4 .4 rg (=) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (func) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (counter) Tj 0 0 0 rg ( ) Tj .4 .4 .4 rg (=) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (itertools) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (count) Tj 0 0 0 rg (\() Tj .4 .4 .4 rg (1) Tj 0 0 0 rg (\)) Tj 0 0 0 rg  T* (        ) Tj 0 0 0 rg (name) Tj 0 0 0 rg ( ) Tj .4 .4 .4 rg (=) Tj 0 0 0 rg ( ) Tj .729412 .129412 .129412 rg (') Tj /F3 10 Tf .733333 .4 .533333 rg (%s) Tj /F4 10 Tf .729412 .129412 .129412 rg (-) Tj /F3 10 Tf .733333 .4 .533333 rg (%s) Tj /F4 10 Tf .729412 .129412 .129412 rg (') Tj 0 0 0 rg ( ) Tj .4 .4 .4 rg (%) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (\() Tj 0 0 0 rg (func) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (__name__) Tj 0 0 0 rg (,) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (counter) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (next) Tj 0 0 0 rg (\(\)\)) Tj 0 0 0 rg  T*  T* (        ) Tj /F3 10 Tf 0 .501961 0 rg (def) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 1 rg (func_wrapper) Tj 0 0 0 rg (\(\):) Tj 0 0 0 rg  T* (            ) Tj /F3 10 Tf 0 .501961 0 rg (try) Tj /F4 10 Tf 0 0 0 rg (:) Tj 0 0 0 rg  T* (                ) Tj 0 0 0 rg (result) Tj 0 0 0 rg ( ) Tj .4 .4 .4 rg (=) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (func) Tj 0 0 0 rg (\() Tj .4 .4 .4 rg (*) Tj 0 0 0 rg (args) Tj 0 0 0 rg (,) Tj 0 0 0 rg ( ) Tj .4 .4 .4 rg (**) Tj 0 0 0 rg (kw) Tj 0 0 0 rg (\)) Tj 0 0 0 rg  T* (            ) Tj /F3 10 Tf 0 .501961 0 rg (except) Tj /F4 10 Tf 0 0 0 rg (:) Tj 0 0 0 rg  T* (                ) Tj 0 .501961 0 rg (self) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (on_failure) Tj 0 0 0 rg (\() Tj 0 0 0 rg (sys) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (exc_info) Tj 0 0 0 rg (\(\)\)) Tj 0 0 0 rg  T* (            ) Tj /F3 10 Tf 0 .501961 0 rg (else) Tj /F4 10 Tf 0 0 0 rg (:) Tj 0 0 0 rg  T* (                ) Tj /F3 10 Tf 0 .501961 0 rg (return) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 .501961 0 rg (self) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (on_success) Tj 0 0 0 rg (\() Tj 0 0 0 rg (result) Tj 0 0 0 rg (\)) Tj 0 0 0 rg  T* ET
 Q
 Q
 Q
@@ -2717,14 +3579,12 @@ Q
  
 endstream
 endobj
-% 'R92': class PDFStream 
 92 0 obj
-% page stream
-<< /Length 7221 >>
+<< /Length 17364 >>
 stream
 1 0 0 1 0 0 cm  BT /F1 12 Tf 14.4 TL ET
 q
-1 0 0 1 62.69291 703.8236 cm
+1 0 0 1 62.69291 691.8236 cm
 q
 q
 1 0 0 1 0 0 cm
@@ -2734,30 +3594,78 @@ q
 .662745 .662745 .662745 RG
 .5 w
 .960784 .960784 .862745 rg
-n -6 -6 468.6898 60 re B*
+n -6 -6 468.6898 72 re B*
 Q
 q
-BT 1 0 0 1 0 38 Tm 12 TL /F4 10 Tf 0 0 0 rg (                ) Tj 0 .501961 0 rg (self) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (on_closing) Tj (\(\)) Tj  T* (        ) Tj (thread) Tj ( ) Tj .4 .4 .4 rg (=) Tj 0 0 0 rg ( ) Tj 0 .501961 0 rg (self) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (threadfactory) Tj (\() Tj 0 .501961 0 rg (None) Tj 0 0 0 rg (,) Tj ( ) Tj (func_wrapper) Tj (,) Tj ( ) Tj (name) Tj (\)) Tj  T* (        ) Tj (thread) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (start) Tj (\(\)) Tj  T* (        ) Tj /F3 10 Tf 0 .501961 0 rg (return) Tj /F4 10 Tf 0 0 0 rg ( ) Tj (thread) Tj T* ET
+.960784 .960784 .862745 rg
+n 72 48.75 42 12 re f*
+.960784 .960784 .862745 rg
+n 114 48.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 96 36.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 120 36.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 126 36.75 60 12 re f*
+.960784 .960784 .862745 rg
+n 186 36.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 48 24.75 36 12 re f*
+.960784 .960784 .862745 rg
+n 90 24.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 102 24.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 126 24.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 132 24.75 78 12 re f*
+.960784 .960784 .862745 rg
+n 210 24.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 216 24.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 240 24.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 252 24.75 72 12 re f*
+.960784 .960784 .862745 rg
+n 324 24.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 336 24.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 360 24.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 48 12.75 36 12 re f*
+.960784 .960784 .862745 rg
+n 84 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 90 12.75 30 12 re f*
+.960784 .960784 .862745 rg
+n 120 12.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 48 .75 36 12 re f*
+.960784 .960784 .862745 rg
+n 90 .75 36 12 re f*
+BT 1 0 0 1 0 50 Tm 12 TL /F4 10 Tf 0 0 0 rg (            ) Tj /F3 10 Tf 0 .501961 0 rg (finally) Tj /F4 10 Tf 0 0 0 rg (:) Tj 0 0 0 rg  T* (                ) Tj 0 .501961 0 rg (self) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (on_closing) Tj 0 0 0 rg (\(\)) Tj 0 0 0 rg  T* (        ) Tj 0 0 0 rg (thread) Tj 0 0 0 rg ( ) Tj .4 .4 .4 rg (=) Tj 0 0 0 rg ( ) Tj 0 .501961 0 rg (self) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (threadfactory) Tj 0 0 0 rg (\() Tj 0 .501961 0 rg (None) Tj 0 0 0 rg (,) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (func_wrapper) Tj 0 0 0 rg (,) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (name) Tj 0 0 0 rg (\)) Tj 0 0 0 rg  T* (        ) Tj 0 0 0 rg (thread) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (start) Tj 0 0 0 rg (\(\)) Tj 0 0 0 rg  T* (        ) Tj /F3 10 Tf 0 .501961 0 rg (return) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 0 rg (thread) Tj T* ET
 Q
 Q
 Q
 Q
 Q
 q
-1 0 0 1 62.69291 671.8236 cm
+1 0 0 1 62.69291 659.8236 cm
 q
-BT 1 0 0 1 0 14 Tm .865984 Tw 12 TL /F1 10 Tf 0 0 0 rg (The decorated function returns the current execution thread, which can be stored and checked later, for) Tj T* 0 Tw (instance to verify that the thread ) Tj /F4 10 Tf (.isAlive\(\)) Tj /F1 10 Tf (.) Tj T* ET
+BT 1 0 0 1 0 14 Tm .865984 Tw 12 TL /F1 10 Tf 0 0 0 rg (The decorated function returns the current execution thread, which can be stored and checked later, for) Tj T* 0 Tw (instance to verify that the thread ) Tj /F4 10 Tf 0 0 0 rg (.isAlive\(\)) Tj /F1 10 Tf 0 0 0 rg (.) Tj T* ET
 Q
 Q
 q
-1 0 0 1 62.69291 629.8236 cm
+1 0 0 1 62.69291 617.8236 cm
 q
 0 0 0 rg
 BT 1 0 0 1 0 26 Tm /F1 10 Tf 12 TL .691654 Tw (Here is an example of usage. Suppose one wants to write some data to an external resource which can) Tj T* 0 Tw .21683 Tw (be accessed by a single user at once \(for instance a printer\). Then the access to the writing function must) Tj T* 0 Tw (be locked. Here is a minimalistic example:) Tj T* ET
 Q
 Q
 q
-1 0 0 1 62.69291 476.6236 cm
+1 0 0 1 62.69291 464.6236 cm
 q
 q
 1 0 0 1 0 0 cm
@@ -2770,20 +3678,130 @@ q
 n -6 -6 468.6898 144 re B*
 Q
 q
-BT 1 0 0 1 0 122 Tm 12 TL /F4 10 Tf .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj (async) Tj ( ) Tj .4 .4 .4 rg (=) Tj 0 0 0 rg ( ) Tj (decorator) Tj (\() Tj (Async) Tj (\() Tj (threading) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (Thread) Tj (\)\)) Tj  T*  T* .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj (datalist) Tj ( ) Tj .4 .4 .4 rg (=) Tj 0 0 0 rg ( ) Tj ([]) Tj ( ) Tj /F6 10 Tf .25098 .501961 .501961 rg (# for simplicity the written data are stored into a list.) Tj /F4 10 Tf 0 0 0 rg  T*  T* .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj .666667 .133333 1 rg (@async) Tj 0 0 0 rg  T* .4 .4 .4 rg (...) Tj 0 0 0 rg ( ) Tj /F3 10 Tf 0 .501961 0 rg (def) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 1 rg (write) Tj 0 0 0 rg (\() Tj (data) Tj (\):) Tj  T* .4 .4 .4 rg (...) Tj 0 0 0 rg (     ) Tj /F6 10 Tf .25098 .501961 .501961 rg (# append data to the datalist by locking) Tj /F4 10 Tf 0 0 0 rg  T* .4 .4 .4 rg (...) Tj 0 0 0 rg (     ) Tj /F3 10 Tf 0 .501961 0 rg (with) Tj /F4 10 Tf 0 0 0 rg ( ) Tj (threading) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (Lock) Tj (\(\):) Tj  T* .4 .4 .4 rg (...) Tj 0 0 0 rg (         ) Tj (time) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (sleep) Tj (\() Tj .4 .4 .4 rg (1) Tj 0 0 0 rg (\)) Tj ( ) Tj /F6 10 Tf .25098 .501961 .501961 rg (# emulate some long running operation) Tj /F4 10 Tf 0 0 0 rg  T* .4 .4 .4 rg (...) Tj 0 0 0 rg (         ) Tj (datalist) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (append) Tj (\() Tj (data) Tj (\)) Tj  T* .4 .4 .4 rg (...) Tj 0 0 0 rg (     ) Tj /F6 10 Tf .25098 .501961 .501961 rg (# other operations not requiring a lock here) Tj T* ET
+.960784 .960784 .862745 rg
+n 0 120.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 6 120.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 12 120.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 24 120.75 30 12 re f*
+.960784 .960784 .862745 rg
+n 60 120.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 72 120.75 54 12 re f*
+.960784 .960784 .862745 rg
+n 126 120.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 132 120.75 30 12 re f*
+.960784 .960784 .862745 rg
+n 162 120.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 168 120.75 54 12 re f*
+.960784 .960784 .862745 rg
+n 222 120.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 228 120.75 36 12 re f*
+.960784 .960784 .862745 rg
+n 264 120.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 0 96.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 6 96.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 12 96.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 24 96.75 48 12 re f*
+.960784 .960784 .862745 rg
+n 78 96.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 90 96.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 108 96.75 342 12 re f*
+.960784 .960784 .862745 rg
+n 0 72.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 6 72.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 12 72.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 24 72.75 36 12 re f*
+.960784 .960784 .862745 rg
+n 0 60.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 24 60.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 48 60.75 30 12 re f*
+.960784 .960784 .862745 rg
+n 78 60.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 84 60.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 108 60.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 0 48.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 48 48.75 240 12 re f*
+.960784 .960784 .862745 rg
+n 0 36.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 48 36.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 78 36.75 54 12 re f*
+.960784 .960784 .862745 rg
+n 132 36.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 138 36.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 162 36.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 0 24.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 72 24.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 96 24.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 102 24.75 30 12 re f*
+.960784 .960784 .862745 rg
+n 132 24.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 138 24.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 144 24.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 156 24.75 222 12 re f*
+.960784 .960784 .862745 rg
+n 0 12.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 72 12.75 48 12 re f*
+.960784 .960784 .862745 rg
+n 120 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 126 12.75 36 12 re f*
+.960784 .960784 .862745 rg
+n 162 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 168 12.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 192 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 0 .75 18 12 re f*
+.960784 .960784 .862745 rg
+n 48 .75 264 12 re f*
+BT 1 0 0 1 0 122 Tm 12 TL /F4 10 Tf .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (async) Tj 0 0 0 rg ( ) Tj .4 .4 .4 rg (=) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (decorator) Tj 0 0 0 rg (\() Tj 0 0 0 rg (Async) Tj 0 0 0 rg (\() Tj 0 0 0 rg (threading) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (Thread) Tj 0 0 0 rg (\)\)) Tj 0 0 0 rg  T*  T* .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (datalist) Tj 0 0 0 rg ( ) Tj .4 .4 .4 rg (=) Tj 0 0 0 rg ( ) Tj 0 0 0 rg ([]) Tj 0 0 0 rg ( ) Tj /F6 10 Tf .25098 .501961 .501961 rg (# for simplicity the written data are stored into a list.) Tj /F4 10 Tf 0 0 0 rg  T*  T* .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj .666667 .133333 1 rg (@async) Tj 0 0 0 rg  T* .4 .4 .4 rg (...) Tj 0 0 0 rg ( ) Tj /F3 10 Tf 0 .501961 0 rg (def) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 1 rg (write) Tj 0 0 0 rg (\() Tj 0 0 0 rg (data) Tj 0 0 0 rg (\):) Tj 0 0 0 rg  T* .4 .4 .4 rg (...) Tj 0 0 0 rg (     ) Tj /F6 10 Tf .25098 .501961 .501961 rg (# append data to the datalist by locking) Tj /F4 10 Tf 0 0 0 rg  T* .4 .4 .4 rg (...) Tj 0 0 0 rg (     ) Tj /F3 10 Tf 0 .501961 0 rg (with) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 0 rg (threading) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (Lock) Tj 0 0 0 rg (\(\):) Tj 0 0 0 rg  T* .4 .4 .4 rg (...) Tj 0 0 0 rg (         ) Tj 0 0 0 rg (time) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (sleep) Tj 0 0 0 rg (\() Tj .4 .4 .4 rg (1) Tj 0 0 0 rg (\)) Tj 0 0 0 rg ( ) Tj /F6 10 Tf .25098 .501961 .501961 rg (# emulate some long running operation) Tj /F4 10 Tf 0 0 0 rg  T* .4 .4 .4 rg (...) Tj 0 0 0 rg (         ) Tj 0 0 0 rg (datalist) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (append) Tj 0 0 0 rg (\() Tj 0 0 0 rg (data) Tj 0 0 0 rg (\)) Tj 0 0 0 rg  T* .4 .4 .4 rg (...) Tj 0 0 0 rg (     ) Tj /F6 10 Tf .25098 .501961 .501961 rg (# other operations not requiring a lock here) Tj T* ET
 Q
 Q
 Q
 Q
 Q
 q
-1 0 0 1 62.69291 444.6236 cm
+1 0 0 1 62.69291 432.6236 cm
 q
-BT 1 0 0 1 0 14 Tm .905868 Tw 12 TL /F1 10 Tf 0 0 0 rg (Each call to ) Tj /F4 10 Tf (write ) Tj /F1 10 Tf (will create a new writer thread, but there will be no synchronization problems since) Tj T* 0 Tw /F4 10 Tf (write ) Tj /F1 10 Tf (is locked.) Tj T* ET
+BT 1 0 0 1 0 14 Tm .905868 Tw 12 TL /F1 10 Tf 0 0 0 rg (Each call to ) Tj /F4 10 Tf 0 0 0 rg (write ) Tj /F1 10 Tf 0 0 0 rg (will create a new writer thread, but there will be no synchronization problems since) Tj T* 0 Tw /F4 10 Tf 0 0 0 rg (write ) Tj /F1 10 Tf 0 0 0 rg (is locked.) Tj T* ET
 Q
 Q
 q
-1 0 0 1 62.69291 279.4236 cm
+1 0 0 1 62.69291 267.4236 cm
 q
 q
 1 0 0 1 0 0 cm
@@ -2796,26 +3814,160 @@ q
 n -6 -6 468.6898 156 re B*
 Q
 q
-BT 1 0 0 1 0 134 Tm 12 TL /F4 10 Tf .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj (write) Tj (\() Tj .729412 .129412 .129412 rg ("data1") Tj 0 0 0 rg (\)) Tj  T* .4 .4 .4 rg (<) Tj 0 0 0 rg (Thread) Tj (\() Tj (write) Tj .4 .4 .4 rg (-) Tj (1) Tj 0 0 0 rg (,) Tj ( ) Tj (started) Tj .4 .4 .4 rg (...) Tj 0 0 0 rg (\)) Tj .4 .4 .4 rg (>) Tj 0 0 0 rg  T*  T* .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj (time) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (sleep) Tj (\() Tj .4 .4 .4 rg (.) Tj (1) Tj 0 0 0 rg (\)) Tj ( ) Tj /F6 10 Tf .25098 .501961 .501961 rg (# wait a bit, so we are sure data2 is written after data1) Tj /F4 10 Tf 0 0 0 rg  T*  T* .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj (write) Tj (\() Tj .729412 .129412 .129412 rg ("data2") Tj 0 0 0 rg (\)) Tj  T* .4 .4 .4 rg (<) Tj 0 0 0 rg (Thread) Tj (\() Tj (write) Tj .4 .4 .4 rg (-) Tj (2) Tj 0 0 0 rg (,) Tj ( ) Tj (started) Tj .4 .4 .4 rg (...) Tj 0 0 0 rg (\)) Tj .4 .4 .4 rg (>) Tj 0 0 0 rg  T*  T* .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj (time) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (sleep) Tj (\() Tj .4 .4 .4 rg (2) Tj 0 0 0 rg (\)) Tj ( ) Tj /F6 10 Tf .25098 .501961 .501961 rg (# wait for the writers to complete) Tj /F4 10 Tf 0 0 0 rg  T*  T* .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj /F3 10 Tf 0 .501961 0 rg (print) Tj /F4 10 Tf 0 0 0 rg ( ) Tj (datalist) Tj  T* ([) Tj .729412 .129412 .129412 rg ('data1') Tj 0 0 0 rg (,) Tj ( ) Tj .729412 .129412 .129412 rg ('data2') Tj 0 0 0 rg (]) Tj T* ET
+.960784 .960784 .862745 rg
+n 0 132.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 6 132.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 12 132.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 24 132.75 30 12 re f*
+.960784 .960784 .862745 rg
+n 54 132.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 60 132.75 42 12 re f*
+.960784 .960784 .862745 rg
+n 102 132.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 0 120.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 6 120.75 36 12 re f*
+.960784 .960784 .862745 rg
+n 42 120.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 48 120.75 30 12 re f*
+.960784 .960784 .862745 rg
+n 78 120.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 84 120.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 90 120.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 102 120.75 42 12 re f*
+.960784 .960784 .862745 rg
+n 144 120.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 162 120.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 168 120.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 0 96.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 6 96.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 12 96.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 24 96.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 48 96.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 54 96.75 30 12 re f*
+.960784 .960784 .862745 rg
+n 84 96.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 90 96.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 96 96.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 102 96.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 114 96.75 342 12 re f*
+.960784 .960784 .862745 rg
+n 0 72.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 6 72.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 12 72.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 24 72.75 30 12 re f*
+.960784 .960784 .862745 rg
+n 54 72.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 60 72.75 42 12 re f*
+.960784 .960784 .862745 rg
+n 102 72.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 0 60.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 6 60.75 36 12 re f*
+.960784 .960784 .862745 rg
+n 42 60.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 48 60.75 30 12 re f*
+.960784 .960784 .862745 rg
+n 78 60.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 84 60.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 90 60.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 102 60.75 42 12 re f*
+.960784 .960784 .862745 rg
+n 144 60.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 162 60.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 168 60.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 0 36.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 6 36.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 12 36.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 24 36.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 48 36.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 54 36.75 30 12 re f*
+.960784 .960784 .862745 rg
+n 84 36.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 90 36.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 96 36.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 108 36.75 204 12 re f*
+.960784 .960784 .862745 rg
+n 0 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 6 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 12 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 24 12.75 30 12 re f*
+.960784 .960784 .862745 rg
+n 60 12.75 48 12 re f*
+.960784 .960784 .862745 rg
+n 0 .75 6 12 re f*
+.960784 .960784 .862745 rg
+n 6 .75 42 12 re f*
+.960784 .960784 .862745 rg
+n 48 .75 6 12 re f*
+.960784 .960784 .862745 rg
+n 60 .75 42 12 re f*
+.960784 .960784 .862745 rg
+n 102 .75 6 12 re f*
+BT 1 0 0 1 0 134 Tm 12 TL /F4 10 Tf .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (write) Tj 0 0 0 rg (\() Tj .729412 .129412 .129412 rg ("data1") Tj 0 0 0 rg (\)) Tj 0 0 0 rg  T* .4 .4 .4 rg (<) Tj 0 0 0 rg (Thread) Tj 0 0 0 rg (\() Tj 0 0 0 rg (write) Tj .4 .4 .4 rg (-) Tj .4 .4 .4 rg (1) Tj 0 0 0 rg (,) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (started) Tj .4 .4 .4 rg (...) Tj 0 0 0 rg (\)) Tj .4 .4 .4 rg (>) Tj 0 0 0 rg  T*  T* .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (time) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (sleep) Tj 0 0 0 rg (\() Tj .4 .4 .4 rg (.) Tj .4 .4 .4 rg (1) Tj 0 0 0 rg (\)) Tj 0 0 0 rg ( ) Tj /F6 10 Tf .25098 .501961 .501961 rg (# wait a bit, so we are sure data2 is written after data1) Tj /F4 10 Tf 0 0 0 rg  T*  T* .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (write) Tj 0 0 0 rg (\() Tj .729412 .129412 .129412 rg ("data2") Tj 0 0 0 rg (\)) Tj 0 0 0 rg  T* .4 .4 .4 rg (<) Tj 0 0 0 rg (Thread) Tj 0 0 0 rg (\() Tj 0 0 0 rg (write) Tj .4 .4 .4 rg (-) Tj .4 .4 .4 rg (2) Tj 0 0 0 rg (,) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (started) Tj .4 .4 .4 rg (...) Tj 0 0 0 rg (\)) Tj .4 .4 .4 rg (>) Tj 0 0 0 rg  T*  T* .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (time) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (sleep) Tj 0 0 0 rg (\() Tj .4 .4 .4 rg (2) Tj 0 0 0 rg (\)) Tj 0 0 0 rg ( ) Tj /F6 10 Tf .25098 .501961 .501961 rg (# wait for the writers to complete) Tj /F4 10 Tf 0 0 0 rg  T*  T* .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj /F3 10 Tf 0 .501961 0 rg (print) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 0 rg (datalist) Tj 0 0 0 rg  T* 0 0 0 rg ([) Tj .729412 .129412 .129412 rg ('data1') Tj 0 0 0 rg (,) Tj 0 0 0 rg ( ) Tj .729412 .129412 .129412 rg ('data2') Tj 0 0 0 rg (]) Tj T* ET
 Q
 Q
 Q
 Q
 Q
 q
-1 0 0 1 62.69291 246.4236 cm
+1 0 0 1 62.69291 234.4236 cm
 q
 BT 1 0 0 1 0 3.5 Tm 21 TL /F2 17.5 Tf 0 0 0 rg (contextmanager) Tj T* ET
 Q
 Q
 q
-1 0 0 1 62.69291 216.4236 cm
+1 0 0 1 62.69291 204.4236 cm
 q
-BT 1 0 0 1 0 14 Tm 2.685984 Tw 12 TL /F1 10 Tf 0 0 0 rg (For a long time Python had in its standard library a ) Tj /F4 10 Tf (contextmanager ) Tj /F1 10 Tf (decorator, able to convert) Tj T* 0 Tw (generator functions into ) Tj /F4 10 Tf (GeneratorContextManager ) Tj /F1 10 Tf (factories. For instance if you write) Tj T* ET
+BT 1 0 0 1 0 14 Tm 2.685984 Tw 12 TL /F1 10 Tf 0 0 0 rg (For a long time Python had in its standard library a ) Tj /F4 10 Tf 0 0 0 rg (contextmanager ) Tj /F1 10 Tf 0 0 0 rg (decorator, able to convert) Tj T* 0 Tw (generator functions into ) Tj /F4 10 Tf 0 0 0 rg (GeneratorContextManager ) Tj /F1 10 Tf 0 0 0 rg (factories. For instance if you write) Tj T* ET
 Q
 Q
 q
-1 0 0 1 62.69291 123.2236 cm
+1 0 0 1 62.69291 111.2236 cm
 q
 q
 1 0 0 1 0 0 cm
@@ -2828,25 +3980,85 @@ q
 n -6 -6 468.6898 84 re B*
 Q
 q
-BT 1 0 0 1 0 62 Tm 12 TL /F4 10 Tf .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj /F3 10 Tf 0 .501961 0 rg (from) Tj /F4 10 Tf 0 0 0 rg ( ) Tj /F3 10 Tf 0 0 1 rg (contextlib) Tj /F4 10 Tf 0 0 0 rg ( ) Tj /F3 10 Tf 0 .501961 0 rg (import) Tj /F4 10 Tf 0 0 0 rg ( ) Tj (contextmanager) Tj  T* .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj .666667 .133333 1 rg (@contextmanager) Tj 0 0 0 rg  T* .4 .4 .4 rg (...) Tj 0 0 0 rg ( ) Tj /F3 10 Tf 0 .501961 0 rg (def) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 1 rg (before_after) Tj 0 0 0 rg (\() Tj (before) Tj (,) Tj ( ) Tj (after) Tj (\):) Tj  T* .4 .4 .4 rg (...) Tj 0 0 0 rg (     ) Tj /F3 10 Tf 0 .501961 0 rg (print) Tj /F4 10 Tf 0 0 0 rg (\() Tj (before) Tj (\)) Tj  T* .4 .4 .4 rg (...) Tj 0 0 0 rg (     ) Tj /F3 10 Tf 0 .501961 0 rg (yield) Tj /F4 10 Tf 0 0 0 rg  T* .4 .4 .4 rg (...) Tj 0 0 0 rg (     ) Tj /F3 10 Tf 0 .501961 0 rg (print) Tj /F4 10 Tf 0 0 0 rg (\() Tj (after) Tj (\)) Tj T* ET
+.960784 .960784 .862745 rg
+n 0 60.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 6 60.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 12 60.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 24 60.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 54 60.75 60 12 re f*
+.960784 .960784 .862745 rg
+n 120 60.75 36 12 re f*
+.960784 .960784 .862745 rg
+n 162 60.75 84 12 re f*
+.960784 .960784 .862745 rg
+n 0 48.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 6 48.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 12 48.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 24 48.75 90 12 re f*
+.960784 .960784 .862745 rg
+n 0 36.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 24 36.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 48 36.75 72 12 re f*
+.960784 .960784 .862745 rg
+n 120 36.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 126 36.75 36 12 re f*
+.960784 .960784 .862745 rg
+n 162 36.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 174 36.75 30 12 re f*
+.960784 .960784 .862745 rg
+n 204 36.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 0 24.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 48 24.75 30 12 re f*
+.960784 .960784 .862745 rg
+n 78 24.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 84 24.75 36 12 re f*
+.960784 .960784 .862745 rg
+n 120 24.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 0 12.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 48 12.75 30 12 re f*
+.960784 .960784 .862745 rg
+n 0 .75 18 12 re f*
+.960784 .960784 .862745 rg
+n 48 .75 30 12 re f*
+.960784 .960784 .862745 rg
+n 78 .75 6 12 re f*
+.960784 .960784 .862745 rg
+n 84 .75 30 12 re f*
+.960784 .960784 .862745 rg
+n 114 .75 6 12 re f*
+BT 1 0 0 1 0 62 Tm 12 TL /F4 10 Tf .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj /F3 10 Tf 0 .501961 0 rg (from) Tj /F4 10 Tf 0 0 0 rg ( ) Tj /F3 10 Tf 0 0 1 rg (contextlib) Tj /F4 10 Tf 0 0 0 rg ( ) Tj /F3 10 Tf 0 .501961 0 rg (import) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 0 rg (contextmanager) Tj 0 0 0 rg  T* .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj .666667 .133333 1 rg (@contextmanager) Tj 0 0 0 rg  T* .4 .4 .4 rg (...) Tj 0 0 0 rg ( ) Tj /F3 10 Tf 0 .501961 0 rg (def) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 1 rg (before_after) Tj 0 0 0 rg (\() Tj 0 0 0 rg (before) Tj 0 0 0 rg (,) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (after) Tj 0 0 0 rg (\):) Tj 0 0 0 rg  T* .4 .4 .4 rg (...) Tj 0 0 0 rg (     ) Tj /F3 10 Tf 0 .501961 0 rg (print) Tj /F4 10 Tf 0 0 0 rg (\() Tj 0 0 0 rg (before) Tj 0 0 0 rg (\)) Tj 0 0 0 rg  T* .4 .4 .4 rg (...) Tj 0 0 0 rg (     ) Tj /F3 10 Tf 0 .501961 0 rg (yield) Tj /F4 10 Tf 0 0 0 rg  T* .4 .4 .4 rg (...) Tj 0 0 0 rg (     ) Tj /F3 10 Tf 0 .501961 0 rg (print) Tj /F4 10 Tf 0 0 0 rg (\() Tj 0 0 0 rg (after) Tj 0 0 0 rg (\)) Tj T* ET
 Q
 Q
 Q
 Q
 Q
 q
-1 0 0 1 62.69291 91.22362 cm
+1 0 0 1 62.69291 79.22362 cm
 q
-BT 1 0 0 1 0 14 Tm .150888 Tw 12 TL /F1 10 Tf 0 0 0 rg (then ) Tj /F4 10 Tf (before_after ) Tj /F1 10 Tf (is a factory function returning ) Tj /F4 10 Tf (GeneratorContextManager ) Tj /F1 10 Tf (objects which can be) Tj T* 0 Tw (used with the ) Tj /F4 10 Tf (with ) Tj /F1 10 Tf (statement:) Tj T* ET
+BT 1 0 0 1 0 14 Tm .150888 Tw 12 TL /F1 10 Tf 0 0 0 rg (then ) Tj /F4 10 Tf 0 0 0 rg (before_after ) Tj /F1 10 Tf 0 0 0 rg (is a factory function returning ) Tj /F4 10 Tf 0 0 0 rg (GeneratorContextManager ) Tj /F1 10 Tf 0 0 0 rg (objects which can be) Tj T* 0 Tw (used with the ) Tj /F4 10 Tf 0 0 0 rg (with ) Tj /F1 10 Tf 0 0 0 rg (statement:) Tj T* ET
 Q
 Q
  
 endstream
 endobj
-% 'R93': class PDFStream 
 93 0 obj
-% page stream
-<< /Length 7180 >>
+<< /Length 13803 >>
 stream
 1 0 0 1 0 0 cm  BT /F1 12 Tf 14.4 TL ET
 q
@@ -2863,7 +4075,83 @@ q
 n -6 -6 468.6898 108 re B*
 Q
 q
-BT 1 0 0 1 0 86 Tm 12 TL /F4 10 Tf .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj (ba) Tj ( ) Tj .4 .4 .4 rg (=) Tj 0 0 0 rg ( ) Tj (before_after) Tj (\() Tj .729412 .129412 .129412 rg ('BEFORE') Tj 0 0 0 rg (,) Tj ( ) Tj .729412 .129412 .129412 rg ('AFTER') Tj 0 0 0 rg (\)) Tj  T* .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj 0 .501961 0 rg (type) Tj 0 0 0 rg (\() Tj (ba) Tj (\)) Tj  T* .4 .4 .4 rg (<) Tj /F3 10 Tf 0 .501961 0 rg (class) Tj /F4 10 Tf 0 0 0 rg ( ) Tj (') Tj /F3 10 Tf 0 0 1 rg (contextlib) Tj /F4 10 Tf .4 .4 .4 rg (.) Tj 0 0 0 rg (GeneratorContextManager) Tj .729412 .129412 .129412 rg (') Tj (>) Tj 0 0 0 rg  T* .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj /F3 10 Tf 0 .501961 0 rg (with) Tj /F4 10 Tf 0 0 0 rg ( ) Tj (ba) Tj (:) Tj  T* .4 .4 .4 rg (...) Tj 0 0 0 rg (     ) Tj /F3 10 Tf 0 .501961 0 rg (print) Tj /F4 10 Tf 0 0 0 rg ( ) Tj .729412 .129412 .129412 rg ('hello') Tj 0 0 0 rg  T* (BEFORE) Tj  T* (hello) Tj  T* (AFTER) Tj T* ET
+.960784 .960784 .862745 rg
+n 0 84.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 6 84.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 12 84.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 24 84.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 42 84.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 54 84.75 72 12 re f*
+.960784 .960784 .862745 rg
+n 126 84.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 132 84.75 48 12 re f*
+.960784 .960784 .862745 rg
+n 180 84.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 192 84.75 42 12 re f*
+.960784 .960784 .862745 rg
+n 234 84.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 0 72.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 6 72.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 12 72.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 24 72.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 48 72.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 54 72.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 66 72.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 0 60.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 6 60.75 30 12 re f*
+.960784 .960784 .862745 rg
+n 42 60.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 48 60.75 60 12 re f*
+.960784 .960784 .862745 rg
+n 108 60.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 114 60.75 138 12 re f*
+.960784 .960784 .862745 rg
+n 252 60.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 258 60.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 0 48.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 6 48.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 12 48.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 24 48.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 54 48.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 66 48.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 0 36.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 48 36.75 30 12 re f*
+.960784 .960784 .862745 rg
+n 84 36.75 42 12 re f*
+.960784 .960784 .862745 rg
+n 0 24.75 36 12 re f*
+.960784 .960784 .862745 rg
+n 0 12.75 30 12 re f*
+.960784 .960784 .862745 rg
+n 0 .75 30 12 re f*
+BT 1 0 0 1 0 86 Tm 12 TL /F4 10 Tf .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (ba) Tj 0 0 0 rg ( ) Tj .4 .4 .4 rg (=) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (before_after) Tj 0 0 0 rg (\() Tj .729412 .129412 .129412 rg ('BEFORE') Tj 0 0 0 rg (,) Tj 0 0 0 rg ( ) Tj .729412 .129412 .129412 rg ('AFTER') Tj 0 0 0 rg (\)) Tj 0 0 0 rg  T* .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj 0 .501961 0 rg (type) Tj 0 0 0 rg (\() Tj 0 0 0 rg (ba) Tj 0 0 0 rg (\)) Tj 0 0 0 rg  T* .4 .4 .4 rg (<) Tj /F3 10 Tf 0 .501961 0 rg (class) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 0 rg (') Tj /F3 10 Tf 0 0 1 rg (contextlib) Tj /F4 10 Tf .4 .4 .4 rg (.) Tj 0 0 0 rg (GeneratorContextManager) Tj .729412 .129412 .129412 rg (') Tj (>) Tj 0 0 0 rg  T* .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj /F3 10 Tf 0 .501961 0 rg (with) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 0 rg (ba) Tj 0 0 0 rg (:) Tj 0 0 0 rg  T* .4 .4 .4 rg (...) Tj 0 0 0 rg (     ) Tj /F3 10 Tf 0 .501961 0 rg (print) Tj /F4 10 Tf 0 0 0 rg ( ) Tj .729412 .129412 .129412 rg ('hello') Tj 0 0 0 rg  T* 0 0 0 rg (BEFORE) Tj 0 0 0 rg  T* 0 0 0 rg (hello) Tj 0 0 0 rg  T* 0 0 0 rg (AFTER) Tj T* ET
 Q
 Q
 Q
@@ -2872,7 +4160,7 @@ Q
 q
 1 0 0 1 62.69291 611.8236 cm
 q
-BT 1 0 0 1 0 26 Tm .462488 Tw 12 TL /F1 10 Tf 0 0 0 rg (Basically, it is as if the content of the ) Tj /F4 10 Tf (with ) Tj /F1 10 Tf (block was executed in the place of the ) Tj /F4 10 Tf (yield ) Tj /F1 10 Tf (expression in) Tj T* 0 Tw 2.691797 Tw (the generator function. In Python 3.2 ) Tj /F4 10 Tf (GeneratorContextManager ) Tj /F1 10 Tf (objects were enhanced with a) Tj T* 0 Tw /F4 10 Tf (__call__ ) Tj /F1 10 Tf (method, so that they can be used as decorators as in this example:) Tj T* ET
+BT 1 0 0 1 0 26 Tm .462488 Tw 12 TL /F1 10 Tf 0 0 0 rg (Basically, it is as if the content of the ) Tj /F4 10 Tf 0 0 0 rg (with ) Tj /F1 10 Tf 0 0 0 rg (block was executed in the place of the ) Tj /F4 10 Tf 0 0 0 rg (yield ) Tj /F1 10 Tf 0 0 0 rg (expression in) Tj T* 0 Tw 2.691797 Tw (the generator function. In Python 3.2 ) Tj /F4 10 Tf 0 0 0 rg (GeneratorContextManager ) Tj /F1 10 Tf 0 0 0 rg (objects were enhanced with a) Tj T* 0 Tw /F4 10 Tf 0 0 0 rg (__call__ ) Tj /F1 10 Tf 0 0 0 rg (method, so that they can be used as decorators as in this example:) Tj T* ET
 Q
 Q
 q
@@ -2889,7 +4177,47 @@ q
 n -6 -6 468.6898 108 re B*
 Q
 q
-BT 1 0 0 1 0 86 Tm 12 TL /F4 10 Tf .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj .666667 .133333 1 rg (@ba) Tj 0 0 0 rg  T* .4 .4 .4 rg (...) Tj 0 0 0 rg ( ) Tj /F3 10 Tf 0 .501961 0 rg (def) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 1 rg (hello) Tj 0 0 0 rg (\(\):) Tj  T* .4 .4 .4 rg (...) Tj 0 0 0 rg (     ) Tj /F3 10 Tf 0 .501961 0 rg (print) Tj /F4 10 Tf 0 0 0 rg ( ) Tj .729412 .129412 .129412 rg ('hello') Tj 0 0 0 rg  T* .4 .4 .4 rg (...) Tj 0 0 0 rg  T* .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj (hello) Tj (\(\)) Tj  T* (BEFORE) Tj  T* (hello) Tj  T* (AFTER) Tj T* ET
+.960784 .960784 .862745 rg
+n 0 84.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 6 84.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 12 84.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 24 84.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 0 72.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 24 72.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 48 72.75 30 12 re f*
+.960784 .960784 .862745 rg
+n 78 72.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 0 60.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 48 60.75 30 12 re f*
+.960784 .960784 .862745 rg
+n 84 60.75 42 12 re f*
+.960784 .960784 .862745 rg
+n 0 48.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 0 36.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 6 36.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 12 36.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 24 36.75 30 12 re f*
+.960784 .960784 .862745 rg
+n 54 36.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 0 24.75 36 12 re f*
+.960784 .960784 .862745 rg
+n 0 12.75 30 12 re f*
+.960784 .960784 .862745 rg
+n 0 .75 30 12 re f*
+BT 1 0 0 1 0 86 Tm 12 TL /F4 10 Tf .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj .666667 .133333 1 rg (@ba) Tj 0 0 0 rg  T* .4 .4 .4 rg (...) Tj 0 0 0 rg ( ) Tj /F3 10 Tf 0 .501961 0 rg (def) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 1 rg (hello) Tj 0 0 0 rg (\(\):) Tj 0 0 0 rg  T* .4 .4 .4 rg (...) Tj 0 0 0 rg (     ) Tj /F3 10 Tf 0 .501961 0 rg (print) Tj /F4 10 Tf 0 0 0 rg ( ) Tj .729412 .129412 .129412 rg ('hello') Tj 0 0 0 rg  T* .4 .4 .4 rg (...) Tj 0 0 0 rg  T* .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (hello) Tj 0 0 0 rg (\(\)) Tj 0 0 0 rg  T* 0 0 0 rg (BEFORE) Tj 0 0 0 rg  T* 0 0 0 rg (hello) Tj 0 0 0 rg  T* 0 0 0 rg (AFTER) Tj T* ET
 Q
 Q
 Q
@@ -2898,29 +4226,35 @@ Q
 q
 1 0 0 1 62.69291 366.6236 cm
 q
-BT 1 0 0 1 0 110 Tm .20561 Tw 12 TL /F1 10 Tf 0 0 0 rg (The ) Tj /F4 10 Tf (ba ) Tj /F1 10 Tf (decorator is basically inserting a ) Tj /F4 10 Tf (with) Tj ( ) Tj (ba: ) Tj /F1 10 Tf (block inside the function. However there two issues:) Tj T* 0 Tw 1.402126 Tw (the first is that ) Tj /F4 10 Tf (GeneratorContextManager ) Tj /F1 10 Tf (objects are callable only in Python 3.2, so the previous) Tj T* 0 Tw .356905 Tw (example will break in older versions of Python; the second is that ) Tj /F4 10 Tf (GeneratorContextManager ) Tj /F1 10 Tf (objects) Tj T* 0 Tw .57561 Tw (do not preserve the signature of the decorated functions: the decorated ) Tj /F4 10 Tf (hello ) Tj /F1 10 Tf (function here will have a) Tj T* 0 Tw 3.990814 Tw (generic signature ) Tj /F4 10 Tf (hello\(*args,) Tj ( ) Tj (**kwargs\) ) Tj /F1 10 Tf (but will break when called with more than zero) Tj T* 0 Tw 7.708314 Tw (arguments. For such reasons the decorator module, starting with release 3.4, offers a) Tj T* 0 Tw .616647 Tw /F4 10 Tf (decorator.contextmanager ) Tj /F1 10 Tf (decorator that solves both problems and works even in Python 2.5. The) Tj T* 0 Tw .34998 Tw (usage is the same and factories decorated with ) Tj /F4 10 Tf (decorator.contextmanager ) Tj /F1 10 Tf (will returns instances of) Tj T* 0 Tw 4.152823 Tw /F4 10 Tf (ContextManager) Tj /F1 10 Tf (, a subclass of ) Tj /F4 10 Tf (contextlib.GeneratorContextManager ) Tj /F1 10 Tf (with a ) Tj /F4 10 Tf (__call__) Tj T* 0 Tw /F1 10 Tf (method acting as a signature-preserving decorator.) Tj T* ET
+BT 1 0 0 1 0 110 Tm .20561 Tw 12 TL /F1 10 Tf 0 0 0 rg (The ) Tj /F4 10 Tf 0 0 0 rg (ba ) Tj /F1 10 Tf 0 0 0 rg (decorator is basically inserting a ) Tj /F4 10 Tf 0 0 0 rg (with) Tj ( ) Tj (ba: ) Tj /F1 10 Tf 0 0 0 rg (block inside the function. However there two issues:) Tj T* 0 Tw 1.402126 Tw (the first is that ) Tj /F4 10 Tf 0 0 0 rg (GeneratorContextManager ) Tj /F1 10 Tf 0 0 0 rg (objects are callable only in Python 3.2, so the previous) Tj T* 0 Tw .356905 Tw (example will break in older versions of Python; the second is that ) Tj /F4 10 Tf 0 0 0 rg (GeneratorContextManager ) Tj /F1 10 Tf 0 0 0 rg (objects) Tj T* 0 Tw .57561 Tw (do not preserve the signature of the decorated functions: the decorated ) Tj /F4 10 Tf 0 0 0 rg (hello ) Tj /F1 10 Tf 0 0 0 rg (function here will have a) Tj T* 0 Tw 3.990814 Tw (generic signature ) Tj /F4 10 Tf 0 0 0 rg (hello\(*args,) Tj ( ) Tj (**kwargs\) ) Tj /F1 10 Tf 0 0 0 rg (but will break when called with more than zero) Tj T* 0 Tw 7.708314 Tw (arguments. For such reasons the decorator module, starting with release 3.4, offers a) Tj T* 0 Tw .616647 Tw /F4 10 Tf 0 0 0 rg (decorator.contextmanager ) Tj /F1 10 Tf 0 0 0 rg (decorator that solves both problems and works even in Python 2.5. The) Tj T* 0 Tw .34998 Tw (usage is the same and factories decorated with ) Tj /F4 10 Tf 0 0 0 rg (decorator.contextmanager ) Tj /F1 10 Tf 0 0 0 rg (will returns instances of) Tj T* 0 Tw 4.152823 Tw /F4 10 Tf 0 0 0 rg (ContextManager) Tj /F1 10 Tf 0 0 0 rg (, a subclass of ) Tj /F4 10 Tf 0 0 0 rg (contextlib.GeneratorContextManager ) Tj /F1 10 Tf 0 0 0 rg (with a ) Tj /F4 10 Tf 0 0 0 rg (__call__) Tj T* 0 Tw /F1 10 Tf 0 0 0 rg (method acting as a signature-preserving decorator.) Tj T* ET
+Q
+Q
+q
+1 0 0 1 62.69291 336.6236 cm
+q
+BT 1 0 0 1 0 14 Tm 2.756905 Tw 12 TL /F2 10 Tf 0 0 0 rg (Disclaimer) Tj /F1 10 Tf (: the ) Tj /F4 10 Tf 0 0 0 rg (contextmanager ) Tj /F1 10 Tf 0 0 0 rg (decorator is an ) Tj /F5 10 Tf (experimental ) Tj /F1 10 Tf (feature: it may go away in future) Tj T* 0 Tw (versions of the decorator module. Use it at your own risk.) Tj T* ET
 Q
 Q
 q
-1 0 0 1 62.69291 333.6236 cm
+1 0 0 1 62.69291 303.6236 cm
 q
-BT 1 0 0 1 0 3.5 Tm 21 TL /F2 17.5 Tf 0 0 0 rg (The ) Tj /F3 17.5 Tf (FunctionMaker ) Tj /F2 17.5 Tf (class) Tj T* ET
+BT 1 0 0 1 0 3.5 Tm 21 TL /F2 17.5 Tf 0 0 0 rg (The ) Tj /F3 17.5 Tf 0 0 0 rg (FunctionMaker ) Tj /F2 17.5 Tf 0 0 0 rg (class) Tj T* ET
 Q
 Q
 q
-1 0 0 1 62.69291 267.6236 cm
+1 0 0 1 62.69291 237.6236 cm
 q
-BT 1 0 0 1 0 50 Tm 2.241412 Tw 12 TL /F1 10 Tf 0 0 0 rg (You may wonder about how the functionality of the ) Tj /F4 10 Tf (decorator ) Tj /F1 10 Tf (module is implemented. The basic) Tj T* 0 Tw 1.545868 Tw (building block is a ) Tj /F4 10 Tf (FunctionMaker ) Tj /F1 10 Tf (class which is able to generate on the fly functions with a given) Tj T* 0 Tw .047485 Tw (name and signature from a function template passed as a string. Generally speaking, you should not need) Tj T* 0 Tw 1.164983 Tw (to resort to ) Tj /F4 10 Tf (FunctionMaker ) Tj /F1 10 Tf (when writing ordinary decorators, but it is handy in some circumstances.) Tj T* 0 Tw (You will see an example shortly, in the implementation of a cool decorator utility \() Tj /F4 10 Tf (decorator_apply) Tj /F1 10 Tf (\).) Tj T* ET
+BT 1 0 0 1 0 50 Tm 2.241412 Tw 12 TL /F1 10 Tf 0 0 0 rg (You may wonder about how the functionality of the ) Tj /F4 10 Tf 0 0 0 rg (decorator ) Tj /F1 10 Tf 0 0 0 rg (module is implemented. The basic) Tj T* 0 Tw 1.545868 Tw (building block is a ) Tj /F4 10 Tf 0 0 0 rg (FunctionMaker ) Tj /F1 10 Tf 0 0 0 rg (class which is able to generate on the fly functions with a given) Tj T* 0 Tw .047485 Tw (name and signature from a function template passed as a string. Generally speaking, you should not need) Tj T* 0 Tw 1.164983 Tw (to resort to ) Tj /F4 10 Tf 0 0 0 rg (FunctionMaker ) Tj /F1 10 Tf 0 0 0 rg (when writing ordinary decorators, but it is handy in some circumstances.) Tj T* 0 Tw (You will see an example shortly, in the implementation of a cool decorator utility \() Tj /F4 10 Tf 0 0 0 rg (decorator_apply) Tj /F1 10 Tf 0 0 0 rg (\).) Tj T* ET
 Q
 Q
 q
-1 0 0 1 62.69291 225.6236 cm
+1 0 0 1 62.69291 195.6236 cm
 q
-BT 1 0 0 1 0 26 Tm .414597 Tw 12 TL /F4 10 Tf 0 0 0 rg (FunctionMaker ) Tj /F1 10 Tf (provides a ) Tj /F4 10 Tf (.create ) Tj /F1 10 Tf (classmethod which takes as input the name, signature, and body) Tj T* 0 Tw .632927 Tw (of the function we want to generate as well as the execution environment were the function is generated) Tj T* 0 Tw (by ) Tj /F4 10 Tf (exec) Tj /F1 10 Tf (. Here is an example:) Tj T* ET
+BT 1 0 0 1 0 26 Tm .414597 Tw 12 TL /F4 10 Tf 0 0 0 rg (FunctionMaker ) Tj /F1 10 Tf 0 0 0 rg (provides a ) Tj /F4 10 Tf 0 0 0 rg (.create ) Tj /F1 10 Tf 0 0 0 rg (classmethod which takes as input the name, signature, and body) Tj T* 0 Tw .632927 Tw (of the function we want to generate as well as the execution environment were the function is generated) Tj T* 0 Tw (by ) Tj /F4 10 Tf 0 0 0 rg (exec) Tj /F1 10 Tf 0 0 0 rg (. Here is an example:) Tj T* ET
 Q
 Q
 q
-1 0 0 1 62.69291 132.4236 cm
+1 0 0 1 62.69291 102.4236 cm
 q
 q
 1 0 0 1 0 0 cm
@@ -2933,41 +4267,143 @@ q
 n -6 -6 468.6898 84 re B*
 Q
 q
-BT 1 0 0 1 0 62 Tm 12 TL /F4 10 Tf .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj /F3 10 Tf 0 .501961 0 rg (def) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 1 rg (f) Tj 0 0 0 rg (\() Tj .4 .4 .4 rg (*) Tj 0 0 0 rg (args) Tj (,) Tj ( ) Tj .4 .4 .4 rg (**) Tj 0 0 0 rg (kw) Tj (\):) Tj ( ) Tj /F6 10 Tf .25098 .501961 .501961 rg (# a function with a generic signature) Tj /F4 10 Tf 0 0 0 rg  T* .4 .4 .4 rg (...) Tj 0 0 0 rg (     ) Tj /F3 10 Tf 0 .501961 0 rg (print) Tj /F4 10 Tf 0 0 0 rg ( ) Tj (args) Tj (,) Tj ( ) Tj (kw) Tj  T*  T* .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj (f1) Tj ( ) Tj .4 .4 .4 rg (=) Tj 0 0 0 rg ( ) Tj (FunctionMaker) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (create) Tj (\() Tj .729412 .129412 .129412 rg ('f1\(a, b\)') Tj 0 0 0 rg (,) Tj ( ) Tj .729412 .129412 .129412 rg ('f\(a, b\)') Tj 0 0 0 rg (,) Tj ( ) Tj 0 .501961 0 rg (dict) Tj 0 0 0 rg (\() Tj (f) Tj .4 .4 .4 rg (=) Tj 0 0 0 rg (f) Tj (\)\)) Tj  T* .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj (f1) Tj (\() Tj .4 .4 .4 rg (1) Tj 0 0 0 rg (,) Tj .4 .4 .4 rg (2) Tj 0 0 0 rg (\)) Tj  T* (\() Tj .4 .4 .4 rg (1) Tj 0 0 0 rg (,) Tj ( ) Tj .4 .4 .4 rg (2) Tj 0 0 0 rg (\)) Tj ( ) Tj ({}) Tj T* ET
-Q
-Q
+.960784 .960784 .862745 rg
+n 0 60.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 6 60.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 12 60.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 24 60.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 48 60.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 54 60.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 60 60.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 66 60.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 90 60.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 102 60.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 114 60.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 126 60.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 144 60.75 222 12 re f*
+.960784 .960784 .862745 rg
+n 0 48.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 48 48.75 30 12 re f*
+.960784 .960784 .862745 rg
+n 84 48.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 108 48.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 120 48.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 0 24.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 6 24.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 12 24.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 24 24.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 42 24.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 54 24.75 78 12 re f*
+.960784 .960784 .862745 rg
+n 132 24.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 138 24.75 36 12 re f*
+.960784 .960784 .862745 rg
+n 174 24.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 180 24.75 60 12 re f*
+.960784 .960784 .862745 rg
+n 240 24.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 252 24.75 54 12 re f*
+.960784 .960784 .862745 rg
+n 306 24.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 318 24.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 342 24.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 348 24.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 354 24.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 360 24.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 366 24.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 0 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 6 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 12 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 24 12.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 36 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 42 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 48 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 54 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 60 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 0 .75 6 12 re f*
+.960784 .960784 .862745 rg
+n 6 .75 6 12 re f*
+.960784 .960784 .862745 rg
+n 12 .75 6 12 re f*
+.960784 .960784 .862745 rg
+n 24 .75 6 12 re f*
+.960784 .960784 .862745 rg
+n 30 .75 6 12 re f*
+.960784 .960784 .862745 rg
+n 42 .75 12 12 re f*
+BT 1 0 0 1 0 62 Tm 12 TL /F4 10 Tf .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj /F3 10 Tf 0 .501961 0 rg (def) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 1 rg (f) Tj 0 0 0 rg (\() Tj .4 .4 .4 rg (*) Tj 0 0 0 rg (args) Tj 0 0 0 rg (,) Tj 0 0 0 rg ( ) Tj .4 .4 .4 rg (**) Tj 0 0 0 rg (kw) Tj 0 0 0 rg (\):) Tj 0 0 0 rg ( ) Tj /F6 10 Tf .25098 .501961 .501961 rg (# a function with a generic signature) Tj /F4 10 Tf 0 0 0 rg  T* .4 .4 .4 rg (...) Tj 0 0 0 rg (     ) Tj /F3 10 Tf 0 .501961 0 rg (print) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 0 rg (args) Tj 0 0 0 rg (,) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (kw) Tj 0 0 0 rg  T*  T* .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (f1) Tj 0 0 0 rg ( ) Tj .4 .4 .4 rg (=) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (FunctionMaker) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (create) Tj 0 0 0 rg (\() Tj .729412 .129412 .129412 rg ('f1\(a, b\)') Tj 0 0 0 rg (,) Tj 0 0 0 rg ( ) Tj .729412 .129412 .129412 rg ('f\(a, b\)') Tj 0 0 0 rg (,) Tj 0 0 0 rg ( ) Tj 0 .501961 0 rg (dict) Tj 0 0 0 rg (\() Tj 0 0 0 rg (f) Tj .4 .4 .4 rg (=) Tj 0 0 0 rg (f) Tj 0 0 0 rg (\)\)) Tj 0 0 0 rg  T* .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (f1) Tj 0 0 0 rg (\() Tj .4 .4 .4 rg (1) Tj 0 0 0 rg (,) Tj .4 .4 .4 rg (2) Tj 0 0 0 rg (\)) Tj 0 0 0 rg  T* 0 0 0 rg (\() Tj .4 .4 .4 rg (1) Tj 0 0 0 rg (,) Tj 0 0 0 rg ( ) Tj .4 .4 .4 rg (2) Tj 0 0 0 rg (\)) Tj 0 0 0 rg ( ) Tj 0 0 0 rg ({}) Tj T* ET
 Q
 Q
 Q
-q
-1 0 0 1 62.69291 100.4236 cm
-q
-BT 1 0 0 1 0 14 Tm .226654 Tw 12 TL /F1 10 Tf 0 0 0 rg (It is important to notice that the function body is interpolated before being executed, so be careful with the) Tj T* 0 Tw /F4 10 Tf (% ) Tj /F1 10 Tf (sign!) Tj T* ET
 Q
 Q
  
 endstream
 endobj
-% 'R94': class PDFStream 
 94 0 obj
-% page stream
-<< /Length 7802 >>
+<< /Length 13724 >>
 stream
 1 0 0 1 0 0 cm  BT /F1 12 Tf 14.4 TL ET
 q
-1 0 0 1 62.69291 729.0236 cm
+1 0 0 1 62.69291 741.0236 cm
 q
-BT 1 0 0 1 0 26 Tm 1.995433 Tw 12 TL /F4 10 Tf 0 0 0 rg (FunctionMaker.create ) Tj /F1 10 Tf (also accepts keyword arguments and such arguments are attached to the) Tj T* 0 Tw 1.64686 Tw (resulting function. This is useful if you want to set some function attributes, for instance the docstring) Tj T* 0 Tw /F4 10 Tf (__doc__) Tj /F1 10 Tf (.) Tj T* ET
+BT 1 0 0 1 0 14 Tm .226654 Tw 12 TL /F1 10 Tf 0 0 0 rg (It is important to notice that the function body is interpolated before being executed, so be careful with the) Tj T* 0 Tw /F4 10 Tf 0 0 0 rg (% ) Tj /F1 10 Tf 0 0 0 rg (sign!) Tj T* ET
 Q
 Q
 q
-1 0 0 1 62.69291 687.0236 cm
+1 0 0 1 62.69291 699.0236 cm
+q
+BT 1 0 0 1 0 26 Tm 1.995433 Tw 12 TL /F4 10 Tf 0 0 0 rg (FunctionMaker.create ) Tj /F1 10 Tf 0 0 0 rg (also accepts keyword arguments and such arguments are attached to the) Tj T* 0 Tw 1.64686 Tw (resulting function. This is useful if you want to set some function attributes, for instance the docstring) Tj T* 0 Tw /F4 10 Tf 0 0 0 rg (__doc__) Tj /F1 10 Tf 0 0 0 rg (.) Tj T* ET
+Q
+Q
+q
+1 0 0 1 62.69291 657.0236 cm
 q
-BT 1 0 0 1 0 26 Tm .605318 Tw 12 TL /F1 10 Tf 0 0 0 rg (For debugging/introspection purposes it may be useful to see the source code of the generated function;) Tj T* 0 Tw 2.246235 Tw (to do that, just pass the flag ) Tj /F4 10 Tf (addsource=True ) Tj /F1 10 Tf (and a ) Tj /F4 10 Tf (__source__ ) Tj /F1 10 Tf (attribute will be added to the) Tj T* 0 Tw (generated function:) Tj T* ET
+BT 1 0 0 1 0 26 Tm .605318 Tw 12 TL /F1 10 Tf 0 0 0 rg (For debugging/introspection purposes it may be useful to see the source code of the generated function;) Tj T* 0 Tw 2.246235 Tw (to do that, just pass the flag ) Tj /F4 10 Tf 0 0 0 rg (addsource=True ) Tj /F1 10 Tf 0 0 0 rg (and a ) Tj /F4 10 Tf 0 0 0 rg (__source__ ) Tj /F1 10 Tf 0 0 0 rg (attribute will be added to the) Tj T* 0 Tw (generated function:) Tj T* ET
 Q
 Q
 q
-1 0 0 1 62.69291 593.8236 cm
+1 0 0 1 62.69291 563.8236 cm
 q
 q
 1 0 0 1 0 0 cm
@@ -2980,38 +4416,132 @@ q
 n -6 -6 468.6898 84 re B*
 Q
 q
-BT 1 0 0 1 0 62 Tm 12 TL /F4 10 Tf .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj (f1) Tj ( ) Tj .4 .4 .4 rg (=) Tj 0 0 0 rg ( ) Tj (FunctionMaker) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (create) Tj (\() Tj  T* .4 .4 .4 rg (...) Tj 0 0 0 rg (     ) Tj .729412 .129412 .129412 rg ('f1\(a, b\)') Tj 0 0 0 rg (,) Tj ( ) Tj .729412 .129412 .129412 rg ('f\(a, b\)') Tj 0 0 0 rg (,) Tj ( ) Tj 0 .501961 0 rg (dict) Tj 0 0 0 rg (\() Tj (f) Tj .4 .4 .4 rg (=) Tj 0 0 0 rg (f) Tj (\),) Tj ( ) Tj (addsource) Tj .4 .4 .4 rg (=) Tj 0 .501961 0 rg (True) Tj 0 0 0 rg (\)) Tj  T* .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj /F3 10 Tf 0 .501961 0 rg (print) Tj /F4 10 Tf 0 0 0 rg ( ) Tj (f1) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (__source__) Tj  T* /F3 10 Tf 0 .501961 0 rg (def) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 1 rg (f1) Tj 0 0 0 rg (\() Tj (a) Tj (,) Tj ( ) Tj (b) Tj (\):) Tj  T* (    ) Tj (f) Tj (\() Tj (a) Tj (,) Tj ( ) Tj (b) Tj (\)) Tj  T* .4 .4 .4 rg (<) Tj 0 0 0 rg (BLANKLINE) Tj .4 .4 .4 rg (>) Tj T* ET
+.960784 .960784 .862745 rg
+n 0 60.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 6 60.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 12 60.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 24 60.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 42 60.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 54 60.75 78 12 re f*
+.960784 .960784 .862745 rg
+n 132 60.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 138 60.75 36 12 re f*
+.960784 .960784 .862745 rg
+n 174 60.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 0 48.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 48 48.75 60 12 re f*
+.960784 .960784 .862745 rg
+n 108 48.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 120 48.75 54 12 re f*
+.960784 .960784 .862745 rg
+n 174 48.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 186 48.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 210 48.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 216 48.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 222 48.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 228 48.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 234 48.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 252 48.75 54 12 re f*
+.960784 .960784 .862745 rg
+n 306 48.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 312 48.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 336 48.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 0 36.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 6 36.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 12 36.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 24 36.75 30 12 re f*
+.960784 .960784 .862745 rg
+n 60 36.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 72 36.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 78 36.75 60 12 re f*
+.960784 .960784 .862745 rg
+n 0 24.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 24 24.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 36 24.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 42 24.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 48 24.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 60 24.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 66 24.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 24 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 30 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 36 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 42 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 54 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 60 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 0 .75 6 12 re f*
+.960784 .960784 .862745 rg
+n 6 .75 54 12 re f*
+.960784 .960784 .862745 rg
+n 60 .75 6 12 re f*
+BT 1 0 0 1 0 62 Tm 12 TL /F4 10 Tf .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (f1) Tj 0 0 0 rg ( ) Tj .4 .4 .4 rg (=) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (FunctionMaker) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (create) Tj 0 0 0 rg (\() Tj 0 0 0 rg  T* .4 .4 .4 rg (...) Tj 0 0 0 rg (     ) Tj .729412 .129412 .129412 rg ('f1\(a, b\)') Tj 0 0 0 rg (,) Tj 0 0 0 rg ( ) Tj .729412 .129412 .129412 rg ('f\(a, b\)') Tj 0 0 0 rg (,) Tj 0 0 0 rg ( ) Tj 0 .501961 0 rg (dict) Tj 0 0 0 rg (\() Tj 0 0 0 rg (f) Tj .4 .4 .4 rg (=) Tj 0 0 0 rg (f) Tj 0 0 0 rg (\),) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (addsource) Tj .4 .4 .4 rg (=) Tj 0 .501961 0 rg (True) Tj 0 0 0 rg (\)) Tj 0 0 0 rg  T* .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj /F3 10 Tf 0 .501961 0 rg (print) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 0 rg (f1) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (__source__) Tj 0 0 0 rg  T* /F3 10 Tf 0 .501961 0 rg (def) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 1 rg (f1) Tj 0 0 0 rg (\() Tj 0 0 0 rg (a) Tj 0 0 0 rg (,) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (b) Tj 0 0 0 rg (\):) Tj 0 0 0 rg  T* (    ) Tj 0 0 0 rg (f) Tj 0 0 0 rg (\() Tj 0 0 0 rg (a) Tj 0 0 0 rg (,) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (b) Tj 0 0 0 rg (\)) Tj 0 0 0 rg  T* .4 .4 .4 rg (<) Tj 0 0 0 rg (BLANKLINE) Tj .4 .4 .4 rg (>) Tj T* ET
 Q
 Q
 Q
 Q
 Q
 q
-1 0 0 1 62.69291 453.8236 cm
+1 0 0 1 62.69291 423.8236 cm
 q
-BT 1 0 0 1 0 122 Tm .870651 Tw 12 TL /F4 10 Tf 0 0 0 rg (FunctionMaker.create ) Tj /F1 10 Tf (can take as first argument a string, as in the examples before, or a function.) Tj T* 0 Tw .224985 Tw (This is the most common usage, since typically you want to decorate a pre-existing function. A framework) Tj T* 0 Tw 1.606136 Tw (author may want to use directly ) Tj /F4 10 Tf (FunctionMaker.create ) Tj /F1 10 Tf (instead of ) Tj /F4 10 Tf (decorator) Tj /F1 10 Tf (, since it gives you) Tj T* 0 Tw 1.36686 Tw (direct access to the body of the generated function. For instance, suppose you want to instrument the) Tj T* 0 Tw .372209 Tw /F4 10 Tf (__init__ ) Tj /F1 10 Tf (methods of a set of classes, by preserving their signature \(such use case is not made up; this) Tj T* 0 Tw .673828 Tw (is done in SQAlchemy and in other frameworks\). When the first argument of ) Tj /F4 10 Tf (FunctionMaker.create) Tj T* 0 Tw 3.405814 Tw /F1 10 Tf (is a function, a ) Tj /F4 10 Tf (FunctionMaker ) Tj /F1 10 Tf (object is instantiated internally, with attributes ) Tj /F4 10 Tf (args) Tj /F1 10 Tf (, ) Tj /F4 10 Tf (varargs) Tj /F1 10 Tf (,) Tj T* 0 Tw 5.509982 Tw /F4 10 Tf (keywords ) Tj /F1 10 Tf (and ) Tj /F4 10 Tf (defaults ) Tj /F1 10 Tf (which are the the return values of the standard library function) Tj T* 0 Tw .561318 Tw /F4 10 Tf (inspect.getargspec) Tj /F1 10 Tf (. For each argument in the ) Tj /F4 10 Tf (args ) Tj /F1 10 Tf (\(which is a list of strings containing the names) Tj T* 0 Tw 1.599985 Tw (of the mandatory arguments\) an attribute ) Tj /F4 10 Tf (arg0) Tj /F1 10 Tf (, ) Tj /F4 10 Tf (arg1) Tj /F1 10 Tf (, ..., ) Tj /F4 10 Tf (argN ) Tj /F1 10 Tf (is also generated. Finally, there is a) Tj T* 0 Tw /F4 10 Tf (signature ) Tj /F1 10 Tf (attribute, a string with the signature of the original function.) Tj T* ET
+BT 1 0 0 1 0 122 Tm .870651 Tw 12 TL /F4 10 Tf 0 0 0 rg (FunctionMaker.create ) Tj /F1 10 Tf 0 0 0 rg (can take as first argument a string, as in the examples before, or a function.) Tj T* 0 Tw .224985 Tw (This is the most common usage, since typically you want to decorate a pre-existing function. A framework) Tj T* 0 Tw 1.606136 Tw (author may want to use directly ) Tj /F4 10 Tf 0 0 0 rg (FunctionMaker.create ) Tj /F1 10 Tf 0 0 0 rg (instead of ) Tj /F4 10 Tf 0 0 0 rg (decorator) Tj /F1 10 Tf 0 0 0 rg (, since it gives you) Tj T* 0 Tw 1.36686 Tw (direct access to the body of the generated function. For instance, suppose you want to instrument the) Tj T* 0 Tw .372209 Tw /F4 10 Tf 0 0 0 rg (__init__ ) Tj /F1 10 Tf 0 0 0 rg (methods of a set of classes, by preserving their signature \(such use case is not made up; this) Tj T* 0 Tw .673828 Tw (is done in SQAlchemy and in other frameworks\). When the first argument of ) Tj /F4 10 Tf 0 0 0 rg (FunctionMaker.create) Tj T* 0 Tw 3.405814 Tw /F1 10 Tf 0 0 0 rg (is a function, a ) Tj /F4 10 Tf 0 0 0 rg (FunctionMaker ) Tj /F1 10 Tf 0 0 0 rg (object is instantiated internally, with attributes ) Tj /F4 10 Tf 0 0 0 rg (args) Tj /F1 10 Tf 0 0 0 rg (, ) Tj /F4 10 Tf 0 0 0 rg (varargs) Tj /F1 10 Tf 0 0 0 rg (,) Tj T* 0 Tw 5.509982 Tw /F4 10 Tf 0 0 0 rg (keywords ) Tj /F1 10 Tf 0 0 0 rg (and ) Tj /F4 10 Tf 0 0 0 rg (defaults ) Tj /F1 10 Tf 0 0 0 rg (which are the the return values of the standard library function) Tj T* 0 Tw .561318 Tw /F4 10 Tf 0 0 0 rg (inspect.getargspec) Tj /F1 10 Tf 0 0 0 rg (. For each argument in the ) Tj /F4 10 Tf 0 0 0 rg (args ) Tj /F1 10 Tf 0 0 0 rg (\(which is a list of strings containing the names) Tj T* 0 Tw 1.599985 Tw (of the mandatory arguments\) an attribute ) Tj /F4 10 Tf 0 0 0 rg (arg0) Tj /F1 10 Tf 0 0 0 rg (, ) Tj /F4 10 Tf 0 0 0 rg (arg1) Tj /F1 10 Tf 0 0 0 rg (, ..., ) Tj /F4 10 Tf 0 0 0 rg (argN ) Tj /F1 10 Tf 0 0 0 rg (is also generated. Finally, there is a) Tj T* 0 Tw /F4 10 Tf 0 0 0 rg (signature ) Tj /F1 10 Tf 0 0 0 rg (attribute, a string with the signature of the original function.) Tj T* ET
 Q
 Q
 q
-1 0 0 1 62.69291 375.8236 cm
+1 0 0 1 62.69291 345.8236 cm
 q
-BT 1 0 0 1 0 62 Tm 4.63311 Tw 12 TL /F1 10 Tf 0 0 0 rg (Notice that while I do not have plans to change or remove the functionality provided in the) Tj T* 0 Tw 1.00936 Tw /F4 10 Tf (FunctionMaker ) Tj /F1 10 Tf (class, I do not guarantee that it will stay unchanged forever. For instance, right now I) Tj T* 0 Tw .791318 Tw (am using the traditional string interpolation syntax for function templates, but Python 2.6 and Python 3.0) Tj T* 0 Tw .712093 Tw (provide a newer interpolation syntax and I may use the new syntax in the future. On the other hand, the) Tj T* 0 Tw .639985 Tw (functionality provided by ) Tj /F4 10 Tf (decorator ) Tj /F1 10 Tf (has been there from version 0.1 and it is guaranteed to stay there) Tj T* 0 Tw (forever.) Tj T* ET
+BT 1 0 0 1 0 62 Tm 4.63311 Tw 12 TL /F1 10 Tf 0 0 0 rg (Notice that while I do not have plans to change or remove the functionality provided in the) Tj T* 0 Tw 1.00936 Tw /F4 10 Tf 0 0 0 rg (FunctionMaker ) Tj /F1 10 Tf 0 0 0 rg (class, I do not guarantee that it will stay unchanged forever. For instance, right now I) Tj T* 0 Tw .791318 Tw (am using the traditional string interpolation syntax for function templates, but Python 2.6 and Python 3.0) Tj T* 0 Tw .712093 Tw (provide a newer interpolation syntax and I may use the new syntax in the future. On the other hand, the) Tj T* 0 Tw .639985 Tw (functionality provided by ) Tj /F4 10 Tf 0 0 0 rg (decorator ) Tj /F1 10 Tf 0 0 0 rg (has been there from version 0.1 and it is guaranteed to stay there) Tj T* 0 Tw (forever.) Tj T* ET
 Q
 Q
 q
-1 0 0 1 62.69291 342.8236 cm
+1 0 0 1 62.69291 312.8236 cm
 q
 BT 1 0 0 1 0 3.5 Tm 21 TL /F2 17.5 Tf 0 0 0 rg (Getting the source code) Tj T* ET
 Q
 Q
 q
-1 0 0 1 62.69291 264.8236 cm
+1 0 0 1 62.69291 234.8236 cm
 q
-BT 1 0 0 1 0 62 Tm 5.045529 Tw 12 TL /F1 10 Tf 0 0 0 rg (Internally ) Tj /F4 10 Tf (FunctionMaker.create ) Tj /F1 10 Tf (uses ) Tj /F4 10 Tf (exec ) Tj /F1 10 Tf (to generate the decorated function. Therefore) Tj T* 0 Tw 2.542126 Tw /F4 10 Tf (inspect.getsource ) Tj /F1 10 Tf (will not work for decorated functions. That means that the usual '??' trick in) Tj T* 0 Tw 26.45775 Tw (IPython will give you the \(right on the spot\) message) Tj T* 0 Tw .261647 Tw /F4 10 Tf (Dynamically) Tj ( ) Tj (generated) Tj ( ) Tj (function.) Tj ( ) Tj (No) Tj ( ) Tj (source) Tj ( ) Tj (code available) Tj /F1 10 Tf (. In the past I have considered) Tj T* 0 Tw .945366 Tw (this acceptable, since ) Tj /F4 10 Tf (inspect.getsource ) Tj /F1 10 Tf (does not really work even with regular decorators. In that) Tj T* 0 Tw (case ) Tj /F4 10 Tf (inspect.getsource ) Tj /F1 10 Tf (gives you the wrapper source code which is probably not what you want:) Tj T* ET
+BT 1 0 0 1 0 62 Tm 5.045529 Tw 12 TL /F1 10 Tf 0 0 0 rg (Internally ) Tj /F4 10 Tf 0 0 0 rg (FunctionMaker.create ) Tj /F1 10 Tf 0 0 0 rg (uses ) Tj /F4 10 Tf 0 0 0 rg (exec ) Tj /F1 10 Tf 0 0 0 rg (to generate the decorated function. Therefore) Tj T* 0 Tw 2.542126 Tw /F4 10 Tf 0 0 0 rg (inspect.getsource ) Tj /F1 10 Tf 0 0 0 rg (will not work for decorated functions. That means that the usual '??' trick in) Tj T* 0 Tw 26.45775 Tw (IPython will give you the \(right on the spot\) message) Tj T* 0 Tw .261647 Tw /F4 10 Tf 0 0 0 rg (Dynamically) Tj ( ) Tj (generated) Tj ( ) Tj (function.) Tj ( ) Tj (No) Tj ( ) Tj (source) Tj ( ) Tj (code available) Tj /F1 10 Tf 0 0 0 rg (. In the past I have considered) Tj T* 0 Tw .945366 Tw (this acceptable, since ) Tj /F4 10 Tf 0 0 0 rg (inspect.getsource ) Tj /F1 10 Tf 0 0 0 rg (does not really work even with regular decorators. In that) Tj T* 0 Tw (case ) Tj /F4 10 Tf 0 0 0 rg (inspect.getsource ) Tj /F1 10 Tf 0 0 0 rg (gives you the wrapper source code which is probably not what you want:) Tj T* ET
 Q
 Q
 q
-1 0 0 1 62.69291 195.6236 cm
+1 0 0 1 62.69291 165.6236 cm
 q
 q
 1 0 0 1 0 0 cm
@@ -3024,14 +4554,64 @@ q
 n -6 -6 468.6898 60 re B*
 Q
 q
-BT 1 0 0 1 0 38 Tm 12 TL /F3 10 Tf 0 .501961 0 rg (def) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 1 rg (identity_dec) Tj 0 0 0 rg (\() Tj (func) Tj (\):) Tj  T* (    ) Tj /F3 10 Tf 0 .501961 0 rg (def) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 1 rg (wrapper) Tj 0 0 0 rg (\() Tj .4 .4 .4 rg (*) Tj 0 0 0 rg (args) Tj (,) Tj ( ) Tj .4 .4 .4 rg (**) Tj 0 0 0 rg (kw) Tj (\):) Tj  T* (        ) Tj /F3 10 Tf 0 .501961 0 rg (return) Tj /F4 10 Tf 0 0 0 rg ( ) Tj (func) Tj (\() Tj .4 .4 .4 rg (*) Tj 0 0 0 rg (args) Tj (,) Tj ( ) Tj .4 .4 .4 rg (**) Tj 0 0 0 rg (kw) Tj (\)) Tj  T* (    ) Tj /F3 10 Tf 0 .501961 0 rg (return) Tj /F4 10 Tf 0 0 0 rg ( ) Tj (wrapper) Tj T* ET
+.960784 .960784 .862745 rg
+n 0 36.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 24 36.75 72 12 re f*
+.960784 .960784 .862745 rg
+n 96 36.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 102 36.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 126 36.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 24 24.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 48 24.75 42 12 re f*
+.960784 .960784 .862745 rg
+n 90 24.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 96 24.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 102 24.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 126 24.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 138 24.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 150 24.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 162 24.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 48 12.75 36 12 re f*
+.960784 .960784 .862745 rg
+n 90 12.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 114 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 120 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 126 12.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 150 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 162 12.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 174 12.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 186 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 24 .75 36 12 re f*
+.960784 .960784 .862745 rg
+n 66 .75 42 12 re f*
+BT 1 0 0 1 0 38 Tm 12 TL /F3 10 Tf 0 .501961 0 rg (def) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 1 rg (identity_dec) Tj 0 0 0 rg (\() Tj 0 0 0 rg (func) Tj 0 0 0 rg (\):) Tj 0 0 0 rg  T* (    ) Tj /F3 10 Tf 0 .501961 0 rg (def) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 1 rg (wrapper) Tj 0 0 0 rg (\() Tj .4 .4 .4 rg (*) Tj 0 0 0 rg (args) Tj 0 0 0 rg (,) Tj 0 0 0 rg ( ) Tj .4 .4 .4 rg (**) Tj 0 0 0 rg (kw) Tj 0 0 0 rg (\):) Tj 0 0 0 rg  T* (        ) Tj /F3 10 Tf 0 .501961 0 rg (return) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 0 rg (func) Tj 0 0 0 rg (\() Tj .4 .4 .4 rg (*) Tj 0 0 0 rg (args) Tj 0 0 0 rg (,) Tj 0 0 0 rg ( ) Tj .4 .4 .4 rg (**) Tj 0 0 0 rg (kw) Tj 0 0 0 rg (\)) Tj 0 0 0 rg  T* (    ) Tj /F3 10 Tf 0 .501961 0 rg (return) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 0 rg (wrapper) Tj T* ET
 Q
 Q
 Q
 Q
 Q
 q
-1 0 0 1 62.69291 90.42362 cm
+1 0 0 1 62.69291 84.42362 cm
 q
 q
 1 0 0 1 0 0 cm
@@ -3041,10 +4621,58 @@ q
 .662745 .662745 .662745 RG
 .5 w
 .960784 .960784 .862745 rg
-n -6 -6 468.6898 96 re B*
+n -6 -6 468.6898 72 re B*
 Q
 q
-BT 1 0 0 1 0 74 Tm 12 TL /F4 10 Tf .666667 .133333 1 rg (@identity_dec) Tj 0 0 0 rg  T* /F3 10 Tf 0 .501961 0 rg (def) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 1 rg (example) Tj 0 0 0 rg (\(\):) Tj ( ) Tj /F3 10 Tf 0 .501961 0 rg (pass) Tj /F4 10 Tf 0 0 0 rg  T*  T* .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj /F3 10 Tf 0 .501961 0 rg (print) Tj /F4 10 Tf 0 0 0 rg ( ) Tj (inspect) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (getsource) Tj (\() Tj (example) Tj (\)) Tj  T* (    ) Tj /F3 10 Tf 0 .501961 0 rg (def) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 1 rg (wrapper) Tj 0 0 0 rg (\() Tj .4 .4 .4 rg (*) Tj 0 0 0 rg (args) Tj (,) Tj ( ) Tj .4 .4 .4 rg (**) Tj 0 0 0 rg (kw) Tj (\):) Tj  T* (        ) Tj /F3 10 Tf 0 .501961 0 rg (return) Tj /F4 10 Tf 0 0 0 rg ( ) Tj (func) Tj (\() Tj .4 .4 .4 rg (*) Tj 0 0 0 rg (args) Tj (,) Tj ( ) Tj .4 .4 .4 rg (**) Tj 0 0 0 rg (kw) Tj (\)) Tj  T* .4 .4 .4 rg (<) Tj 0 0 0 rg (BLANKLINE) Tj .4 .4 .4 rg (>) Tj T* ET
+.960784 .960784 .862745 rg
+n 0 48.75 78 12 re f*
+.960784 .960784 .862745 rg
+n 0 36.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 24 36.75 42 12 re f*
+.960784 .960784 .862745 rg
+n 66 36.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 90 36.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 0 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 6 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 12 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 24 12.75 30 12 re f*
+.960784 .960784 .862745 rg
+n 60 12.75 42 12 re f*
+.960784 .960784 .862745 rg
+n 102 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 108 12.75 54 12 re f*
+.960784 .960784 .862745 rg
+n 162 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 168 12.75 42 12 re f*
+.960784 .960784 .862745 rg
+n 210 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 24 .75 18 12 re f*
+.960784 .960784 .862745 rg
+n 48 .75 42 12 re f*
+.960784 .960784 .862745 rg
+n 90 .75 6 12 re f*
+.960784 .960784 .862745 rg
+n 96 .75 6 12 re f*
+.960784 .960784 .862745 rg
+n 102 .75 24 12 re f*
+.960784 .960784 .862745 rg
+n 126 .75 6 12 re f*
+.960784 .960784 .862745 rg
+n 138 .75 12 12 re f*
+.960784 .960784 .862745 rg
+n 150 .75 12 12 re f*
+.960784 .960784 .862745 rg
+n 162 .75 12 12 re f*
+BT 1 0 0 1 0 50 Tm 12 TL /F4 10 Tf .666667 .133333 1 rg (@identity_dec) Tj 0 0 0 rg  T* /F3 10 Tf 0 .501961 0 rg (def) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 1 rg (example) Tj 0 0 0 rg (\(\):) Tj 0 0 0 rg ( ) Tj /F3 10 Tf 0 .501961 0 rg (pass) Tj /F4 10 Tf 0 0 0 rg  T*  T* .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj /F3 10 Tf 0 .501961 0 rg (print) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 0 rg (inspect) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (getsource) Tj 0 0 0 rg (\() Tj 0 0 0 rg (example) Tj 0 0 0 rg (\)) Tj 0 0 0 rg  T* (    ) Tj /F3 10 Tf 0 .501961 0 rg (def) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 1 rg (wrapper) Tj 0 0 0 rg (\() Tj .4 .4 .4 rg (*) Tj 0 0 0 rg (args) Tj 0 0 0 rg (,) Tj 0 0 0 rg ( ) Tj .4 .4 .4 rg (**) Tj 0 0 0 rg (kw) Tj 0 0 0 rg (\):) Tj 0 0 0 rg  T* ET
 Q
 Q
 Q
@@ -3053,20 +4681,62 @@ Q
  
 endstream
 endobj
-% 'R95': class PDFStream 
 95 0 obj
-% page stream
-<< /Length 7279 >>
+<< /Length 13714 >>
 stream
 1 0 0 1 0 0 cm  BT /F1 12 Tf 14.4 TL ET
 q
-1 0 0 1 62.69291 717.0236 cm
+1 0 0 1 62.69291 727.8236 cm
+q
+q
+1 0 0 1 0 0 cm
+q
+1 0 0 1 6.6 6.6 cm
+q
+.662745 .662745 .662745 RG
+.5 w
+.960784 .960784 .862745 rg
+n -6 -6 468.6898 36 re B*
+Q
 q
-BT 1 0 0 1 0 38 Tm 1.471235 Tw 12 TL /F1 10 Tf 0 0 0 rg (\(see bug report ) Tj 0 0 .501961 rg (1764286 ) Tj 0 0 0 rg (for an explanation of what is happening\). Unfortunately the bug is still there,) Tj T* 0 Tw 1.541235 Tw (even in Python 2.7 and 3.1. There is however a workaround. The decorator module adds an attribute) Tj T* 0 Tw .103984 Tw /F4 10 Tf (.__wrapped__ ) Tj /F1 10 Tf (to the decorated function, containing a reference to the original function. The easy way to) Tj T* 0 Tw (get the source code is to call ) Tj /F4 10 Tf (inspect.getsource ) Tj /F1 10 Tf (on the undecorated function:) Tj T* ET
+.960784 .960784 .862745 rg
+n 48 12.75 36 12 re f*
+.960784 .960784 .862745 rg
+n 90 12.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 114 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 120 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 126 12.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 150 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 162 12.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 174 12.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 186 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 0 .75 6 12 re f*
+.960784 .960784 .862745 rg
+n 6 .75 54 12 re f*
+.960784 .960784 .862745 rg
+n 60 .75 6 12 re f*
+BT 1 0 0 1 0 14 Tm 12 TL /F4 10 Tf 0 0 0 rg (        ) Tj /F3 10 Tf 0 .501961 0 rg (return) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 0 rg (func) Tj 0 0 0 rg (\() Tj .4 .4 .4 rg (*) Tj 0 0 0 rg (args) Tj 0 0 0 rg (,) Tj 0 0 0 rg ( ) Tj .4 .4 .4 rg (**) Tj 0 0 0 rg (kw) Tj 0 0 0 rg (\)) Tj 0 0 0 rg  T* .4 .4 .4 rg (<) Tj 0 0 0 rg (BLANKLINE) Tj .4 .4 .4 rg (>) Tj T* ET
+Q
+Q
+Q
 Q
 Q
 q
-1 0 0 1 62.69291 611.8236 cm
+1 0 0 1 62.69291 671.8236 cm
+q
+BT 1 0 0 1 0 38 Tm 1.471235 Tw 12 TL /F1 10 Tf 0 0 0 rg (\(see bug report ) Tj 0 0 .501961 rg (1764286 ) Tj 0 0 0 rg (for an explanation of what is happening\). Unfortunately the bug is still there,) Tj T* 0 Tw 1.541235 Tw (even in Python 2.7 and 3.1. There is however a workaround. The decorator module adds an attribute) Tj T* 0 Tw .103984 Tw /F4 10 Tf 0 0 0 rg (.__wrapped__ ) Tj /F1 10 Tf 0 0 0 rg (to the decorated function, containing a reference to the original function. The easy way to) Tj T* 0 Tw (get the source code is to call ) Tj /F4 10 Tf 0 0 0 rg (inspect.getsource ) Tj /F1 10 Tf 0 0 0 rg (on the undecorated function:) Tj T* ET
+Q
+Q
+q
+1 0 0 1 62.69291 554.6236 cm
 q
 q
 1 0 0 1 0 0 cm
@@ -3076,29 +4746,117 @@ q
 .662745 .662745 .662745 RG
 .5 w
 .960784 .960784 .862745 rg
-n -6 -6 468.6898 96 re B*
+n -6 -6 468.6898 108 re B*
 Q
 q
-BT 1 0 0 1 0 74 Tm 12 TL /F4 10 Tf .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj /F3 10 Tf 0 .501961 0 rg (print) Tj /F4 10 Tf 0 0 0 rg ( ) Tj (inspect) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (getsource) Tj (\() Tj (factorial) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (__wrapped__) Tj (\)) Tj  T* .666667 .133333 1 rg (@tail_recursive) Tj 0 0 0 rg  T* /F3 10 Tf 0 .501961 0 rg (def) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 1 rg (factorial) Tj 0 0 0 rg (\() Tj (n) Tj (,) Tj ( ) Tj (acc) Tj .4 .4 .4 rg (=) Tj (1) Tj 0 0 0 rg (\):) Tj  T* (    ) Tj .729412 .129412 .129412 rg ("The good old factorial") Tj 0 0 0 rg  T* (    ) Tj /F3 10 Tf 0 .501961 0 rg (if) Tj /F4 10 Tf 0 0 0 rg ( ) Tj (n) Tj ( ) Tj .4 .4 .4 rg (==) Tj 0 0 0 rg ( ) Tj .4 .4 .4 rg (0) Tj 0 0 0 rg (:) Tj ( ) Tj /F3 10 Tf 0 .501961 0 rg (return) Tj /F4 10 Tf 0 0 0 rg ( ) Tj (acc) Tj  T* (    ) Tj /F3 10 Tf 0 .501961 0 rg (return) Tj /F4 10 Tf 0 0 0 rg ( ) Tj (factorial) Tj (\() Tj (n) Tj .4 .4 .4 rg (-) Tj (1) Tj 0 0 0 rg (,) Tj ( ) Tj (n) Tj .4 .4 .4 rg (*) Tj 0 0 0 rg (acc) Tj (\)) Tj  T* .4 .4 .4 rg (<) Tj 0 0 0 rg (BLANKLINE) Tj .4 .4 .4 rg (>) Tj T* ET
+.960784 .960784 .862745 rg
+n 0 84.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 6 84.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 12 84.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 24 84.75 30 12 re f*
+.960784 .960784 .862745 rg
+n 60 84.75 42 12 re f*
+.960784 .960784 .862745 rg
+n 102 84.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 108 84.75 54 12 re f*
+.960784 .960784 .862745 rg
+n 162 84.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 168 84.75 54 12 re f*
+.960784 .960784 .862745 rg
+n 222 84.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 228 84.75 66 12 re f*
+.960784 .960784 .862745 rg
+n 294 84.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 0 72.75 90 12 re f*
+.960784 .960784 .862745 rg
+n 0 60.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 24 60.75 54 12 re f*
+.960784 .960784 .862745 rg
+n 78 60.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 84 60.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 90 60.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 102 60.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 120 60.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 126 60.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 132 60.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 24 48.75 144 12 re f*
+.960784 .960784 .862745 rg
+n 24 36.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 42 36.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 54 36.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 72 36.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 78 36.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 48 24.75 36 12 re f*
+.960784 .960784 .862745 rg
+n 90 24.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 24 12.75 36 12 re f*
+.960784 .960784 .862745 rg
+n 66 12.75 54 12 re f*
+.960784 .960784 .862745 rg
+n 120 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 126 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 132 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 138 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 144 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 156 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 162 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 168 12.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 186 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 0 .75 6 12 re f*
+.960784 .960784 .862745 rg
+n 6 .75 54 12 re f*
+.960784 .960784 .862745 rg
+n 60 .75 6 12 re f*
+BT 1 0 0 1 0 86 Tm 12 TL /F4 10 Tf .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj /F3 10 Tf 0 .501961 0 rg (print) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 0 rg (inspect) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (getsource) Tj 0 0 0 rg (\() Tj 0 0 0 rg (factorial) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (__wrapped__) Tj 0 0 0 rg (\)) Tj 0 0 0 rg  T* .666667 .133333 1 rg (@tail_recursive) Tj 0 0 0 rg  T* /F3 10 Tf 0 .501961 0 rg (def) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 1 rg (factorial) Tj 0 0 0 rg (\() Tj 0 0 0 rg (n) Tj 0 0 0 rg (,) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (acc) Tj .4 .4 .4 rg (=) Tj .4 .4 .4 rg (1) Tj 0 0 0 rg (\):) Tj 0 0 0 rg  T* (    ) Tj .729412 .129412 .129412 rg ("The good old factorial") Tj 0 0 0 rg  T* (    ) Tj /F3 10 Tf 0 .501961 0 rg (if) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 0 rg (n) Tj 0 0 0 rg ( ) Tj .4 .4 .4 rg (==) Tj 0 0 0 rg ( ) Tj .4 .4 .4 rg (0) Tj 0 0 0 rg (:) Tj 0 0 0 rg  T* (        ) Tj /F3 10 Tf 0 .501961 0 rg (return) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 0 rg (acc) Tj 0 0 0 rg  T* (    ) Tj /F3 10 Tf 0 .501961 0 rg (return) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 0 rg (factorial) Tj 0 0 0 rg (\() Tj 0 0 0 rg (n) Tj .4 .4 .4 rg (-) Tj .4 .4 .4 rg (1) Tj 0 0 0 rg (,) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (n) Tj .4 .4 .4 rg (*) Tj 0 0 0 rg (acc) Tj 0 0 0 rg (\)) Tj 0 0 0 rg  T* .4 .4 .4 rg (<) Tj 0 0 0 rg (BLANKLINE) Tj .4 .4 .4 rg (>) Tj T* ET
 Q
 Q
 Q
 Q
 Q
 q
-1 0 0 1 62.69291 578.8236 cm
+1 0 0 1 62.69291 521.6236 cm
 q
 BT 1 0 0 1 0 3.5 Tm 21 TL /F2 17.5 Tf 0 0 0 rg (Dealing with third party decorators) Tj T* ET
 Q
 Q
 q
-1 0 0 1 62.69291 524.8236 cm
+1 0 0 1 62.69291 467.6236 cm
 q
-BT 1 0 0 1 0 38 Tm .321654 Tw 12 TL /F1 10 Tf 0 0 0 rg (Sometimes you find on the net some cool decorator that you would like to include in your code. However,) Tj T* 0 Tw .50061 Tw (more often than not the cool decorator is not signature-preserving. Therefore you may want an easy way) Tj T* 0 Tw 1.814597 Tw (to upgrade third party decorators to signature-preserving decorators without having to rewrite them in) Tj T* 0 Tw (terms of ) Tj /F4 10 Tf (decorator) Tj /F1 10 Tf (. You can use a ) Tj /F4 10 Tf (FunctionMaker ) Tj /F1 10 Tf (to implement that functionality as follows:) Tj T* ET
+BT 1 0 0 1 0 38 Tm .321654 Tw 12 TL /F1 10 Tf 0 0 0 rg (Sometimes you find on the net some cool decorator that you would like to include in your code. However,) Tj T* 0 Tw .50061 Tw (more often than not the cool decorator is not signature-preserving. Therefore you may want an easy way) Tj T* 0 Tw 1.814597 Tw (to upgrade third party decorators to signature-preserving decorators without having to rewrite them in) Tj T* 0 Tw (terms of ) Tj /F4 10 Tf 0 0 0 rg (decorator) Tj /F1 10 Tf 0 0 0 rg (. You can use a ) Tj /F4 10 Tf 0 0 0 rg (FunctionMaker ) Tj /F1 10 Tf 0 0 0 rg (to implement that functionality as follows:) Tj T* ET
 Q
 Q
 q
-1 0 0 1 62.69291 407.6236 cm
+1 0 0 1 62.69291 350.4236 cm
 q
 q
 1 0 0 1 0 0 cm
@@ -3111,32 +4869,100 @@ q
 n -6 -6 468.6898 108 re B*
 Q
 q
-BT 1 0 0 1 0 86 Tm 12 TL /F3 10 Tf 0 .501961 0 rg (def) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 1 rg (decorator_apply) Tj 0 0 0 rg (\() Tj (dec) Tj (,) Tj ( ) Tj (func) Tj (\):) Tj  T* (    ) Tj /F6 10 Tf .729412 .129412 .129412 rg (""") Tj T* (    Decorate a function by preserving the signature even if dec) Tj T* (    is not a signature-preserving decorator.) Tj T* (    """) Tj /F4 10 Tf 0 0 0 rg  T* (    ) Tj /F3 10 Tf 0 .501961 0 rg (return) Tj /F4 10 Tf 0 0 0 rg ( ) Tj (FunctionMaker) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (create) Tj (\() Tj  T* (        ) Tj (func) Tj (,) Tj ( ) Tj .729412 .129412 .129412 rg ('return decorated\() Tj /F3 10 Tf .733333 .4 .533333 rg (%\(signature\)s) Tj /F4 10 Tf .729412 .129412 .129412 rg (\)') Tj 0 0 0 rg (,) Tj  T* (        ) Tj 0 .501961 0 rg (dict) Tj 0 0 0 rg (\() Tj (decorated) Tj .4 .4 .4 rg (=) Tj 0 0 0 rg (dec) Tj (\() Tj (func) Tj (\)\),) Tj ( ) Tj (__wrapped__) Tj .4 .4 .4 rg (=) Tj 0 0 0 rg (func) Tj (\)) Tj T* ET
+.960784 .960784 .862745 rg
+n 0 84.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 24 84.75 90 12 re f*
+.960784 .960784 .862745 rg
+n 114 84.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 120 84.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 138 84.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 150 84.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 174 84.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 24 72.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 0 60.75 378 12 re f*
+.960784 .960784 .862745 rg
+n 0 48.75 264 12 re f*
+.960784 .960784 .862745 rg
+n 0 36.75 42 12 re f*
+.960784 .960784 .862745 rg
+n 24 24.75 36 12 re f*
+.960784 .960784 .862745 rg
+n 66 24.75 78 12 re f*
+.960784 .960784 .862745 rg
+n 144 24.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 150 24.75 36 12 re f*
+.960784 .960784 .862745 rg
+n 186 24.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 48 12.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 72 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 84 12.75 108 12 re f*
+.960784 .960784 .862745 rg
+n 192 12.75 78 12 re f*
+.960784 .960784 .862745 rg
+n 270 12.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 282 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 48 .75 24 12 re f*
+.960784 .960784 .862745 rg
+n 72 .75 6 12 re f*
+.960784 .960784 .862745 rg
+n 78 .75 54 12 re f*
+.960784 .960784 .862745 rg
+n 132 .75 6 12 re f*
+.960784 .960784 .862745 rg
+n 138 .75 18 12 re f*
+.960784 .960784 .862745 rg
+n 156 .75 6 12 re f*
+.960784 .960784 .862745 rg
+n 162 .75 24 12 re f*
+.960784 .960784 .862745 rg
+n 186 .75 18 12 re f*
+.960784 .960784 .862745 rg
+n 210 .75 66 12 re f*
+.960784 .960784 .862745 rg
+n 276 .75 6 12 re f*
+.960784 .960784 .862745 rg
+n 282 .75 24 12 re f*
+.960784 .960784 .862745 rg
+n 306 .75 6 12 re f*
+BT 1 0 0 1 0 86 Tm 12 TL /F3 10 Tf 0 .501961 0 rg (def) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 1 rg (decorator_apply) Tj 0 0 0 rg (\() Tj 0 0 0 rg (dec) Tj 0 0 0 rg (,) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (func) Tj 0 0 0 rg (\):) Tj 0 0 0 rg  T* (    ) Tj /F6 10 Tf .729412 .129412 .129412 rg (""") Tj T* (    Decorate a function by preserving the signature even if dec) Tj T* (    is not a signature-preserving decorator.) Tj T* (    """) Tj /F4 10 Tf 0 0 0 rg  T* (    ) Tj /F3 10 Tf 0 .501961 0 rg (return) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 0 rg (FunctionMaker) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (create) Tj 0 0 0 rg (\() Tj 0 0 0 rg  T* (        ) Tj 0 0 0 rg (func) Tj 0 0 0 rg (,) Tj 0 0 0 rg ( ) Tj .729412 .129412 .129412 rg ('return decorated\() Tj /F3 10 Tf .733333 .4 .533333 rg (%\(signature\)s) Tj /F4 10 Tf .729412 .129412 .129412 rg (\)') Tj 0 0 0 rg (,) Tj 0 0 0 rg  T* (        ) Tj 0 .501961 0 rg (dict) Tj 0 0 0 rg (\() Tj 0 0 0 rg (decorated) Tj .4 .4 .4 rg (=) Tj 0 0 0 rg (dec) Tj 0 0 0 rg (\() Tj 0 0 0 rg (func) Tj 0 0 0 rg (\)\),) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (__wrapped__) Tj .4 .4 .4 rg (=) Tj 0 0 0 rg (func) Tj 0 0 0 rg (\)) Tj T* ET
 Q
 Q
 Q
 Q
 Q
 q
-1 0 0 1 62.69291 375.6236 cm
+1 0 0 1 62.69291 318.4236 cm
 q
-BT 1 0 0 1 0 14 Tm .698314 Tw 12 TL /F4 10 Tf 0 0 0 rg (decorator_apply ) Tj /F1 10 Tf (sets the attribute ) Tj /F4 10 Tf (.__wrapped__ ) Tj /F1 10 Tf (of the generated function to the original function,) Tj T* 0 Tw (so that you can get the right source code.) Tj T* ET
+BT 1 0 0 1 0 14 Tm .698314 Tw 12 TL /F4 10 Tf 0 0 0 rg (decorator_apply ) Tj /F1 10 Tf 0 0 0 rg (sets the attribute ) Tj /F4 10 Tf 0 0 0 rg (.__wrapped__ ) Tj /F1 10 Tf 0 0 0 rg (of the generated function to the original function,) Tj T* 0 Tw (so that you can get the right source code.) Tj T* ET
 Q
 Q
 q
-1 0 0 1 62.69291 333.6236 cm
+1 0 0 1 62.69291 276.4236 cm
 q
-BT 1 0 0 1 0 26 Tm .13104 Tw 12 TL /F1 10 Tf 0 0 0 rg (Notice that I am not providing this functionality in the ) Tj /F4 10 Tf (decorator ) Tj /F1 10 Tf (module directly since I think it is best to) Tj T* 0 Tw 2.070751 Tw (rewrite the decorator rather than adding an additional level of indirection. However, practicality beats) Tj T* 0 Tw (purity, so you can add ) Tj /F4 10 Tf (decorator_apply ) Tj /F1 10 Tf (to your toolbox and use it if you need to.) Tj T* ET
+BT 1 0 0 1 0 26 Tm .13104 Tw 12 TL /F1 10 Tf 0 0 0 rg (Notice that I am not providing this functionality in the ) Tj /F4 10 Tf 0 0 0 rg (decorator ) Tj /F1 10 Tf 0 0 0 rg (module directly since I think it is best to) Tj T* 0 Tw 2.070751 Tw (rewrite the decorator rather than adding an additional level of indirection. However, practicality beats) Tj T* 0 Tw (purity, so you can add ) Tj /F4 10 Tf 0 0 0 rg (decorator_apply ) Tj /F1 10 Tf 0 0 0 rg (to your toolbox and use it if you need to.) Tj T* ET
 Q
 Q
 q
-1 0 0 1 62.69291 279.6236 cm
+1 0 0 1 62.69291 222.4236 cm
 q
-BT 1 0 0 1 0 38 Tm 1.74881 Tw 12 TL /F1 10 Tf 0 0 0 rg (In order to give an example of usage of ) Tj /F4 10 Tf (decorator_apply) Tj /F1 10 Tf (, I will show a pretty slick decorator that) Tj T* 0 Tw 1.276651 Tw (converts a tail-recursive function in an iterative function. I have shamelessly stolen the basic idea from) Tj T* 0 Tw 43.62829 Tw (Kay Schluehr's recipe in the Python Cookbook,) Tj T* 0 Tw 0 0 .501961 rg (http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/496691) Tj 0 0 0 rg (.) Tj T* ET
+BT 1 0 0 1 0 38 Tm 1.74881 Tw 12 TL /F1 10 Tf 0 0 0 rg (In order to give an example of usage of ) Tj /F4 10 Tf 0 0 0 rg (decorator_apply) Tj /F1 10 Tf 0 0 0 rg (, I will show a pretty slick decorator that) Tj T* 0 Tw 1.276651 Tw (converts a tail-recursive function in an iterative function. I have shamelessly stolen the basic idea from) Tj T* 0 Tw 43.62829 Tw (Kay Schluehr's recipe in the Python Cookbook,) Tj T* 0 Tw 0 0 .501961 rg (http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/496691) Tj 0 0 0 rg (.) Tj T* ET
 Q
 Q
 q
-1 0 0 1 62.69291 78.42362 cm
+1 0 0 1 62.69291 81.22362 cm
 q
 q
 1 0 0 1 0 0 cm
@@ -3146,10 +4972,64 @@ q
 .662745 .662745 .662745 RG
 .5 w
 .960784 .960784 .862745 rg
-n -6 -6 468.6898 192 re B*
+n -6 -6 468.6898 132 re B*
 Q
 q
-BT 1 0 0 1 0 170 Tm 12 TL /F3 10 Tf 0 .501961 0 rg (class) Tj /F4 10 Tf 0 0 0 rg ( ) Tj /F3 10 Tf 0 0 1 rg (TailRecursive) Tj /F4 10 Tf 0 0 0 rg (\() Tj 0 .501961 0 rg (object) Tj 0 0 0 rg (\):) Tj  T* (    ) Tj /F6 10 Tf .729412 .129412 .129412 rg (""") Tj T* (    tail_recursive decorator based on Kay Schluehr's recipe) Tj T* (    http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/496691) Tj T* (    with improvements by me and George Sakkis.) Tj T* (    """) Tj /F4 10 Tf 0 0 0 rg  T*  T* (    ) Tj /F3 10 Tf 0 .501961 0 rg (def) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 1 rg (__init__) Tj 0 0 0 rg (\() Tj 0 .501961 0 rg (self) Tj 0 0 0 rg (,) Tj ( ) Tj (func) Tj (\):) Tj  T* (        ) Tj 0 .501961 0 rg (self) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (func) Tj ( ) Tj .4 .4 .4 rg (=) Tj 0 0 0 rg ( ) Tj (func) Tj  T* (        ) Tj 0 .501961 0 rg (self) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (firstcall) Tj ( ) Tj .4 .4 .4 rg (=) Tj 0 0 0 rg ( ) Tj 0 .501961 0 rg (True) Tj 0 0 0 rg  T* (        ) Tj 0 .501961 0 rg (self) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (CONTINUE) Tj ( ) Tj .4 .4 .4 rg (=) Tj 0 0 0 rg ( ) Tj 0 .501961 0 rg (object) Tj 0 0 0 rg (\(\)) Tj ( ) Tj /F6 10 Tf .25098 .501961 .501961 rg (# sentinel) Tj /F4 10 Tf 0 0 0 rg  T*  T* (    ) Tj /F3 10 Tf 0 .501961 0 rg (def) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 1 rg (__call__) Tj 0 0 0 rg (\() Tj 0 .501961 0 rg (self) Tj 0 0 0 rg (,) Tj ( ) Tj .4 .4 .4 rg (*) Tj 0 0 0 rg (args) Tj (,) Tj ( ) Tj .4 .4 .4 rg (**) Tj 0 0 0 rg (kwd) Tj (\):) Tj  T* (        ) Tj (CONTINUE) Tj ( ) Tj .4 .4 .4 rg (=) Tj 0 0 0 rg ( ) Tj 0 .501961 0 rg (self) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (CONTINUE) Tj  T* (        ) Tj /F3 10 Tf 0 .501961 0 rg (if) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 .501961 0 rg (self) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (firstcall) Tj (:) Tj  T* ET
+.960784 .960784 .862745 rg
+n 0 108.75 30 12 re f*
+.960784 .960784 .862745 rg
+n 36 108.75 78 12 re f*
+.960784 .960784 .862745 rg
+n 114 108.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 120 108.75 36 12 re f*
+.960784 .960784 .862745 rg
+n 156 108.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 24 96.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 0 84.75 354 12 re f*
+.960784 .960784 .862745 rg
+n 0 72.75 396 12 re f*
+.960784 .960784 .862745 rg
+n 0 60.75 276 12 re f*
+.960784 .960784 .862745 rg
+n 0 48.75 42 12 re f*
+.960784 .960784 .862745 rg
+n 24 24.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 48 24.75 48 12 re f*
+.960784 .960784 .862745 rg
+n 96 24.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 102 24.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 126 24.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 138 24.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 162 24.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 48 12.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 72 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 78 12.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 108 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 120 12.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 48 .75 24 12 re f*
+.960784 .960784 .862745 rg
+n 72 .75 6 12 re f*
+.960784 .960784 .862745 rg
+n 78 .75 54 12 re f*
+.960784 .960784 .862745 rg
+n 138 .75 6 12 re f*
+.960784 .960784 .862745 rg
+n 150 .75 24 12 re f*
+BT 1 0 0 1 0 110 Tm 12 TL /F3 10 Tf 0 .501961 0 rg (class) Tj /F4 10 Tf 0 0 0 rg ( ) Tj /F3 10 Tf 0 0 1 rg (TailRecursive) Tj /F4 10 Tf 0 0 0 rg (\() Tj 0 .501961 0 rg (object) Tj 0 0 0 rg (\):) Tj 0 0 0 rg  T* (    ) Tj /F6 10 Tf .729412 .129412 .129412 rg (""") Tj T* (    tail_recursive decorator based on Kay Schluehr's recipe) Tj T* (    http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/496691) Tj T* (    with improvements by me and George Sakkis.) Tj T* (    """) Tj /F4 10 Tf 0 0 0 rg  T*  T* (    ) Tj /F3 10 Tf 0 .501961 0 rg (def) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 1 rg (__init__) Tj 0 0 0 rg (\() Tj 0 .501961 0 rg (self) Tj 0 0 0 rg (,) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (func) Tj 0 0 0 rg (\):) Tj 0 0 0 rg  T* (        ) Tj 0 .501961 0 rg (self) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (func) Tj 0 0 0 rg ( ) Tj .4 .4 .4 rg (=) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (func) Tj 0 0 0 rg  T* (        ) Tj 0 .501961 0 rg (self) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (firstcall) Tj 0 0 0 rg ( ) Tj .4 .4 .4 rg (=) Tj 0 0 0 rg ( ) Tj 0 .501961 0 rg (True) Tj 0 0 0 rg  T* ET
 Q
 Q
 Q
@@ -3158,14 +5038,12 @@ Q
  
 endstream
 endobj
-% 'R96': class PDFStream 
 96 0 obj
-% page stream
-<< /Length 7146 >>
+<< /Length 16920 >>
 stream
 1 0 0 1 0 0 cm  BT /F1 12 Tf 14.4 TL ET
 q
-1 0 0 1 62.69291 583.8236 cm
+1 0 0 1 62.69291 523.8236 cm
 q
 q
 1 0 0 1 0 0 cm
@@ -3175,24 +5053,204 @@ q
 .662745 .662745 .662745 RG
 .5 w
 .960784 .960784 .862745 rg
-n -6 -6 468.6898 180 re B*
+n -6 -6 468.6898 240 re B*
 Q
 q
-BT 1 0 0 1 0 158 Tm 12 TL /F4 10 Tf 0 0 0 rg (            ) Tj (func) Tj ( ) Tj .4 .4 .4 rg (=) Tj 0 0 0 rg ( ) Tj 0 .501961 0 rg (self) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (func) Tj  T* (            ) Tj 0 .501961 0 rg (self) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (firstcall) Tj ( ) Tj .4 .4 .4 rg (=) Tj 0 0 0 rg ( ) Tj 0 .501961 0 rg (False) Tj 0 0 0 rg  T* (            ) Tj /F3 10 Tf 0 .501961 0 rg (try) Tj /F4 10 Tf 0 0 0 rg (:) Tj  T* (                ) Tj /F3 10 Tf 0 .501961 0 rg (while) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 .501961 0 rg (True) Tj 0 0 0 rg (:) Tj  T* (                    ) Tj (result) Tj ( ) Tj .4 .4 .4 rg (=) Tj 0 0 0 rg ( ) Tj (func) Tj (\() Tj .4 .4 .4 rg (*) Tj 0 0 0 rg (args) Tj (,) Tj ( ) Tj .4 .4 .4 rg (**) Tj 0 0 0 rg (kwd) Tj (\)) Tj  T* (                    ) Tj /F3 10 Tf 0 .501961 0 rg (if) Tj /F4 10 Tf 0 0 0 rg ( ) Tj (result) Tj ( ) Tj /F3 10 Tf .666667 .133333 1 rg (is) Tj /F4 10 Tf 0 0 0 rg ( ) Tj (CONTINUE) Tj (:) Tj ( ) Tj /F6 10 Tf .25098 .501961 .501961 rg (# update arguments) Tj /F4 10 Tf 0 0 0 rg  T* (                        ) Tj (args) Tj (,) Tj ( ) Tj (kwd) Tj ( ) Tj .4 .4 .4 rg (=) Tj 0 0 0 rg ( ) Tj 0 .501961 0 rg (self) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (argskwd) Tj  T* (                    ) Tj /F3 10 Tf 0 .501961 0 rg (else) Tj /F4 10 Tf 0 0 0 rg (:) Tj ( ) Tj /F6 10 Tf .25098 .501961 .501961 rg (# last call) Tj /F4 10 Tf 0 0 0 rg  T* (                        ) Tj /F3 10 Tf 0 .501961 0 rg (return) Tj /F4 10 Tf 0 0 0 rg ( ) Tj (result) Tj  T* (            ) Tj /F3 10 Tf 0 .501961 0 rg (finally) Tj /F4 10 Tf 0 0 0 rg (:) Tj  T* (                ) Tj 0 .501961 0 rg (self) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (firstcall) Tj ( ) Tj .4 .4 .4 rg (=) Tj 0 0 0 rg ( ) Tj 0 .501961 0 rg (True) Tj 0 0 0 rg  T* (        ) Tj /F3 10 Tf 0 .501961 0 rg (else) Tj /F4 10 Tf 0 0 0 rg (:) Tj ( ) Tj /F6 10 Tf .25098 .501961 .501961 rg (# return the arguments of the tail call) Tj /F4 10 Tf 0 0 0 rg  T* (            ) Tj 0 .501961 0 rg (self) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (argskwd) Tj ( ) Tj .4 .4 .4 rg (=) Tj 0 0 0 rg ( ) Tj (args) Tj (,) Tj ( ) Tj (kwd) Tj  T* (            ) Tj /F3 10 Tf 0 .501961 0 rg (return) Tj /F4 10 Tf 0 0 0 rg ( ) Tj (CONTINUE) Tj T* ET
+.960784 .960784 .862745 rg
+n 48 216.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 72 216.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 78 216.75 48 12 re f*
+.960784 .960784 .862745 rg
+n 132 216.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 144 216.75 36 12 re f*
+.960784 .960784 .862745 rg
+n 180 216.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 204 216.75 60 12 re f*
+.960784 .960784 .862745 rg
+n 24 192.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 48 192.75 48 12 re f*
+.960784 .960784 .862745 rg
+n 96 192.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 102 192.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 126 192.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 138 192.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 144 192.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 168 192.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 180 192.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 192 192.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 210 192.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 48 180.75 48 12 re f*
+.960784 .960784 .862745 rg
+n 102 180.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 114 180.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 138 180.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 144 180.75 48 12 re f*
+.960784 .960784 .862745 rg
+n 48 168.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 66 168.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 90 168.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 96 168.75 54 12 re f*
+.960784 .960784 .862745 rg
+n 150 168.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 72 156.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 102 156.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 114 156.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 138 156.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 144 156.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 72 144.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 96 144.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 102 144.75 54 12 re f*
+.960784 .960784 .862745 rg
+n 162 144.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 174 144.75 30 12 re f*
+.960784 .960784 .862745 rg
+n 72 132.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 90 132.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 96 120.75 30 12 re f*
+.960784 .960784 .862745 rg
+n 132 120.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 156 120.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 120 108.75 36 12 re f*
+.960784 .960784 .862745 rg
+n 162 108.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 174 108.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 198 108.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 204 108.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 210 108.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 234 108.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 246 108.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 258 108.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 276 108.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 120 96.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 138 96.75 36 12 re f*
+.960784 .960784 .862745 rg
+n 180 96.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 198 96.75 48 12 re f*
+.960784 .960784 .862745 rg
+n 246 96.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 264 96.75 108 12 re f*
+.960784 .960784 .862745 rg
+n 144 84.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 168 84.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 180 84.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 204 84.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 216 84.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 240 84.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 246 84.75 42 12 re f*
+.960784 .960784 .862745 rg
+n 120 72.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 144 72.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 162 72.75 66 12 re f*
+.960784 .960784 .862745 rg
+n 144 60.75 36 12 re f*
+.960784 .960784 .862745 rg
+n 186 60.75 36 12 re f*
+.960784 .960784 .862745 rg
+n 72 48.75 42 12 re f*
+.960784 .960784 .862745 rg
+n 114 48.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 96 36.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 120 36.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 126 36.75 54 12 re f*
+.960784 .960784 .862745 rg
+n 186 36.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 198 36.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 48 24.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 72 24.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 90 24.75 234 12 re f*
+.960784 .960784 .862745 rg
+n 72 12.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 96 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 102 12.75 42 12 re f*
+.960784 .960784 .862745 rg
+n 150 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 162 12.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 186 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 198 12.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 72 .75 36 12 re f*
+.960784 .960784 .862745 rg
+n 114 .75 48 12 re f*
+BT 1 0 0 1 0 218 Tm 12 TL /F4 10 Tf 0 0 0 rg (        ) Tj 0 .501961 0 rg (self) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (CONTINUE) Tj 0 0 0 rg ( ) Tj .4 .4 .4 rg (=) Tj 0 0 0 rg ( ) Tj 0 .501961 0 rg (object) Tj 0 0 0 rg (\(\)) Tj 0 0 0 rg (  ) Tj /F6 10 Tf .25098 .501961 .501961 rg (# sentinel) Tj /F4 10 Tf 0 0 0 rg  T*  T* (    ) Tj /F3 10 Tf 0 .501961 0 rg (def) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 1 rg (__call__) Tj 0 0 0 rg (\() Tj 0 .501961 0 rg (self) Tj 0 0 0 rg (,) Tj 0 0 0 rg ( ) Tj .4 .4 .4 rg (*) Tj 0 0 0 rg (args) Tj 0 0 0 rg (,) Tj 0 0 0 rg ( ) Tj .4 .4 .4 rg (**) Tj 0 0 0 rg (kwd) Tj 0 0 0 rg (\):) Tj 0 0 0 rg  T* (        ) Tj 0 0 0 rg (CONTINUE) Tj 0 0 0 rg ( ) Tj .4 .4 .4 rg (=) Tj 0 0 0 rg ( ) Tj 0 .501961 0 rg (self) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (CONTINUE) Tj 0 0 0 rg  T* (        ) Tj /F3 10 Tf 0 .501961 0 rg (if) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 .501961 0 rg (self) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (firstcall) Tj 0 0 0 rg (:) Tj 0 0 0 rg  T* (            ) Tj 0 0 0 rg (func) Tj 0 0 0 rg ( ) Tj .4 .4 .4 rg (=) Tj 0 0 0 rg ( ) Tj 0 .501961 0 rg (self) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (func) Tj 0 0 0 rg  T* (            ) Tj 0 .501961 0 rg (self) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (firstcall) Tj 0 0 0 rg ( ) Tj .4 .4 .4 rg (=) Tj 0 0 0 rg ( ) Tj 0 .501961 0 rg (False) Tj 0 0 0 rg  T* (            ) Tj /F3 10 Tf 0 .501961 0 rg (try) Tj /F4 10 Tf 0 0 0 rg (:) Tj 0 0 0 rg  T* (                ) Tj /F3 10 Tf 0 .501961 0 rg (while) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 .501961 0 rg (True) Tj 0 0 0 rg (:) Tj 0 0 0 rg  T* (                    ) Tj 0 0 0 rg (result) Tj 0 0 0 rg ( ) Tj .4 .4 .4 rg (=) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (func) Tj 0 0 0 rg (\() Tj .4 .4 .4 rg (*) Tj 0 0 0 rg (args) Tj 0 0 0 rg (,) Tj 0 0 0 rg ( ) Tj .4 .4 .4 rg (**) Tj 0 0 0 rg (kwd) Tj 0 0 0 rg (\)) Tj 0 0 0 rg  T* (                    ) Tj /F3 10 Tf 0 .501961 0 rg (if) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 0 rg (result) Tj 0 0 0 rg ( ) Tj /F3 10 Tf .666667 .133333 1 rg (is) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 0 rg (CONTINUE) Tj 0 0 0 rg (:) Tj 0 0 0 rg (  ) Tj /F6 10 Tf .25098 .501961 .501961 rg (# update arguments) Tj /F4 10 Tf 0 0 0 rg  T* (                        ) Tj 0 0 0 rg (args) Tj 0 0 0 rg (,) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (kwd) Tj 0 0 0 rg ( ) Tj .4 .4 .4 rg (=) Tj 0 0 0 rg ( ) Tj 0 .501961 0 rg (self) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (argskwd) Tj 0 0 0 rg  T* (                    ) Tj /F3 10 Tf 0 .501961 0 rg (else) Tj /F4 10 Tf 0 0 0 rg (:) Tj 0 0 0 rg (  ) Tj /F6 10 Tf .25098 .501961 .501961 rg (# last call) Tj /F4 10 Tf 0 0 0 rg  T* (                        ) Tj /F3 10 Tf 0 .501961 0 rg (return) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 0 rg (result) Tj 0 0 0 rg  T* (            ) Tj /F3 10 Tf 0 .501961 0 rg (finally) Tj /F4 10 Tf 0 0 0 rg (:) Tj 0 0 0 rg  T* (                ) Tj 0 .501961 0 rg (self) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (firstcall) Tj 0 0 0 rg ( ) Tj .4 .4 .4 rg (=) Tj 0 0 0 rg ( ) Tj 0 .501961 0 rg (True) Tj 0 0 0 rg  T* (        ) Tj /F3 10 Tf 0 .501961 0 rg (else) Tj /F4 10 Tf 0 0 0 rg (:) Tj 0 0 0 rg (  ) Tj /F6 10 Tf .25098 .501961 .501961 rg (# return the arguments of the tail call) Tj /F4 10 Tf 0 0 0 rg  T* (            ) Tj 0 .501961 0 rg (self) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (argskwd) Tj 0 0 0 rg ( ) Tj .4 .4 .4 rg (=) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (args) Tj 0 0 0 rg (,) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (kwd) Tj 0 0 0 rg  T* (            ) Tj /F3 10 Tf 0 .501961 0 rg (return) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 0 rg (CONTINUE) Tj T* ET
 Q
 Q
 Q
 Q
 Q
 q
-1 0 0 1 62.69291 563.8236 cm
+1 0 0 1 62.69291 503.8236 cm
 q
 0 0 0 rg
 BT 1 0 0 1 0 2 Tm /F1 10 Tf 12 TL (Here the decorator is implemented as a class returning callable objects.) Tj T* ET
 Q
 Q
 q
-1 0 0 1 62.69291 518.6236 cm
+1 0 0 1 62.69291 458.6236 cm
 q
 q
 1 0 0 1 0 0 cm
@@ -3205,21 +5263,45 @@ q
 n -6 -6 468.6898 36 re B*
 Q
 q
-BT 1 0 0 1 0 14 Tm 12 TL /F3 10 Tf 0 .501961 0 rg (def) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 1 rg (tail_recursive) Tj 0 0 0 rg (\() Tj (func) Tj (\):) Tj  T* (    ) Tj /F3 10 Tf 0 .501961 0 rg (return) Tj /F4 10 Tf 0 0 0 rg ( ) Tj (decorator_apply) Tj (\() Tj (TailRecursive) Tj (,) Tj ( ) Tj (func) Tj (\)) Tj T* ET
+.960784 .960784 .862745 rg
+n 0 12.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 24 12.75 84 12 re f*
+.960784 .960784 .862745 rg
+n 108 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 114 12.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 138 12.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 24 .75 36 12 re f*
+.960784 .960784 .862745 rg
+n 66 .75 90 12 re f*
+.960784 .960784 .862745 rg
+n 156 .75 6 12 re f*
+.960784 .960784 .862745 rg
+n 162 .75 78 12 re f*
+.960784 .960784 .862745 rg
+n 240 .75 6 12 re f*
+.960784 .960784 .862745 rg
+n 252 .75 24 12 re f*
+.960784 .960784 .862745 rg
+n 276 .75 6 12 re f*
+BT 1 0 0 1 0 14 Tm 12 TL /F3 10 Tf 0 .501961 0 rg (def) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 1 rg (tail_recursive) Tj 0 0 0 rg (\() Tj 0 0 0 rg (func) Tj 0 0 0 rg (\):) Tj 0 0 0 rg  T* (    ) Tj /F3 10 Tf 0 .501961 0 rg (return) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 0 rg (decorator_apply) Tj 0 0 0 rg (\() Tj 0 0 0 rg (TailRecursive) Tj 0 0 0 rg (,) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (func) Tj 0 0 0 rg (\)) Tj T* ET
 Q
 Q
 Q
 Q
 Q
 q
-1 0 0 1 62.69291 498.6236 cm
+1 0 0 1 62.69291 438.6236 cm
 q
 0 0 0 rg
 BT 1 0 0 1 0 2 Tm /F1 10 Tf 12 TL (Here is how you apply the upgraded decorator to the good old factorial:) Tj T* ET
 Q
 Q
 q
-1 0 0 1 62.69291 417.4236 cm
+1 0 0 1 62.69291 345.4236 cm
 q
 q
 1 0 0 1 0 0 cm
@@ -3229,17 +5311,75 @@ q
 .662745 .662745 .662745 RG
 .5 w
 .960784 .960784 .862745 rg
-n -6 -6 468.6898 72 re B*
+n -6 -6 468.6898 84 re B*
 Q
 q
-BT 1 0 0 1 0 50 Tm 12 TL /F4 10 Tf .666667 .133333 1 rg (@tail_recursive) Tj 0 0 0 rg  T* /F3 10 Tf 0 .501961 0 rg (def) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 1 rg (factorial) Tj 0 0 0 rg (\() Tj (n) Tj (,) Tj ( ) Tj (acc) Tj .4 .4 .4 rg (=) Tj (1) Tj 0 0 0 rg (\):) Tj  T* (    ) Tj .729412 .129412 .129412 rg ("The good old factorial") Tj 0 0 0 rg  T* (    ) Tj /F3 10 Tf 0 .501961 0 rg (if) Tj /F4 10 Tf 0 0 0 rg ( ) Tj (n) Tj ( ) Tj .4 .4 .4 rg (==) Tj 0 0 0 rg ( ) Tj .4 .4 .4 rg (0) Tj 0 0 0 rg (:) Tj ( ) Tj /F3 10 Tf 0 .501961 0 rg (return) Tj /F4 10 Tf 0 0 0 rg ( ) Tj (acc) Tj  T* (    ) Tj /F3 10 Tf 0 .501961 0 rg (return) Tj /F4 10 Tf 0 0 0 rg ( ) Tj (factorial) Tj (\() Tj (n) Tj .4 .4 .4 rg (-) Tj (1) Tj 0 0 0 rg (,) Tj ( ) Tj (n) Tj .4 .4 .4 rg (*) Tj 0 0 0 rg (acc) Tj (\)) Tj T* ET
+.960784 .960784 .862745 rg
+n 0 60.75 90 12 re f*
+.960784 .960784 .862745 rg
+n 0 48.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 24 48.75 54 12 re f*
+.960784 .960784 .862745 rg
+n 78 48.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 84 48.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 90 48.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 102 48.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 120 48.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 126 48.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 132 48.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 24 36.75 144 12 re f*
+.960784 .960784 .862745 rg
+n 24 24.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 42 24.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 54 24.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 72 24.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 78 24.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 48 12.75 36 12 re f*
+.960784 .960784 .862745 rg
+n 90 12.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 24 .75 36 12 re f*
+.960784 .960784 .862745 rg
+n 66 .75 54 12 re f*
+.960784 .960784 .862745 rg
+n 120 .75 6 12 re f*
+.960784 .960784 .862745 rg
+n 126 .75 6 12 re f*
+.960784 .960784 .862745 rg
+n 132 .75 6 12 re f*
+.960784 .960784 .862745 rg
+n 138 .75 6 12 re f*
+.960784 .960784 .862745 rg
+n 144 .75 6 12 re f*
+.960784 .960784 .862745 rg
+n 156 .75 6 12 re f*
+.960784 .960784 .862745 rg
+n 162 .75 6 12 re f*
+.960784 .960784 .862745 rg
+n 168 .75 18 12 re f*
+.960784 .960784 .862745 rg
+n 186 .75 6 12 re f*
+BT 1 0 0 1 0 62 Tm 12 TL /F4 10 Tf .666667 .133333 1 rg (@tail_recursive) Tj 0 0 0 rg  T* /F3 10 Tf 0 .501961 0 rg (def) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 1 rg (factorial) Tj 0 0 0 rg (\() Tj 0 0 0 rg (n) Tj 0 0 0 rg (,) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (acc) Tj .4 .4 .4 rg (=) Tj .4 .4 .4 rg (1) Tj 0 0 0 rg (\):) Tj 0 0 0 rg  T* (    ) Tj .729412 .129412 .129412 rg ("The good old factorial") Tj 0 0 0 rg  T* (    ) Tj /F3 10 Tf 0 .501961 0 rg (if) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 0 rg (n) Tj 0 0 0 rg ( ) Tj .4 .4 .4 rg (==) Tj 0 0 0 rg ( ) Tj .4 .4 .4 rg (0) Tj 0 0 0 rg (:) Tj 0 0 0 rg  T* (        ) Tj /F3 10 Tf 0 .501961 0 rg (return) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 0 rg (acc) Tj 0 0 0 rg  T* (    ) Tj /F3 10 Tf 0 .501961 0 rg (return) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 0 rg (factorial) Tj 0 0 0 rg (\() Tj 0 0 0 rg (n) Tj .4 .4 .4 rg (-) Tj .4 .4 .4 rg (1) Tj 0 0 0 rg (,) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (n) Tj .4 .4 .4 rg (*) Tj 0 0 0 rg (acc) Tj 0 0 0 rg (\)) Tj T* ET
 Q
 Q
 Q
 Q
 Q
 q
-1 0 0 1 62.69291 372.2236 cm
+1 0 0 1 62.69291 300.2236 cm
 q
 q
 1 0 0 1 0 0 cm
@@ -3252,20 +5392,38 @@ q
 n -6 -6 468.6898 36 re B*
 Q
 q
-BT 1 0 0 1 0 14 Tm 12 TL /F4 10 Tf .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj /F3 10 Tf 0 .501961 0 rg (print) Tj /F4 10 Tf 0 0 0 rg ( ) Tj (factorial) Tj (\() Tj .4 .4 .4 rg (4) Tj 0 0 0 rg (\)) Tj  T* .4 .4 .4 rg (24) Tj T* ET
+.960784 .960784 .862745 rg
+n 0 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 6 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 12 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 24 12.75 30 12 re f*
+.960784 .960784 .862745 rg
+n 60 12.75 54 12 re f*
+.960784 .960784 .862745 rg
+n 114 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 120 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 126 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 0 .75 12 12 re f*
+BT 1 0 0 1 0 14 Tm 12 TL /F4 10 Tf .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj /F3 10 Tf 0 .501961 0 rg (print) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 0 rg (factorial) Tj 0 0 0 rg (\() Tj .4 .4 .4 rg (4) Tj 0 0 0 rg (\)) Tj 0 0 0 rg  T* .4 .4 .4 rg (24) Tj T* ET
 Q
 Q
 Q
 Q
 Q
 q
-1 0 0 1 62.69291 316.2236 cm
+1 0 0 1 62.69291 244.2236 cm
 q
-BT 1 0 0 1 0 38 Tm .188935 Tw 12 TL /F1 10 Tf 0 0 0 rg (This decorator is pretty impressive, and should give you some food for your mind ;\) Notice that there is no) Tj T* 0 Tw 1.339983 Tw (recursion limit now, and you can easily compute ) Tj /F4 10 Tf (factorial\(1001\) ) Tj /F1 10 Tf (or larger without filling the stack) Tj T* 0 Tw .909431 Tw (frame. Notice also that the decorator will not work on functions which are not tail recursive, such as the) Tj T* 0 Tw (following) Tj T* ET
+BT 1 0 0 1 0 38 Tm .188935 Tw 12 TL /F1 10 Tf 0 0 0 rg (This decorator is pretty impressive, and should give you some food for your mind ;\) Notice that there is no) Tj T* 0 Tw 1.339983 Tw (recursion limit now, and you can easily compute ) Tj /F4 10 Tf 0 0 0 rg (factorial\(1001\) ) Tj /F1 10 Tf 0 0 0 rg (or larger without filling the stack) Tj T* 0 Tw .909431 Tw (frame. Notice also that the decorator will not work on functions which are not tail recursive, such as the) Tj T* 0 Tw (following) Tj T* ET
 Q
 Q
 q
-1 0 0 1 62.69291 259.0236 cm
+1 0 0 1 62.69291 175.0236 cm
 q
 q
 1 0 0 1 0 0 cm
@@ -3275,67 +5433,88 @@ q
 .662745 .662745 .662745 RG
 .5 w
 .960784 .960784 .862745 rg
-n -6 -6 468.6898 48 re B*
+n -6 -6 468.6898 60 re B*
 Q
 q
-BT 1 0 0 1 0 26 Tm 12 TL /F3 10 Tf 0 .501961 0 rg (def) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 1 rg (fact) Tj 0 0 0 rg (\() Tj (n) Tj (\):) Tj ( ) Tj /F6 10 Tf .25098 .501961 .501961 rg (# this is not tail-recursive) Tj /F4 10 Tf 0 0 0 rg  T* (    ) Tj /F3 10 Tf 0 .501961 0 rg (if) Tj /F4 10 Tf 0 0 0 rg ( ) Tj (n) Tj ( ) Tj .4 .4 .4 rg (==) Tj 0 0 0 rg ( ) Tj .4 .4 .4 rg (0) Tj 0 0 0 rg (:) Tj ( ) Tj /F3 10 Tf 0 .501961 0 rg (return) Tj /F4 10 Tf 0 0 0 rg ( ) Tj .4 .4 .4 rg (1) Tj 0 0 0 rg  T* (    ) Tj /F3 10 Tf 0 .501961 0 rg (return) Tj /F4 10 Tf 0 0 0 rg ( ) Tj (n) Tj ( ) Tj .4 .4 .4 rg (*) Tj 0 0 0 rg ( ) Tj (fact) Tj (\() Tj (n) Tj .4 .4 .4 rg (-) Tj (1) Tj 0 0 0 rg (\)) Tj T* ET
+.960784 .960784 .862745 rg
+n 0 36.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 24 36.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 48 36.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 54 36.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 60 36.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 84 36.75 168 12 re f*
+.960784 .960784 .862745 rg
+n 24 24.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 42 24.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 54 24.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 72 24.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 78 24.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 48 12.75 36 12 re f*
+.960784 .960784 .862745 rg
+n 90 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 24 .75 36 12 re f*
+.960784 .960784 .862745 rg
+n 66 .75 6 12 re f*
+.960784 .960784 .862745 rg
+n 78 .75 6 12 re f*
+.960784 .960784 .862745 rg
+n 90 .75 24 12 re f*
+.960784 .960784 .862745 rg
+n 114 .75 6 12 re f*
+.960784 .960784 .862745 rg
+n 120 .75 6 12 re f*
+.960784 .960784 .862745 rg
+n 126 .75 6 12 re f*
+.960784 .960784 .862745 rg
+n 132 .75 6 12 re f*
+.960784 .960784 .862745 rg
+n 138 .75 6 12 re f*
+BT 1 0 0 1 0 38 Tm 12 TL /F3 10 Tf 0 .501961 0 rg (def) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 1 rg (fact) Tj 0 0 0 rg (\() Tj 0 0 0 rg (n) Tj 0 0 0 rg (\):) Tj 0 0 0 rg (  ) Tj /F6 10 Tf .25098 .501961 .501961 rg (# this is not tail-recursive) Tj /F4 10 Tf 0 0 0 rg  T* (    ) Tj /F3 10 Tf 0 .501961 0 rg (if) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 0 rg (n) Tj 0 0 0 rg ( ) Tj .4 .4 .4 rg (==) Tj 0 0 0 rg ( ) Tj .4 .4 .4 rg (0) Tj 0 0 0 rg (:) Tj 0 0 0 rg  T* (        ) Tj /F3 10 Tf 0 .501961 0 rg (return) Tj /F4 10 Tf 0 0 0 rg ( ) Tj .4 .4 .4 rg (1) Tj 0 0 0 rg  T* (    ) Tj /F3 10 Tf 0 .501961 0 rg (return) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 0 rg (n) Tj 0 0 0 rg ( ) Tj .4 .4 .4 rg (*) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (fact) Tj 0 0 0 rg (\() Tj 0 0 0 rg (n) Tj .4 .4 .4 rg (-) Tj .4 .4 .4 rg (1) Tj 0 0 0 rg (\)) Tj T* ET
 Q
 Q
 Q
 Q
 Q
 q
-1 0 0 1 62.69291 227.0236 cm
+1 0 0 1 62.69291 143.0236 cm
 q
 0 0 0 rg
 BT 1 0 0 1 0 14 Tm /F1 10 Tf 12 TL .541098 Tw (\(reminder: a function is tail recursive if it either returns a value without making a recursive call, or returns) Tj T* 0 Tw (directly the result of a recursive call\).) Tj T* ET
 Q
 Q
 q
-1 0 0 1 62.69291 194.0236 cm
+1 0 0 1 62.69291 110.0236 cm
 q
 BT 1 0 0 1 0 3.5 Tm 21 TL /F2 17.5 Tf 0 0 0 rg (Caveats and limitations) Tj T* ET
 Q
 Q
 q
-1 0 0 1 62.69291 164.0236 cm
+1 0 0 1 62.69291 80.02362 cm
 q
 0 0 0 rg
 BT 1 0 0 1 0 14 Tm /F1 10 Tf 12 TL .474987 Tw (The first thing you should be aware of, it the fact that decorators have a performance penalty. The worse) Tj T* 0 Tw (case is shown by the following example:) Tj T* ET
 Q
 Q
-q
-1 0 0 1 62.69291 82.82362 cm
-q
-q
-1 0 0 1 0 0 cm
-q
-1 0 0 1 6.6 6.6 cm
-q
-.662745 .662745 .662745 RG
-.5 w
-.960784 .960784 .862745 rg
-n -6 -6 468.6898 72 re B*
-Q
-q
-0 0 0 rg
-BT 1 0 0 1 0 50 Tm /F4 10 Tf 12 TL ($ cat performance.sh) Tj T* (python -m timeit -s ") Tj T* (from decorator import decorator) Tj T*  T* (@decorator) Tj T* ET
-Q
-Q
-Q
-Q
-Q
  
 endstream
 endobj
-% 'R97': class PDFStream 
 97 0 obj
-% page stream
-<< /Length 6291 >>
+<< /Length 10417 >>
 stream
 1 0 0 1 0 0 cm  BT /F1 12 Tf 14.4 TL ET
 q
-1 0 0 1 62.69291 607.8236 cm
+1 0 0 1 62.69291 547.8236 cm
 q
 q
 1 0 0 1 0 0 cm
@@ -3345,24 +5524,24 @@ q
 .662745 .662745 .662745 RG
 .5 w
 .960784 .960784 .862745 rg
-n -6 -6 468.6898 156 re B*
+n -6 -6 468.6898 216 re B*
 Q
 q
 0 0 0 rg
-BT 1 0 0 1 0 134 Tm /F4 10 Tf 12 TL (def do_nothing\(func, *args, **kw\):) Tj T* (    return func\(*args, **kw\)) Tj T*  T* (@do_nothing) Tj T* (def f\(\):) Tj T* (    pass) Tj T* (" "f\(\)") Tj T*  T* (python -m timeit -s ") Tj T* (def f\(\):) Tj T* (    pass) Tj T* (" "f\(\)") Tj T* ET
+BT 1 0 0 1 0 194 Tm /F4 10 Tf 12 TL ($ cat performance.sh) Tj T* (python -m timeit -s ") Tj T* (from decorator import decorator) Tj T*  T* (@decorator) Tj T* (def do_nothing\(func, *args, **kw\):) Tj T* (    return func\(*args, **kw\)) Tj T*  T* (@do_nothing) Tj T* (def f\(\):) Tj T* (    pass) Tj T* (" "f\(\)") Tj T*  T* (python -m timeit -s ") Tj T* (def f\(\):) Tj T* (    pass) Tj T* (" "f\(\)") Tj T* ET
 Q
 Q
 Q
 Q
 Q
 q
-1 0 0 1 62.69291 575.8236 cm
+1 0 0 1 62.69291 515.8236 cm
 q
-BT 1 0 0 1 0 14 Tm .266235 Tw 12 TL /F1 10 Tf 0 0 0 rg (On my MacBook, using the ) Tj /F4 10 Tf (do_nothing ) Tj /F1 10 Tf (decorator instead of the plain function is more than three times) Tj T* 0 Tw (slower:) Tj T* ET
+BT 1 0 0 1 0 14 Tm .266235 Tw 12 TL /F1 10 Tf 0 0 0 rg (On my MacBook, using the ) Tj /F4 10 Tf 0 0 0 rg (do_nothing ) Tj /F1 10 Tf 0 0 0 rg (decorator instead of the plain function is more than three times) Tj T* 0 Tw (slower:) Tj T* ET
 Q
 Q
 q
-1 0 0 1 62.69291 518.6236 cm
+1 0 0 1 62.69291 458.6236 cm
 q
 q
 1 0 0 1 0 0 cm
@@ -3383,20 +5562,20 @@ Q
 Q
 Q
 q
-1 0 0 1 62.69291 474.6236 cm
+1 0 0 1 62.69291 414.6236 cm
 q
-BT 1 0 0 1 0 26 Tm 1.25832 Tw 12 TL /F1 10 Tf 0 0 0 rg (It should be noted that a real life function would probably do something more useful than ) Tj /F4 10 Tf (f ) Tj /F1 10 Tf (here, and) Tj T* 0 Tw .91811 Tw (therefore in real life the performance penalty could be completely negligible. As always, the only way to) Tj T* 0 Tw (know if there is a penalty in your specific use case is to measure it.) Tj T* ET
+BT 1 0 0 1 0 26 Tm 1.25832 Tw 12 TL /F1 10 Tf 0 0 0 rg (It should be noted that a real life function would probably do something more useful than ) Tj /F4 10 Tf 0 0 0 rg (f ) Tj /F1 10 Tf 0 0 0 rg (here, and) Tj T* 0 Tw .91811 Tw (therefore in real life the performance penalty could be completely negligible. As always, the only way to) Tj T* 0 Tw (know if there is a penalty in your specific use case is to measure it.) Tj T* ET
 Q
 Q
 q
-1 0 0 1 62.69291 444.6236 cm
+1 0 0 1 62.69291 384.6236 cm
 q
 0 0 0 rg
 BT 1 0 0 1 0 14 Tm /F1 10 Tf 12 TL .867984 Tw (You should be aware that decorators will make your tracebacks longer and more difficult to understand.) Tj T* 0 Tw (Consider this example:) Tj T* ET
 Q
 Q
 q
-1 0 0 1 62.69291 387.4236 cm
+1 0 0 1 62.69291 327.4236 cm
 q
 q
 1 0 0 1 0 0 cm
@@ -3409,20 +5588,44 @@ q
 n -6 -6 468.6898 48 re B*
 Q
 q
-BT 1 0 0 1 0 26 Tm 12 TL /F4 10 Tf .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj .666667 .133333 1 rg (@trace) Tj 0 0 0 rg  T* .4 .4 .4 rg (...) Tj 0 0 0 rg ( ) Tj /F3 10 Tf 0 .501961 0 rg (def) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 1 rg (f) Tj 0 0 0 rg (\(\):) Tj  T* .4 .4 .4 rg (...) Tj 0 0 0 rg (     ) Tj .4 .4 .4 rg (1) Tj (/) Tj (0) Tj T* ET
+.960784 .960784 .862745 rg
+n 0 24.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 6 24.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 12 24.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 24 24.75 36 12 re f*
+.960784 .960784 .862745 rg
+n 0 12.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 24 12.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 48 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 54 12.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 0 .75 18 12 re f*
+.960784 .960784 .862745 rg
+n 48 .75 6 12 re f*
+.960784 .960784 .862745 rg
+n 54 .75 6 12 re f*
+.960784 .960784 .862745 rg
+n 60 .75 6 12 re f*
+BT 1 0 0 1 0 26 Tm 12 TL /F4 10 Tf .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj .666667 .133333 1 rg (@trace) Tj 0 0 0 rg  T* .4 .4 .4 rg (...) Tj 0 0 0 rg ( ) Tj /F3 10 Tf 0 .501961 0 rg (def) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 1 rg (f) Tj 0 0 0 rg (\(\):) Tj 0 0 0 rg  T* .4 .4 .4 rg (...) Tj 0 0 0 rg (     ) Tj .4 .4 .4 rg (1) Tj .4 .4 .4 rg (/) Tj .4 .4 .4 rg (0) Tj T* ET
 Q
 Q
 Q
 Q
 Q
 q
-1 0 0 1 62.69291 355.4236 cm
+1 0 0 1 62.69291 295.4236 cm
 q
-BT 1 0 0 1 0 14 Tm .583318 Tw 12 TL /F1 10 Tf 0 0 0 rg (Calling ) Tj /F4 10 Tf (f\(\) ) Tj /F1 10 Tf (will give you a ) Tj /F4 10 Tf (ZeroDivisionError) Tj /F1 10 Tf (, but since the function is decorated the traceback will) Tj T* 0 Tw (be longer:) Tj T* ET
+BT 1 0 0 1 0 14 Tm .583318 Tw 12 TL /F1 10 Tf 0 0 0 rg (Calling ) Tj /F4 10 Tf 0 0 0 rg (f\(\) ) Tj /F1 10 Tf 0 0 0 rg (will give you a ) Tj /F4 10 Tf 0 0 0 rg (ZeroDivisionError) Tj /F1 10 Tf 0 0 0 rg (, but since the function is decorated the traceback will) Tj T* 0 Tw (be longer:) Tj T* ET
 Q
 Q
 q
-1 0 0 1 62.69291 226.2236 cm
+1 0 0 1 62.69291 166.2236 cm
 q
 q
 1 0 0 1 0 0 cm
@@ -3435,41 +5638,177 @@ q
 n -6 -6 468.6898 120 re B*
 Q
 q
-BT 1 0 0 1 0 98 Tm 12 TL /F4 10 Tf .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj (f) Tj (\(\)) Tj  T* (Traceback) Tj ( ) Tj (\() Tj (most) Tj ( ) Tj (recent) Tj ( ) Tj (call) Tj ( ) Tj (last) Tj (\):) Tj  T* (  ) Tj .4 .4 .4 rg (...) Tj 0 0 0 rg  T* (     ) Tj (File) Tj ( ) Tj .729412 .129412 .129412 rg (") Tj (<) Tj (string) Tj (>) Tj (") Tj 0 0 0 rg (,) Tj ( ) Tj (line) Tj ( ) Tj .4 .4 .4 rg (2) Tj 0 0 0 rg (,) Tj ( ) Tj /F3 10 Tf .666667 .133333 1 rg (in) Tj /F4 10 Tf 0 0 0 rg ( ) Tj (f) Tj  T* (     ) Tj (File) Tj ( ) Tj .729412 .129412 .129412 rg (") Tj (<) Tj (doctest __main__[18]) Tj (>) Tj (") Tj 0 0 0 rg (,) Tj ( ) Tj (line) Tj ( ) Tj .4 .4 .4 rg (4) Tj 0 0 0 rg (,) Tj ( ) Tj /F3 10 Tf .666667 .133333 1 rg (in) Tj /F4 10 Tf 0 0 0 rg ( ) Tj (trace) Tj  T* (       ) Tj /F3 10 Tf 0 .501961 0 rg (return) Tj /F4 10 Tf 0 0 0 rg ( ) Tj (f) Tj (\() Tj .4 .4 .4 rg (*) Tj 0 0 0 rg (args) Tj (,) Tj ( ) Tj .4 .4 .4 rg (**) Tj 0 0 0 rg (kw) Tj (\)) Tj  T* (     ) Tj (File) Tj ( ) Tj .729412 .129412 .129412 rg (") Tj (<) Tj (doctest __main__[47]) Tj (>) Tj (") Tj 0 0 0 rg (,) Tj ( ) Tj (line) Tj ( ) Tj .4 .4 .4 rg (3) Tj 0 0 0 rg (,) Tj ( ) Tj /F3 10 Tf .666667 .133333 1 rg (in) Tj /F4 10 Tf 0 0 0 rg ( ) Tj (f) Tj  T* (       ) Tj .4 .4 .4 rg (1) Tj (/) Tj (0) Tj 0 0 0 rg  T* /F3 10 Tf .823529 .254902 .227451 rg (ZeroDivisionError) Tj /F4 10 Tf 0 0 0 rg (:) Tj ( ) Tj (integer) Tj ( ) Tj (division) Tj ( ) Tj /F3 10 Tf .666667 .133333 1 rg (or) Tj /F4 10 Tf 0 0 0 rg ( ) Tj (modulo) Tj ( ) Tj (by) Tj ( ) Tj (zero) Tj T* ET
-Q
-Q
+.960784 .960784 .862745 rg
+n 0 96.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 6 96.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 12 96.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 24 96.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 30 96.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 0 84.75 54 12 re f*
+.960784 .960784 .862745 rg
+n 60 84.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 66 84.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 96 84.75 36 12 re f*
+.960784 .960784 .862745 rg
+n 138 84.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 168 84.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 192 84.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 12 72.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 30 60.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 60 60.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 66 60.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 72 60.75 36 12 re f*
+.960784 .960784 .862745 rg
+n 108 60.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 114 60.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 120 60.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 132 60.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 162 60.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 168 60.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 180 60.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 198 60.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 30 48.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 60 48.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 66 48.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 72 48.75 120 12 re f*
+.960784 .960784 .862745 rg
+n 192 48.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 198 48.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 204 48.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 216 48.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 246 48.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 252 48.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 264 48.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 282 48.75 30 12 re f*
+.960784 .960784 .862745 rg
+n 42 36.75 36 12 re f*
+.960784 .960784 .862745 rg
+n 84 36.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 90 36.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 96 36.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 102 36.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 126 36.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 138 36.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 150 36.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 162 36.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 30 24.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 60 24.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 66 24.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 72 24.75 120 12 re f*
+.960784 .960784 .862745 rg
+n 192 24.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 198 24.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 204 24.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 216 24.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 246 24.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 252 24.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 264 24.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 282 24.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 42 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 48 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 54 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 0 .75 102 12 re f*
+.960784 .960784 .862745 rg
+n 102 .75 6 12 re f*
+.960784 .960784 .862745 rg
+n 114 .75 42 12 re f*
+.960784 .960784 .862745 rg
+n 162 .75 48 12 re f*
+.960784 .960784 .862745 rg
+n 216 .75 12 12 re f*
+.960784 .960784 .862745 rg
+n 234 .75 36 12 re f*
+.960784 .960784 .862745 rg
+n 276 .75 12 12 re f*
+.960784 .960784 .862745 rg
+n 294 .75 24 12 re f*
+BT 1 0 0 1 0 98 Tm 12 TL /F4 10 Tf .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (f) Tj 0 0 0 rg (\(\)) Tj 0 0 0 rg  T* 0 0 0 rg (Traceback) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (\() Tj 0 0 0 rg (most) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (recent) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (call) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (last) Tj 0 0 0 rg (\):) Tj 0 0 0 rg  T* (  ) Tj .4 .4 .4 rg (...) Tj 0 0 0 rg  T* (     ) Tj 0 0 0 rg (File) Tj 0 0 0 rg ( ) Tj .729412 .129412 .129412 rg (") Tj (<) Tj (string) Tj (>) Tj (") Tj 0 0 0 rg (,) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (line) Tj 0 0 0 rg ( ) Tj .4 .4 .4 rg (2) Tj 0 0 0 rg (,) Tj 0 0 0 rg ( ) Tj /F3 10 Tf .666667 .133333 1 rg (in) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 0 rg (f) Tj 0 0 0 rg  T* (     ) Tj 0 0 0 rg (File) Tj 0 0 0 rg ( ) Tj .729412 .129412 .129412 rg (") Tj (<) Tj (doctest __main__[18]) Tj (>) Tj (") Tj 0 0 0 rg (,) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (line) Tj 0 0 0 rg ( ) Tj .4 .4 .4 rg (4) Tj 0 0 0 rg (,) Tj 0 0 0 rg ( ) Tj /F3 10 Tf .666667 .133333 1 rg (in) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 0 rg (trace) Tj 0 0 0 rg  T* (       ) Tj /F3 10 Tf 0 .501961 0 rg (return) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 0 rg (f) Tj 0 0 0 rg (\() Tj .4 .4 .4 rg (*) Tj 0 0 0 rg (args) Tj 0 0 0 rg (,) Tj 0 0 0 rg ( ) Tj .4 .4 .4 rg (**) Tj 0 0 0 rg (kw) Tj 0 0 0 rg (\)) Tj 0 0 0 rg  T* (     ) Tj 0 0 0 rg (File) Tj 0 0 0 rg ( ) Tj .729412 .129412 .129412 rg (") Tj (<) Tj (doctest __main__[47]) Tj (>) Tj (") Tj 0 0 0 rg (,) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (line) Tj 0 0 0 rg ( ) Tj .4 .4 .4 rg (3) Tj 0 0 0 rg (,) Tj 0 0 0 rg ( ) Tj /F3 10 Tf .666667 .133333 1 rg (in) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 0 rg (f) Tj 0 0 0 rg  T* (       ) Tj .4 .4 .4 rg (1) Tj .4 .4 .4 rg (/) Tj .4 .4 .4 rg (0) Tj 0 0 0 rg  T* /F3 10 Tf .823529 .254902 .227451 rg (ZeroDivisionError) Tj /F4 10 Tf 0 0 0 rg (:) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (integer) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (division) Tj 0 0 0 rg ( ) Tj /F3 10 Tf .666667 .133333 1 rg (or) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 0 rg (modulo) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (by) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (zero) Tj T* ET
 Q
 Q
 Q
-q
-1 0 0 1 62.69291 158.2236 cm
-q
-BT 1 0 0 1 0 50 Tm 1.05528 Tw 12 TL /F1 10 Tf 0 0 0 rg (You see here the inner call to the decorator ) Tj /F4 10 Tf (trace) Tj /F1 10 Tf (, which calls ) Tj /F4 10 Tf (f\(*args,) Tj ( ) Tj (**kw\)) Tj /F1 10 Tf (, and a reference to) Tj T* 0 Tw .076457 Tw /F4 10 Tf (File) Tj ( ) Tj (") Tj (<) Tj (string) Tj (>) Tj (",) Tj ( ) Tj (line) Tj ( ) Tj (2,) Tj ( ) Tj (in) Tj ( ) Tj (f) Tj /F1 10 Tf (. This latter reference is due to the fact that internally the decorator) Tj T* 0 Tw 2.053318 Tw (module uses ) Tj /F4 10 Tf (exec ) Tj /F1 10 Tf (to generate the decorated function. Notice that ) Tj /F4 10 Tf (exec ) Tj /F1 10 Tf (is ) Tj /F5 10 Tf (not ) Tj /F1 10 Tf (responsibile for the) Tj T* 0 Tw 1.507485 Tw (performance penalty, since is the called ) Tj /F5 10 Tf (only once ) Tj /F1 10 Tf (at function decoration time, and not every time the) Tj T* 0 Tw (decorated function is called.) Tj T* ET
 Q
 Q
 q
-1 0 0 1 62.69291 80.22362 cm
+1 0 0 1 62.69291 98.22362 cm
 q
-BT 1 0 0 1 0 62 Tm .932209 Tw 12 TL /F1 10 Tf 0 0 0 rg (At present, there is no clean way to avoid ) Tj /F4 10 Tf (exec) Tj /F1 10 Tf (. A clean solution would require to change the CPython) Tj T* 0 Tw .777485 Tw (implementation of functions and add an hook to make it possible to change their signature directly. That) Tj T* 0 Tw .74186 Tw (could happen in future versions of Python \(see PEP ) Tj 0 0 .501961 rg (362) Tj 0 0 0 rg (\) and then the decorator module would become) Tj T* 0 Tw 2.385318 Tw (obsolete. However, at present, even in Python 3.1 it is impossible to change the function signature) Tj T* 0 Tw .931751 Tw (directly, therefore the ) Tj /F4 10 Tf (decorator ) Tj /F1 10 Tf (module is still useful. Actually, this is one of the main reasons why I) Tj T* 0 Tw (keep maintaining the module and releasing new versions.) Tj T* ET
+BT 1 0 0 1 0 50 Tm 1.05528 Tw 12 TL /F1 10 Tf 0 0 0 rg (You see here the inner call to the decorator ) Tj /F4 10 Tf 0 0 0 rg (trace) Tj /F1 10 Tf 0 0 0 rg (, which calls ) Tj /F4 10 Tf 0 0 0 rg (f\(*args,) Tj ( ) Tj (**kw\)) Tj /F1 10 Tf 0 0 0 rg (, and a reference to) Tj T* 0 Tw .076457 Tw /F4 10 Tf 0 0 0 rg (File) Tj ( ) Tj (") Tj (<) Tj (string) Tj (>) Tj (",) Tj ( ) Tj (line) Tj ( ) Tj (2,) Tj ( ) Tj (in) Tj ( ) Tj (f) Tj /F1 10 Tf 0 0 0 rg (. This latter reference is due to the fact that internally the decorator) Tj T* 0 Tw 2.053318 Tw (module uses ) Tj /F4 10 Tf 0 0 0 rg (exec ) Tj /F1 10 Tf 0 0 0 rg (to generate the decorated function. Notice that ) Tj /F4 10 Tf 0 0 0 rg (exec ) Tj /F1 10 Tf 0 0 0 rg (is ) Tj /F5 10 Tf (not ) Tj /F1 10 Tf (responsibile for the) Tj T* 0 Tw 1.507485 Tw (performance penalty, since is the called ) Tj /F5 10 Tf (only once ) Tj /F1 10 Tf (at function decoration time, and not every time the) Tj T* 0 Tw (decorated function is called.) Tj T* ET
 Q
 Q
  
 endstream
 endobj
-% 'R98': class PDFStream 
 98 0 obj
-% page stream
-<< /Length 8028 >>
+<< /Length 17481 >>
 stream
 1 0 0 1 0 0 cm  BT /F1 12 Tf 14.4 TL ET
 q
-1 0 0 1 62.69291 705.0236 cm
+1 0 0 1 62.69291 693.0236 cm
+q
+BT 1 0 0 1 0 62 Tm .932209 Tw 12 TL /F1 10 Tf 0 0 0 rg (At present, there is no clean way to avoid ) Tj /F4 10 Tf 0 0 0 rg (exec) Tj /F1 10 Tf 0 0 0 rg (. A clean solution would require to change the CPython) Tj T* 0 Tw .777485 Tw (implementation of functions and add an hook to make it possible to change their signature directly. That) Tj T* 0 Tw .74186 Tw (could happen in future versions of Python \(see PEP ) Tj 0 0 .501961 rg (362) Tj 0 0 0 rg (\) and then the decorator module would become) Tj T* 0 Tw 2.385318 Tw (obsolete. However, at present, even in Python 3.1 it is impossible to change the function signature) Tj T* 0 Tw .931751 Tw (directly, therefore the ) Tj /F4 10 Tf 0 0 0 rg (decorator ) Tj /F1 10 Tf 0 0 0 rg (module is still useful. Actually, this is one of the main reasons why I) Tj T* 0 Tw (keep maintaining the module and releasing new versions.) Tj T* ET
+Q
+Q
+q
+1 0 0 1 62.69291 627.0236 cm
 q
-BT 1 0 0 1 0 50 Tm 1.043828 Tw 12 TL /F1 10 Tf 0 0 0 rg (In the present implementation, decorators generated by ) Tj /F4 10 Tf (decorator ) Tj /F1 10 Tf (can only be used on user-defined) Tj T* 0 Tw .152485 Tw (Python functions or methods, not on generic callable objects, nor on built-in functions, due to limitations of) Tj T* 0 Tw .591235 Tw (the ) Tj /F4 10 Tf (inspect ) Tj /F1 10 Tf (module in the standard library. Moreover, notice that you can decorate a method, but only) Tj T* 0 Tw 2.693516 Tw (before if becomes a bound or unbound method, i.e. inside the class. Here is an example of valid) Tj T* 0 Tw (decoration:) Tj T* ET
+BT 1 0 0 1 0 50 Tm 1.043828 Tw 12 TL /F1 10 Tf 0 0 0 rg (In the present implementation, decorators generated by ) Tj /F4 10 Tf 0 0 0 rg (decorator ) Tj /F1 10 Tf 0 0 0 rg (can only be used on user-defined) Tj T* 0 Tw .152485 Tw (Python functions or methods, not on generic callable objects, nor on built-in functions, due to limitations of) Tj T* 0 Tw .591235 Tw (the ) Tj /F4 10 Tf 0 0 0 rg (inspect ) Tj /F1 10 Tf 0 0 0 rg (module in the standard library. Moreover, notice that you can decorate a method, but only) Tj T* 0 Tw 2.693516 Tw (before if becomes a bound or unbound method, i.e. inside the class. Here is an example of valid) Tj T* 0 Tw (decoration:) Tj T* ET
 Q
 Q
 q
-1 0 0 1 62.69291 635.8236 cm
+1 0 0 1 62.69291 557.8236 cm
 q
 q
 1 0 0 1 0 0 cm
@@ -3482,21 +5821,57 @@ q
 n -6 -6 468.6898 60 re B*
 Q
 q
-BT 1 0 0 1 0 38 Tm 12 TL /F4 10 Tf .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj /F3 10 Tf 0 .501961 0 rg (class) Tj /F4 10 Tf 0 0 0 rg ( ) Tj /F3 10 Tf 0 0 1 rg (C) Tj /F4 10 Tf 0 0 0 rg (\() Tj 0 .501961 0 rg (object) Tj 0 0 0 rg (\):) Tj  T* .4 .4 .4 rg (...) Tj 0 0 0 rg (      ) Tj .666667 .133333 1 rg (@trace) Tj 0 0 0 rg  T* .4 .4 .4 rg (...) Tj 0 0 0 rg (      ) Tj /F3 10 Tf 0 .501961 0 rg (def) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 1 rg (meth) Tj 0 0 0 rg (\() Tj 0 .501961 0 rg (self) Tj 0 0 0 rg (\):) Tj  T* .4 .4 .4 rg (...) Tj 0 0 0 rg (          ) Tj /F3 10 Tf 0 .501961 0 rg (pass) Tj T* ET
+.960784 .960784 .862745 rg
+n 0 36.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 6 36.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 12 36.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 24 36.75 30 12 re f*
+.960784 .960784 .862745 rg
+n 60 36.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 66 36.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 72 36.75 36 12 re f*
+.960784 .960784 .862745 rg
+n 108 36.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 0 24.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 54 24.75 36 12 re f*
+.960784 .960784 .862745 rg
+n 0 12.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 54 12.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 78 12.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 102 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 108 12.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 132 12.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 0 .75 18 12 re f*
+.960784 .960784 .862745 rg
+n 78 .75 24 12 re f*
+BT 1 0 0 1 0 38 Tm 12 TL /F4 10 Tf .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj /F3 10 Tf 0 .501961 0 rg (class) Tj /F4 10 Tf 0 0 0 rg ( ) Tj /F3 10 Tf 0 0 1 rg (C) Tj /F4 10 Tf 0 0 0 rg (\() Tj 0 .501961 0 rg (object) Tj 0 0 0 rg (\):) Tj 0 0 0 rg  T* .4 .4 .4 rg (...) Tj 0 0 0 rg (      ) Tj .666667 .133333 1 rg (@trace) Tj 0 0 0 rg  T* .4 .4 .4 rg (...) Tj 0 0 0 rg (      ) Tj /F3 10 Tf 0 .501961 0 rg (def) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 1 rg (meth) Tj 0 0 0 rg (\() Tj 0 .501961 0 rg (self) Tj 0 0 0 rg (\):) Tj 0 0 0 rg  T* .4 .4 .4 rg (...) Tj 0 0 0 rg (          ) Tj /F3 10 Tf 0 .501961 0 rg (pass) Tj T* ET
 Q
 Q
 Q
 Q
 Q
 q
-1 0 0 1 62.69291 615.8236 cm
+1 0 0 1 62.69291 537.8236 cm
 q
 0 0 0 rg
 BT 1 0 0 1 0 2 Tm /F1 10 Tf 12 TL (Here is an example of invalid decoration, when the decorator in called too late:) Tj T* ET
 Q
 Q
 q
-1 0 0 1 62.69291 498.6236 cm
+1 0 0 1 62.69291 420.6236 cm
 q
 q
 1 0 0 1 0 0 cm
@@ -3509,21 +5884,121 @@ q
 n -6 -6 468.6898 108 re B*
 Q
 q
-BT 1 0 0 1 0 86 Tm 12 TL /F4 10 Tf .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj /F3 10 Tf 0 .501961 0 rg (class) Tj /F4 10 Tf 0 0 0 rg ( ) Tj /F3 10 Tf 0 0 1 rg (C) Tj /F4 10 Tf 0 0 0 rg (\() Tj 0 .501961 0 rg (object) Tj 0 0 0 rg (\):) Tj  T* .4 .4 .4 rg (...) Tj 0 0 0 rg (      ) Tj /F3 10 Tf 0 .501961 0 rg (def) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 1 rg (meth) Tj 0 0 0 rg (\() Tj 0 .501961 0 rg (self) Tj 0 0 0 rg (\):) Tj  T* .4 .4 .4 rg (...) Tj 0 0 0 rg (          ) Tj /F3 10 Tf 0 .501961 0 rg (pass) Tj /F4 10 Tf 0 0 0 rg  T* .4 .4 .4 rg (...) Tj 0 0 0 rg  T* .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj (trace) Tj (\() Tj (C) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (meth) Tj (\)) Tj  T* (Traceback) Tj ( ) Tj (\() Tj (most) Tj ( ) Tj (recent) Tj ( ) Tj (call) Tj ( ) Tj (last) Tj (\):) Tj  T* (  ) Tj .4 .4 .4 rg (...) Tj 0 0 0 rg  T* /F3 10 Tf .823529 .254902 .227451 rg (TypeError) Tj /F4 10 Tf 0 0 0 rg (:) Tj ( ) Tj (You) Tj ( ) Tj (are) Tj ( ) Tj (decorating) Tj ( ) Tj (a) Tj ( ) Tj (non) Tj ( ) Tj (function) Tj (:) Tj ( ) Tj .4 .4 .4 rg (<) Tj 0 0 0 rg (unbound) Tj ( ) Tj (method) Tj ( ) Tj (C) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (meth) Tj .4 .4 .4 rg (>) Tj T* ET
+.960784 .960784 .862745 rg
+n 0 84.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 6 84.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 12 84.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 24 84.75 30 12 re f*
+.960784 .960784 .862745 rg
+n 60 84.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 66 84.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 72 84.75 36 12 re f*
+.960784 .960784 .862745 rg
+n 108 84.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 0 72.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 54 72.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 78 72.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 102 72.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 108 72.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 132 72.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 0 60.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 78 60.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 0 48.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 0 36.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 6 36.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 12 36.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 24 36.75 30 12 re f*
+.960784 .960784 .862745 rg
+n 54 36.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 60 36.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 66 36.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 72 36.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 96 36.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 0 24.75 54 12 re f*
+.960784 .960784 .862745 rg
+n 60 24.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 66 24.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 96 24.75 36 12 re f*
+.960784 .960784 .862745 rg
+n 138 24.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 168 24.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 192 24.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 12 12.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 0 .75 54 12 re f*
+.960784 .960784 .862745 rg
+n 54 .75 6 12 re f*
+.960784 .960784 .862745 rg
+n 66 .75 18 12 re f*
+.960784 .960784 .862745 rg
+n 90 .75 18 12 re f*
+.960784 .960784 .862745 rg
+n 114 .75 60 12 re f*
+.960784 .960784 .862745 rg
+n 180 .75 6 12 re f*
+.960784 .960784 .862745 rg
+n 192 .75 18 12 re f*
+.960784 .960784 .862745 rg
+n 216 .75 48 12 re f*
+.960784 .960784 .862745 rg
+n 264 .75 6 12 re f*
+.960784 .960784 .862745 rg
+n 276 .75 6 12 re f*
+.960784 .960784 .862745 rg
+n 282 .75 42 12 re f*
+.960784 .960784 .862745 rg
+n 330 .75 36 12 re f*
+.960784 .960784 .862745 rg
+n 372 .75 6 12 re f*
+.960784 .960784 .862745 rg
+n 378 .75 6 12 re f*
+.960784 .960784 .862745 rg
+n 384 .75 24 12 re f*
+.960784 .960784 .862745 rg
+n 408 .75 6 12 re f*
+BT 1 0 0 1 0 86 Tm 12 TL /F4 10 Tf .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj /F3 10 Tf 0 .501961 0 rg (class) Tj /F4 10 Tf 0 0 0 rg ( ) Tj /F3 10 Tf 0 0 1 rg (C) Tj /F4 10 Tf 0 0 0 rg (\() Tj 0 .501961 0 rg (object) Tj 0 0 0 rg (\):) Tj 0 0 0 rg  T* .4 .4 .4 rg (...) Tj 0 0 0 rg (      ) Tj /F3 10 Tf 0 .501961 0 rg (def) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 1 rg (meth) Tj 0 0 0 rg (\() Tj 0 .501961 0 rg (self) Tj 0 0 0 rg (\):) Tj 0 0 0 rg  T* .4 .4 .4 rg (...) Tj 0 0 0 rg (          ) Tj /F3 10 Tf 0 .501961 0 rg (pass) Tj /F4 10 Tf 0 0 0 rg  T* .4 .4 .4 rg (...) Tj 0 0 0 rg  T* .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (trace) Tj 0 0 0 rg (\() Tj 0 0 0 rg (C) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (meth) Tj 0 0 0 rg (\)) Tj 0 0 0 rg  T* 0 0 0 rg (Traceback) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (\() Tj 0 0 0 rg (most) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (recent) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (call) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (last) Tj 0 0 0 rg (\):) Tj 0 0 0 rg  T* (  ) Tj .4 .4 .4 rg (...) Tj 0 0 0 rg  T* /F3 10 Tf .823529 .254902 .227451 rg (TypeError) Tj /F4 10 Tf 0 0 0 rg (:) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (You) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (are) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (decorating) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (a) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (non) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (function) Tj 0 0 0 rg (:) Tj 0 0 0 rg ( ) Tj .4 .4 .4 rg (<) Tj 0 0 0 rg (unbound) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (method) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (C) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (meth) Tj .4 .4 .4 rg (>) Tj T* ET
 Q
 Q
 Q
 Q
 Q
 q
-1 0 0 1 62.69291 478.6236 cm
+1 0 0 1 62.69291 400.6236 cm
 q
 0 0 0 rg
 BT 1 0 0 1 0 2 Tm /F1 10 Tf 12 TL (The solution is to extract the inner function from the unbound method:) Tj T* ET
 Q
 Q
 q
-1 0 0 1 62.69291 433.4236 cm
+1 0 0 1 62.69291 355.4236 cm
 q
 q
 1 0 0 1 0 0 cm
@@ -3536,20 +6011,58 @@ q
 n -6 -6 468.6898 36 re B*
 Q
 q
-BT 1 0 0 1 0 14 Tm 12 TL /F4 10 Tf .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj (trace) Tj (\() Tj (C) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (meth) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (im_func) Tj (\)) Tj  T* .4 .4 .4 rg (<) Tj 0 0 0 rg (function) Tj ( ) Tj (meth) Tj ( ) Tj (at) Tj ( ) Tj .4 .4 .4 rg (0) Tj 0 0 0 rg (x) Tj .4 .4 .4 rg (...) Tj (>) Tj T* ET
+.960784 .960784 .862745 rg
+n 0 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 6 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 12 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 24 12.75 30 12 re f*
+.960784 .960784 .862745 rg
+n 54 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 60 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 66 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 72 12.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 96 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 102 12.75 42 12 re f*
+.960784 .960784 .862745 rg
+n 144 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 0 .75 6 12 re f*
+.960784 .960784 .862745 rg
+n 6 .75 48 12 re f*
+.960784 .960784 .862745 rg
+n 60 .75 24 12 re f*
+.960784 .960784 .862745 rg
+n 90 .75 12 12 re f*
+.960784 .960784 .862745 rg
+n 108 .75 6 12 re f*
+.960784 .960784 .862745 rg
+n 114 .75 6 12 re f*
+.960784 .960784 .862745 rg
+n 120 .75 18 12 re f*
+.960784 .960784 .862745 rg
+n 138 .75 6 12 re f*
+BT 1 0 0 1 0 14 Tm 12 TL /F4 10 Tf .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (trace) Tj 0 0 0 rg (\() Tj 0 0 0 rg (C) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (meth) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (im_func) Tj 0 0 0 rg (\)) Tj 0 0 0 rg  T* .4 .4 .4 rg (<) Tj 0 0 0 rg (function) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (meth) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (at) Tj 0 0 0 rg ( ) Tj .4 .4 .4 rg (0) Tj 0 0 0 rg (x) Tj .4 .4 .4 rg (...) Tj (>) Tj T* ET
 Q
 Q
 Q
 Q
 Q
 q
-1 0 0 1 62.69291 401.4236 cm
+1 0 0 1 62.69291 323.4236 cm
 q
-BT 1 0 0 1 0 14 Tm .785777 Tw 12 TL /F1 10 Tf 0 0 0 rg (There is a restriction on the names of the arguments: for instance, if try to call an argument ) Tj /F4 10 Tf (_call_ ) Tj /F1 10 Tf (or) Tj T* 0 Tw /F4 10 Tf (_func_ ) Tj /F1 10 Tf (you will get a ) Tj /F4 10 Tf (NameError) Tj /F1 10 Tf (:) Tj T* ET
+BT 1 0 0 1 0 14 Tm .785777 Tw 12 TL /F1 10 Tf 0 0 0 rg (There is a restriction on the names of the arguments: for instance, if try to call an argument ) Tj /F4 10 Tf 0 0 0 rg (_call_ ) Tj /F1 10 Tf 0 0 0 rg (or) Tj T* 0 Tw /F4 10 Tf 0 0 0 rg (_func_ ) Tj /F1 10 Tf 0 0 0 rg (you will get a ) Tj /F4 10 Tf 0 0 0 rg (NameError) Tj /F1 10 Tf 0 0 0 rg (:) Tj T* ET
 Q
 Q
 q
-1 0 0 1 62.69291 284.2236 cm
+1 0 0 1 62.69291 206.2236 cm
 q
 q
 1 0 0 1 0 0 cm
@@ -3562,20 +6075,98 @@ q
 n -6 -6 468.6898 108 re B*
 Q
 q
-BT 1 0 0 1 0 86 Tm 12 TL /F4 10 Tf .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj .666667 .133333 1 rg (@trace) Tj 0 0 0 rg  T* .4 .4 .4 rg (...) Tj 0 0 0 rg ( ) Tj /F3 10 Tf 0 .501961 0 rg (def) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 1 rg (f) Tj 0 0 0 rg (\() Tj (_func_) Tj (\):) Tj ( ) Tj /F3 10 Tf 0 .501961 0 rg (print) Tj /F4 10 Tf 0 0 0 rg ( ) Tj (f) Tj  T* .4 .4 .4 rg (...) Tj 0 0 0 rg  T* (Traceback) Tj ( ) Tj (\() Tj (most) Tj ( ) Tj (recent) Tj ( ) Tj (call) Tj ( ) Tj (last) Tj (\):) Tj  T* (  ) Tj .4 .4 .4 rg (...) Tj 0 0 0 rg  T* /F3 10 Tf .823529 .254902 .227451 rg (NameError) Tj /F4 10 Tf 0 0 0 rg (:) Tj ( ) Tj (_func_) Tj ( ) Tj /F3 10 Tf .666667 .133333 1 rg (is) Tj /F4 10 Tf 0 0 0 rg ( ) Tj (overridden) Tj ( ) Tj /F3 10 Tf .666667 .133333 1 rg (in) Tj /F4 10 Tf 0 0 0 rg  T* /F3 10 Tf 0 .501961 0 rg (def) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 1 rg (f) Tj 0 0 0 rg (\() Tj (_func_) Tj (\):) Tj  T* (    ) Tj /F3 10 Tf 0 .501961 0 rg (return) Tj /F4 10 Tf 0 0 0 rg ( ) Tj (_call_) Tj (\() Tj (_func_) Tj (,) Tj ( ) Tj (_func_) Tj (\)) Tj T* ET
+.960784 .960784 .862745 rg
+n 0 84.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 6 84.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 12 84.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 24 84.75 36 12 re f*
+.960784 .960784 .862745 rg
+n 0 72.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 24 72.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 48 72.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 54 72.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 60 72.75 36 12 re f*
+.960784 .960784 .862745 rg
+n 96 72.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 114 72.75 30 12 re f*
+.960784 .960784 .862745 rg
+n 150 72.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 0 60.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 0 48.75 54 12 re f*
+.960784 .960784 .862745 rg
+n 60 48.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 66 48.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 96 48.75 36 12 re f*
+.960784 .960784 .862745 rg
+n 138 48.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 168 48.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 192 48.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 12 36.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 0 24.75 54 12 re f*
+.960784 .960784 .862745 rg
+n 54 24.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 66 24.75 36 12 re f*
+.960784 .960784 .862745 rg
+n 108 24.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 126 24.75 60 12 re f*
+.960784 .960784 .862745 rg
+n 192 24.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 0 12.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 24 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 30 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 36 12.75 36 12 re f*
+.960784 .960784 .862745 rg
+n 72 12.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 24 .75 36 12 re f*
+.960784 .960784 .862745 rg
+n 66 .75 36 12 re f*
+.960784 .960784 .862745 rg
+n 102 .75 6 12 re f*
+.960784 .960784 .862745 rg
+n 108 .75 36 12 re f*
+.960784 .960784 .862745 rg
+n 144 .75 6 12 re f*
+.960784 .960784 .862745 rg
+n 156 .75 36 12 re f*
+.960784 .960784 .862745 rg
+n 192 .75 6 12 re f*
+BT 1 0 0 1 0 86 Tm 12 TL /F4 10 Tf .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj .666667 .133333 1 rg (@trace) Tj 0 0 0 rg  T* .4 .4 .4 rg (...) Tj 0 0 0 rg ( ) Tj /F3 10 Tf 0 .501961 0 rg (def) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 1 rg (f) Tj 0 0 0 rg (\() Tj 0 0 0 rg (_func_) Tj 0 0 0 rg (\):) Tj 0 0 0 rg ( ) Tj /F3 10 Tf 0 .501961 0 rg (print) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 0 rg (f) Tj 0 0 0 rg  T* .4 .4 .4 rg (...) Tj 0 0 0 rg  T* 0 0 0 rg (Traceback) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (\() Tj 0 0 0 rg (most) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (recent) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (call) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (last) Tj 0 0 0 rg (\):) Tj 0 0 0 rg  T* (  ) Tj .4 .4 .4 rg (...) Tj 0 0 0 rg  T* /F3 10 Tf .823529 .254902 .227451 rg (NameError) Tj /F4 10 Tf 0 0 0 rg (:) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (_func_) Tj 0 0 0 rg ( ) Tj /F3 10 Tf .666667 .133333 1 rg (is) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 0 rg (overridden) Tj 0 0 0 rg ( ) Tj /F3 10 Tf .666667 .133333 1 rg (in) Tj /F4 10 Tf 0 0 0 rg  T* /F3 10 Tf 0 .501961 0 rg (def) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 1 rg (f) Tj 0 0 0 rg (\() Tj 0 0 0 rg (_func_) Tj 0 0 0 rg (\):) Tj 0 0 0 rg  T* (    ) Tj /F3 10 Tf 0 .501961 0 rg (return) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 0 rg (_call_) Tj 0 0 0 rg (\() Tj 0 0 0 rg (_func_) Tj 0 0 0 rg (,) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (_func_) Tj 0 0 0 rg (\)) Tj T* ET
 Q
 Q
 Q
 Q
 Q
 q
-1 0 0 1 62.69291 240.2236 cm
+1 0 0 1 62.69291 162.2236 cm
 q
-BT 1 0 0 1 0 26 Tm .194651 Tw 12 TL /F1 10 Tf 0 0 0 rg (Finally, the implementation is such that the decorated function attribute ) Tj /F4 10 Tf (.func_globals ) Tj /F1 10 Tf (is a ) Tj /F5 10 Tf (copy ) Tj /F1 10 Tf (of the) Tj T* 0 Tw 2.966136 Tw (original function attribute. Moreover the decorated function contains a ) Tj /F5 10 Tf (copy ) Tj /F1 10 Tf (of the original function) Tj T* 0 Tw (dictionary \() Tj /F4 10 Tf (vars\(decorated_f\)) Tj ( ) Tj (is) Tj ( ) Tj (not) Tj ( ) Tj (vars\(f\)) Tj /F1 10 Tf (\):) Tj T* ET
+BT 1 0 0 1 0 26 Tm .194651 Tw 12 TL /F1 10 Tf 0 0 0 rg (Finally, the implementation is such that the decorated function attribute ) Tj /F4 10 Tf 0 0 0 rg (.func_globals ) Tj /F1 10 Tf 0 0 0 rg (is a ) Tj /F5 10 Tf (copy ) Tj /F1 10 Tf (of the) Tj T* 0 Tw .864651 Tw (original function attribute. On the other hand the function attribute dictionary of the decorated function is) Tj T* 0 Tw (just a reference to the original function dictionary, i.e. ) Tj /F4 10 Tf 0 0 0 rg (vars\(decorated_f\)) Tj ( ) Tj (is) Tj ( ) Tj (vars\(f\)) Tj /F1 10 Tf 0 0 0 rg (:) Tj T* ET
 Q
 Q
 q
-1 0 0 1 62.69291 87.02362 cm
+1 0 0 1 62.69291 81.02362 cm
 q
 q
 1 0 0 1 0 0 cm
@@ -3585,10 +6176,82 @@ q
 .662745 .662745 .662745 RG
 .5 w
 .960784 .960784 .862745 rg
-n -6 -6 468.6898 144 re B*
+n -6 -6 468.6898 72 re B*
 Q
 q
-BT 1 0 0 1 0 122 Tm 12 TL /F4 10 Tf .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj /F3 10 Tf 0 .501961 0 rg (def) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 1 rg (f) Tj 0 0 0 rg (\(\):) Tj ( ) Tj /F3 10 Tf 0 .501961 0 rg (pass) Tj /F4 10 Tf 0 0 0 rg ( ) Tj /F6 10 Tf .25098 .501961 .501961 rg (# the original function) Tj /F4 10 Tf 0 0 0 rg  T* .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj (f) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (attr1) Tj ( ) Tj .4 .4 .4 rg (=) Tj 0 0 0 rg ( ) Tj .729412 .129412 .129412 rg ("something") Tj 0 0 0 rg ( ) Tj /F6 10 Tf .25098 .501961 .501961 rg (# setting an attribute) Tj /F4 10 Tf 0 0 0 rg  T* .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj (f) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (attr2) Tj ( ) Tj .4 .4 .4 rg (=) Tj 0 0 0 rg ( ) Tj .729412 .129412 .129412 rg ("something else") Tj 0 0 0 rg ( ) Tj /F6 10 Tf .25098 .501961 .501961 rg (# setting another attribute) Tj /F4 10 Tf 0 0 0 rg  T*  T* .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj (traced_f) Tj ( ) Tj .4 .4 .4 rg (=) Tj 0 0 0 rg ( ) Tj (trace) Tj (\() Tj (f) Tj (\)) Tj ( ) Tj /F6 10 Tf .25098 .501961 .501961 rg (# the decorated function) Tj /F4 10 Tf 0 0 0 rg  T*  T* .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj (traced_f) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (attr1) Tj  T* .729412 .129412 .129412 rg ('something') Tj 0 0 0 rg  T* .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj (traced_f) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (attr2) Tj ( ) Tj .4 .4 .4 rg (=) Tj 0 0 0 rg ( ) Tj .729412 .129412 .129412 rg ("something different") Tj 0 0 0 rg ( ) Tj /F6 10 Tf .25098 .501961 .501961 rg (# setting attr) Tj /F4 10 Tf 0 0 0 rg  T* .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj (f) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (attr2) Tj ( ) Tj /F6 10 Tf .25098 .501961 .501961 rg (# the original attribute did not change) Tj /F4 10 Tf 0 0 0 rg  T* .729412 .129412 .129412 rg ('something else') Tj T* ET
+.960784 .960784 .862745 rg
+n 0 48.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 6 48.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 12 48.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 24 48.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 48 48.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 54 48.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 78 48.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 108 48.75 138 12 re f*
+.960784 .960784 .862745 rg
+n 0 36.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 6 36.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 12 36.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 24 36.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 30 36.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 36 36.75 30 12 re f*
+.960784 .960784 .862745 rg
+n 72 36.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 84 36.75 66 12 re f*
+.960784 .960784 .862745 rg
+n 156 36.75 132 12 re f*
+.960784 .960784 .862745 rg
+n 0 24.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 6 24.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 12 24.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 24 24.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 30 24.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 36 24.75 30 12 re f*
+.960784 .960784 .862745 rg
+n 72 24.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 84 24.75 96 12 re f*
+.960784 .960784 .862745 rg
+n 186 24.75 162 12 re f*
+.960784 .960784 .862745 rg
+n 0 .75 6 12 re f*
+.960784 .960784 .862745 rg
+n 6 .75 6 12 re f*
+.960784 .960784 .862745 rg
+n 12 .75 6 12 re f*
+.960784 .960784 .862745 rg
+n 24 .75 48 12 re f*
+.960784 .960784 .862745 rg
+n 78 .75 6 12 re f*
+.960784 .960784 .862745 rg
+n 90 .75 30 12 re f*
+.960784 .960784 .862745 rg
+n 120 .75 6 12 re f*
+.960784 .960784 .862745 rg
+n 126 .75 6 12 re f*
+.960784 .960784 .862745 rg
+n 132 .75 6 12 re f*
+.960784 .960784 .862745 rg
+n 144 .75 144 12 re f*
+BT 1 0 0 1 0 50 Tm 12 TL /F4 10 Tf .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj /F3 10 Tf 0 .501961 0 rg (def) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 1 rg (f) Tj 0 0 0 rg (\(\):) Tj 0 0 0 rg ( ) Tj /F3 10 Tf 0 .501961 0 rg (pass) Tj /F4 10 Tf 0 0 0 rg ( ) Tj /F6 10 Tf .25098 .501961 .501961 rg (# the original function) Tj /F4 10 Tf 0 0 0 rg  T* .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (f) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (attr1) Tj 0 0 0 rg ( ) Tj .4 .4 .4 rg (=) Tj 0 0 0 rg ( ) Tj .729412 .129412 .129412 rg ("something") Tj 0 0 0 rg ( ) Tj /F6 10 Tf .25098 .501961 .501961 rg (# setting an attribute) Tj /F4 10 Tf 0 0 0 rg  T* .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (f) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (attr2) Tj 0 0 0 rg ( ) Tj .4 .4 .4 rg (=) Tj 0 0 0 rg ( ) Tj .729412 .129412 .129412 rg ("something else") Tj 0 0 0 rg ( ) Tj /F6 10 Tf .25098 .501961 .501961 rg (# setting another attribute) Tj /F4 10 Tf 0 0 0 rg  T*  T* .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (traced_f) Tj 0 0 0 rg ( ) Tj .4 .4 .4 rg (=) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (trace) Tj 0 0 0 rg (\() Tj 0 0 0 rg (f) Tj 0 0 0 rg (\)) Tj 0 0 0 rg ( ) Tj /F6 10 Tf .25098 .501961 .501961 rg (# the decorated function) Tj /F4 10 Tf 0 0 0 rg  T* ET
 Q
 Q
 Q
@@ -3597,73 +6260,121 @@ Q
  
 endstream
 endobj
-% 'R99': class PDFStream 
 99 0 obj
-% page stream
-<< /Length 6552 >>
+<< /Length 6515 >>
 stream
 1 0 0 1 0 0 cm  BT /F1 12 Tf 14.4 TL ET
 q
-1 0 0 1 62.69291 744.0236 cm
+1 0 0 1 62.69291 679.8236 cm
 q
-BT 1 0 0 1 0 3.5 Tm 21 TL /F2 17.5 Tf 0 0 0 rg (Compatibility notes) Tj T* ET
-Q
-Q
 q
-1 0 0 1 62.69291 678.0236 cm
+1 0 0 1 0 0 cm
 q
-BT 1 0 0 1 0 50 Tm 1.404985 Tw 12 TL /F1 10 Tf 0 0 0 rg (Version 3.3 is the first version of the ) Tj /F4 10 Tf (decorator ) Tj /F1 10 Tf (module to fully support Python 3, including ) Tj 0 0 .501961 rg (function) Tj T* 0 Tw .07881 Tw (annotations) Tj 0 0 0 rg (. Version 3.2 was the first version to support Python 3 via the ) Tj /F4 10 Tf (2to3 ) Tj /F1 10 Tf (conversion tool invoked in) Tj T* 0 Tw .373555 Tw (the build process by the ) Tj 0 0 .501961 rg (distribute ) Tj 0 0 0 rg (project, the Python 3-compatible replacement of easy_install. The hard) Tj T* 0 Tw .326235 Tw (work \(for me\) has been converting the documentation and the doctests. This has been possible only after) Tj T* 0 Tw (that ) Tj 0 0 .501961 rg (docutils ) Tj 0 0 0 rg (and ) Tj 0 0 .501961 rg (pygments ) Tj 0 0 0 rg (have been ported to Python 3.) Tj T* ET
-Q
-Q
+1 0 0 1 6.6 6.6 cm
 q
-1 0 0 1 62.69291 600.0236 cm
+.662745 .662745 .662745 RG
+.5 w
+.960784 .960784 .862745 rg
+n -6 -6 468.6898 84 re B*
+Q
 q
-BT 1 0 0 1 0 62 Tm .793984 Tw 12 TL /F1 10 Tf 0 0 0 rg (Version 3 of the ) Tj /F4 10 Tf (decorator ) Tj /F1 10 Tf (module do not contain any backward incompatible change, apart from the) Tj T* 0 Tw 3.63498 Tw (removal of the functions ) Tj /F4 10 Tf (get_info ) Tj /F1 10 Tf (and ) Tj /F4 10 Tf (new_wrapper) Tj /F1 10 Tf (, which have been deprecated for years.) Tj T* 0 Tw .293672 Tw /F4 10 Tf (get_info ) Tj /F1 10 Tf (has been removed since it was little used and since it had to be changed anyway to work with) Tj T* 0 Tw 2.298555 Tw (Python 3.0; ) Tj /F4 10 Tf (new_wrapper ) Tj /F1 10 Tf (has been removed since it was useless: its major use case \(converting) Tj T* 0 Tw 7.136976 Tw (signature changing decorators to signature preserving decorators\) has been subsumed by) Tj T* 0 Tw /F4 10 Tf (decorator_apply) Tj /F1 10 Tf (, whereas the other use case can be managed with the ) Tj /F4 10 Tf (FunctionMaker) Tj /F1 10 Tf (.) Tj T* ET
+.960784 .960784 .862745 rg
+n 0 48.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 6 48.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 12 48.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 24 48.75 48 12 re f*
+.960784 .960784 .862745 rg
+n 72 48.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 78 48.75 30 12 re f*
+.960784 .960784 .862745 rg
+n 0 36.75 66 12 re f*
+.960784 .960784 .862745 rg
+n 0 24.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 6 24.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 12 24.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 24 24.75 48 12 re f*
+.960784 .960784 .862745 rg
+n 72 24.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 78 24.75 30 12 re f*
+.960784 .960784 .862745 rg
+n 114 24.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 126 24.75 126 12 re f*
+.960784 .960784 .862745 rg
+n 264 24.75 84 12 re f*
+.960784 .960784 .862745 rg
+n 0 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 6 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 12 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 24 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 30 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 36 12.75 30 12 re f*
+.960784 .960784 .862745 rg
+n 78 12.75 210 12 re f*
+.960784 .960784 .862745 rg
+n 0 .75 126 12 re f*
+BT 1 0 0 1 0 62 Tm 12 TL /F4 10 Tf 0 0 0 rg  T* .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (traced_f) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (attr1) Tj 0 0 0 rg  T* .729412 .129412 .129412 rg ('something') Tj 0 0 0 rg  T* .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (traced_f) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (attr2) Tj 0 0 0 rg ( ) Tj .4 .4 .4 rg (=) Tj 0 0 0 rg ( ) Tj .729412 .129412 .129412 rg ("something different") Tj 0 0 0 rg (  ) Tj /F6 10 Tf .25098 .501961 .501961 rg (# setting attr) Tj /F4 10 Tf 0 0 0 rg  T* .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (f) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (attr2) Tj 0 0 0 rg (  ) Tj /F6 10 Tf .25098 .501961 .501961 rg (# the original attribute did change) Tj /F4 10 Tf 0 0 0 rg  T* .729412 .129412 .129412 rg ('something different') Tj T* ET
+Q
+Q
+Q
 Q
 Q
 q
-1 0 0 1 62.69291 558.0236 cm
+1 0 0 1 62.69291 646.8236 cm
 q
-BT 1 0 0 1 0 26 Tm 1.329213 Tw 12 TL /F1 10 Tf 0 0 0 rg (There are a few changes in the documentation: I removed the ) Tj /F4 10 Tf (decorator_factory ) Tj /F1 10 Tf (example, which) Tj T* 0 Tw 2.562927 Tw (was confusing some of my users, and I removed the part about exotic signatures in the Python 3) Tj T* 0 Tw (documentation, since Python 3 does not support them.) Tj T* ET
+BT 1 0 0 1 0 3.5 Tm 21 TL /F2 17.5 Tf 0 0 0 rg (Compatibility notes) Tj T* ET
 Q
 Q
 q
-1 0 0 1 62.69291 492.0236 cm
+1 0 0 1 62.69291 592.8236 cm
 q
-BT 1 0 0 1 0 50 Tm .942651 Tw 12 TL /F1 10 Tf 0 0 0 rg (Finally ) Tj /F4 10 Tf (decorator ) Tj /F1 10 Tf (cannot be used as a class decorator and the ) Tj 0 0 .501961 rg (functionality introduced in version 2.3) Tj T* 0 Tw .241163 Tw 0 0 0 rg (has been removed. That means that in order to define decorator factories with classes you need to define) Tj T* 0 Tw 1.122126 Tw (the ) Tj /F4 10 Tf (__call__ ) Tj /F1 10 Tf (method explicitly \(no magic anymore\). All these changes should not cause any trouble,) Tj T* 0 Tw .601163 Tw (since they were all rarely used features. Should you have any trouble, you can always downgrade to the) Tj T* 0 Tw (2.3 version.) Tj T* ET
+BT 1 0 0 1 0 38 Tm 1.831984 Tw 12 TL /F1 10 Tf 0 0 0 rg (This version fully supports Python 3, including ) Tj 0 0 .501961 rg (function annotations) Tj 0 0 0 rg (. Moreover it is the first version to) Tj T* 0 Tw 4.83748 Tw (support generic callers, i.e. callable objects with the right signature, not necessarily functions.) Tj T* 0 Tw .70436 Tw /F4 10 Tf 0 0 0 rg (contextmanager ) Tj /F1 10 Tf 0 0 0 rg (will not work in Python 2.4. The decorated function dictionary is now the same of the) Tj T* 0 Tw (original function dictionary, wheread in past versions they were different objects.) Tj T* ET
 Q
 Q
 q
-1 0 0 1 62.69291 426.0236 cm
+1 0 0 1 62.69291 526.8236 cm
 q
-BT 1 0 0 1 0 50 Tm .196098 Tw 12 TL /F1 10 Tf 0 0 0 rg (The examples shown here have been tested with Python 2.6. Python 2.4 is also supported - of course the) Tj T* 0 Tw 1.649398 Tw (examples requiring the ) Tj /F4 10 Tf (with ) Tj /F1 10 Tf (statement will not work there. Python 2.5 works fine, but if you run the) Tj T* 0 Tw 1.41784 Tw (examples in the interactive interpreter you will notice a few differences since ) Tj /F4 10 Tf (getargspec ) Tj /F1 10 Tf (returns an) Tj T* 0 Tw .909982 Tw /F4 10 Tf (ArgSpec ) Tj /F1 10 Tf (namedtuple instead of a regular tuple. That means that running the file ) Tj /F4 10 Tf (documentation.py) Tj T* 0 Tw /F1 10 Tf (under Python 2.5 will print a few errors, but they are not serious.) Tj T* ET
+BT 1 0 0 1 0 50 Tm .936654 Tw 12 TL /F1 10 Tf 0 0 0 rg (The examples shown here have been tested with Python 2.7 and 3.4. Python 2.4 is also supported - of) Tj T* 0 Tw .734104 Tw (course the examples requiring the ) Tj /F4 10 Tf 0 0 0 rg (with ) Tj /F1 10 Tf 0 0 0 rg (statement will not work there. Python 2.5 works fine, but if you) Tj T* 0 Tw 2.409983 Tw (run the examples in the interactive interpreter you will notice a few differences since ) Tj /F4 10 Tf 0 0 0 rg (getargspec) Tj T* 0 Tw 4.486412 Tw /F1 10 Tf 0 0 0 rg (returns an ) Tj /F4 10 Tf 0 0 0 rg (ArgSpec ) Tj /F1 10 Tf 0 0 0 rg (namedtuple instead of a regular tuple. That means that running the file) Tj T* 0 Tw /F4 10 Tf 0 0 0 rg (documentation.py ) Tj /F1 10 Tf 0 0 0 rg (under Python 2.5 will print a few errors, but they are not serious.) Tj T* ET
 Q
 Q
 q
-1 0 0 1 62.69291 393.0236 cm
+1 0 0 1 62.69291 493.8236 cm
 q
 BT 1 0 0 1 0 3.5 Tm 21 TL /F2 17.5 Tf 0 0 0 rg (LICENCE) Tj T* ET
 Q
 Q
 q
-1 0 0 1 62.69291 375.0236 cm
+1 0 0 1 62.69291 475.8236 cm
 q
 0 0 0 rg
-BT 1 0 0 1 0 2 Tm /F1 10 Tf 12 TL (Copyright \(c\) 2005-2012, Michele Simionato All rights reserved.) Tj T* ET
+BT 1 0 0 1 0 2 Tm /F1 10 Tf 12 TL (Copyright \(c\) 2005-2015, Michele Simionato All rights reserved.) Tj T* ET
 Q
 Q
 q
-1 0 0 1 62.69291 345.0236 cm
+1 0 0 1 62.69291 445.8236 cm
 q
 0 0 0 rg
 BT 1 0 0 1 0 14 Tm /F1 10 Tf 12 TL 1.328555 Tw (Redistribution and use in source and binary forms, with or without modification, are permitted provided) Tj T* 0 Tw (that the following conditions are met:) Tj T* ET
 Q
 Q
 q
-1 0 0 1 62.69291 339.0236 cm
+1 0 0 1 62.69291 440.4661 cm
 Q
 q
-1 0 0 1 62.69291 291.0236 cm
+1 0 0 1 62.69291 392.4661 cm
 0 0 0 rg
 BT /F1 10 Tf 12 TL ET
 BT 1 0 0 1 0 2 Tm  T* ET
@@ -3678,17 +6389,17 @@ q
 Q
 Q
 q
-1 0 0 1 62.69291 291.0236 cm
+1 0 0 1 62.69291 392.4661 cm
 Q
 q
-1 0 0 1 62.69291 165.0236 cm
+1 0 0 1 62.69291 266.4661 cm
 q
 0 0 0 rg
 BT 1 0 0 1 0 110 Tm /F1 10 Tf 12 TL .17998 Tw (THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND) Tj T* 0 Tw 2.911797 Tw (ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED) Tj T* 0 Tw 5.165529 Tw (WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE) Tj T* 0 Tw 1.395433 Tw (DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE) Tj T* 0 Tw 5.53122 Tw (FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL) Tj T* 0 Tw 2.705976 Tw (DAMAGES \(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR) Tj T* 0 Tw 3.868976 Tw (SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION\) HOWEVER) Tj T* 0 Tw 1.326647 Tw (CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR) Tj T* 0 Tw 1.525366 Tw (TORT \(INCLUDING NEGLIGENCE OR OTHERWISE\) ARISING IN ANY WAY OUT OF THE USE OF) Tj T* 0 Tw (THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.) Tj T* ET
 Q
 Q
 q
-1 0 0 1 62.69291 135.0236 cm
+1 0 0 1 62.69291 236.4661 cm
 q
 0 0 0 rg
 BT 1 0 0 1 0 14 Tm /F1 10 Tf 12 TL .407132 Tw (If you use this software and you are happy with it, consider sending me a note, just to gratify my ego. On) Tj T* 0 Tw (the other hand, if you use this software and you are unhappy with it, send me a patch!) Tj T* ET
@@ -3697,256 +6408,179 @@ Q
  
 endstream
 endobj
-% 'R100': class PDFPageLabels 
 100 0 obj
-% Document Root
-<< /Nums [ 0
- 101 0 R
- 1
- 102 0 R
- 2
- 103 0 R
- 3
- 104 0 R
- 4
- 105 0 R
- 5
- 106 0 R
- 6
- 107 0 R
- 7
- 108 0 R
- 8
- 109 0 R
- 9
- 110 0 R
- 10
- 111 0 R
- 11
- 112 0 R
- 12
- 113 0 R
- 13
- 114 0 R
- 14
- 115 0 R ] >>
-endobj
-% 'R101': class PDFPageLabel 
+<< /Nums [ 0 101 0 R 1 102 0 R 2 103 0 R 3 104 0 R 4 105 0 R 
+  5 106 0 R 6 107 0 R 7 108 0 R 8 109 0 R 9 110 0 R 
+  10 111 0 R 11 112 0 R 12 113 0 R 13 114 0 R 14 115 0 R ] >>
+endobj
 101 0 obj
-% None
-<< /S /D
- /St 1 >>
+<< /S /D /St 1 >>
 endobj
-% 'R102': class PDFPageLabel 
 102 0 obj
-% None
-<< /S /D
- /St 2 >>
+<< /S /D /St 2 >>
 endobj
-% 'R103': class PDFPageLabel 
 103 0 obj
-% None
-<< /S /D
- /St 3 >>
+<< /S /D /St 3 >>
 endobj
-% 'R104': class PDFPageLabel 
 104 0 obj
-% None
-<< /S /D
- /St 4 >>
+<< /S /D /St 4 >>
 endobj
-% 'R105': class PDFPageLabel 
 105 0 obj
-% None
-<< /S /D
- /St 5 >>
+<< /S /D /St 5 >>
 endobj
-% 'R106': class PDFPageLabel 
 106 0 obj
-% None
-<< /S /D
- /St 6 >>
+<< /S /D /St 6 >>
 endobj
-% 'R107': class PDFPageLabel 
 107 0 obj
-% None
-<< /S /D
- /St 7 >>
+<< /S /D /St 7 >>
 endobj
-% 'R108': class PDFPageLabel 
 108 0 obj
-% None
-<< /S /D
- /St 8 >>
+<< /S /D /St 8 >>
 endobj
-% 'R109': class PDFPageLabel 
 109 0 obj
-% None
-<< /S /D
- /St 9 >>
+<< /S /D /St 9 >>
 endobj
-% 'R110': class PDFPageLabel 
 110 0 obj
-% None
-<< /S /D
- /St 10 >>
+<< /S /D /St 10 >>
 endobj
-% 'R111': class PDFPageLabel 
 111 0 obj
-% None
-<< /S /D
- /St 11 >>
+<< /S /D /St 11 >>
 endobj
-% 'R112': class PDFPageLabel 
 112 0 obj
-% None
-<< /S /D
- /St 12 >>
+<< /S /D /St 12 >>
 endobj
-% 'R113': class PDFPageLabel 
 113 0 obj
-% None
-<< /S /D
- /St 13 >>
+<< /S /D /St 13 >>
 endobj
-% 'R114': class PDFPageLabel 
 114 0 obj
-% None
-<< /S /D
- /St 14 >>
+<< /S /D /St 14 >>
 endobj
-% 'R115': class PDFPageLabel 
 115 0 obj
-% None
-<< /S /D
- /St 15 >>
+<< /S /D /St 15 >>
 endobj
 xref
 0 116
 0000000000 65535 f
-0000000113 00000 n
+0000000075 00000 n
+0000000161 00000 n
 0000000271 00000 n
-0000000436 00000 n
-0000000611 00000 n
-0000000794 00000 n
-0000001046 00000 n
-0000001295 00000 n
-0000001469 00000 n
-0000001710 00000 n
-0000001951 00000 n
-0000002193 00000 n
-0000002435 00000 n
-0000002677 00000 n
-0000002919 00000 n
-0000003162 00000 n
-0000003405 00000 n
-0000003648 00000 n
-0000003891 00000 n
-0000004133 00000 n
-0000004375 00000 n
-0000004618 00000 n
-0000004861 00000 n
-0000005104 00000 n
-0000005347 00000 n
-0000005590 00000 n
-0000005833 00000 n
-0000006076 00000 n
-0000006319 00000 n
-0000006562 00000 n
-0000006805 00000 n
-0000007048 00000 n
-0000007291 00000 n
-0000007534 00000 n
-0000007777 00000 n
-0000008020 00000 n
-0000008263 00000 n
-0000008506 00000 n
-0000008733 00000 n
-0000009311 00000 n
-0000009506 00000 n
-0000009762 00000 n
-0000009953 00000 n
-0000010213 00000 n
-0000010523 00000 n
-0000010803 00000 n
-0000011083 00000 n
-0000011363 00000 n
-0000011643 00000 n
-0000011923 00000 n
-0000012203 00000 n
-0000012484 00000 n
-0000012779 00000 n
-0000013034 00000 n
-0000013302 00000 n
-0000013613 00000 n
-0000013908 00000 n
-0000014153 00000 n
-0000014455 00000 n
-0000014750 00000 n
-0000015010 00000 n
-0000015270 00000 n
-0000015528 00000 n
-0000015780 00000 n
-0000016020 00000 n
-0000016327 00000 n
-0000016674 00000 n
-0000016834 00000 n
-0000017119 00000 n
-0000017245 00000 n
-0000017418 00000 n
-0000017605 00000 n
-0000017805 00000 n
-0000017993 00000 n
-0000018186 00000 n
-0000018385 00000 n
-0000018569 00000 n
-0000018750 00000 n
-0000018940 00000 n
-0000019140 00000 n
-0000019340 00000 n
-0000019552 00000 n
-0000019752 00000 n
-0000019948 00000 n
-0000020100 00000 n
-0000020335 00000 n
-0000029480 00000 n
-0000037125 00000 n
-0000045281 00000 n
-0000052495 00000 n
-0000061446 00000 n
-0000068701 00000 n
-0000076181 00000 n
-0000083501 00000 n
-0000090780 00000 n
-0000098681 00000 n
-0000106059 00000 n
-0000113304 00000 n
-0000119694 00000 n
-0000127821 00000 n
-0000134477 00000 n
-0000134774 00000 n
-0000134853 00000 n
-0000134932 00000 n
-0000135011 00000 n
-0000135090 00000 n
-0000135169 00000 n
-0000135248 00000 n
-0000135327 00000 n
-0000135406 00000 n
-0000135485 00000 n
-0000135565 00000 n
-0000135645 00000 n
-0000135725 00000 n
-0000135805 00000 n
-0000135885 00000 n
+0000000386 00000 n
+0000000499 00000 n
+0000000688 00000 n
+0000000886 00000 n
+0000000994 00000 n
+0000001165 00000 n
+0000001336 00000 n
+0000001508 00000 n
+0000001680 00000 n
+0000001852 00000 n
+0000002024 00000 n
+0000002196 00000 n
+0000002368 00000 n
+0000002540 00000 n
+0000002712 00000 n
+0000002884 00000 n
+0000003056 00000 n
+0000003228 00000 n
+0000003400 00000 n
+0000003572 00000 n
+0000003744 00000 n
+0000003916 00000 n
+0000004088 00000 n
+0000004260 00000 n
+0000004432 00000 n
+0000004604 00000 n
+0000004776 00000 n
+0000004948 00000 n
+0000005120 00000 n
+0000005292 00000 n
+0000005464 00000 n
+0000005636 00000 n
+0000005808 00000 n
+0000005980 00000 n
+0000006152 00000 n
+0000006324 00000 n
+0000006496 00000 n
+0000006668 00000 n
+0000006840 00000 n
+0000007012 00000 n
+0000007501 00000 n
+0000007620 00000 n
+0000007825 00000 n
+0000007942 00000 n
+0000008169 00000 n
+0000008405 00000 n
+0000008615 00000 n
+0000008825 00000 n
+0000009035 00000 n
+0000009245 00000 n
+0000009455 00000 n
+0000009665 00000 n
+0000009875 00000 n
+0000010085 00000 n
+0000010276 00000 n
+0000010494 00000 n
+0000010730 00000 n
+0000010940 00000 n
+0000011150 00000 n
+0000011345 00000 n
+0000011574 00000 n
+0000011770 00000 n
+0000011999 00000 n
+0000012109 00000 n
+0000012357 00000 n
+0000012435 00000 n
+0000012552 00000 n
+0000012681 00000 n
+0000012823 00000 n
+0000012953 00000 n
+0000013088 00000 n
+0000013230 00000 n
+0000013356 00000 n
+0000013479 00000 n
+0000013611 00000 n
+0000013752 00000 n
+0000013893 00000 n
+0000014046 00000 n
+0000014187 00000 n
+0000014324 00000 n
+0000014436 00000 n
+0000014603 00000 n
+0000023769 00000 n
+0000036376 00000 n
+0000053623 00000 n
+0000069507 00000 n
+0000091890 00000 n
+0000110195 00000 n
+0000126839 00000 n
+0000144261 00000 n
+0000158122 00000 n
+0000171904 00000 n
+0000185676 00000 n
+0000202654 00000 n
+0000213129 00000 n
+0000230668 00000 n
+0000237240 00000 n
+0000237439 00000 n
+0000237477 00000 n
+0000237515 00000 n
+0000237553 00000 n
+0000237591 00000 n
+0000237629 00000 n
+0000237667 00000 n
+0000237705 00000 n
+0000237743 00000 n
+0000237781 00000 n
+0000237820 00000 n
+0000237859 00000 n
+0000237898 00000 n
+0000237937 00000 n
+0000237976 00000 n
 trailer
 << /ID 
- % ReportLab generated PDF document -- digest (http://www.reportlab.com) 
- [(%\2119\\+X\235\026\270\000 \364\017F\214k) (%\2119\\+X\235\026\270\000 \364\017F\214k)] 
-
- /Info 67 0 R
- /Root 66 0 R
- /Size 116 >>
+ % ReportLab generated PDF document -- digest (http://www.reportlab.com)
+ [(\222\367\264\017\265\014D\323N7\214\254\213\217\0272) (\222\367\264\017\265\014D\323N7\214\254\213\217\0272)]
+ /Info 67 0 R /Root 66 0 R /Size 116 >>
 startxref
-135934
+238015
 %%EOF
diff --git a/documentation.py b/documentation.py
index 17de544..86ba66f 100644
--- a/documentation.py
+++ b/documentation.py
@@ -24,7 +24,7 @@ believe the change is for the best, and that decorators are a great
 idea since:
 
 * decorators help reducing boilerplate code;
-* decorators help separation of concerns; 
+* decorators help separation of concerns;
 * decorators enhance readability and maintenability;
 * decorators are explicit.
 
@@ -47,8 +47,8 @@ Definitions
 ------------------------------------
 
 Technically speaking, any Python object which can be called with one argument
-can be used as  a decorator. However, this definition is somewhat too large 
-to be really useful. It is more convenient to split the generic class of 
+can be used as  a decorator. However, this definition is somewhat too large
+to be really useful. It is more convenient to split the generic class of
 decorators in two subclasses:
 
 + *signature-preserving* decorators, i.e. callable objects taking a
@@ -61,7 +61,7 @@ decorators in two subclasses:
 
 Signature-changing decorators have their use: for instance the
 builtin classes ``staticmethod`` and ``classmethod`` are in this
-group, since they take functions and return descriptor objects which 
+group, since they take functions and return descriptor objects which
 are not functions, nor callables.
 
 However, signature-preserving decorators are more common and easier to
@@ -69,8 +69,8 @@ reason about; in particular signature-preserving decorators can be
 composed together whereas other decorators in general cannot.
 
 Writing signature-preserving decorators from scratch is not that
-obvious, especially if one wants to define proper decorators that 
-can accept functions with any signature. A simple example will clarify 
+obvious, especially if one wants to define proper decorators that
+can accept functions with any signature. A simple example will clarify
 the issue.
 
 Statement of the problem
@@ -80,8 +80,8 @@ A very common use case for decorators is the memoization of functions.
 A ``memoize`` decorator works by caching
 the result of the function call in a dictionary, so that the next time
 the function is called with the same input parameters the result is retrieved
-from the cache and not recomputed. There are many implementations of 
-``memoize`` in http://www.python.org/moin/PythonDecoratorLibrary, 
+from the cache and not recomputed. There are many implementations of
+``memoize`` in http://www.python.org/moin/PythonDecoratorLibrary,
 but they do not preserve the signature.
 A simple implementation could be the following (notice
 that in general it is impossible to memoize correctly something
@@ -95,9 +95,9 @@ been added in Python 2.5 expressly to simplify the definition of decorators
 ``__name__``, ``__doc__``, ``__module__`` and ``__dict__``
 from the original function to the decorated function by hand).
 
-.. _functools.update_wrapper: http://www.python.org/doc/2.5.2/lib/module-functools.html
+.. _functools.update_wrapper: https://docs.python.org/2/library/functools.html#functools.update_wrapper
 
-The implementation above works in the sense that the decorator 
+The implementation above works in the sense that the decorator
 can accept functions with generic signatures; unfortunately this
 implementation does *not* define a signature-preserving decorator, since in
 general ``memoize_uw`` returns a function with a
@@ -118,14 +118,14 @@ keyword arguments:
 
 .. code-block:: python
 
- >>> from inspect import getargspec 
+ >>> from inspect import getargspec
  >>> print getargspec(f1) # I am using Python 2.6+ here
  ArgSpec(args=[], varargs='args', keywords='kw', defaults=None)
 
 This means that introspection tools such as pydoc will give
 wrong informations about the signature of ``f1``. This is pretty bad:
-pydoc will tell you that the function accepts a generic signature 
-``*args``, ``**kw``, but when you try to call the function with more than an 
+pydoc will tell you that the function accepts a generic signature
+``*args``, ``**kw``, but when you try to call the function with more than an
 argument, you will get an error:
 
 .. code-block:: python
@@ -185,7 +185,7 @@ The signature of ``heavy_computation`` is the one you would expect:
 
 .. code-block:: python
 
- >>> print getargspec(heavy_computation) 
+ >>> print getargspec(heavy_computation)
  ArgSpec(args=[], varargs=None, keywords=None, defaults=None)
 
 A ``trace`` decorator
@@ -218,33 +218,33 @@ and it that it has the correct signature:
 
 .. code-block:: python
 
- >>> print getargspec(f1) 
+ >>> print getargspec(f1)
  ArgSpec(args=['x'], varargs=None, keywords=None, defaults=None)
 
 The same decorator works with functions of any signature:
 
 .. code-block:: python
- 
+
  >>> @trace
  ... def f(x, y=1, z=2, *args, **kw):
  ...     pass
 
  >>> f(0, 3)
  calling f with args (0, 3, 2), {}
- 
- >>> print getargspec(f) 
+
+ >>> print getargspec(f)
  ArgSpec(args=['x', 'y', 'z'], varargs='args', keywords='kw', defaults=(1, 2))
 
 That includes even functions with exotic signatures like the following:
 
 .. code-block:: python
- 
+
  >>> @trace
  ... def exotic_signature((x, y)=(1,2)): return x+y
- 
+
  >>> print getargspec(exotic_signature)
  ArgSpec(args=[['x', 'y']], varargs=None, keywords=None, defaults=((1, 2),))
- >>> exotic_signature() 
+ >>> exotic_signature()
  calling exotic_signature with args ((1, 2),), {}
  3
 
@@ -301,14 +301,14 @@ If you are using an old Python version (Python 2.4) the
 -------------------------------------------
 
 Sometimes one has to deal with blocking resources, such as ``stdin``, and
-sometimes it is best to have back a "busy" message than to block everything. 
+sometimes it is best to have back a "busy" message than to block everything.
 This behavior can be implemented with a suitable family of decorators,
 where the parameter is the busy message:
 
 $$blocking
-   
+
 Functions decorated with ``blocking`` will return a busy message if
-the resource is unavailable, and the intended result if the resource is 
+the resource is unavailable, and the intended result if the resource is
 available. For instance:
 
 .. code-block:: python
@@ -321,7 +321,7 @@ available. For instance:
  >>> print read_data() # data is not available yet
  Please wait ...
 
- >>> time.sleep(1)  
+ >>> time.sleep(1)
  >>> print read_data() # data is not available yet
  Please wait ...
 
@@ -340,11 +340,11 @@ We have just seen an examples of a simple decorator factory,
 implemented as a function returning a decorator.
 For more complex situations, it is more
 convenient to implement decorator factories as classes returning
-callable objects that can be converted into decorators. 
+callable objects that can be converted into decorators.
 
 As an example, here will I show a decorator
 which is able to convert a blocking function into an asynchronous
-function. The function, when called, 
+function. The function, when called,
 is executed in a separate thread. Moreover, it is possible to set
 three callbacks ``on_success``, ``on_failure`` and ``on_closing``,
 to specify how to manage the function call (of course the code here
@@ -356,13 +356,13 @@ $$on_failure
 $$on_closing
 $$Async
 
-The decorated function returns 
-the current execution thread, which can be stored and checked later, for 
-instance to verify that the thread ``.isAlive()``.
+The decorated function returns the current execution thread, which can
+be stored and checked later, for  instance to verify that the
+thread ``.isAlive()``.
 
 Here is an example of usage. Suppose one wants to write some data to
 an external resource which can be accessed by a single user at once
-(for instance a printer). Then the access to the writing function must 
+(for instance a printer). Then the access to the writing function must
 be locked. Here is a minimalistic example:
 
 .. code-block:: python
@@ -379,7 +379,7 @@ be locked. Here is a minimalistic example:
  ...         datalist.append(data)
  ...     # other operations not requiring a lock here
 
-Each call to ``write`` will create a new writer thread, but there will 
+Each call to ``write`` will create a new writer thread, but there will
 be no synchronization problems since ``write`` is locked.
 
 .. code-block:: python
@@ -415,7 +415,7 @@ factories. For instance if you write
 
 
 then ``before_after`` is a factory function returning
-``GeneratorContextManager`` objects which can be used with 
+``GeneratorContextManager`` objects which can be used with
 the ``with`` statement:
 
 .. code-block:: python
@@ -431,7 +431,7 @@ the ``with`` statement:
 
 Basically, it is as if the content of the ``with`` block was executed
 in the place of the ``yield`` expression in the generator function.
-In Python 3.2 ``GeneratorContextManager`` 
+In Python 3.2 ``GeneratorContextManager``
 objects were enhanced with a ``__call__``
 method, so that they can be used as decorators as in this example:
 
@@ -446,11 +446,11 @@ method, so that they can be used as decorators as in this example:
  hello
  AFTER
 
-The ``ba`` decorator is basically inserting a ``with ba:`` 
+The ``ba`` decorator is basically inserting a ``with ba:``
 block inside the function.
-However there two issues: the first is that ``GeneratorContextManager`` 
+However there two issues: the first is that ``GeneratorContextManager``
 objects are callable only in Python 3.2, so the previous example will break
-in older versions of Python; the second is that 
+in older versions of Python; the second is that
 ``GeneratorContextManager`` objects do not preserve the signature
 of the decorated functions: the decorated ``hello`` function here will have
 a generic signature ``hello(*args, **kwargs)`` but will break when
@@ -458,7 +458,7 @@ called with more than zero arguments. For such reasons the decorator
 module, starting with release 3.4, offers a ``decorator.contextmanager``
 decorator that solves both problems and works even in Python 2.5.
 The usage is the same and factories decorated with ``decorator.contextmanager``
-will returns instances of ``ContextManager``, a subclass of 
+will returns instances of ``ContextManager``, a subclass of
 ``contextlib.GeneratorContextManager`` with a ``__call__`` method
 acting as a signature-preserving decorator.
 
@@ -529,7 +529,7 @@ with attributes ``args``, ``varargs``,
 the return values of the standard library function ``inspect.getargspec``.
 For each argument in the ``args`` (which is a list of strings containing
 the names of the mandatory arguments) an attribute ``arg0``, ``arg1``,
-..., ``argN`` is also generated. Finally, there is a ``signature`` 
+..., ``argN`` is also generated. Finally, there is a ``signature``
 attribute, a string with the signature of the original function.
 
 Notice that while I do not have plans
@@ -582,7 +582,8 @@ undecorated function:
  @tail_recursive
  def factorial(n, acc=1):
      "The good old factorial"
-     if n == 0: return acc
+     if n == 0:
+         return acc
      return factorial(n-1, n*acc)
  <BLANKLINE>
 
@@ -592,8 +593,8 @@ Dealing with third party decorators
 -----------------------------------------------------------------
 
 Sometimes you find on the net some cool decorator that you would
-like to include in your code. However, more often than not the cool 
-decorator is not signature-preserving. Therefore you may want an easy way to 
+like to include in your code. However, more often than not the cool
+decorator is not signature-preserving. Therefore you may want an easy way to
 upgrade third party decorators to signature-preserving decorators without
 having to rewrite them in terms of ``decorator``. You can use a
 ``FunctionMaker`` to implement that functionality as follows:
@@ -610,10 +611,10 @@ than adding an additional level of indirection. However, practicality
 beats purity, so you can add ``decorator_apply`` to your toolbox and
 use it if you need to.
 
-In order to give an example of usage of ``decorator_apply``, I will show a 
+In order to give an example of usage of ``decorator_apply``, I will show a
 pretty slick decorator that converts a tail-recursive function in an iterative
 function. I have shamelessly stolen the basic idea from Kay Schluehr's recipe
-in the Python Cookbook, 
+in the Python Cookbook,
 http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/496691.
 
 $$TailRecursive
@@ -629,11 +630,11 @@ $$factorial
 
 .. code-block:: python
 
- >>> print factorial(4) 
+ >>> print factorial(4)
  24
 
 This decorator is pretty impressive, and should give you some food for
-your mind ;) Notice that there is no recursion limit now, and you can 
+your mind ;) Notice that there is no recursion limit now, and you can
 easily compute ``factorial(1001)`` or larger without filling the stack
 frame. Notice also that the decorator will not work on functions which
 are not tail recursive, such as the following
@@ -647,8 +648,8 @@ call).
 Caveats and limitations
 -------------------------------------------
 
-The first thing you should be aware of, it the fact that decorators 
-have a performance penalty. 
+The first thing you should be aware of, it the fact that decorators
+have a performance penalty.
 The worse case is shown by the following example::
 
  $ cat performance.sh
@@ -657,7 +658,7 @@ The worse case is shown by the following example::
 
  @decorator
  def do_nothing(func, *args, **kw):
-     return func(*args, **kw) 
+     return func(*args, **kw)
 
  @do_nothing
  def f():
@@ -676,10 +677,10 @@ plain function is more than three times slower::
  1000000 loops, best of 3: 0.995 usec per loop
  1000000 loops, best of 3: 0.273 usec per loop
 
-It should be noted that a real life function would probably do 
+It should be noted that a real life function would probably do
 something more useful than ``f`` here, and therefore in real life the
 performance penalty could be completely negligible.  As always, the
-only way to know if there is 
+only way to know if there is
 a penalty in your specific use case is to measure it.
 
 You should be aware that decorators will make your tracebacks
@@ -706,8 +707,8 @@ function is decorated the traceback will be longer:
         1/0
  ZeroDivisionError: integer division or modulo by zero
 
-You see here the inner call to the decorator ``trace``, which calls 
-``f(*args, **kw)``, and a reference to  ``File "<string>", line 2, in f``. 
+You see here the inner call to the decorator ``trace``, which calls
+``f(*args, **kw)``, and a reference to  ``File "<string>", line 2, in f``.
 This latter reference is due to the fact that internally the decorator
 module uses ``exec`` to generate the decorated function. Notice that
 ``exec`` is *not* responsibile for the performance penalty, since is the
@@ -716,8 +717,8 @@ the decorated function is called.
 
 At present, there is no clean way to avoid ``exec``. A clean solution
 would require to change the CPython implementation of functions and
-add an hook to make it possible to change their signature directly. 
-That could happen in future versions of Python (see PEP 362_) and 
+add an hook to make it possible to change their signature directly.
+That could happen in future versions of Python (see PEP 362_) and
 then the decorator module would become obsolete. However, at present,
 even in Python 3.1 it is impossible to change the function signature
 directly, therefore the ``decorator`` module is still useful.
@@ -727,7 +728,7 @@ the module and releasing new versions.
 .. _362: http://www.python.org/dev/peps/pep-0362
 
 In the present implementation, decorators generated by ``decorator``
-can only be used on user-defined Python functions or methods, not on generic 
+can only be used on user-defined Python functions or methods, not on generic
 callable objects, nor on built-in functions, due to limitations of the
 ``inspect`` module in the standard library. Moreover, notice
 that you can decorate a method, but only before if becomes a bound or unbound
@@ -736,7 +737,7 @@ Here is an example of valid decoration:
 
 .. code-block:: python
 
- >>> class C(object): 
+ >>> class C(object):
  ...      @trace
  ...      def meth(self):
  ...          pass
@@ -793,8 +794,8 @@ original function dictionary, i.e. ``vars(decorated_f) is vars(f)``:
 
  >>> traced_f.attr1
  'something'
- >>> traced_f.attr2 = "something different" # setting attr
- >>> f.attr2 # the original attribute did change
+ >>> traced_f.attr2 = "something different"  # setting attr
+ >>> f.attr2  # the original attribute did change
  'something different'
 
 Compatibility notes
@@ -809,7 +810,7 @@ dictionary is now the same of the original function
 dictionary, wheread in past versions they were
 different objects.
 
-The examples shown here have been tested with Python 2.7 and 3.3. Python 2.4
+The examples shown here have been tested with Python 2.7 and 3.4. Python 2.4
 is also supported - of course the examples requiring the ``with``
 statement will not work there. Python 2.5 works fine, but if you
 run the examples in the interactive interpreter
@@ -817,7 +818,7 @@ you will notice a few differences since
 ``getargspec`` returns an ``ArgSpec`` namedtuple instead of a regular
 tuple. That means that running the file
 ``documentation.py`` under Python 2.5 will print a few errors, but
-they are not serious. 
+they are not serious.
 
 .. _function annotations: http://www.python.org/dev/peps/pep-3107/
 .. _distribute: http://packages.python.org/distribute/
@@ -827,19 +828,19 @@ they are not serious.
 LICENCE
 ---------------------------------------------
 
-Copyright (c) 2005-2012, Michele Simionato
+Copyright (c) 2005-2015, Michele Simionato
 All rights reserved.
 
 Redistribution and use in source and binary forms, with or without
 modification, are permitted provided that the following conditions are
 met:
 
-  Redistributions of source code must retain the above copyright 
+  Redistributions of source code must retain the above copyright
   notice, this list of conditions and the following disclaimer.
   Redistributions in bytecode form must reproduce the above copyright
   notice, this list of conditions and the following disclaimer in
   the documentation and/or other materials provided with the
-  distribution. 
+  distribution.
 
 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
@@ -854,12 +855,17 @@ TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
 USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
 DAMAGE.
 
-If you use this software and you are happy with it, consider sending me a 
+If you use this software and you are happy with it, consider sending me a
 note, just to gratify my ego. On the other hand, if you use this software and
 you are unhappy with it, send me a patch!
 """
 from __future__ import with_statement
-import sys, threading, time, functools, inspect, itertools  
+import sys
+import threading
+import time
+import functools
+import inspect
+import itertools  
 from decorator import *
 from functools import partial
 from setup import VERSION
@@ -868,34 +874,41 @@ today = time.strftime('%Y-%m-%d')
 
 __doc__ = __doc__.replace('$VERSION', VERSION).replace('$DATE', today)
 
+
 def decorator_apply(dec, func):
     """
-    Decorate a function by preserving the signature even if dec 
+    Decorate a function by preserving the signature even if dec
     is not a signature-preserving decorator.
     """
     return FunctionMaker.create(
         func, 'return decorated(%(signature)s)',
         dict(decorated=dec(func)), __wrapped__=func)
 
+
 def _trace(f, *args, **kw):
     print "calling %s with args %s, %s" % (f.__name__, args, kw)
     return f(*args, **kw)
 
+
 def trace(f):
     return decorator(_trace, f)
 
-def on_success(result): # default implementation
+
+def on_success(result):  # default implementation
     "Called on the result of the function"
     return result
 
-def on_failure(exc_info): # default implementation
+
+def on_failure(exc_info):  # default implementation
     "Called if the function fails"
     pass
 
-def on_closing(): # default implementation
+
+def on_closing():  # default implementation
     "Called at the end, both in case of success and failure"
     pass
 
+
 class Async(object):
     """
     A decorator converting blocking functions into asynchronous
@@ -915,9 +928,10 @@ class Async(object):
     def __call__(self, func, *args, **kw):
         try:
             counter = func.counter
-        except AttributeError: # instantiate the counter at the first call
+        except AttributeError:  # instantiate the counter at the first call
             counter = func.counter = itertools.count(1)
         name = '%s-%s' % (func.__name__, counter.next())
+
         def func_wrapper():
             try:
                 result = func(*args, **kw)
@@ -931,18 +945,22 @@ class Async(object):
         thread.start()
         return thread
 
+
 def identity_dec(func):
     def wrapper(*args, **kw):
         return func(*args, **kw)
     return wrapper
 
+
 @identity_dec
 def example(): pass
 
+
 def memoize_uw(func):
     func.cache = {}
+
     def memoize(*args, **kw):
-        if kw: # frozenset is used to ensure hashability
+        if kw:  # frozenset is used to ensure hashability
             key = args, frozenset(kw.iteritems())
         else:
             key = args
@@ -954,51 +972,61 @@ def memoize_uw(func):
             return result
     return functools.update_wrapper(memoize, func)
 
+
 def _memoize(func, *args, **kw):
-    if kw: # frozenset is used to ensure hashability
+    if kw:  # frozenset is used to ensure hashability
         key = args, frozenset(kw.iteritems())
     else:
         key = args
-    cache = func.cache # attributed added by memoize
+    cache = func.cache  # attributed added by memoize
     if key in cache:
         return cache[key]
     else:
         cache[key] = result = func(*args, **kw)
         return result
 
+
 def memoize(f):
     f.cache = {}
     return decorator(_memoize, f)
 
+
 def blocking(not_avail):
     def blocking(f, *args, **kw):
-        if not hasattr(f, "thread"): # no thread running
-            def set_result(): f.result = f(*args, **kw)
+        if not hasattr(f, "thread"):  # no thread running
+            def set_result():
+                f.result = f(*args, **kw)
             f.thread = threading.Thread(None, set_result)
             f.thread.start()
             return not_avail
         elif f.thread.isAlive():
             return not_avail
-        else: # the thread is ended, return the stored result
+        else:  # the thread is ended, return the stored result
             del f.thread
             return f.result
     return decorator(blocking)
 
+
 class User(object):
     "Will just be able to see a page"
 
+
 class PowerUser(User):
     "Will be able to add new pages too"
 
+
 class Admin(PowerUser):
     "Will be able to delete pages too"
 
+
 def get_userclass():
     return User
 
+
 class PermissionError(Exception):
     pass
 
+
 def restricted(user_class):
     def restricted(func, *args, **kw):
         "Restrict access to a given class of users"
@@ -1011,6 +1039,7 @@ def restricted(user_class):
                 % (userclass.__name__, func.__name__))
     return decorator(restricted)
 
+
 class Action(object):
     """
     >>> a = Action()
@@ -1033,6 +1062,7 @@ class Action(object):
     def delete(self):
         pass
 
+
 class TailRecursive(object):
     """
     tail_recursive decorator based on Kay Schluehr's recipe
@@ -1043,7 +1073,7 @@ class TailRecursive(object):
     def __init__(self, func):
         self.func = func
         self.firstcall = True
-        self.CONTINUE = object() # sentinel
+        self.CONTINUE = object()  # sentinel
 
     def __call__(self, *args, **kwd):
         CONTINUE = self.CONTINUE
@@ -1053,29 +1083,35 @@ class TailRecursive(object):
             try:
                 while True:
                     result = func(*args, **kwd)
-                    if result is CONTINUE: # update arguments
+                    if result is CONTINUE:  # update arguments
                         args, kwd = self.argskwd
-                    else: # last call
+                    else:  # last call
                         return result
             finally:
                 self.firstcall = True
-        else: # return the arguments of the tail call
+        else:  # return the arguments of the tail call
             self.argskwd = args, kwd
             return CONTINUE
 
+
 def tail_recursive(func):
     return decorator_apply(TailRecursive, func)
 
+
 @tail_recursive
 def factorial(n, acc=1):
     "The good old factorial"
-    if n == 0: return acc
+    if n == 0:
+        return acc
     return factorial(n-1, n*acc)
 
-def fact(n): # this is not tail-recursive
-    if n == 0: return 1
+
+def fact(n):  # this is not tail-recursive
+    if n == 0:
+        return 1
     return n * fact(n-1)
 
+
 def a_test_for_pylons():
     """
     In version 3.1.0 decorator(caller) returned a nameless partial
@@ -1090,13 +1126,15 @@ def a_test_for_pylons():
     'The good old factorial'
     """
 
+
 @contextmanager
 def before_after(before, after):
     print(before)
     yield
     print(after)
 
-ba = before_after('BEFORE', 'AFTER') # ContextManager instance
+ba = before_after('BEFORE', 'AFTER')  # ContextManager instance
+
 
 @ba
 def hello(user):
@@ -1111,4 +1149,5 @@ def hello(user):
     print('hello %s' % user)
 
 if __name__ == '__main__':
-    import doctest; doctest.testmod()
+    import doctest
+    doctest.testmod()
diff --git a/documentation.rst b/documentation.rst
new file mode 100644
index 0000000..3c10cae
--- /dev/null
+++ b/documentation.rst
@@ -0,0 +1,1037 @@
+
+The ``decorator`` module
+=============================================================
+
+:Author: Michele Simionato
+:E-mail: michele.simionato@gmail.com
+:Version: 3.4.1 (2015-03-16)
+:Requires: Python 2.4+
+:Download page: http://pypi.python.org/pypi/decorator/3.4.1
+:Installation: ``easy_install decorator``
+:License: BSD license
+
+.. contents::
+
+Introduction
+------------------------------------------------
+
+Python decorators are an interesting example of why syntactic sugar
+matters. In principle, their introduction in Python 2.4 changed
+nothing, since they do not provide any new functionality which was not
+already present in the language. In practice, their introduction has
+significantly changed the way we structure our programs in Python. I
+believe the change is for the best, and that decorators are a great
+idea since:
+
+* decorators help reducing boilerplate code;
+* decorators help separation of concerns;
+* decorators enhance readability and maintenability;
+* decorators are explicit.
+
+Still, as of now, writing custom decorators correctly requires
+some experience and it is not as easy as it could be. For instance,
+typical implementations of decorators involve nested functions, and
+we all know that flat is better than nested.
+
+The aim of the ``decorator`` module it to simplify the usage of
+decorators for the average programmer, and to popularize decorators by
+showing various non-trivial examples. Of course, as all techniques,
+decorators can be abused (I have seen that) and you should not try to
+solve every problem with a decorator, just because you can.
+
+You may find the source code for all the examples
+discussed here in the ``documentation.py`` file, which contains
+this documentation in the form of doctests.
+
+Definitions
+------------------------------------
+
+Technically speaking, any Python object which can be called with one argument
+can be used as  a decorator. However, this definition is somewhat too large
+to be really useful. It is more convenient to split the generic class of
+decorators in two subclasses:
+
++ *signature-preserving* decorators, i.e. callable objects taking a
+  function as input and returning a function *with the same
+  signature* as output;
+
++ *signature-changing* decorators, i.e. decorators that change
+  the signature of their input function, or decorators returning
+  non-callable objects.
+
+Signature-changing decorators have their use: for instance the
+builtin classes ``staticmethod`` and ``classmethod`` are in this
+group, since they take functions and return descriptor objects which
+are not functions, nor callables.
+
+However, signature-preserving decorators are more common and easier to
+reason about; in particular signature-preserving decorators can be
+composed together whereas other decorators in general cannot.
+
+Writing signature-preserving decorators from scratch is not that
+obvious, especially if one wants to define proper decorators that
+can accept functions with any signature. A simple example will clarify
+the issue.
+
+Statement of the problem
+------------------------------
+
+A very common use case for decorators is the memoization of functions.
+A ``memoize`` decorator works by caching
+the result of the function call in a dictionary, so that the next time
+the function is called with the same input parameters the result is retrieved
+from the cache and not recomputed. There are many implementations of
+``memoize`` in http://www.python.org/moin/PythonDecoratorLibrary,
+but they do not preserve the signature.
+A simple implementation could be the following (notice
+that in general it is impossible to memoize correctly something
+that depends on non-hashable arguments):
+
+.. code-block:: python
+
+ def memoize_uw(func):
+     func.cache = {}
+ 
+     def memoize(*args, **kw):
+         if kw:  # frozenset is used to ensure hashability
+             key = args, frozenset(kw.iteritems())
+         else:
+             key = args
+         cache = func.cache
+         if key in cache:
+             return cache[key]
+         else:
+             cache[key] = result = func(*args, **kw)
+             return result
+     return functools.update_wrapper(memoize, func)
+
+
+Here we used the functools.update_wrapper_ utility, which has
+been added in Python 2.5 expressly to simplify the definition of decorators
+(in older versions of Python you need to copy the function attributes
+``__name__``, ``__doc__``, ``__module__`` and ``__dict__``
+from the original function to the decorated function by hand).
+
+.. _functools.update_wrapper: https://docs.python.org/2/library/functools.html#functools.update_wrapper
+
+The implementation above works in the sense that the decorator
+can accept functions with generic signatures; unfortunately this
+implementation does *not* define a signature-preserving decorator, since in
+general ``memoize_uw`` returns a function with a
+*different signature* from the original function.
+
+Consider for instance the following case:
+
+.. code-block:: python
+
+ >>> @memoize_uw
+ ... def f1(x):
+ ...     time.sleep(1) # simulate some long computation
+ ...     return x
+
+Here the original function takes a single argument named ``x``,
+but the decorated function takes any number of arguments and
+keyword arguments:
+
+.. code-block:: python
+
+ >>> from inspect import getargspec
+ >>> print getargspec(f1) # I am using Python 2.6+ here
+ ArgSpec(args=[], varargs='args', keywords='kw', defaults=None)
+
+This means that introspection tools such as pydoc will give
+wrong informations about the signature of ``f1``. This is pretty bad:
+pydoc will tell you that the function accepts a generic signature
+``*args``, ``**kw``, but when you try to call the function with more than an
+argument, you will get an error:
+
+.. code-block:: python
+
+ >>> f1(0, 1)
+ Traceback (most recent call last):
+    ...
+ TypeError: f1() takes exactly 1 argument (2 given)
+
+The solution
+-----------------------------------------
+
+The solution is to provide a generic factory of generators, which
+hides the complexity of making signature-preserving decorators
+from the application programmer. The ``decorator`` function in
+the ``decorator`` module is such a factory:
+
+.. code-block:: python
+
+ >>> from decorator import decorator
+
+``decorator`` takes two arguments, a caller function describing the
+functionality of the decorator and a function to be decorated; it
+returns the decorated function. The caller function must have
+signature ``(f, *args, **kw)`` and it must call the original function ``f``
+with arguments ``args`` and ``kw``, implementing the wanted capability,
+i.e. memoization in this case:
+
+.. code-block:: python
+
+ def _memoize(func, *args, **kw):
+     if kw:  # frozenset is used to ensure hashability
+         key = args, frozenset(kw.iteritems())
+     else:
+         key = args
+     cache = func.cache  # attributed added by memoize
+     if key in cache:
+         return cache[key]
+     else:
+         cache[key] = result = func(*args, **kw)
+         return result
+
+
+At this point you can define your decorator as follows:
+
+.. code-block:: python
+
+ def memoize(f):
+     f.cache = {}
+     return decorator(_memoize, f)
+
+
+The difference with respect to the ``memoize_uw`` approach, which is based
+on nested functions, is that the decorator module forces you to lift
+the inner function at the outer level (*flat is better than nested*).
+Moreover, you are forced to pass explicitly the function you want to
+decorate to the caller function.
+
+Here is a test of usage:
+
+.. code-block:: python
+
+ >>> @memoize
+ ... def heavy_computation():
+ ...     time.sleep(2)
+ ...     return "done"
+
+ >>> print heavy_computation() # the first time it will take 2 seconds
+ done
+
+ >>> print heavy_computation() # the second time it will be instantaneous
+ done
+
+The signature of ``heavy_computation`` is the one you would expect:
+
+.. code-block:: python
+
+ >>> print getargspec(heavy_computation)
+ ArgSpec(args=[], varargs=None, keywords=None, defaults=None)
+
+A ``trace`` decorator
+------------------------------------------------------
+
+As an additional example, here is how you can define a trivial
+``trace`` decorator, which prints a message everytime the traced
+function is called:
+
+.. code-block:: python
+
+ def _trace(f, *args, **kw):
+     print "calling %s with args %s, %s" % (f.__name__, args, kw)
+     return f(*args, **kw)
+
+
+.. code-block:: python
+
+ def trace(f):
+     return decorator(_trace, f)
+
+
+Here is an example of usage:
+
+.. code-block:: python
+ 
+ >>> @trace
+ ... def f1(x):
+ ...     pass
+
+It is immediate to verify that ``f1`` works
+
+.. code-block:: python
+
+ >>> f1(0)
+ calling f1 with args (0,), {}
+
+and it that it has the correct signature:
+
+.. code-block:: python
+
+ >>> print getargspec(f1)
+ ArgSpec(args=['x'], varargs=None, keywords=None, defaults=None)
+
+The same decorator works with functions of any signature:
+
+.. code-block:: python
+
+ >>> @trace
+ ... def f(x, y=1, z=2, *args, **kw):
+ ...     pass
+
+ >>> f(0, 3)
+ calling f with args (0, 3, 2), {}
+
+ >>> print getargspec(f)
+ ArgSpec(args=['x', 'y', 'z'], varargs='args', keywords='kw', defaults=(1, 2))
+
+That includes even functions with exotic signatures like the following:
+
+.. code-block:: python
+
+ >>> @trace
+ ... def exotic_signature((x, y)=(1,2)): return x+y
+
+ >>> print getargspec(exotic_signature)
+ ArgSpec(args=[['x', 'y']], varargs=None, keywords=None, defaults=((1, 2),))
+ >>> exotic_signature()
+ calling exotic_signature with args ((1, 2),), {}
+ 3
+
+Notice that the support for exotic signatures has been deprecated
+in Python 2.6 and removed in Python 3.0.
+
+``decorator`` is a decorator
+---------------------------------------------
+
+It may be annoying to write a caller function (like the ``_trace``
+function above) and then a trivial wrapper
+(``def trace(f): return decorator(_trace, f)``) every time. For this reason,
+the ``decorator`` module provides an easy shortcut to convert
+the caller function into a signature-preserving decorator:
+you can just call ``decorator`` with a single argument.
+In our example you can just write ``trace = decorator(_trace)``.
+The ``decorator`` function can also be used as a signature-changing
+decorator, just as ``classmethod`` and ``staticmethod``.
+However, ``classmethod`` and ``staticmethod`` return generic
+objects which are not callable, while ``decorator`` returns
+signature-preserving decorators, i.e. functions of a single argument.
+For instance, you can write directly
+
+.. code-block:: python
+
+ >>> @decorator
+ ... def trace(f, *args, **kw):
+ ...     print "calling %s with args %s, %s" % (f.func_name, args, kw)
+ ...     return f(*args, **kw)
+
+and now ``trace`` will be a decorator. Actually ``trace`` is a ``partial``
+object which can be used as a decorator:
+
+.. code-block:: python
+
+ >>> trace 
+ <function trace at 0x...>
+
+Here is an example of usage:
+
+.. code-block:: python
+
+ >>> @trace
+ ... def func(): pass
+
+ >>> func()
+ calling func with args (), {}
+
+If you are using an old Python version (Python 2.4) the
+``decorator`` module provides a poor man replacement for
+``functools.partial``.
+
+``blocking``
+-------------------------------------------
+
+Sometimes one has to deal with blocking resources, such as ``stdin``, and
+sometimes it is best to have back a "busy" message than to block everything.
+This behavior can be implemented with a suitable family of decorators,
+where the parameter is the busy message:
+
+.. code-block:: python
+
+ def blocking(not_avail):
+     def blocking(f, *args, **kw):
+         if not hasattr(f, "thread"):  # no thread running
+             def set_result():
+                 f.result = f(*args, **kw)
+             f.thread = threading.Thread(None, set_result)
+             f.thread.start()
+             return not_avail
+         elif f.thread.isAlive():
+             return not_avail
+         else:  # the thread is ended, return the stored result
+             del f.thread
+             return f.result
+     return decorator(blocking)
+
+
+Functions decorated with ``blocking`` will return a busy message if
+the resource is unavailable, and the intended result if the resource is
+available. For instance:
+
+.. code-block:: python
+
+ >>> @blocking("Please wait ...")
+ ... def read_data():
+ ...     time.sleep(3) # simulate a blocking resource
+ ...     return "some data"
+
+ >>> print read_data() # data is not available yet
+ Please wait ...
+
+ >>> time.sleep(1)
+ >>> print read_data() # data is not available yet
+ Please wait ...
+
+ >>> time.sleep(1)
+ >>> print read_data() # data is not available yet
+ Please wait ...
+
+ >>> time.sleep(1.1) # after 3.1 seconds, data is available
+ >>> print read_data()
+ some data
+
+``async``
+--------------------------------------------
+
+We have just seen an examples of a simple decorator factory,
+implemented as a function returning a decorator.
+For more complex situations, it is more
+convenient to implement decorator factories as classes returning
+callable objects that can be converted into decorators.
+
+As an example, here will I show a decorator
+which is able to convert a blocking function into an asynchronous
+function. The function, when called,
+is executed in a separate thread. Moreover, it is possible to set
+three callbacks ``on_success``, ``on_failure`` and ``on_closing``,
+to specify how to manage the function call (of course the code here
+is just an example, it is not a recommended way of doing multi-threaded
+programming). The implementation is the following:
+
+.. code-block:: python
+
+ def on_success(result):  # default implementation
+     "Called on the result of the function"
+     return result
+
+.. code-block:: python
+
+ def on_failure(exc_info):  # default implementation
+     "Called if the function fails"
+     pass
+
+.. code-block:: python
+
+ def on_closing():  # default implementation
+     "Called at the end, both in case of success and failure"
+     pass
+
+.. code-block:: python
+
+ class Async(object):
+     """
+     A decorator converting blocking functions into asynchronous
+     functions, by using threads or processes. Examples:
+ 
+     async_with_threads =  Async(threading.Thread)
+     async_with_processes =  Async(multiprocessing.Process)
+     """
+ 
+     def __init__(self, threadfactory, on_success=on_success,
+                  on_failure=on_failure, on_closing=on_closing):
+         self.threadfactory = threadfactory
+         self.on_success = on_success
+         self.on_failure = on_failure
+         self.on_closing = on_closing
+ 
+     def __call__(self, func, *args, **kw):
+         try:
+             counter = func.counter
+         except AttributeError:  # instantiate the counter at the first call
+             counter = func.counter = itertools.count(1)
+         name = '%s-%s' % (func.__name__, counter.next())
+ 
+         def func_wrapper():
+             try:
+                 result = func(*args, **kw)
+             except:
+                 self.on_failure(sys.exc_info())
+             else:
+                 return self.on_success(result)
+             finally:
+                 self.on_closing()
+         thread = self.threadfactory(None, func_wrapper, name)
+         thread.start()
+         return thread
+
+
+The decorated function returns the current execution thread, which can
+be stored and checked later, for  instance to verify that the
+thread ``.isAlive()``.
+
+Here is an example of usage. Suppose one wants to write some data to
+an external resource which can be accessed by a single user at once
+(for instance a printer). Then the access to the writing function must
+be locked. Here is a minimalistic example:
+
+.. code-block:: python
+
+ >>> async = decorator(Async(threading.Thread))
+
+ >>> datalist = [] # for simplicity the written data are stored into a list.
+
+ >>> @async
+ ... def write(data):
+ ...     # append data to the datalist by locking
+ ...     with threading.Lock():
+ ...         time.sleep(1) # emulate some long running operation
+ ...         datalist.append(data)
+ ...     # other operations not requiring a lock here
+
+Each call to ``write`` will create a new writer thread, but there will
+be no synchronization problems since ``write`` is locked.
+
+.. code-block:: python
+
+ >>> write("data1") 
+ <Thread(write-1, started...)>
+ 
+ >>> time.sleep(.1) # wait a bit, so we are sure data2 is written after data1
+ 
+ >>> write("data2") 
+ <Thread(write-2, started...)>
+ 
+ >>> time.sleep(2) # wait for the writers to complete
+ 
+ >>> print datalist
+ ['data1', 'data2']
+
+contextmanager
+-------------------------------------
+
+For a long time Python had in its standard library a ``contextmanager``
+decorator, able to convert generator functions into ``GeneratorContextManager``
+factories. For instance if you write
+
+.. code-block:: python
+
+ >>> from contextlib import contextmanager
+ >>> @contextmanager
+ ... def before_after(before, after):
+ ...     print(before)
+ ...     yield
+ ...     print(after)
+
+
+then ``before_after`` is a factory function returning
+``GeneratorContextManager`` objects which can be used with
+the ``with`` statement:
+
+.. code-block:: python
+
+ >>> ba = before_after('BEFORE', 'AFTER')
+ >>> type(ba)
+ <class 'contextlib.GeneratorContextManager'>
+ >>> with ba:
+ ...     print 'hello'
+ BEFORE
+ hello
+ AFTER
+
+Basically, it is as if the content of the ``with`` block was executed
+in the place of the ``yield`` expression in the generator function.
+In Python 3.2 ``GeneratorContextManager``
+objects were enhanced with a ``__call__``
+method, so that they can be used as decorators as in this example:
+
+.. code-block:: python
+
+ >>> @ba 
+ ... def hello():
+ ...     print 'hello'
+ ...
+ >>> hello() 
+ BEFORE
+ hello
+ AFTER
+
+The ``ba`` decorator is basically inserting a ``with ba:``
+block inside the function.
+However there two issues: the first is that ``GeneratorContextManager``
+objects are callable only in Python 3.2, so the previous example will break
+in older versions of Python; the second is that
+``GeneratorContextManager`` objects do not preserve the signature
+of the decorated functions: the decorated ``hello`` function here will have
+a generic signature ``hello(*args, **kwargs)`` but will break when
+called with more than zero arguments. For such reasons the decorator
+module, starting with release 3.4, offers a ``decorator.contextmanager``
+decorator that solves both problems and works even in Python 2.5.
+The usage is the same and factories decorated with ``decorator.contextmanager``
+will returns instances of ``ContextManager``, a subclass of
+``contextlib.GeneratorContextManager`` with a ``__call__`` method
+acting as a signature-preserving decorator.
+
+**Disclaimer**: the ``contextmanager`` decorator is an *experimental* feature:
+it may go away in future versions of the decorator module. Use it at your
+own risk.
+
+The ``FunctionMaker`` class
+---------------------------------------------------------------
+
+You may wonder about how the functionality of the ``decorator`` module
+is implemented. The basic building block is
+a ``FunctionMaker`` class which is able to generate on the fly
+functions with a given name and signature from a function template
+passed as a string. Generally speaking, you should not need to
+resort to ``FunctionMaker`` when writing ordinary decorators, but
+it is handy in some circumstances. You will see an example shortly, in
+the implementation of a cool decorator utility (``decorator_apply``).
+
+``FunctionMaker`` provides a ``.create`` classmethod which
+takes as input the name, signature, and body of the function
+we want to generate as well as the execution environment
+were the function is generated by ``exec``. Here is an example:
+
+.. code-block:: python
+
+ >>> def f(*args, **kw): # a function with a generic signature
+ ...     print args, kw
+
+ >>> f1 = FunctionMaker.create('f1(a, b)', 'f(a, b)', dict(f=f))
+ >>> f1(1,2)
+ (1, 2) {}
+
+It is important to notice that the function body is interpolated
+before being executed, so be careful with the ``%`` sign!
+
+``FunctionMaker.create`` also accepts keyword arguments and such
+arguments are attached to the resulting function. This is useful
+if you want to set some function attributes, for instance the
+docstring ``__doc__``.
+
+For debugging/introspection purposes it may be useful to see
+the source code of the generated function; to do that, just
+pass the flag ``addsource=True`` and a ``__source__`` attribute will
+be added to the generated function:
+
+.. code-block:: python
+
+ >>> f1 = FunctionMaker.create(
+ ...     'f1(a, b)', 'f(a, b)', dict(f=f), addsource=True)
+ >>> print f1.__source__
+ def f1(a, b):
+     f(a, b)
+ <BLANKLINE>
+
+``FunctionMaker.create`` can take as first argument a string,
+as in the examples before, or a function. This is the most common
+usage, since typically you want to decorate a pre-existing
+function. A framework author may want to use directly ``FunctionMaker.create``
+instead of ``decorator``, since it gives you direct access to the body
+of the generated function. For instance, suppose you want to instrument
+the ``__init__`` methods of a set of classes, by preserving their
+signature (such use case is not made up; this is done in SQAlchemy
+and in other frameworks). When the first argument of ``FunctionMaker.create``
+is a function, a ``FunctionMaker`` object is instantiated internally,
+with attributes ``args``, ``varargs``,
+``keywords`` and ``defaults`` which are the
+the return values of the standard library function ``inspect.getargspec``.
+For each argument in the ``args`` (which is a list of strings containing
+the names of the mandatory arguments) an attribute ``arg0``, ``arg1``,
+..., ``argN`` is also generated. Finally, there is a ``signature``
+attribute, a string with the signature of the original function.
+
+Notice that while I do not have plans
+to change or remove the functionality provided in the
+``FunctionMaker`` class, I do not guarantee that it will stay
+unchanged forever. For instance, right now I am using the traditional
+string interpolation syntax for function templates, but Python 2.6
+and Python 3.0 provide a newer interpolation syntax and I may use
+the new syntax in the future.
+On the other hand, the functionality provided by
+``decorator`` has been there from version 0.1 and it is guaranteed to
+stay there forever.
+
+Getting the source code
+---------------------------------------------------
+
+Internally ``FunctionMaker.create`` uses ``exec`` to generate the
+decorated function. Therefore
+``inspect.getsource`` will not work for decorated functions. That
+means that the usual '??' trick in IPython will give you the (right on
+the spot) message ``Dynamically generated function. No source code
+available``.  In the past I have considered this acceptable, since
+``inspect.getsource`` does not really work even with regular
+decorators. In that case ``inspect.getsource`` gives you the wrapper
+source code which is probably not what you want:
+
+.. code-block:: python
+
+ def identity_dec(func):
+     def wrapper(*args, **kw):
+         return func(*args, **kw)
+     return wrapper
+
+
+.. code-block:: python
+
+ @identity_dec
+ def example(): pass
+
+ >>> print inspect.getsource(example)
+     def wrapper(*args, **kw):
+         return func(*args, **kw)
+ <BLANKLINE>
+
+(see bug report 1764286_ for an explanation of what is happening).
+Unfortunately the bug is still there, even in Python 2.7 and 3.1.
+There is however a workaround. The decorator module adds an
+attribute ``.__wrapped__`` to the decorated function, containing
+a reference to the original function. The easy way to get
+the source code is to call ``inspect.getsource`` on the
+undecorated function:
+
+.. code-block:: python
+
+ >>> print inspect.getsource(factorial.__wrapped__)
+ @tail_recursive
+ def factorial(n, acc=1):
+     "The good old factorial"
+     if n == 0:
+         return acc
+     return factorial(n-1, n*acc)
+ <BLANKLINE>
+
+.. _1764286: http://bugs.python.org/issue1764286
+
+Dealing with third party decorators
+-----------------------------------------------------------------
+
+Sometimes you find on the net some cool decorator that you would
+like to include in your code. However, more often than not the cool
+decorator is not signature-preserving. Therefore you may want an easy way to
+upgrade third party decorators to signature-preserving decorators without
+having to rewrite them in terms of ``decorator``. You can use a
+``FunctionMaker`` to implement that functionality as follows:
+
+.. code-block:: python
+
+ def decorator_apply(dec, func):
+     """
+     Decorate a function by preserving the signature even if dec
+     is not a signature-preserving decorator.
+     """
+     return FunctionMaker.create(
+         func, 'return decorated(%(signature)s)',
+         dict(decorated=dec(func)), __wrapped__=func)
+
+
+``decorator_apply`` sets the attribute ``.__wrapped__`` of the generated
+function to the original function, so that you can get the right
+source code.
+
+Notice that I am not providing this functionality in the ``decorator``
+module directly since I think it is best to rewrite the decorator rather
+than adding an additional level of indirection. However, practicality
+beats purity, so you can add ``decorator_apply`` to your toolbox and
+use it if you need to.
+
+In order to give an example of usage of ``decorator_apply``, I will show a
+pretty slick decorator that converts a tail-recursive function in an iterative
+function. I have shamelessly stolen the basic idea from Kay Schluehr's recipe
+in the Python Cookbook,
+http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/496691.
+
+.. code-block:: python
+
+ class TailRecursive(object):
+     """
+     tail_recursive decorator based on Kay Schluehr's recipe
+     http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/496691
+     with improvements by me and George Sakkis.
+     """
+ 
+     def __init__(self, func):
+         self.func = func
+         self.firstcall = True
+         self.CONTINUE = object()  # sentinel
+ 
+     def __call__(self, *args, **kwd):
+         CONTINUE = self.CONTINUE
+         if self.firstcall:
+             func = self.func
+             self.firstcall = False
+             try:
+                 while True:
+                     result = func(*args, **kwd)
+                     if result is CONTINUE:  # update arguments
+                         args, kwd = self.argskwd
+                     else:  # last call
+                         return result
+             finally:
+                 self.firstcall = True
+         else:  # return the arguments of the tail call
+             self.argskwd = args, kwd
+             return CONTINUE
+
+
+Here the decorator is implemented as a class returning callable
+objects.
+
+.. code-block:: python
+
+ def tail_recursive(func):
+     return decorator_apply(TailRecursive, func)
+
+
+Here is how you apply the upgraded decorator to the good old factorial:
+
+.. code-block:: python
+
+ @tail_recursive
+ def factorial(n, acc=1):
+     "The good old factorial"
+     if n == 0:
+         return acc
+     return factorial(n-1, n*acc)
+
+
+.. code-block:: python
+
+ >>> print factorial(4)
+ 24
+
+This decorator is pretty impressive, and should give you some food for
+your mind ;) Notice that there is no recursion limit now, and you can
+easily compute ``factorial(1001)`` or larger without filling the stack
+frame. Notice also that the decorator will not work on functions which
+are not tail recursive, such as the following
+
+.. code-block:: python
+
+ def fact(n):  # this is not tail-recursive
+     if n == 0:
+         return 1
+     return n * fact(n-1)
+
+
+(reminder: a function is tail recursive if it either returns a value without
+making a recursive call, or returns directly the result of a recursive
+call).
+
+Caveats and limitations
+-------------------------------------------
+
+The first thing you should be aware of, it the fact that decorators
+have a performance penalty.
+The worse case is shown by the following example::
+
+ $ cat performance.sh
+ python -m timeit -s "
+ from decorator import decorator
+
+ @decorator
+ def do_nothing(func, *args, **kw):
+     return func(*args, **kw)
+
+ @do_nothing
+ def f():
+     pass
+ " "f()"
+
+ python -m timeit -s "
+ def f():
+     pass
+ " "f()"
+
+On my MacBook, using the ``do_nothing`` decorator instead of the
+plain function is more than three times slower::
+
+ $ bash performance.sh
+ 1000000 loops, best of 3: 0.995 usec per loop
+ 1000000 loops, best of 3: 0.273 usec per loop
+
+It should be noted that a real life function would probably do
+something more useful than ``f`` here, and therefore in real life the
+performance penalty could be completely negligible.  As always, the
+only way to know if there is
+a penalty in your specific use case is to measure it.
+
+You should be aware that decorators will make your tracebacks
+longer and more difficult to understand. Consider this example:
+
+.. code-block:: python
+
+ >>> @trace
+ ... def f():
+ ...     1/0
+
+Calling ``f()`` will give you a ``ZeroDivisionError``, but since the
+function is decorated the traceback will be longer:
+
+.. code-block:: python
+
+ >>> f()
+ Traceback (most recent call last):
+   ...
+      File "<string>", line 2, in f
+      File "<doctest __main__[18]>", line 4, in trace
+        return f(*args, **kw)
+      File "<doctest __main__[47]>", line 3, in f
+        1/0
+ ZeroDivisionError: integer division or modulo by zero
+
+You see here the inner call to the decorator ``trace``, which calls
+``f(*args, **kw)``, and a reference to  ``File "<string>", line 2, in f``.
+This latter reference is due to the fact that internally the decorator
+module uses ``exec`` to generate the decorated function. Notice that
+``exec`` is *not* responsibile for the performance penalty, since is the
+called *only once* at function decoration time, and not every time
+the decorated function is called.
+
+At present, there is no clean way to avoid ``exec``. A clean solution
+would require to change the CPython implementation of functions and
+add an hook to make it possible to change their signature directly.
+That could happen in future versions of Python (see PEP 362_) and
+then the decorator module would become obsolete. However, at present,
+even in Python 3.1 it is impossible to change the function signature
+directly, therefore the ``decorator`` module is still useful.
+Actually, this is one of the main reasons why I keep maintaining
+the module and releasing new versions.
+
+.. _362: http://www.python.org/dev/peps/pep-0362
+
+In the present implementation, decorators generated by ``decorator``
+can only be used on user-defined Python functions or methods, not on generic
+callable objects, nor on built-in functions, due to limitations of the
+``inspect`` module in the standard library. Moreover, notice
+that you can decorate a method, but only before if becomes a bound or unbound
+method, i.e. inside the class.
+Here is an example of valid decoration:
+
+.. code-block:: python
+
+ >>> class C(object):
+ ...      @trace
+ ...      def meth(self):
+ ...          pass
+
+Here is an example of invalid decoration, when the decorator in
+called too late:
+
+.. code-block:: python
+
+ >>> class C(object):
+ ...      def meth(self):
+ ...          pass
+ ...
+ >>> trace(C.meth)
+ Traceback (most recent call last):
+   ...
+ TypeError: You are decorating a non function: <unbound method C.meth>
+
+The solution is to extract the inner function from the unbound method:
+
+.. code-block:: python
+
+ >>> trace(C.meth.im_func) 
+ <function meth at 0x...>
+
+There is a restriction on the names of the arguments: for instance,
+if try to call an argument ``_call_`` or ``_func_``
+you will get a ``NameError``:
+
+.. code-block:: python
+
+ >>> @trace
+ ... def f(_func_): print f
+ ... 
+ Traceback (most recent call last):
+   ...
+ NameError: _func_ is overridden in
+ def f(_func_):
+     return _call_(_func_, _func_)
+
+Finally, the implementation is such that the decorated function
+attribute ``.func_globals`` is a *copy* of the original function
+attribute. On the other hand the function attribute dictionary
+of the decorated function is just a reference to the
+original function dictionary, i.e. ``vars(decorated_f) is vars(f)``:
+
+.. code-block:: python
+
+ >>> def f(): pass # the original function
+ >>> f.attr1 = "something" # setting an attribute
+ >>> f.attr2 = "something else" # setting another attribute
+
+ >>> traced_f = trace(f) # the decorated function
+
+ >>> traced_f.attr1
+ 'something'
+ >>> traced_f.attr2 = "something different"  # setting attr
+ >>> f.attr2  # the original attribute did change
+ 'something different'
+
+Compatibility notes
+---------------------------------------------------------------
+
+This version fully supports Python 3, including `function
+annotations`_. Moreover it is the first version to support
+generic callers, i.e. callable objects with the right
+signature, not necessarily functions. ``contextmanager``
+will not work in Python 2.4. The decorated function
+dictionary is now the same of the original function
+dictionary, wheread in past versions they were
+different objects.
+
+The examples shown here have been tested with Python 2.7 and 3.4. Python 2.4
+is also supported - of course the examples requiring the ``with``
+statement will not work there. Python 2.5 works fine, but if you
+run the examples in the interactive interpreter
+you will notice a few differences since
+``getargspec`` returns an ``ArgSpec`` namedtuple instead of a regular
+tuple. That means that running the file
+``documentation.py`` under Python 2.5 will print a few errors, but
+they are not serious.
+
+.. _function annotations: http://www.python.org/dev/peps/pep-3107/
+.. _distribute: http://packages.python.org/distribute/
+.. _docutils: http://docutils.sourceforge.net/
+.. _pygments: http://pygments.org/
+
+LICENCE
+---------------------------------------------
+
+Copyright (c) 2005-2015, Michele Simionato
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are
+met:
+
+  Redistributions of source code must retain the above copyright
+  notice, this list of conditions and the following disclaimer.
+  Redistributions in bytecode form must reproduce the above copyright
+  notice, this list of conditions and the following disclaimer in
+  the documentation and/or other materials provided with the
+  distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
+OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
+TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
+USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
+DAMAGE.
+
+If you use this software and you are happy with it, consider sending me a
+note, just to gratify my ego. On the other hand, if you use this software and
+you are unhappy with it, send me a patch!
diff --git a/documentation3.html b/documentation3.html
deleted file mode 100644
index c5e2fac..0000000
--- a/documentation3.html
+++ /dev/null
@@ -1,1102 +0,0 @@
-<?xml version="1.0" encoding="utf-8" ?>
-<!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" xml:lang="en" lang="en">
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
-<meta name="generator" content="Docutils 0.8.1: http://docutils.sourceforge.net/" />
-<title>The decorator module</title>
-<meta name="author" content="Michele Simionato" />
-<style type="text/css">
-
-.highlight  { background: #f8f8f8; }
-.highlight .c { color: #408080; font-style: italic } /* Comment */
-.highlight .err { border: 1px solid #FF0000 } /* Error */
-.highlight .k { color: #008000; font-weight: bold } /* Keyword */
-.highlight .o { color: #666666 } /* Operator */
-.highlight .cm { color: #408080; font-style: italic } /* Comment.Multiline */
-.highlight .cp { color: #BC7A00 } /* Comment.Preproc */
-.highlight .c1 { color: #408080; font-style: italic } /* Comment.Single */
-.highlight .cs { color: #408080; font-style: italic } /* Comment.Special */
-.highlight .gd { color: #A00000 } /* Generic.Deleted */
-.highlight .ge { font-style: italic } /* Generic.Emph */
-.highlight .gr { color: #FF0000 } /* Generic.Error */
-.highlight .gh { color: #000080; font-weight: bold } /* Generic.Heading */
-.highlight .gi { color: #00A000 } /* Generic.Inserted */
-.highlight .go { color: #808080 } /* Generic.Output */
-.highlight .gp { color: #000080; font-weight: bold } /* Generic.Prompt */
-.highlight .gs { font-weight: bold } /* Generic.Strong */
-.highlight .gu { color: #800080; font-weight: bold } /* Generic.Subheading */
-.highlight .gt { color: #0040D0 } /* Generic.Traceback */
-.highlight .kc { color: #008000; font-weight: bold } /* Keyword.Constant */
-.highlight .kd { color: #008000; font-weight: bold } /* Keyword.Declaration */
-.highlight .kp { color: #008000 } /* Keyword.Pseudo */
-.highlight .kr { color: #008000; font-weight: bold } /* Keyword.Reserved */
-.highlight .kt { color: #008000; font-weight: bold } /* Keyword.Type */
-.highlight .m { color: #666666 } /* Literal.Number */
-.highlight .s { color: #BA2121 } /* Literal.String */
-.highlight .na { color: #7D9029 } /* Name.Attribute */
-.highlight .nb { color: #008000 } /* Name.Builtin */
-.highlight .nc { color: #0000FF; font-weight: bold } /* Name.Class */
-.highlight .no { color: #880000 } /* Name.Constant */
-.highlight .nd { color: #AA22FF } /* Name.Decorator */
-.highlight .ni { color: #999999; font-weight: bold } /* Name.Entity */
-.highlight .ne { color: #D2413A; font-weight: bold } /* Name.Exception */
-.highlight .nf { color: #0000FF } /* Name.Function */
-.highlight .nl { color: #A0A000 } /* Name.Label */
-.highlight .nn { color: #0000FF; font-weight: bold } /* Name.Namespace */
-.highlight .nt { color: #008000; font-weight: bold } /* Name.Tag */
-.highlight .nv { color: #19177C } /* Name.Variable */
-.highlight .ow { color: #AA22FF; font-weight: bold } /* Operator.Word */
-.highlight .w { color: #bbbbbb } /* Text.Whitespace */
-.highlight .mf { color: #666666 } /* Literal.Number.Float */
-.highlight .mh { color: #666666 } /* Literal.Number.Hex */
-.highlight .mi { color: #666666 } /* Literal.Number.Integer */
-.highlight .mo { color: #666666 } /* Literal.Number.Oct */
-.highlight .sb { color: #BA2121 } /* Literal.String.Backtick */
-.highlight .sc { color: #BA2121 } /* Literal.String.Char */
-.highlight .sd { color: #BA2121; font-style: italic } /* Literal.String.Doc */
-.highlight .s2 { color: #BA2121 } /* Literal.String.Double */
-.highlight .se { color: #BB6622; font-weight: bold } /* Literal.String.Escape */
-.highlight .sh { color: #BA2121 } /* Literal.String.Heredoc */
-.highlight .si { color: #BB6688; font-weight: bold } /* Literal.String.Interpol */
-.highlight .sx { color: #008000 } /* Literal.String.Other */
-.highlight .sr { color: #BB6688 } /* Literal.String.Regex */
-.highlight .s1 { color: #BA2121 } /* Literal.String.Single */
-.highlight .ss { color: #19177C } /* Literal.String.Symbol */
-.highlight .bp { color: #008000 } /* Name.Builtin.Pseudo */
-.highlight .vc { color: #19177C } /* Name.Variable.Class */
-.highlight .vg { color: #19177C } /* Name.Variable.Global */
-.highlight .vi { color: #19177C } /* Name.Variable.Instance */
-.highlight .il { color: #666666 } /* Literal.Number.Integer.Long */
-
-</style>
-</head>
-<body>
-<div class="document" id="the-decorator-module">
-<h1 class="title">The <tt class="docutils literal">decorator</tt> module</h1>
-<table class="docinfo" frame="void" rules="none">
-<col class="docinfo-name" />
-<col class="docinfo-content" />
-<tbody valign="top">
-<tr><th class="docinfo-name">Author:</th>
-<td>Michele Simionato</td></tr>
-<tr class="field"><th class="docinfo-name">E-mail:</th><td class="field-body"><a class="reference external" href="mailto:michele.simionato&#64;gmail.com">michele.simionato&#64;gmail.com</a></td>
-</tr>
-<tr><th class="docinfo-name">Version:</th>
-<td>3.4.0 (2012-10-18)</td></tr>
-<tr class="field"><th class="docinfo-name">Requires:</th><td class="field-body">Python 2.4+</td>
-</tr>
-<tr class="field"><th class="docinfo-name">Download page:</th><td class="field-body"><a class="reference external" href="http://pypi.python.org/pypi/decorator/3.4.0">http://pypi.python.org/pypi/decorator/3.4.0</a></td>
-</tr>
-<tr class="field"><th class="docinfo-name">Installation:</th><td class="field-body"><tt class="docutils literal">easy_install decorator</tt></td>
-</tr>
-<tr class="field"><th class="docinfo-name">License:</th><td class="field-body">BSD license</td>
-</tr>
-</tbody>
-</table>
-<div class="contents topic" id="contents">
-<p class="topic-title first">Contents</p>
-<ul class="simple">
-<li><a class="reference internal" href="#introduction" id="id4">Introduction</a></li>
-<li><a class="reference internal" href="#definitions" id="id5">Definitions</a></li>
-<li><a class="reference internal" href="#statement-of-the-problem" id="id6">Statement of the problem</a></li>
-<li><a class="reference internal" href="#the-solution" id="id7">The solution</a></li>
-<li><a class="reference internal" href="#a-trace-decorator" id="id8">A <tt class="docutils literal">trace</tt> decorator</a></li>
-<li><a class="reference internal" href="#function-annotations" id="id9">Function annotations</a></li>
-<li><a class="reference internal" href="#decorator-is-a-decorator" id="id10"><tt class="docutils literal">decorator</tt> is a decorator</a></li>
-<li><a class="reference internal" href="#blocking" id="id11"><tt class="docutils literal">blocking</tt></a></li>
-<li><a class="reference internal" href="#async" id="id12"><tt class="docutils literal">async</tt></a></li>
-<li><a class="reference internal" href="#contextmanager" id="id13">contextmanager</a></li>
-<li><a class="reference internal" href="#the-functionmaker-class" id="id14">The <tt class="docutils literal">FunctionMaker</tt> class</a></li>
-<li><a class="reference internal" href="#getting-the-source-code" id="id15">Getting the source code</a></li>
-<li><a class="reference internal" href="#dealing-with-third-party-decorators" id="id16">Dealing with third party decorators</a></li>
-<li><a class="reference internal" href="#caveats-and-limitations" id="id17">Caveats and limitations</a></li>
-<li><a class="reference internal" href="#compatibility-notes" id="id18">Compatibility notes</a></li>
-<li><a class="reference internal" href="#licence" id="id19">LICENCE</a></li>
-</ul>
-</div>
-<div class="section" id="introduction">
-<h1><a class="toc-backref" href="#id4">Introduction</a></h1>
-<p>Python decorators are an interesting example of why syntactic sugar
-matters. In principle, their introduction in Python 2.4 changed
-nothing, since they do not provide any new functionality which was not
-already present in the language. In practice, their introduction has
-significantly changed the way we structure our programs in Python. I
-believe the change is for the best, and that decorators are a great
-idea since:</p>
-<ul class="simple">
-<li>decorators help reducing boilerplate code;</li>
-<li>decorators help separation of concerns;</li>
-<li>decorators enhance readability and maintenability;</li>
-<li>decorators are explicit.</li>
-</ul>
-<p>Still, as of now, writing custom decorators correctly requires
-some experience and it is not as easy as it could be. For instance,
-typical implementations of decorators involve nested functions, and
-we all know that flat is better than nested.</p>
-<p>The aim of the <tt class="docutils literal">decorator</tt> module it to simplify the usage of
-decorators for the average programmer, and to popularize decorators by
-showing various non-trivial examples. Of course, as all techniques,
-decorators can be abused (I have seen that) and you should not try to
-solve every problem with a decorator, just because you can.</p>
-<p>You may find the source code for all the examples
-discussed here in the <tt class="docutils literal">documentation.py</tt> file, which contains
-this documentation in the form of doctests.</p>
-</div>
-<div class="section" id="definitions">
-<h1><a class="toc-backref" href="#id5">Definitions</a></h1>
-<p>Technically speaking, any Python object which can be called with one argument
-can be used as  a decorator. However, this definition is somewhat too large
-to be really useful. It is more convenient to split the generic class of
-decorators in two subclasses:</p>
-<ul class="simple">
-<li><em>signature-preserving</em> decorators, i.e. callable objects taking a
-function as input and returning a function <em>with the same
-signature</em> as output;</li>
-<li><em>signature-changing</em> decorators, i.e. decorators that change
-the signature of their input function, or decorators returning
-non-callable objects.</li>
-</ul>
-<p>Signature-changing decorators have their use: for instance the
-builtin classes <tt class="docutils literal">staticmethod</tt> and <tt class="docutils literal">classmethod</tt> are in this
-group, since they take functions and return descriptor objects which
-are not functions, nor callables.</p>
-<p>However, signature-preserving decorators are more common and easier to
-reason about; in particular signature-preserving decorators can be
-composed together whereas other decorators in general cannot.</p>
-<p>Writing signature-preserving decorators from scratch is not that
-obvious, especially if one wants to define proper decorators that
-can accept functions with any signature. A simple example will clarify
-the issue.</p>
-</div>
-<div class="section" id="statement-of-the-problem">
-<h1><a class="toc-backref" href="#id6">Statement of the problem</a></h1>
-<p>A very common use case for decorators is the memoization of functions.
-A <tt class="docutils literal">memoize</tt> decorator works by caching
-the result of the function call in a dictionary, so that the next time
-the function is called with the same input parameters the result is retrieved
-from the cache and not recomputed. There are many implementations of
-<tt class="docutils literal">memoize</tt> in <a class="reference external" href="http://www.python.org/moin/PythonDecoratorLibrary">http://www.python.org/moin/PythonDecoratorLibrary</a>,
-but they do not preserve the signature.
-A simple implementation could be the following (notice
-that in general it is impossible to memoize correctly something
-that depends on non-hashable arguments):</p>
-<div class="codeblock python">
-<div class="highlight"><pre><span class="k">def</span> <span class="nf">memoize_uw</span><span class="p">(</span><span class="n">func</span><span class="p">):</span>
-    <span class="n">func</span><span class="o">.</span><span class="n">cache</span> <span class="o">=</span> <span class="p">{}</span>
-    <span class="k">def</span> <span class="nf">memoize</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">kw</span><span class="p">):</span>
-        <span class="k">if</span> <span class="n">kw</span><span class="p">:</span> <span class="c"># frozenset is used to ensure hashability</span>
-            <span class="n">key</span> <span class="o">=</span> <span class="n">args</span><span class="p">,</span> <span class="nb">frozenset</span><span class="p">(</span><span class="n">kw</span><span class="o">.</span><span class="n">iteritems</span><span class="p">())</span>
-        <span class="k">else</span><span class="p">:</span>
-            <span class="n">key</span> <span class="o">=</span> <span class="n">args</span>
-        <span class="n">cache</span> <span class="o">=</span> <span class="n">func</span><span class="o">.</span><span class="n">cache</span>
-        <span class="k">if</span> <span class="n">key</span> <span class="ow">in</span> <span class="n">cache</span><span class="p">:</span>
-            <span class="k">return</span> <span class="n">cache</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="n">cache</span><span class="p">[</span><span class="n">key</span><span class="p">]</span> <span class="o">=</span> <span class="n">result</span> <span class="o">=</span> <span class="n">func</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">kw</span><span class="p">)</span>
-            <span class="k">return</span> <span class="n">result</span>
-    <span class="k">return</span> <span class="n">functools</span><span class="o">.</span><span class="n">update_wrapper</span><span class="p">(</span><span class="n">memoize</span><span class="p">,</span> <span class="n">func</span><span class="p">)</span>
-</pre></div>
-
-</div>
-<p>Here we used the <a class="reference external" href="http://www.python.org/doc/2.5.2/lib/module-functools.html">functools.update_wrapper</a> utility, which has
-been added in Python 2.5 expressly to simplify the definition of decorators
-(in older versions of Python you need to copy the function attributes
-<tt class="docutils literal">__name__</tt>, <tt class="docutils literal">__doc__</tt>, <tt class="docutils literal">__module__</tt> and <tt class="docutils literal">__dict__</tt>
-from the original function to the decorated function by hand).</p>
-<p>The implementation above works in the sense that the decorator
-can accept functions with generic signatures; unfortunately this
-implementation does <em>not</em> define a signature-preserving decorator, since in
-general <tt class="docutils literal">memoize_uw</tt> returns a function with a
-<em>different signature</em> from the original function.</p>
-<p>Consider for instance the following case:</p>
-<div class="codeblock python">
-<div class="highlight"><pre><span class="o">&gt;&gt;&gt;</span> <span class="nd">@memoize_uw</span>
-<span class="o">...</span> <span class="k">def</span> <span class="nf">f1</span><span class="p">(</span><span class="n">x</span><span class="p">):</span>
-<span class="o">...</span>     <span class="n">time</span><span class="o">.</span><span class="n">sleep</span><span class="p">(</span><span class="mi">1</span><span class="p">)</span> <span class="c"># simulate some long computation</span>
-<span class="o">...</span>     <span class="k">return</span> <span class="n">x</span>
-</pre></div>
-
-</div>
-<p>Here the original function takes a single argument named <tt class="docutils literal">x</tt>,
-but the decorated function takes any number of arguments and
-keyword arguments:</p>
-<div class="codeblock python">
-<div class="highlight"><pre><span class="o">&gt;&gt;&gt;</span> <span class="kn">from</span> <span class="nn">inspect</span> <span class="kn">import</span> <span class="n">getargspec</span>
-<span class="o">&gt;&gt;&gt;</span> <span class="k">print</span><span class="p">(</span><span class="n">getargspec</span><span class="p">(</span><span class="n">f1</span><span class="p">))</span>
-<span class="n">ArgSpec</span><span class="p">(</span><span class="n">args</span><span class="o">=</span><span class="p">[],</span> <span class="n">varargs</span><span class="o">=</span><span class="s">&#39;args&#39;</span><span class="p">,</span> <span class="n">keywords</span><span class="o">=</span><span class="s">&#39;kw&#39;</span><span class="p">,</span> <span class="n">defaults</span><span class="o">=</span><span class="bp">None</span><span class="p">)</span>
-</pre></div>
-
-</div>
-<p>This means that introspection tools such as pydoc will give
-wrong informations about the signature of <tt class="docutils literal">f1</tt>. This is pretty bad:
-pydoc will tell you that the function accepts a generic signature
-<tt class="docutils literal">*args</tt>, <tt class="docutils literal">**kw</tt>, but when you try to call the function with more than an
-argument, you will get an error:</p>
-<div class="codeblock python">
-<div class="highlight"><pre><span class="o">&gt;&gt;&gt;</span> <span class="n">f1</span><span class="p">(</span><span class="mi">0</span><span class="p">,</span> <span class="mi">1</span><span class="p">)</span>
-<span class="n">Traceback</span> <span class="p">(</span><span class="n">most</span> <span class="n">recent</span> <span class="n">call</span> <span class="n">last</span><span class="p">):</span>
-   <span class="o">...</span>
-<span class="ne">TypeError</span><span class="p">:</span> <span class="n">f1</span><span class="p">()</span> <span class="n">takes</span> <span class="n">exactly</span> <span class="mi">1</span> <span class="n">positional</span> <span class="n">argument</span> <span class="p">(</span><span class="mi">2</span> <span class="n">given</span><span class="p">)</span>
-</pre></div>
-
-</div>
-</div>
-<div class="section" id="the-solution">
-<h1><a class="toc-backref" href="#id7">The solution</a></h1>
-<p>The solution is to provide a generic factory of generators, which
-hides the complexity of making signature-preserving decorators
-from the application programmer. The <tt class="docutils literal">decorator</tt> function in
-the <tt class="docutils literal">decorator</tt> module is such a factory:</p>
-<div class="codeblock python">
-<div class="highlight"><pre><span class="o">&gt;&gt;&gt;</span> <span class="kn">from</span> <span class="nn">decorator</span> <span class="kn">import</span> <span class="n">decorator</span>
-</pre></div>
-
-</div>
-<p><tt class="docutils literal">decorator</tt> takes two arguments, a caller function describing the
-functionality of the decorator and a function to be decorated; it
-returns the decorated function. The caller function must have
-signature <tt class="docutils literal">(f, *args, **kw)</tt> and it must call the original function <tt class="docutils literal">f</tt>
-with arguments <tt class="docutils literal">args</tt> and <tt class="docutils literal">kw</tt>, implementing the wanted capability,
-i.e. memoization in this case:</p>
-<div class="codeblock python">
-<div class="highlight"><pre><span class="k">def</span> <span class="nf">_memoize</span><span class="p">(</span><span class="n">func</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">kw</span><span class="p">):</span>
-    <span class="k">if</span> <span class="n">kw</span><span class="p">:</span> <span class="c"># frozenset is used to ensure hashability</span>
-        <span class="n">key</span> <span class="o">=</span> <span class="n">args</span><span class="p">,</span> <span class="nb">frozenset</span><span class="p">(</span><span class="n">kw</span><span class="o">.</span><span class="n">iteritems</span><span class="p">())</span>
-    <span class="k">else</span><span class="p">:</span>
-        <span class="n">key</span> <span class="o">=</span> <span class="n">args</span>
-    <span class="n">cache</span> <span class="o">=</span> <span class="n">func</span><span class="o">.</span><span class="n">cache</span> <span class="c"># attributed added by memoize</span>
-    <span class="k">if</span> <span class="n">key</span> <span class="ow">in</span> <span class="n">cache</span><span class="p">:</span>
-        <span class="k">return</span> <span class="n">cache</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="n">cache</span><span class="p">[</span><span class="n">key</span><span class="p">]</span> <span class="o">=</span> <span class="n">result</span> <span class="o">=</span> <span class="n">func</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">kw</span><span class="p">)</span>
-        <span class="k">return</span> <span class="n">result</span>
-</pre></div>
-
-</div>
-<p>At this point you can define your decorator as follows:</p>
-<div class="codeblock python">
-<div class="highlight"><pre><span class="k">def</span> <span class="nf">memoize</span><span class="p">(</span><span class="n">f</span><span class="p">):</span>
-    <span class="n">f</span><span class="o">.</span><span class="n">cache</span> <span class="o">=</span> <span class="p">{}</span>
-    <span class="k">return</span> <span class="n">decorator</span><span class="p">(</span><span class="n">_memoize</span><span class="p">,</span> <span class="n">f</span><span class="p">)</span>
-</pre></div>
-
-</div>
-<p>The difference with respect to the <tt class="docutils literal">memoize_uw</tt> approach, which is based
-on nested functions, is that the decorator module forces you to lift
-the inner function at the outer level (<em>flat is better than nested</em>).
-Moreover, you are forced to pass explicitly the function you want to
-decorate to the caller function.</p>
-<p>Here is a test of usage:</p>
-<div class="codeblock python">
-<div class="highlight"><pre><span class="o">&gt;&gt;&gt;</span> <span class="nd">@memoize</span>
-<span class="o">...</span> <span class="k">def</span> <span class="nf">heavy_computation</span><span class="p">():</span>
-<span class="o">...</span>     <span class="n">time</span><span class="o">.</span><span class="n">sleep</span><span class="p">(</span><span class="mi">2</span><span class="p">)</span>
-<span class="o">...</span>     <span class="k">return</span> <span class="s">&quot;done&quot;</span>
-
-<span class="o">&gt;&gt;&gt;</span> <span class="k">print</span><span class="p">(</span><span class="n">heavy_computation</span><span class="p">())</span> <span class="c"># the first time it will take 2 seconds</span>
-<span class="n">done</span>
-
-<span class="o">&gt;&gt;&gt;</span> <span class="k">print</span><span class="p">(</span><span class="n">heavy_computation</span><span class="p">())</span> <span class="c"># the second time it will be instantaneous</span>
-<span class="n">done</span>
-</pre></div>
-
-</div>
-<p>The signature of <tt class="docutils literal">heavy_computation</tt> is the one you would expect:</p>
-<div class="codeblock python">
-<div class="highlight"><pre><span class="o">&gt;&gt;&gt;</span> <span class="k">print</span><span class="p">(</span><span class="n">getargspec</span><span class="p">(</span><span class="n">heavy_computation</span><span class="p">))</span>
-<span class="n">ArgSpec</span><span class="p">(</span><span class="n">args</span><span class="o">=</span><span class="p">[],</span> <span class="n">varargs</span><span class="o">=</span><span class="bp">None</span><span class="p">,</span> <span class="n">keywords</span><span class="o">=</span><span class="bp">None</span><span class="p">,</span> <span class="n">defaults</span><span class="o">=</span><span class="bp">None</span><span class="p">)</span>
-</pre></div>
-
-</div>
-</div>
-<div class="section" id="a-trace-decorator">
-<h1><a class="toc-backref" href="#id8">A <tt class="docutils literal">trace</tt> decorator</a></h1>
-<p>As an additional example, here is how you can define a trivial
-<tt class="docutils literal">trace</tt> decorator, which prints a message everytime the traced
-function is called:</p>
-<div class="codeblock python">
-<div class="highlight"><pre><span class="k">def</span> <span class="nf">_trace</span><span class="p">(</span><span class="n">f</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">kw</span><span class="p">):</span>
-    <span class="n">kwstr</span> <span class="o">=</span> <span class="s">&#39;, &#39;</span><span class="o">.</span><span class="n">join</span><span class="p">(</span><span class="s">&#39;</span><span class="si">%r</span><span class="s">: </span><span class="si">%r</span><span class="s">&#39;</span> <span class="o">%</span> <span class="p">(</span><span class="n">k</span><span class="p">,</span> <span class="n">kw</span><span class="p">[</span><span class="n">k</span><span class="p">])</span> <span class="k">for</span> <span class="n">k</span> <span class="ow">in</span> <span class="nb">sorted</span><span class="p">(</span><span class="n">kw</span><span class="p">))</span>
-    <span class="k">print</span><span class="p">(</span><span class="s">&quot;calling </span><span class="si">%s</span><span class="s"> with args </span><span class="si">%s</span><span class="s">, {</span><span class="si">%s</span><span class="s">}&quot;</span> <span class="o">%</span> <span class="p">(</span><span class="n">f</span><span class="o">.</span><span class="n">__name__</span><span class="p">,</span> <span class="n">args</span><span class="p">,</span> <span class="n">kwstr</span><span class="p">))</span>
-    <span class="k">return</span> <span class="n">f</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">kw</span><span class="p">)</span>
-</pre></div>
-
-</div>
-<div class="codeblock python">
-<div class="highlight"><pre><span class="k">def</span> <span class="nf">trace</span><span class="p">(</span><span class="n">f</span><span class="p">):</span>
-    <span class="k">return</span> <span class="n">decorator</span><span class="p">(</span><span class="n">_trace</span><span class="p">,</span> <span class="n">f</span><span class="p">)</span>
-</pre></div>
-
-</div>
-<p>Here is an example of usage:</p>
-<div class="codeblock python">
-<div class="highlight"><pre><span class="o">&gt;&gt;&gt;</span> <span class="nd">@trace</span>
-<span class="o">...</span> <span class="k">def</span> <span class="nf">f1</span><span class="p">(</span><span class="n">x</span><span class="p">):</span>
-<span class="o">...</span>     <span class="k">pass</span>
-</pre></div>
-
-</div>
-<p>It is immediate to verify that <tt class="docutils literal">f1</tt> works</p>
-<div class="codeblock python">
-<div class="highlight"><pre><span class="o">&gt;&gt;&gt;</span> <span class="n">f1</span><span class="p">(</span><span class="mi">0</span><span class="p">)</span>
-<span class="n">calling</span> <span class="n">f1</span> <span class="k">with</span> <span class="n">args</span> <span class="p">(</span><span class="mi">0</span><span class="p">,),</span> <span class="p">{}</span>
-</pre></div>
-
-</div>
-<p>and it that it has the correct signature:</p>
-<div class="codeblock python">
-<div class="highlight"><pre><span class="o">&gt;&gt;&gt;</span> <span class="k">print</span><span class="p">(</span><span class="n">getargspec</span><span class="p">(</span><span class="n">f1</span><span class="p">))</span>
-<span class="n">ArgSpec</span><span class="p">(</span><span class="n">args</span><span class="o">=</span><span class="p">[</span><span class="s">&#39;x&#39;</span><span class="p">],</span> <span class="n">varargs</span><span class="o">=</span><span class="bp">None</span><span class="p">,</span> <span class="n">keywords</span><span class="o">=</span><span class="bp">None</span><span class="p">,</span> <span class="n">defaults</span><span class="o">=</span><span class="bp">None</span><span class="p">)</span>
-</pre></div>
-
-</div>
-<p>The same decorator works with functions of any signature:</p>
-<div class="codeblock python">
-<div class="highlight"><pre><span class="o">&gt;&gt;&gt;</span> <span class="nd">@trace</span>
-<span class="o">...</span> <span class="k">def</span> <span class="nf">f</span><span class="p">(</span><span class="n">x</span><span class="p">,</span> <span class="n">y</span><span class="o">=</span><span class="mi">1</span><span class="p">,</span> <span class="n">z</span><span class="o">=</span><span class="mi">2</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">kw</span><span class="p">):</span>
-<span class="o">...</span>     <span class="k">pass</span>
-
-<span class="o">&gt;&gt;&gt;</span> <span class="n">f</span><span class="p">(</span><span class="mi">0</span><span class="p">,</span> <span class="mi">3</span><span class="p">)</span>
-<span class="n">calling</span> <span class="n">f</span> <span class="k">with</span> <span class="n">args</span> <span class="p">(</span><span class="mi">0</span><span class="p">,</span> <span class="mi">3</span><span class="p">,</span> <span class="mi">2</span><span class="p">),</span> <span class="p">{}</span>
-
-<span class="o">&gt;&gt;&gt;</span> <span class="k">print</span><span class="p">(</span><span class="n">getargspec</span><span class="p">(</span><span class="n">f</span><span class="p">))</span>
-<span class="n">ArgSpec</span><span class="p">(</span><span class="n">args</span><span class="o">=</span><span class="p">[</span><span class="s">&#39;x&#39;</span><span class="p">,</span> <span class="s">&#39;y&#39;</span><span class="p">,</span> <span class="s">&#39;z&#39;</span><span class="p">],</span> <span class="n">varargs</span><span class="o">=</span><span class="s">&#39;args&#39;</span><span class="p">,</span> <span class="n">keywords</span><span class="o">=</span><span class="s">&#39;kw&#39;</span><span class="p">,</span> <span class="n">defaults</span><span class="o">=</span><span class="p">(</span><span class="mi">1</span><span class="p">,</span> <span class="mi">2</span><span class="p">))</span>
-</pre></div>
-
-</div>
-</div>
-<div class="section" id="function-annotations">
-<h1><a class="toc-backref" href="#id9">Function annotations</a></h1>
-<p>Python 3 introduced the concept of <a class="reference external" href="http://www.python.org/dev/peps/pep-3107/">function annotations</a>,i.e. the ability
-to annotate the signature of a function with additional information,
-stored in a dictionary named <tt class="docutils literal">__annotations__</tt>. The decorator module,
-starting from release 3.3, is able to understand and to preserve the
-annotations. Here is an example:</p>
-<div class="codeblock python">
-<div class="highlight"><pre><span class="o">&gt;&gt;&gt;</span> <span class="nd">@trace</span>
-<span class="o">...</span> <span class="k">def</span> <span class="nf">f</span><span class="p">(</span><span class="n">x</span><span class="p">:</span> <span class="s">&#39;the first argument&#39;</span><span class="p">,</span> <span class="n">y</span><span class="p">:</span> <span class="s">&#39;default argument&#39;</span><span class="o">=</span><span class="mi">1</span><span class="p">,</span> <span class="n">z</span><span class="o">=</span><span class="mi">2</span><span class="p">,</span>
-<span class="o">...</span>       <span class="o">*</span><span class="n">args</span><span class="p">:</span> <span class="s">&#39;varargs&#39;</span><span class="p">,</span> <span class="o">**</span><span class="n">kw</span><span class="p">:</span> <span class="s">&#39;kwargs&#39;</span><span class="p">):</span>
-<span class="o">...</span>     <span class="k">pass</span>
-</pre></div>
-
-</div>
-<p>In order to introspect functions with annotations, one needs the
-utility <tt class="docutils literal">inspect.getfullargspec</tt>, new in Python 3:</p>
-<div class="codeblock python">
-<div class="highlight"><pre><span class="o">&gt;&gt;&gt;</span> <span class="kn">from</span> <span class="nn">inspect</span> <span class="kn">import</span> <span class="n">getfullargspec</span>
-<span class="o">&gt;&gt;&gt;</span> <span class="n">argspec</span> <span class="o">=</span> <span class="n">getfullargspec</span><span class="p">(</span><span class="n">f</span><span class="p">)</span>
-<span class="o">&gt;&gt;&gt;</span> <span class="n">argspec</span><span class="o">.</span><span class="n">args</span>
-<span class="p">[</span><span class="s">&#39;x&#39;</span><span class="p">,</span> <span class="s">&#39;y&#39;</span><span class="p">,</span> <span class="s">&#39;z&#39;</span><span class="p">]</span>
-<span class="o">&gt;&gt;&gt;</span> <span class="n">argspec</span><span class="o">.</span><span class="n">varargs</span>
-<span class="s">&#39;args&#39;</span>
-<span class="o">&gt;&gt;&gt;</span> <span class="n">argspec</span><span class="o">.</span><span class="n">varkw</span>
-<span class="s">&#39;kw&#39;</span>
-<span class="o">&gt;&gt;&gt;</span> <span class="n">argspec</span><span class="o">.</span><span class="n">defaults</span>
-<span class="p">(</span><span class="mi">1</span><span class="p">,</span> <span class="mi">2</span><span class="p">)</span>
-<span class="o">&gt;&gt;&gt;</span> <span class="n">argspec</span><span class="o">.</span><span class="n">kwonlyargs</span>
-<span class="p">[]</span>
-<span class="o">&gt;&gt;&gt;</span> <span class="n">argspec</span><span class="o">.</span><span class="n">kwonlydefaults</span>
-</pre></div>
-
-</div>
-<p>You can also check that the <tt class="docutils literal">__annotations__</tt> dictionary is preserved:</p>
-<div class="codeblock python">
-<div class="highlight"><pre><span class="o">&gt;&gt;&gt;</span> <span class="n">f</span><span class="o">.</span><span class="n">__annotations__</span> <span class="o">==</span> <span class="n">f</span><span class="o">.</span><span class="n">__wrapped__</span><span class="o">.</span><span class="n">__annotations__</span>
-<span class="bp">True</span>
-</pre></div>
-
-</div>
-<p>Depending on the version of the decorator module, the two dictionaries can
-be the same object or not: you cannot rely on object identity, but you can
-rely on the content being the same.</p>
-</div>
-<div class="section" id="decorator-is-a-decorator">
-<h1><a class="toc-backref" href="#id10"><tt class="docutils literal">decorator</tt> is a decorator</a></h1>
-<p>It may be annoying to write a caller function (like the <tt class="docutils literal">_trace</tt>
-function above) and then a trivial wrapper
-(<tt class="docutils literal">def trace(f): return decorator(_trace, f)</tt>) every time. For this reason,
-the <tt class="docutils literal">decorator</tt> module provides an easy shortcut to convert
-the caller function into a signature-preserving decorator:
-you can just call <tt class="docutils literal">decorator</tt> with a single argument.
-In our example you can just write <tt class="docutils literal">trace = decorator(_trace)</tt>.
-The <tt class="docutils literal">decorator</tt> function can also be used as a signature-changing
-decorator, just as <tt class="docutils literal">classmethod</tt> and <tt class="docutils literal">staticmethod</tt>.
-However, <tt class="docutils literal">classmethod</tt> and <tt class="docutils literal">staticmethod</tt> return generic
-objects which are not callable, while <tt class="docutils literal">decorator</tt> returns
-signature-preserving decorators, i.e. functions of a single argument.
-For instance, you can write directly</p>
-<div class="codeblock python">
-<div class="highlight"><pre><span class="o">&gt;&gt;&gt;</span> <span class="nd">@decorator</span>
-<span class="o">...</span> <span class="k">def</span> <span class="nf">trace</span><span class="p">(</span><span class="n">f</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">kw</span><span class="p">):</span>
-<span class="o">...</span>     <span class="n">kwstr</span> <span class="o">=</span> <span class="s">&#39;, &#39;</span><span class="o">.</span><span class="n">join</span><span class="p">(</span><span class="s">&#39;</span><span class="si">%r</span><span class="s">: </span><span class="si">%r</span><span class="s">&#39;</span> <span class="o">%</span> <span class="p">(</span><span class="n">k</span><span class="p">,</span> <span class="n">kw</span><span class="p">[</span><span class="n">k</span><span class="p">])</span> <span class="k">for</span> <span class="n">k</span> <span class="ow">in</span> <span class="nb">sorted</span><span class="p">(</span><span class="n">kw</span><span class="p">))</span>
-<span class="o">...</span>     <span class="k">print</span><span class="p">(</span><span class="s">&quot;calling </span><span class="si">%s</span><span class="s"> with args </span><span class="si">%s</span><span class="s">, {</span><span class="si">%s</span><span class="s">}&quot;</span> <span class="o">%</span> <span class="p">(</span><span class="n">f</span><span class="o">.</span><span class="n">__name__</span><span class="p">,</span> <span class="n">args</span><span class="p">,</span> <span class="n">kwstr</span><span class="p">))</span>
-<span class="o">...</span>     <span class="k">return</span> <span class="n">f</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">kw</span><span class="p">)</span>
-</pre></div>
-
-</div>
-<p>and now <tt class="docutils literal">trace</tt> will be a decorator. Actually <tt class="docutils literal">trace</tt> is a <tt class="docutils literal">partial</tt>
-object which can be used as a decorator:</p>
-<div class="codeblock python">
-<div class="highlight"><pre><span class="o">&gt;&gt;&gt;</span> <span class="n">trace</span>
-<span class="o">&lt;</span><span class="n">function</span> <span class="n">trace</span> <span class="n">at</span> <span class="mi">0</span><span class="n">x</span><span class="o">...&gt;</span>
-</pre></div>
-
-</div>
-<p>Here is an example of usage:</p>
-<div class="codeblock python">
-<div class="highlight"><pre><span class="o">&gt;&gt;&gt;</span> <span class="nd">@trace</span>
-<span class="o">...</span> <span class="k">def</span> <span class="nf">func</span><span class="p">():</span> <span class="k">pass</span>
-
-<span class="o">&gt;&gt;&gt;</span> <span class="n">func</span><span class="p">()</span>
-<span class="n">calling</span> <span class="n">func</span> <span class="k">with</span> <span class="n">args</span> <span class="p">(),</span> <span class="p">{}</span>
-</pre></div>
-
-</div>
-<p>If you are using an old Python version (Python 2.4) the
-<tt class="docutils literal">decorator</tt> module provides a poor man replacement for
-<tt class="docutils literal">functools.partial</tt>.</p>
-</div>
-<div class="section" id="blocking">
-<h1><a class="toc-backref" href="#id11"><tt class="docutils literal">blocking</tt></a></h1>
-<p>Sometimes one has to deal with blocking resources, such as <tt class="docutils literal">stdin</tt>, and
-sometimes it is best to have back a &quot;busy&quot; message than to block everything.
-This behavior can be implemented with a suitable family of decorators,
-where the parameter is the busy message:</p>
-<div class="codeblock python">
-<div class="highlight"><pre><span class="k">def</span> <span class="nf">blocking</span><span class="p">(</span><span class="n">not_avail</span><span class="p">):</span>
-    <span class="k">def</span> <span class="nf">blocking</span><span class="p">(</span><span class="n">f</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">kw</span><span class="p">):</span>
-        <span class="k">if</span> <span class="ow">not</span> <span class="nb">hasattr</span><span class="p">(</span><span class="n">f</span><span class="p">,</span> <span class="s">&quot;thread&quot;</span><span class="p">):</span> <span class="c"># no thread running</span>
-            <span class="k">def</span> <span class="nf">set_result</span><span class="p">():</span> <span class="n">f</span><span class="o">.</span><span class="n">result</span> <span class="o">=</span> <span class="n">f</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">kw</span><span class="p">)</span>
-            <span class="n">f</span><span class="o">.</span><span class="n">thread</span> <span class="o">=</span> <span class="n">threading</span><span class="o">.</span><span class="n">Thread</span><span class="p">(</span><span class="bp">None</span><span class="p">,</span> <span class="n">set_result</span><span class="p">)</span>
-            <span class="n">f</span><span class="o">.</span><span class="n">thread</span><span class="o">.</span><span class="n">start</span><span class="p">()</span>
-            <span class="k">return</span> <span class="n">not_avail</span>
-        <span class="k">elif</span> <span class="n">f</span><span class="o">.</span><span class="n">thread</span><span class="o">.</span><span class="n">isAlive</span><span class="p">():</span>
-            <span class="k">return</span> <span class="n">not_avail</span>
-        <span class="k">else</span><span class="p">:</span> <span class="c"># the thread is ended, return the stored result</span>
-            <span class="k">del</span> <span class="n">f</span><span class="o">.</span><span class="n">thread</span>
-            <span class="k">return</span> <span class="n">f</span><span class="o">.</span><span class="n">result</span>
-    <span class="k">return</span> <span class="n">decorator</span><span class="p">(</span><span class="n">blocking</span><span class="p">)</span>
-</pre></div>
-
-</div>
-<p>Functions decorated with <tt class="docutils literal">blocking</tt> will return a busy message if
-the resource is unavailable, and the intended result if the resource is
-available. For instance:</p>
-<div class="codeblock python">
-<div class="highlight"><pre><span class="o">&gt;&gt;&gt;</span> <span class="nd">@blocking</span><span class="p">(</span><span class="s">&quot;Please wait ...&quot;</span><span class="p">)</span>
-<span class="o">...</span> <span class="k">def</span> <span class="nf">read_data</span><span class="p">():</span>
-<span class="o">...</span>     <span class="n">time</span><span class="o">.</span><span class="n">sleep</span><span class="p">(</span><span class="mi">3</span><span class="p">)</span> <span class="c"># simulate a blocking resource</span>
-<span class="o">...</span>     <span class="k">return</span> <span class="s">&quot;some data&quot;</span>
-
-<span class="o">&gt;&gt;&gt;</span> <span class="k">print</span><span class="p">(</span><span class="n">read_data</span><span class="p">())</span> <span class="c"># data is not available yet</span>
-<span class="n">Please</span> <span class="n">wait</span> <span class="o">...</span>
-
-<span class="o">&gt;&gt;&gt;</span> <span class="n">time</span><span class="o">.</span><span class="n">sleep</span><span class="p">(</span><span class="mi">1</span><span class="p">)</span>
-<span class="o">&gt;&gt;&gt;</span> <span class="k">print</span><span class="p">(</span><span class="n">read_data</span><span class="p">())</span> <span class="c"># data is not available yet</span>
-<span class="n">Please</span> <span class="n">wait</span> <span class="o">...</span>
-
-<span class="o">&gt;&gt;&gt;</span> <span class="n">time</span><span class="o">.</span><span class="n">sleep</span><span class="p">(</span><span class="mi">1</span><span class="p">)</span>
-<span class="o">&gt;&gt;&gt;</span> <span class="k">print</span><span class="p">(</span><span class="n">read_data</span><span class="p">())</span> <span class="c"># data is not available yet</span>
-<span class="n">Please</span> <span class="n">wait</span> <span class="o">...</span>
-
-<span class="o">&gt;&gt;&gt;</span> <span class="n">time</span><span class="o">.</span><span class="n">sleep</span><span class="p">(</span><span class="mf">1.1</span><span class="p">)</span> <span class="c"># after 3.1 seconds, data is available</span>
-<span class="o">&gt;&gt;&gt;</span> <span class="k">print</span><span class="p">(</span><span class="n">read_data</span><span class="p">())</span>
-<span class="n">some</span> <span class="n">data</span>
-</pre></div>
-
-</div>
-</div>
-<div class="section" id="async">
-<h1><a class="toc-backref" href="#id12"><tt class="docutils literal">async</tt></a></h1>
-<p>We have just seen an examples of a simple decorator factory,
-implemented as a function returning a decorator.
-For more complex situations, it is more
-convenient to implement decorator factories as classes returning
-callable objects that can be converted into decorators.</p>
-<p>As an example, here will I show a decorator
-which is able to convert a blocking function into an asynchronous
-function. The function, when called,
-is executed in a separate thread. Moreover, it is possible to set
-three callbacks <tt class="docutils literal">on_success</tt>, <tt class="docutils literal">on_failure</tt> and <tt class="docutils literal">on_closing</tt>,
-to specify how to manage the function call (of course the code here
-is just an example, it is not a recommended way of doing multi-threaded
-programming). The implementation is the following:</p>
-<div class="codeblock python">
-<div class="highlight"><pre><span class="k">def</span> <span class="nf">on_success</span><span class="p">(</span><span class="n">result</span><span class="p">):</span> <span class="c"># default implementation</span>
-    <span class="s">&quot;Called on the result of the function&quot;</span>
-    <span class="k">return</span> <span class="n">result</span>
-</pre></div>
-
-</div>
-<div class="codeblock python">
-<div class="highlight"><pre><span class="k">def</span> <span class="nf">on_failure</span><span class="p">(</span><span class="n">exc_info</span><span class="p">):</span> <span class="c"># default implementation</span>
-    <span class="s">&quot;Called if the function fails&quot;</span>
-    <span class="k">pass</span>
-</pre></div>
-
-</div>
-<div class="codeblock python">
-<div class="highlight"><pre><span class="k">def</span> <span class="nf">on_closing</span><span class="p">():</span> <span class="c"># default implementation</span>
-    <span class="s">&quot;Called at the end, both in case of success and failure&quot;</span>
-    <span class="k">pass</span>
-</pre></div>
-
-</div>
-<div class="codeblock python">
-<div class="highlight"><pre><span class="k">class</span> <span class="nc">Async</span><span class="p">(</span><span class="nb">object</span><span class="p">):</span>
-    <span class="sd">&quot;&quot;&quot;</span>
-<span class="sd">    A decorator converting blocking functions into asynchronous</span>
-<span class="sd">    functions, by using threads or processes. Examples:</span>
-
-<span class="sd">    async_with_threads =  Async(threading.Thread)</span>
-<span class="sd">    async_with_processes =  Async(multiprocessing.Process)</span>
-<span class="sd">    &quot;&quot;&quot;</span>
-
-    <span class="k">def</span> <span class="nf">__init__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">threadfactory</span><span class="p">,</span> <span class="n">on_success</span><span class="o">=</span><span class="n">on_success</span><span class="p">,</span>
-                 <span class="n">on_failure</span><span class="o">=</span><span class="n">on_failure</span><span class="p">,</span> <span class="n">on_closing</span><span class="o">=</span><span class="n">on_closing</span><span class="p">):</span>
-        <span class="bp">self</span><span class="o">.</span><span class="n">threadfactory</span> <span class="o">=</span> <span class="n">threadfactory</span>
-        <span class="bp">self</span><span class="o">.</span><span class="n">on_success</span> <span class="o">=</span> <span class="n">on_success</span>
-        <span class="bp">self</span><span class="o">.</span><span class="n">on_failure</span> <span class="o">=</span> <span class="n">on_failure</span>
-        <span class="bp">self</span><span class="o">.</span><span class="n">on_closing</span> <span class="o">=</span> <span class="n">on_closing</span>
-
-    <span class="k">def</span> <span class="nf">__call__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">func</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">kw</span><span class="p">):</span>
-        <span class="k">try</span><span class="p">:</span>
-            <span class="n">counter</span> <span class="o">=</span> <span class="n">func</span><span class="o">.</span><span class="n">counter</span>
-        <span class="k">except</span> <span class="ne">AttributeError</span><span class="p">:</span> <span class="c"># instantiate the counter at the first call</span>
-            <span class="n">counter</span> <span class="o">=</span> <span class="n">func</span><span class="o">.</span><span class="n">counter</span> <span class="o">=</span> <span class="n">itertools</span><span class="o">.</span><span class="n">count</span><span class="p">(</span><span class="mi">1</span><span class="p">)</span>
-        <span class="n">name</span> <span class="o">=</span> <span class="s">&#39;</span><span class="si">%s</span><span class="s">-</span><span class="si">%s</span><span class="s">&#39;</span> <span class="o">%</span> <span class="p">(</span><span class="n">func</span><span class="o">.</span><span class="n">__name__</span><span class="p">,</span> <span class="nb">next</span><span class="p">(</span><span class="n">counter</span><span class="p">))</span>
-        <span class="k">def</span> <span class="nf">func_wrapper</span><span class="p">():</span>
-            <span class="k">try</span><span class="p">:</span>
-                <span class="n">result</span> <span class="o">=</span> <span class="n">func</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">kw</span><span class="p">)</span>
-            <span class="k">except</span><span class="p">:</span>
-                <span class="bp">self</span><span class="o">.</span><span class="n">on_failure</span><span class="p">(</span><span class="n">sys</span><span class="o">.</span><span class="n">exc_info</span><span class="p">())</span>
-            <span class="k">else</span><span class="p">:</span>
-                <span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="n">on_success</span><span class="p">(</span><span class="n">result</span><span class="p">)</span>
-            <span class="k">finally</span><span class="p">:</span>
-                <span class="bp">self</span><span class="o">.</span><span class="n">on_closing</span><span class="p">()</span>
-        <span class="n">thread</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="n">threadfactory</span><span class="p">(</span><span class="bp">None</span><span class="p">,</span> <span class="n">func_wrapper</span><span class="p">,</span> <span class="n">name</span><span class="p">)</span>
-        <span class="n">thread</span><span class="o">.</span><span class="n">start</span><span class="p">()</span>
-        <span class="k">return</span> <span class="n">thread</span>
-</pre></div>
-
-</div>
-<p>The decorated function returns
-the current execution thread, which can be stored and checked later, for
-instance to verify that the thread <tt class="docutils literal">.isAlive()</tt>.</p>
-<p>Here is an example of usage. Suppose one wants to write some data to
-an external resource which can be accessed by a single user at once
-(for instance a printer). Then the access to the writing function must
-be locked. Here is a minimalistic example:</p>
-<div class="codeblock python">
-<div class="highlight"><pre><span class="o">&gt;&gt;&gt;</span> <span class="n">async</span> <span class="o">=</span> <span class="n">decorator</span><span class="p">(</span><span class="n">Async</span><span class="p">(</span><span class="n">threading</span><span class="o">.</span><span class="n">Thread</span><span class="p">))</span>
-
-<span class="o">&gt;&gt;&gt;</span> <span class="n">datalist</span> <span class="o">=</span> <span class="p">[]</span> <span class="c"># for simplicity the written data are stored into a list.</span>
-
-<span class="o">&gt;&gt;&gt;</span> <span class="nd">@async</span>
-<span class="o">...</span> <span class="k">def</span> <span class="nf">write</span><span class="p">(</span><span class="n">data</span><span class="p">):</span>
-<span class="o">...</span>     <span class="c"># append data to the datalist by locking</span>
-<span class="o">...</span>     <span class="k">with</span> <span class="n">threading</span><span class="o">.</span><span class="n">Lock</span><span class="p">():</span>
-<span class="o">...</span>         <span class="n">time</span><span class="o">.</span><span class="n">sleep</span><span class="p">(</span><span class="mi">1</span><span class="p">)</span> <span class="c"># emulate some long running operation</span>
-<span class="o">...</span>         <span class="n">datalist</span><span class="o">.</span><span class="n">append</span><span class="p">(</span><span class="n">data</span><span class="p">)</span>
-<span class="o">...</span>     <span class="c"># other operations not requiring a lock here</span>
-</pre></div>
-
-</div>
-<p>Each call to <tt class="docutils literal">write</tt> will create a new writer thread, but there will
-be no synchronization problems since <tt class="docutils literal">write</tt> is locked.</p>
-<div class="codeblock python">
-<div class="highlight"><pre><span class="o">&gt;&gt;&gt;</span> <span class="n">write</span><span class="p">(</span><span class="s">&quot;data1&quot;</span><span class="p">)</span>
-<span class="o">&lt;</span><span class="n">Thread</span><span class="p">(</span><span class="n">write</span><span class="o">-</span><span class="mi">1</span><span class="p">,</span> <span class="n">started</span><span class="o">...</span><span class="p">)</span><span class="o">&gt;</span>
-
-<span class="o">&gt;&gt;&gt;</span> <span class="n">time</span><span class="o">.</span><span class="n">sleep</span><span class="p">(</span><span class="o">.</span><span class="mi">1</span><span class="p">)</span> <span class="c"># wait a bit, so we are sure data2 is written after data1</span>
-
-<span class="o">&gt;&gt;&gt;</span> <span class="n">write</span><span class="p">(</span><span class="s">&quot;data2&quot;</span><span class="p">)</span>
-<span class="o">&lt;</span><span class="n">Thread</span><span class="p">(</span><span class="n">write</span><span class="o">-</span><span class="mi">2</span><span class="p">,</span> <span class="n">started</span><span class="o">...</span><span class="p">)</span><span class="o">&gt;</span>
-
-<span class="o">&gt;&gt;&gt;</span> <span class="n">time</span><span class="o">.</span><span class="n">sleep</span><span class="p">(</span><span class="mi">2</span><span class="p">)</span> <span class="c"># wait for the writers to complete</span>
-
-<span class="o">&gt;&gt;&gt;</span> <span class="k">print</span><span class="p">(</span><span class="n">datalist</span><span class="p">)</span>
-<span class="p">[</span><span class="s">&#39;data1&#39;</span><span class="p">,</span> <span class="s">&#39;data2&#39;</span><span class="p">]</span>
-</pre></div>
-
-</div>
-</div>
-<div class="section" id="contextmanager">
-<h1><a class="toc-backref" href="#id13">contextmanager</a></h1>
-<p>For a long time Python had in its standard library a <tt class="docutils literal">contextmanager</tt>
-decorator, able to convert generator functions into
-<tt class="docutils literal">_GeneratorContextManager</tt>
-factories. For instance if you write</p>
-<div class="codeblock python">
-<div class="highlight"><pre><span class="o">&gt;&gt;&gt;</span> <span class="kn">from</span> <span class="nn">contextlib</span> <span class="kn">import</span> <span class="n">contextmanager</span>
-<span class="o">&gt;&gt;&gt;</span> <span class="nd">@contextmanager</span>
-<span class="o">...</span> <span class="k">def</span> <span class="nf">before_after</span><span class="p">(</span><span class="n">before</span><span class="p">,</span> <span class="n">after</span><span class="p">):</span>
-<span class="o">...</span>     <span class="k">print</span><span class="p">(</span><span class="n">before</span><span class="p">)</span>
-<span class="o">...</span>     <span class="k">yield</span>
-<span class="o">...</span>     <span class="k">print</span><span class="p">(</span><span class="n">after</span><span class="p">)</span>
-</pre></div>
-
-</div>
-<p>then <tt class="docutils literal">before_after</tt> is a factory function returning
-<tt class="docutils literal">_GeneratorContextManager</tt> objects which can be used with
-the <tt class="docutils literal">with</tt> statement:</p>
-<div class="codeblock python">
-<div class="highlight"><pre><span class="o">&gt;&gt;&gt;</span> <span class="n">ba</span> <span class="o">=</span> <span class="n">before_after</span><span class="p">(</span><span class="s">&#39;BEFORE&#39;</span><span class="p">,</span> <span class="s">&#39;AFTER&#39;</span><span class="p">)</span>
-<span class="o">&gt;&gt;&gt;</span> <span class="nb">type</span><span class="p">(</span><span class="n">ba</span><span class="p">)</span>
-<span class="o">&lt;</span><span class="k">class</span> <span class="err">&#39;</span><span class="nc">contextlib</span><span class="o">.</span><span class="n">_GeneratorContextManager</span><span class="s">&#39;&gt;</span>
-<span class="o">&gt;&gt;&gt;</span> <span class="k">with</span> <span class="n">ba</span><span class="p">:</span>
-<span class="o">...</span>     <span class="k">print</span><span class="p">(</span><span class="s">&#39;hello&#39;</span><span class="p">)</span>
-<span class="n">BEFORE</span>
-<span class="n">hello</span>
-<span class="n">AFTER</span>
-</pre></div>
-
-</div>
-<p>Basically, it is as if the content of the <tt class="docutils literal">with</tt> block was executed
-in the place of the <tt class="docutils literal">yield</tt> expression in the generator function.
-In Python 3.2 <tt class="docutils literal">_GeneratorContextManager</tt>
-objects were enhanced with a <tt class="docutils literal">__call__</tt>
-method, so that they can be used as decorators as in this example:</p>
-<div class="codeblock python">
-<div class="highlight"><pre><span class="o">&gt;&gt;&gt;</span> <span class="nd">@ba</span>
-<span class="o">...</span> <span class="k">def</span> <span class="nf">hello</span><span class="p">():</span>
-<span class="o">...</span>     <span class="k">print</span><span class="p">(</span><span class="s">&#39;hello&#39;</span><span class="p">)</span>
-<span class="o">...</span>
-<span class="o">&gt;&gt;&gt;</span> <span class="n">hello</span><span class="p">()</span>
-<span class="n">BEFORE</span>
-<span class="n">hello</span>
-<span class="n">AFTER</span>
-</pre></div>
-
-</div>
-<p>The <tt class="docutils literal">ba</tt> decorator is basically inserting a <tt class="docutils literal">with ba:</tt>
-block inside the function.
-However there two issues: the first is that <tt class="docutils literal">_GeneratorContextManager</tt>
-objects are callable only in Python 3.2, so the previous example will break
-in older versions of Python; the second is that
-<tt class="docutils literal">_GeneratorContextManager</tt> objects do not preserve the signature
-of the decorated functions: the decorated <tt class="docutils literal">hello</tt> function here will have
-a generic signature <tt class="docutils literal"><span class="pre">hello(*args,</span> **kwargs)</tt> but will break when
-called with more than zero arguments. For such reasons the decorator
-module, starting with release 3.4, offers a <tt class="docutils literal">decorator.contextmanager</tt>
-decorator that solves both problems and works even in Python 2.5.
-The usage is the same and factories decorated with <tt class="docutils literal">decorator.contextmanager</tt>
-will returns instances of <tt class="docutils literal">ContextManager</tt>, a subclass of
-<tt class="docutils literal">contextlib._GeneratorContextManager</tt> with a <tt class="docutils literal">__call__</tt> method
-acting as a signature-preserving decorator.</p>
-</div>
-<div class="section" id="the-functionmaker-class">
-<h1><a class="toc-backref" href="#id14">The <tt class="docutils literal">FunctionMaker</tt> class</a></h1>
-<p>You may wonder about how the functionality of the <tt class="docutils literal">decorator</tt> module
-is implemented. The basic building block is
-a <tt class="docutils literal">FunctionMaker</tt> class which is able to generate on the fly
-functions with a given name and signature from a function template
-passed as a string. Generally speaking, you should not need to
-resort to <tt class="docutils literal">FunctionMaker</tt> when writing ordinary decorators, but
-it is handy in some circumstances. You will see an example shortly, in
-the implementation of a cool decorator utility (<tt class="docutils literal">decorator_apply</tt>).</p>
-<p><tt class="docutils literal">FunctionMaker</tt> provides a <tt class="docutils literal">.create</tt> classmethod which
-takes as input the name, signature, and body of the function
-we want to generate as well as the execution environment
-were the function is generated by <tt class="docutils literal">exec</tt>. Here is an example:</p>
-<div class="codeblock python">
-<div class="highlight"><pre><span class="o">&gt;&gt;&gt;</span> <span class="k">def</span> <span class="nf">f</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">kw</span><span class="p">):</span> <span class="c"># a function with a generic signature</span>
-<span class="o">...</span>     <span class="k">print</span><span class="p">(</span><span class="n">args</span><span class="p">,</span> <span class="n">kw</span><span class="p">)</span>
-
-<span class="o">&gt;&gt;&gt;</span> <span class="n">f1</span> <span class="o">=</span> <span class="n">FunctionMaker</span><span class="o">.</span><span class="n">create</span><span class="p">(</span><span class="s">&#39;f1(a, b)&#39;</span><span class="p">,</span> <span class="s">&#39;f(a, b)&#39;</span><span class="p">,</span> <span class="nb">dict</span><span class="p">(</span><span class="n">f</span><span class="o">=</span><span class="n">f</span><span class="p">))</span>
-<span class="o">&gt;&gt;&gt;</span> <span class="n">f1</span><span class="p">(</span><span class="mi">1</span><span class="p">,</span><span class="mi">2</span><span class="p">)</span>
-<span class="p">(</span><span class="mi">1</span><span class="p">,</span> <span class="mi">2</span><span class="p">)</span> <span class="p">{}</span>
-</pre></div>
-
-</div>
-<p>It is important to notice that the function body is interpolated
-before being executed, so be careful with the <tt class="docutils literal">%</tt> sign!</p>
-<p><tt class="docutils literal">FunctionMaker.create</tt> also accepts keyword arguments and such
-arguments are attached to the resulting function. This is useful
-if you want to set some function attributes, for instance the
-docstring <tt class="docutils literal">__doc__</tt>.</p>
-<p>For debugging/introspection purposes it may be useful to see
-the source code of the generated function; to do that, just
-pass the flag <tt class="docutils literal">addsource=True</tt> and a <tt class="docutils literal">__source__</tt> attribute will
-be added to the generated function:</p>
-<div class="codeblock python">
-<div class="highlight"><pre><span class="o">&gt;&gt;&gt;</span> <span class="n">f1</span> <span class="o">=</span> <span class="n">FunctionMaker</span><span class="o">.</span><span class="n">create</span><span class="p">(</span>
-<span class="o">...</span>     <span class="s">&#39;f1(a, b)&#39;</span><span class="p">,</span> <span class="s">&#39;f(a, b)&#39;</span><span class="p">,</span> <span class="nb">dict</span><span class="p">(</span><span class="n">f</span><span class="o">=</span><span class="n">f</span><span class="p">),</span> <span class="n">addsource</span><span class="o">=</span><span class="bp">True</span><span class="p">)</span>
-<span class="o">&gt;&gt;&gt;</span> <span class="k">print</span><span class="p">(</span><span class="n">f1</span><span class="o">.</span><span class="n">__source__</span><span class="p">)</span>
-<span class="k">def</span> <span class="nf">f1</span><span class="p">(</span><span class="n">a</span><span class="p">,</span> <span class="n">b</span><span class="p">):</span>
-    <span class="n">f</span><span class="p">(</span><span class="n">a</span><span class="p">,</span> <span class="n">b</span><span class="p">)</span>
-<span class="o">&lt;</span><span class="n">BLANKLINE</span><span class="o">&gt;</span>
-</pre></div>
-
-</div>
-<p><tt class="docutils literal">FunctionMaker.create</tt> can take as first argument a string,
-as in the examples before, or a function. This is the most common
-usage, since typically you want to decorate a pre-existing
-function. A framework author may want to use directly <tt class="docutils literal">FunctionMaker.create</tt>
-instead of <tt class="docutils literal">decorator</tt>, since it gives you direct access to the body
-of the generated function. For instance, suppose you want to instrument
-the <tt class="docutils literal">__init__</tt> methods of a set of classes, by preserving their
-signature (such use case is not made up; this is done in SQAlchemy
-and in other frameworks). When the first argument of <tt class="docutils literal">FunctionMaker.create</tt>
-is a function, a <tt class="docutils literal">FunctionMaker</tt> object is instantiated internally,
-with attributes <tt class="docutils literal">args</tt>, <tt class="docutils literal">varargs</tt>,
-<tt class="docutils literal">keywords</tt> and <tt class="docutils literal">defaults</tt> which are the
-the return values of the standard library function <tt class="docutils literal">inspect.getargspec</tt>.
-For each argument in the <tt class="docutils literal">args</tt> (which is a list of strings containing
-the names of the mandatory arguments) an attribute <tt class="docutils literal">arg0</tt>, <tt class="docutils literal">arg1</tt>,
-..., <tt class="docutils literal">argN</tt> is also generated. Finally, there is a <tt class="docutils literal">signature</tt>
-attribute, a string with the signature of the original function.</p>
-<p>Notice that while I do not have plans
-to change or remove the functionality provided in the
-<tt class="docutils literal">FunctionMaker</tt> class, I do not guarantee that it will stay
-unchanged forever. For instance, right now I am using the traditional
-string interpolation syntax for function templates, but Python 2.6
-and Python 3.0 provide a newer interpolation syntax and I may use
-the new syntax in the future.
-On the other hand, the functionality provided by
-<tt class="docutils literal">decorator</tt> has been there from version 0.1 and it is guaranteed to
-stay there forever.</p>
-</div>
-<div class="section" id="getting-the-source-code">
-<h1><a class="toc-backref" href="#id15">Getting the source code</a></h1>
-<p>Internally <tt class="docutils literal">FunctionMaker.create</tt> uses <tt class="docutils literal">exec</tt> to generate the
-decorated function. Therefore
-<tt class="docutils literal">inspect.getsource</tt> will not work for decorated functions. That
-means that the usual '??' trick in IPython will give you the (right on
-the spot) message <tt class="docutils literal">Dynamically generated function. No source code
-available</tt>.  In the past I have considered this acceptable, since
-<tt class="docutils literal">inspect.getsource</tt> does not really work even with regular
-decorators. In that case <tt class="docutils literal">inspect.getsource</tt> gives you the wrapper
-source code which is probably not what you want:</p>
-<div class="codeblock python">
-<div class="highlight"><pre><span class="k">def</span> <span class="nf">identity_dec</span><span class="p">(</span><span class="n">func</span><span class="p">):</span>
-    <span class="k">def</span> <span class="nf">wrapper</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">kw</span><span class="p">):</span>
-        <span class="k">return</span> <span class="n">func</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">kw</span><span class="p">)</span>
-    <span class="k">return</span> <span class="n">wrapper</span>
-</pre></div>
-
-</div>
-<div class="codeblock python">
-<div class="highlight"><pre><span class="nd">@identity_dec</span>
-<span class="k">def</span> <span class="nf">example</span><span class="p">():</span> <span class="k">pass</span>
-
-<span class="o">&gt;&gt;&gt;</span> <span class="k">print</span><span class="p">(</span><span class="n">inspect</span><span class="o">.</span><span class="n">getsource</span><span class="p">(</span><span class="n">example</span><span class="p">))</span>
-    <span class="k">def</span> <span class="nf">wrapper</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">kw</span><span class="p">):</span>
-        <span class="k">return</span> <span class="n">func</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">kw</span><span class="p">)</span>
-<span class="o">&lt;</span><span class="n">BLANKLINE</span><span class="o">&gt;</span>
-</pre></div>
-
-</div>
-<p>(see bug report <a class="reference external" href="http://bugs.python.org/issue1764286">1764286</a> for an explanation of what is happening).
-Unfortunately the bug is still there, even in Python 2.7 and 3.1.
-There is however a workaround. The decorator module adds an
-attribute <tt class="docutils literal">.__wrapped__</tt> to the decorated function, containing
-a reference to the original function. The easy way to get
-the source code is to call <tt class="docutils literal">inspect.getsource</tt> on the
-undecorated function:</p>
-<div class="codeblock python">
-<div class="highlight"><pre><span class="o">&gt;&gt;&gt;</span> <span class="k">print</span><span class="p">(</span><span class="n">inspect</span><span class="o">.</span><span class="n">getsource</span><span class="p">(</span><span class="n">factorial</span><span class="o">.</span><span class="n">__wrapped__</span><span class="p">))</span>
-<span class="nd">@tail_recursive</span>
-<span class="k">def</span> <span class="nf">factorial</span><span class="p">(</span><span class="n">n</span><span class="p">,</span> <span class="n">acc</span><span class="o">=</span><span class="mi">1</span><span class="p">):</span>
-    <span class="s">&quot;The good old factorial&quot;</span>
-    <span class="k">if</span> <span class="n">n</span> <span class="o">==</span> <span class="mi">0</span><span class="p">:</span> <span class="k">return</span> <span class="n">acc</span>
-    <span class="k">return</span> <span class="n">factorial</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">n</span><span class="o">*</span><span class="n">acc</span><span class="p">)</span>
-<span class="o">&lt;</span><span class="n">BLANKLINE</span><span class="o">&gt;</span>
-</pre></div>
-
-</div>
-</div>
-<div class="section" id="dealing-with-third-party-decorators">
-<h1><a class="toc-backref" href="#id16">Dealing with third party decorators</a></h1>
-<p>Sometimes you find on the net some cool decorator that you would
-like to include in your code. However, more often than not the cool
-decorator is not signature-preserving. Therefore you may want an easy way to
-upgrade third party decorators to signature-preserving decorators without
-having to rewrite them in terms of <tt class="docutils literal">decorator</tt>. You can use a
-<tt class="docutils literal">FunctionMaker</tt> to implement that functionality as follows:</p>
-<div class="codeblock python">
-<div class="highlight"><pre><span class="k">def</span> <span class="nf">decorator_apply</span><span class="p">(</span><span class="n">dec</span><span class="p">,</span> <span class="n">func</span><span class="p">):</span>
-    <span class="sd">&quot;&quot;&quot;</span>
-<span class="sd">    Decorate a function by preserving the signature even if dec</span>
-<span class="sd">    is not a signature-preserving decorator.</span>
-<span class="sd">    &quot;&quot;&quot;</span>
-    <span class="k">return</span> <span class="n">FunctionMaker</span><span class="o">.</span><span class="n">create</span><span class="p">(</span>
-        <span class="n">func</span><span class="p">,</span> <span class="s">&#39;return decorated(</span><span class="si">%(signature)s</span><span class="s">)&#39;</span><span class="p">,</span>
-        <span class="nb">dict</span><span class="p">(</span><span class="n">decorated</span><span class="o">=</span><span class="n">dec</span><span class="p">(</span><span class="n">func</span><span class="p">)),</span> <span class="n">__wrapped__</span><span class="o">=</span><span class="n">func</span><span class="p">)</span>
-</pre></div>
-
-</div>
-<p><tt class="docutils literal">decorator_apply</tt> sets the attribute <tt class="docutils literal">.__wrapped__</tt> of the generated
-function to the original function, so that you can get the right
-source code.</p>
-<p>Notice that I am not providing this functionality in the <tt class="docutils literal">decorator</tt>
-module directly since I think it is best to rewrite the decorator rather
-than adding an additional level of indirection. However, practicality
-beats purity, so you can add <tt class="docutils literal">decorator_apply</tt> to your toolbox and
-use it if you need to.</p>
-<p>In order to give an example of usage of <tt class="docutils literal">decorator_apply</tt>, I will show a
-pretty slick decorator that converts a tail-recursive function in an iterative
-function. I have shamelessly stolen the basic idea from Kay Schluehr's recipe
-in the Python Cookbook,
-<a class="reference external" href="http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/496691">http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/496691</a>.</p>
-<div class="codeblock python">
-<div class="highlight"><pre><span class="k">class</span> <span class="nc">TailRecursive</span><span class="p">(</span><span class="nb">object</span><span class="p">):</span>
-    <span class="sd">&quot;&quot;&quot;</span>
-<span class="sd">    tail_recursive decorator based on Kay Schluehr&#39;s recipe</span>
-<span class="sd">    http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/496691</span>
-<span class="sd">    with improvements by me and George Sakkis.</span>
-<span class="sd">    &quot;&quot;&quot;</span>
-
-    <span class="k">def</span> <span class="nf">__init__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">func</span><span class="p">):</span>
-        <span class="bp">self</span><span class="o">.</span><span class="n">func</span> <span class="o">=</span> <span class="n">func</span>
-        <span class="bp">self</span><span class="o">.</span><span class="n">firstcall</span> <span class="o">=</span> <span class="bp">True</span>
-        <span class="bp">self</span><span class="o">.</span><span class="n">CONTINUE</span> <span class="o">=</span> <span class="nb">object</span><span class="p">()</span> <span class="c"># sentinel</span>
-
-    <span class="k">def</span> <span class="nf">__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">kwd</span><span class="p">):</span>
-        <span class="n">CONTINUE</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="n">CONTINUE</span>
-        <span class="k">if</span> <span class="bp">self</span><span class="o">.</span><span class="n">firstcall</span><span class="p">:</span>
-            <span class="n">func</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="n">func</span>
-            <span class="bp">self</span><span class="o">.</span><span class="n">firstcall</span> <span class="o">=</span> <span class="bp">False</span>
-            <span class="k">try</span><span class="p">:</span>
-                <span class="k">while</span> <span class="bp">True</span><span class="p">:</span>
-                    <span class="n">result</span> <span class="o">=</span> <span class="n">func</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">kwd</span><span class="p">)</span>
-                    <span class="k">if</span> <span class="n">result</span> <span class="ow">is</span> <span class="n">CONTINUE</span><span class="p">:</span> <span class="c"># update arguments</span>
-                        <span class="n">args</span><span class="p">,</span> <span class="n">kwd</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="n">argskwd</span>
-                    <span class="k">else</span><span class="p">:</span> <span class="c"># last call</span>
-                        <span class="k">return</span> <span class="n">result</span>
-            <span class="k">finally</span><span class="p">:</span>
-                <span class="bp">self</span><span class="o">.</span><span class="n">firstcall</span> <span class="o">=</span> <span class="bp">True</span>
-        <span class="k">else</span><span class="p">:</span> <span class="c"># return the arguments of the tail call</span>
-            <span class="bp">self</span><span class="o">.</span><span class="n">argskwd</span> <span class="o">=</span> <span class="n">args</span><span class="p">,</span> <span class="n">kwd</span>
-            <span class="k">return</span> <span class="n">CONTINUE</span>
-</pre></div>
-
-</div>
-<p>Here the decorator is implemented as a class returning callable
-objects.</p>
-<div class="codeblock python">
-<div class="highlight"><pre><span class="k">def</span> <span class="nf">tail_recursive</span><span class="p">(</span><span class="n">func</span><span class="p">):</span>
-    <span class="k">return</span> <span class="n">decorator_apply</span><span class="p">(</span><span class="n">TailRecursive</span><span class="p">,</span> <span class="n">func</span><span class="p">)</span>
-</pre></div>
-
-</div>
-<p>Here is how you apply the upgraded decorator to the good old factorial:</p>
-<div class="codeblock python">
-<div class="highlight"><pre><span class="nd">@tail_recursive</span>
-<span class="k">def</span> <span class="nf">factorial</span><span class="p">(</span><span class="n">n</span><span class="p">,</span> <span class="n">acc</span><span class="o">=</span><span class="mi">1</span><span class="p">):</span>
-    <span class="s">&quot;The good old factorial&quot;</span>
-    <span class="k">if</span> <span class="n">n</span> <span class="o">==</span> <span class="mi">0</span><span class="p">:</span> <span class="k">return</span> <span class="n">acc</span>
-    <span class="k">return</span> <span class="n">factorial</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">n</span><span class="o">*</span><span class="n">acc</span><span class="p">)</span>
-</pre></div>
-
-</div>
-<div class="codeblock python">
-<div class="highlight"><pre><span class="o">&gt;&gt;&gt;</span> <span class="k">print</span><span class="p">(</span><span class="n">factorial</span><span class="p">(</span><span class="mi">4</span><span class="p">))</span>
-<span class="mi">24</span>
-</pre></div>
-
-</div>
-<p>This decorator is pretty impressive, and should give you some food for
-your mind ;) Notice that there is no recursion limit now, and you can
-easily compute <tt class="docutils literal">factorial(1001)</tt> or larger without filling the stack
-frame. Notice also that the decorator will not work on functions which
-are not tail recursive, such as the following</p>
-<div class="codeblock python">
-<div class="highlight"><pre><span class="k">def</span> <span class="nf">fact</span><span class="p">(</span><span class="n">n</span><span class="p">):</span> <span class="c"># this is not tail-recursive</span>
-    <span class="k">if</span> <span class="n">n</span> <span class="o">==</span> <span class="mi">0</span><span class="p">:</span> <span class="k">return</span> <span class="mi">1</span>
-    <span class="k">return</span> <span class="n">n</span> <span class="o">*</span> <span class="n">fact</span><span class="p">(</span><span class="n">n</span><span class="o">-</span><span class="mi">1</span><span class="p">)</span>
-</pre></div>
-
-</div>
-<p>(reminder: a function is tail recursive if it either returns a value without
-making a recursive call, or returns directly the result of a recursive
-call).</p>
-</div>
-<div class="section" id="caveats-and-limitations">
-<h1><a class="toc-backref" href="#id17">Caveats and limitations</a></h1>
-<p>The first thing you should be aware of, it the fact that decorators
-have a performance penalty.
-The worse case is shown by the following example:</p>
-<pre class="literal-block">
-$ cat performance.sh
-python3 -m timeit -s &quot;
-from decorator import decorator
-
-&#64;decorator
-def do_nothing(func, *args, **kw):
-    return func(*args, **kw)
-
-&#64;do_nothing
-def f():
-    pass
-&quot; &quot;f()&quot;
-
-python3 -m timeit -s &quot;
-def f():
-    pass
-&quot; &quot;f()&quot;
-</pre>
-<p>On my MacBook, using the <tt class="docutils literal">do_nothing</tt> decorator instead of the
-plain function is more than three times slower:</p>
-<pre class="literal-block">
-$ bash performance.sh
-1000000 loops, best of 3: 0.669 usec per loop
-1000000 loops, best of 3: 0.181 usec per loop
-</pre>
-<p>It should be noted that a real life function would probably do
-something more useful than <tt class="docutils literal">f</tt> here, and therefore in real life the
-performance penalty could be completely negligible.  As always, the
-only way to know if there is
-a penalty in your specific use case is to measure it.</p>
-<p>You should be aware that decorators will make your tracebacks
-longer and more difficult to understand. Consider this example:</p>
-<div class="codeblock python">
-<div class="highlight"><pre><span class="o">&gt;&gt;&gt;</span> <span class="nd">@trace</span>
-<span class="o">...</span> <span class="k">def</span> <span class="nf">f</span><span class="p">():</span>
-<span class="o">...</span>     <span class="mi">1</span><span class="o">/</span><span class="mi">0</span>
-</pre></div>
-
-</div>
-<p>Calling <tt class="docutils literal">f()</tt> will give you a <tt class="docutils literal">ZeroDivisionError</tt>, but since the
-function is decorated the traceback will be longer:</p>
-<div class="codeblock python">
-<div class="highlight"><pre><span class="o">&gt;&gt;&gt;</span> <span class="n">f</span><span class="p">()</span>
-<span class="n">Traceback</span> <span class="p">(</span><span class="n">most</span> <span class="n">recent</span> <span class="n">call</span> <span class="n">last</span><span class="p">):</span>
-  <span class="o">...</span>
-     <span class="n">File</span> <span class="s">&quot;&lt;string&gt;&quot;</span><span class="p">,</span> <span class="n">line</span> <span class="mi">2</span><span class="p">,</span> <span class="ow">in</span> <span class="n">f</span>
-     <span class="n">File</span> <span class="s">&quot;&lt;doctest __main__[22]&gt;&quot;</span><span class="p">,</span> <span class="n">line</span> <span class="mi">4</span><span class="p">,</span> <span class="ow">in</span> <span class="n">trace</span>
-       <span class="k">return</span> <span class="n">f</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">kw</span><span class="p">)</span>
-     <span class="n">File</span> <span class="s">&quot;&lt;doctest __main__[51]&gt;&quot;</span><span class="p">,</span> <span class="n">line</span> <span class="mi">3</span><span class="p">,</span> <span class="ow">in</span> <span class="n">f</span>
-       <span class="mi">1</span><span class="o">/</span><span class="mi">0</span>
-<span class="ne">ZeroDivisionError</span><span class="p">:</span> <span class="o">...</span>
-</pre></div>
-
-</div>
-<p>You see here the inner call to the decorator <tt class="docutils literal">trace</tt>, which calls
-<tt class="docutils literal"><span class="pre">f(*args,</span> **kw)</tt>, and a reference to  <tt class="docutils literal">File <span class="pre">&quot;&lt;string&gt;&quot;,</span> line 2, in f</tt>.
-This latter reference is due to the fact that internally the decorator
-module uses <tt class="docutils literal">exec</tt> to generate the decorated function. Notice that
-<tt class="docutils literal">exec</tt> is <em>not</em> responsibile for the performance penalty, since is the
-called <em>only once</em> at function decoration time, and not every time
-the decorated function is called.</p>
-<p>At present, there is no clean way to avoid <tt class="docutils literal">exec</tt>. A clean solution
-would require to change the CPython implementation of functions and
-add an hook to make it possible to change their signature directly.
-That could happen in future versions of Python (see PEP <a class="reference external" href="http://www.python.org/dev/peps/pep-0362">362</a>) and
-then the decorator module would become obsolete. However, at present,
-even in Python 3.2 it is impossible to change the function signature
-directly, therefore the <tt class="docutils literal">decorator</tt> module is still useful.
-Actually, this is one of the main reasons why I keep maintaining
-the module and releasing new versions.</p>
-<p>In the present implementation, decorators generated by <tt class="docutils literal">decorator</tt>
-can only be used on user-defined Python functions or methods, not on generic
-callable objects, nor on built-in functions, due to limitations of the
-<tt class="docutils literal">inspect</tt> module in the standard library.</p>
-<p>There is a restriction on the names of the arguments: for instance,
-if try to call an argument <tt class="docutils literal">_call_</tt> or <tt class="docutils literal">_func_</tt>
-you will get a <tt class="docutils literal">NameError</tt>:</p>
-<div class="codeblock python">
-<div class="highlight"><pre><span class="o">&gt;&gt;&gt;</span> <span class="nd">@trace</span>
-<span class="o">...</span> <span class="k">def</span> <span class="nf">f</span><span class="p">(</span><span class="n">_func_</span><span class="p">):</span> <span class="k">print</span><span class="p">(</span><span class="n">f</span><span class="p">)</span>
-<span class="o">...</span>
-<span class="n">Traceback</span> <span class="p">(</span><span class="n">most</span> <span class="n">recent</span> <span class="n">call</span> <span class="n">last</span><span class="p">):</span>
-  <span class="o">...</span>
-<span class="ne">NameError</span><span class="p">:</span> <span class="n">_func_</span> <span class="ow">is</span> <span class="n">overridden</span> <span class="ow">in</span>
-<span class="k">def</span> <span class="nf">f</span><span class="p">(</span><span class="n">_func_</span><span class="p">):</span>
-    <span class="k">return</span> <span class="n">_call_</span><span class="p">(</span><span class="n">_func_</span><span class="p">,</span> <span class="n">_func_</span><span class="p">)</span>
-</pre></div>
-
-</div>
-<p>Finally, the implementation is such that the decorated function contains
-a <em>copy</em> of the original function dictionary
-(<tt class="docutils literal">vars(decorated_f) is not vars(f)</tt>):</p>
-<div class="codeblock python">
-<div class="highlight"><pre><span class="o">&gt;&gt;&gt;</span> <span class="k">def</span> <span class="nf">f</span><span class="p">():</span> <span class="k">pass</span> <span class="c"># the original function</span>
-<span class="o">&gt;&gt;&gt;</span> <span class="n">f</span><span class="o">.</span><span class="n">attr1</span> <span class="o">=</span> <span class="s">&quot;something&quot;</span> <span class="c"># setting an attribute</span>
-<span class="o">&gt;&gt;&gt;</span> <span class="n">f</span><span class="o">.</span><span class="n">attr2</span> <span class="o">=</span> <span class="s">&quot;something else&quot;</span> <span class="c"># setting another attribute</span>
-
-<span class="o">&gt;&gt;&gt;</span> <span class="n">traced_f</span> <span class="o">=</span> <span class="n">trace</span><span class="p">(</span><span class="n">f</span><span class="p">)</span> <span class="c"># the decorated function</span>
-
-<span class="o">&gt;&gt;&gt;</span> <span class="n">traced_f</span><span class="o">.</span><span class="n">attr1</span>
-<span class="s">&#39;something&#39;</span>
-<span class="o">&gt;&gt;&gt;</span> <span class="n">traced_f</span><span class="o">.</span><span class="n">attr2</span> <span class="o">=</span> <span class="s">&quot;something different&quot;</span> <span class="c"># setting attr</span>
-<span class="o">&gt;&gt;&gt;</span> <span class="n">f</span><span class="o">.</span><span class="n">attr2</span> <span class="c"># the original attribute did not change</span>
-<span class="s">&#39;something else&#39;</span>
-</pre></div>
-
-</div>
-</div>
-<div class="section" id="compatibility-notes">
-<h1><a class="toc-backref" href="#id18">Compatibility notes</a></h1>
-<p>Version 3.3 is the first version of the <tt class="docutils literal">decorator</tt> module to fully
-support Python 3, including <a class="reference external" href="http://www.python.org/dev/peps/pep-3107/">function annotations</a>. Version 3.2 was the
-first version to support Python 3 via the <tt class="docutils literal">2to3</tt> conversion tool
-invoked in the build process by the <a class="reference external" href="http://packages.python.org/distribute/">distribute</a> project, the Python
-3-compatible replacement of easy_install.  The hard work (for me) has
-been converting the documentation and the doctests.  This has been
-possible only after that <a class="reference external" href="http://docutils.sourceforge.net/">docutils</a> and <a class="reference external" href="http://pygments.org/">pygments</a> have been ported to
-Python 3.</p>
-<p>Version 3 of the <tt class="docutils literal">decorator</tt> module do not contain any backward
-incompatible change, apart from the removal of the functions
-<tt class="docutils literal">get_info</tt> and <tt class="docutils literal">new_wrapper</tt>, which have been deprecated for
-years. <tt class="docutils literal">get_info</tt> has been removed since it was little used and
-since it had to be changed anyway to work with Python 3.0;
-<tt class="docutils literal">new_wrapper</tt> has been removed since it was useless: its major use
-case (converting signature changing decorators to signature preserving
-decorators) has been subsumed by <tt class="docutils literal">decorator_apply</tt>, whereas the other use
-case can be managed with the <tt class="docutils literal">FunctionMaker</tt>.</p>
-<p>There are a few changes in the documentation: I removed the
-<tt class="docutils literal">decorator_factory</tt> example, which was confusing some of my users,
-and I removed the part about exotic signatures in the Python 3
-documentation, since Python 3 does not support them.</p>
-<p>Finally <tt class="docutils literal">decorator</tt> cannot be used as a class decorator and the
-<a class="reference external" href="http://www.phyast.pitt.edu/~micheles/python/documentation.html#class-decorators-and-decorator-factories">functionality introduced in version 2.3</a> has been removed. That
-means that in order to define decorator factories with classes you
-need to define the <tt class="docutils literal">__call__</tt> method explicitly (no magic anymore).
-All these changes should not cause any trouble, since they were
-all rarely used features. Should you have any trouble, you can always
-downgrade to the 2.3 version.</p>
-<p>The examples shown here have been tested with Python 2.6. Python 2.4
-is also supported - of course the examples requiring the <tt class="docutils literal">with</tt>
-statement will not work there. Python 2.5 works fine, but if you
-run the examples in the interactive interpreter
-you will notice a few differences since
-<tt class="docutils literal">getargspec</tt> returns an <tt class="docutils literal">ArgSpec</tt> namedtuple instead of a regular
-tuple. That means that running the file
-<tt class="docutils literal">documentation.py</tt> under Python 2.5 will print a few errors, but
-they are not serious.</p>
-</div>
-<div class="section" id="licence">
-<h1><a class="toc-backref" href="#id19">LICENCE</a></h1>
-<p>Copyright (c) 2005-2012, Michele Simionato
-All rights reserved.</p>
-<p>Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are
-met:</p>
-<blockquote>
-Redistributions of source code must retain the above copyright
-notice, this list of conditions and the following disclaimer.
-Redistributions in bytecode form must reproduce the above copyright
-notice, this list of conditions and the following disclaimer in
-the documentation and/or other materials provided with the
-distribution.</blockquote>
-<p>THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-&quot;AS IS&quot; AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
-INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
-BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
-OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
-TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
-USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
-DAMAGE.</p>
-<p>If you use this software and you are happy with it, consider sending me a
-note, just to gratify my ego. On the other hand, if you use this software and
-you are unhappy with it, send me a patch!</p>
-</div>
-</div>
-</body>
-</html>
diff --git a/documentation3.pdf b/documentation3.pdf
index ffdcc6c..b938ffb 100644
--- a/documentation3.pdf
+++ b/documentation3.pdf
@@ -1,1433 +1,310 @@
 %PDF-1.4
-%���� ReportLab Generated PDF document http://www.reportlab.com
-% 'BasicFonts': class PDFDictionary 
+%���� ReportLab Generated PDF document http://www.reportlab.com
 1 0 obj
-% The standard fonts dictionary
-<< /F1 2 0 R
- /F2 3 0 R
- /F3 4 0 R
- /F4 7 0 R
- /F5 41 0 R
- /F6 43 0 R >>
-endobj
-% 'F1': class PDFType1Font 
+<< /F1 2 0 R /F2 3 0 R /F3 4 0 R /F4 7 0 R /F5 46 0 R /F6 48 0 R >>
+endobj
 2 0 obj
-% Font Helvetica
-<< /BaseFont /Helvetica
- /Encoding /WinAnsiEncoding
- /Name /F1
- /Subtype /Type1
- /Type /Font >>
-endobj
-% 'F2': class PDFType1Font 
+<< /BaseFont /Helvetica /Encoding /WinAnsiEncoding /Name /F1 /Subtype /Type1 /Type /Font >>
+endobj
 3 0 obj
-% Font Helvetica-Bold
-<< /BaseFont /Helvetica-Bold
- /Encoding /WinAnsiEncoding
- /Name /F2
- /Subtype /Type1
- /Type /Font >>
-endobj
-% 'F3': class PDFType1Font 
+<< /BaseFont /Helvetica-Bold /Encoding /WinAnsiEncoding /Name /F2 /Subtype /Type1 /Type /Font >>
+endobj
 4 0 obj
-% Font Courier-Bold
-<< /BaseFont /Courier-Bold
- /Encoding /WinAnsiEncoding
- /Name /F3
- /Subtype /Type1
- /Type /Font >>
-endobj
-% 'Annot.NUMBER1': class PDFDictionary 
+<< /BaseFont /Courier-Bold /Encoding /WinAnsiEncoding /Name /F3 /Subtype /Type1 /Type /Font >>
+endobj
 5 0 obj
-<< /A << /S /URI
- /Type /Action
- /URI (mailto:michele.simionato@gmail.com) >>
- /Border [ 0
- 0
- 0 ]
- /Rect [ 153.7323
- 704.7736
- 289.4623
- 716.7736 ]
- /Subtype /Link
- /Type /Annot >>
-endobj
-% 'Annot.NUMBER2': class PDFDictionary 
+<< /A << /S /URI /Type /Action /URI (mailto:michele.simionato@gmail.com) >> /Border [ 0 0 0 ] /Rect [ 153.7323 704.7736 289.4623 716.7736 ] /Subtype /Link /Type /Annot >>
+endobj
 6 0 obj
-<< /A << /S /URI
- /Type /Action
- /URI (http://pypi.python.org/pypi/decorator/3.4.0) >>
- /Border [ 0
- 0
- 0 ]
- /Rect [ 153.7323
- 659.7736
- 526.5827
- 671.7736 ]
- /Subtype /Link
- /Type /Annot >>
-endobj
-% 'F4': class PDFType1Font 
+<< /A << /S /URI /Type /Action /URI (http://pypi.python.org/pypi/decorator/3.4.1) >> /Border [ 0 0 0 ] /Rect [ 153.7323 659.7736 526.5827 671.7736 ] /Subtype /Link /Type /Annot >>
+endobj
 7 0 obj
-% Font Courier
-<< /BaseFont /Courier
- /Encoding /WinAnsiEncoding
- /Name /F4
- /Subtype /Type1
- /Type /Font >>
-endobj
-% 'Annot.NUMBER3': class LinkAnnotation 
+<< /BaseFont /Courier /Encoding /WinAnsiEncoding /Name /F4 /Subtype /Type1 /Type /Font >>
+endobj
 8 0 obj
-<< /Border [ 0
- 0
- 0 ]
- /Contents ()
- /Dest [ 40 0 R
- /XYZ
- 62.69291
- 275.0236
- 0 ]
- /Rect [ 62.69291
- 560.7736
- 121.0229
- 572.7736 ]
- /Subtype /Link
- /Type /Annot >>
-endobj
-% 'Annot.NUMBER4': class LinkAnnotation 
+<< /Border [ 0 0 0 ] /Contents () /Dest [ 45 0 R /XYZ 62.69291 275.0236 0 ] /Rect [ 62.69291 560.7736 121.0229 572.7736 ] /Subtype /Link /Type /Annot >>
+endobj
 9 0 obj
-<< /Border [ 0
- 0
- 0 ]
- /Contents ()
- /Dest [ 40 0 R
- /XYZ
- 62.69291
- 275.0236
- 0 ]
- /Rect [ 527.0227
- 560.7736
- 532.5827
- 572.7736 ]
- /Subtype /Link
- /Type /Annot >>
-endobj
-% 'Annot.NUMBER5': class LinkAnnotation 
+<< /Border [ 0 0 0 ] /Contents () /Dest [ 45 0 R /XYZ 62.69291 275.0236 0 ] /Rect [ 527.0227 560.7736 532.5827 572.7736 ] /Subtype /Link /Type /Annot >>
+endobj
 10 0 obj
-<< /Border [ 0
- 0
- 0 ]
- /Contents ()
- /Dest [ 45 0 R
- /XYZ
- 62.69291
- 657.0236
- 0 ]
- /Rect [ 62.69291
- 542.7736
- 114.3629
- 554.7736 ]
- /Subtype /Link
- /Type /Annot >>
-endobj
-% 'Annot.NUMBER6': class LinkAnnotation 
+<< /Border [ 0 0 0 ] /Contents () /Dest [ 49 0 R /XYZ 62.69291 633.0236 0 ] /Rect [ 62.69291 542.7736 114.3629 554.7736 ] /Subtype /Link /Type /Annot >>
+endobj
 11 0 obj
-<< /Border [ 0
- 0
- 0 ]
- /Contents ()
- /Dest [ 45 0 R
- /XYZ
- 62.69291
- 657.0236
- 0 ]
- /Rect [ 527.0227
- 542.7736
- 532.5827
- 554.7736 ]
- /Subtype /Link
- /Type /Annot >>
-endobj
-% 'Annot.NUMBER7': class LinkAnnotation 
+<< /Border [ 0 0 0 ] /Contents () /Dest [ 49 0 R /XYZ 62.69291 633.0236 0 ] /Rect [ 527.0227 542.7736 532.5827 554.7736 ] /Subtype /Link /Type /Annot >>
+endobj
 12 0 obj
-<< /Border [ 0
- 0
- 0 ]
- /Contents ()
- /Dest [ 45 0 R
- /XYZ
- 62.69291
- 420.0236
- 0 ]
- /Rect [ 62.69291
- 524.7736
- 183.2629
- 536.7736 ]
- /Subtype /Link
- /Type /Annot >>
-endobj
-% 'Annot.NUMBER8': class LinkAnnotation 
+<< /Border [ 0 0 0 ] /Contents () /Dest [ 49 0 R /XYZ 62.69291 396.0236 0 ] /Rect [ 62.69291 524.7736 183.2629 536.7736 ] /Subtype /Link /Type /Annot >>
+endobj
 13 0 obj
-<< /Border [ 0
- 0
- 0 ]
- /Contents ()
- /Dest [ 45 0 R
- /XYZ
- 62.69291
- 420.0236
- 0 ]
- /Rect [ 527.0227
- 524.7736
- 532.5827
- 536.7736 ]
- /Subtype /Link
- /Type /Annot >>
-endobj
-% 'Annot.NUMBER9': class LinkAnnotation 
+<< /Border [ 0 0 0 ] /Contents () /Dest [ 49 0 R /XYZ 62.69291 396.0236 0 ] /Rect [ 527.0227 524.7736 532.5827 536.7736 ] /Subtype /Link /Type /Annot >>
+endobj
 14 0 obj
-<< /Border [ 0
- 0
- 0 ]
- /Contents ()
- /Dest [ 46 0 R
- /XYZ
- 62.69291
- 409.4236
- 0 ]
- /Rect [ 62.69291
- 506.7736
- 122.1429
- 518.7736 ]
- /Subtype /Link
- /Type /Annot >>
-endobj
-% 'Annot.NUMBER10': class LinkAnnotation 
+<< /Border [ 0 0 0 ] /Contents () /Dest [ 51 0 R /XYZ 62.69291 373.4236 0 ] /Rect [ 62.69291 506.7736 122.1429 518.7736 ] /Subtype /Link /Type /Annot >>
+endobj
 15 0 obj
-<< /Border [ 0
- 0
- 0 ]
- /Contents ()
- /Dest [ 46 0 R
- /XYZ
- 62.69291
- 409.4236
- 0 ]
- /Rect [ 527.0227
- 506.7736
- 532.5827
- 518.7736 ]
- /Subtype /Link
- /Type /Annot >>
-endobj
-% 'Annot.NUMBER11': class LinkAnnotation 
+<< /Border [ 0 0 0 ] /Contents () /Dest [ 51 0 R /XYZ 62.69291 373.4236 0 ] /Rect [ 527.0227 506.7736 532.5827 518.7736 ] /Subtype /Link /Type /Annot >>
+endobj
 16 0 obj
-<< /Border [ 0
- 0
- 0 ]
- /Contents ()
- /Dest [ 47 0 R
- /XYZ
- 62.69291
- 435.4236
- 0 ]
- /Rect [ 62.69291
- 488.7736
- 154.8129
- 500.7736 ]
- /Subtype /Link
- /Type /Annot >>
-endobj
-% 'Annot.NUMBER12': class LinkAnnotation 
+<< /Border [ 0 0 0 ] /Contents () /Dest [ 52 0 R /XYZ 62.69291 370.2236 0 ] /Rect [ 62.69291 488.7736 72.69291 500.7736 ] /Subtype /Link /Type /Annot >>
+endobj
 17 0 obj
-<< /Border [ 0
- 0
- 0 ]
- /Contents ()
- /Dest [ 47 0 R
- /XYZ
- 62.69291
- 435.4236
- 0 ]
- /Rect [ 527.0227
- 488.7736
- 532.5827
- 500.7736 ]
- /Subtype /Link
- /Type /Annot >>
-endobj
-% 'Annot.NUMBER13': class LinkAnnotation 
+<< /Border [ 0 0 0 ] /Contents () /Dest [ 52 0 R /XYZ 62.69291 370.2236 0 ] /Rect [ 72.69291 488.7736 108.6929 500.7736 ] /Subtype /Link /Type /Annot >>
+endobj
 18 0 obj
-<< /Border [ 0
- 0
- 0 ]
- /Contents ()
- /Dest [ 49 0 R
- /XYZ
- 62.69291
- 567.978
- 0 ]
- /Rect [ 62.69291
- 470.7736
- 164.3629
- 482.7736 ]
- /Subtype /Link
- /Type /Annot >>
-endobj
-% 'Annot.NUMBER14': class LinkAnnotation 
+<< /Border [ 0 0 0 ] /Contents () /Dest [ 52 0 R /XYZ 62.69291 370.2236 0 ] /Rect [ 108.6929 488.7736 154.8129 500.7736 ] /Subtype /Link /Type /Annot >>
+endobj
 19 0 obj
-<< /Border [ 0
- 0
- 0 ]
- /Contents ()
- /Dest [ 49 0 R
- /XYZ
- 62.69291
- 567.978
- 0 ]
- /Rect [ 527.0227
- 470.7736
- 532.5827
- 482.7736 ]
- /Subtype /Link
- /Type /Annot >>
-endobj
-% 'Annot.NUMBER15': class LinkAnnotation 
+<< /Border [ 0 0 0 ] /Contents () /Dest [ 52 0 R /XYZ 62.69291 370.2236 0 ] /Rect [ 527.0227 488.7736 532.5827 500.7736 ] /Subtype /Link /Type /Annot >>
+endobj
 20 0 obj
-<< /Border [ 0
- 0
- 0 ]
- /Contents ()
- /Dest [ 50 0 R
- /XYZ
- 62.69291
- 765.0236
- 0 ]
- /Rect [ 62.69291
- 452.7736
- 188.2729
- 464.7736 ]
- /Subtype /Link
- /Type /Annot >>
-endobj
-% 'Annot.NUMBER16': class LinkAnnotation 
+<< /Border [ 0 0 0 ] /Contents () /Dest [ 54 0 R /XYZ 62.69291 501.4236 0 ] /Rect [ 62.69291 470.7736 164.3629 482.7736 ] /Subtype /Link /Type /Annot >>
+endobj
 21 0 obj
-<< /Border [ 0
- 0
- 0 ]
- /Contents ()
- /Dest [ 50 0 R
- /XYZ
- 62.69291
- 765.0236
- 0 ]
- /Rect [ 527.0227
- 452.7736
- 532.5827
- 464.7736 ]
- /Subtype /Link
- /Type /Annot >>
-endobj
-% 'Annot.NUMBER17': class LinkAnnotation 
+<< /Border [ 0 0 0 ] /Contents () /Dest [ 54 0 R /XYZ 62.69291 501.4236 0 ] /Rect [ 527.0227 470.7736 532.5827 482.7736 ] /Subtype /Link /Type /Annot >>
+endobj
 22 0 obj
-<< /Border [ 0
- 0
- 0 ]
- /Contents ()
- /Dest [ 50 0 R
- /XYZ
- 62.69291
- 338.4236
- 0 ]
- /Rect [ 62.69291
- 434.7736
- 110.6929
- 446.7736 ]
- /Subtype /Link
- /Type /Annot >>
-endobj
-% 'Annot.NUMBER18': class LinkAnnotation 
+<< /Border [ 0 0 0 ] /Contents () /Dest [ 55 0 R /XYZ 62.69291 729.0236 0 ] /Rect [ 62.69291 452.7736 122.6929 464.7736 ] /Subtype /Link /Type /Annot >>
+endobj
 23 0 obj
-<< /Border [ 0
- 0
- 0 ]
- /Contents ()
- /Dest [ 50 0 R
- /XYZ
- 62.69291
- 338.4236
- 0 ]
- /Rect [ 527.0227
- 434.7736
- 532.5827
- 446.7736 ]
- /Subtype /Link
- /Type /Annot >>
-endobj
-% 'Annot.NUMBER19': class LinkAnnotation 
+<< /Border [ 0 0 0 ] /Contents () /Dest [ 55 0 R /XYZ 62.69291 729.0236 0 ] /Rect [ 122.6929 452.7736 188.2729 464.7736 ] /Subtype /Link /Type /Annot >>
+endobj
 24 0 obj
-<< /Border [ 0
- 0
- 0 ]
- /Contents ()
- /Dest [ 51 0 R
- /XYZ
- 62.69291
- 479.8236
- 0 ]
- /Rect [ 62.69291
- 416.7736
- 92.69291
- 428.7736 ]
- /Subtype /Link
- /Type /Annot >>
-endobj
-% 'Annot.NUMBER20': class LinkAnnotation 
+<< /Border [ 0 0 0 ] /Contents () /Dest [ 55 0 R /XYZ 62.69291 729.0236 0 ] /Rect [ 527.0227 452.7736 532.5827 464.7736 ] /Subtype /Link /Type /Annot >>
+endobj
 25 0 obj
-<< /Border [ 0
- 0
- 0 ]
- /Contents ()
- /Dest [ 51 0 R
- /XYZ
- 62.69291
- 479.8236
- 0 ]
- /Rect [ 527.0227
- 416.7736
- 532.5827
- 428.7736 ]
- /Subtype /Link
- /Type /Annot >>
-endobj
-% 'Annot.NUMBER21': class LinkAnnotation 
+<< /Border [ 0 0 0 ] /Contents () /Dest [ 55 0 R /XYZ 62.69291 302.4236 0 ] /Rect [ 62.69291 434.7736 110.6929 446.7736 ] /Subtype /Link /Type /Annot >>
+endobj
 26 0 obj
-<< /Border [ 0
- 0
- 0 ]
- /Contents ()
- /Dest [ 53 0 R
- /XYZ
- 62.69291
- 643.8236
- 0 ]
- /Rect [ 62.69291
- 398.7736
- 139.9329
- 410.7736 ]
- /Subtype /Link
- /Type /Annot >>
-endobj
-% 'Annot.NUMBER22': class LinkAnnotation 
+<< /Border [ 0 0 0 ] /Contents () /Dest [ 55 0 R /XYZ 62.69291 302.4236 0 ] /Rect [ 527.0227 434.7736 532.5827 446.7736 ] /Subtype /Link /Type /Annot >>
+endobj
 27 0 obj
-<< /Border [ 0
- 0
- 0 ]
- /Contents ()
- /Dest [ 53 0 R
- /XYZ
- 62.69291
- 643.8236
- 0 ]
- /Rect [ 527.0227
- 398.7736
- 532.5827
- 410.7736 ]
- /Subtype /Link
- /Type /Annot >>
-endobj
-% 'Annot.NUMBER23': class LinkAnnotation 
+<< /Border [ 0 0 0 ] /Contents () /Dest [ 56 0 R /XYZ 62.69291 422.6236 0 ] /Rect [ 62.69291 416.7736 92.69291 428.7736 ] /Subtype /Link /Type /Annot >>
+endobj
 28 0 obj
-<< /Border [ 0
- 0
- 0 ]
- /Contents ()
- /Dest [ 54 0 R
- /XYZ
- 62.69291
- 729.0236
- 0 ]
- /Rect [ 62.69291
- 380.7736
- 192.2729
- 392.7736 ]
- /Subtype /Link
- /Type /Annot >>
-endobj
-% 'Annot.NUMBER24': class LinkAnnotation 
+<< /Border [ 0 0 0 ] /Contents () /Dest [ 56 0 R /XYZ 62.69291 422.6236 0 ] /Rect [ 527.0227 416.7736 532.5827 428.7736 ] /Subtype /Link /Type /Annot >>
+endobj
 29 0 obj
-<< /Border [ 0
- 0
- 0 ]
- /Contents ()
- /Dest [ 54 0 R
- /XYZ
- 62.69291
- 729.0236
- 0 ]
- /Rect [ 521.4627
- 380.7736
- 532.5827
- 392.7736 ]
- /Subtype /Link
- /Type /Annot >>
-endobj
-% 'Annot.NUMBER25': class LinkAnnotation 
+<< /Border [ 0 0 0 ] /Contents () /Dest [ 58 0 R /XYZ 62.69291 563.8236 0 ] /Rect [ 62.69291 398.7736 139.9329 410.7736 ] /Subtype /Link /Type /Annot >>
+endobj
 30 0 obj
-<< /Border [ 0
- 0
- 0 ]
- /Contents ()
- /Dest [ 56 0 R
- /XYZ
- 62.69291
- 765.0236
- 0 ]
- /Rect [ 62.69291
- 362.7736
- 177.1629
- 374.7736 ]
- /Subtype /Link
- /Type /Annot >>
-endobj
-% 'Annot.NUMBER26': class LinkAnnotation 
+<< /Border [ 0 0 0 ] /Contents () /Dest [ 58 0 R /XYZ 62.69291 563.8236 0 ] /Rect [ 527.0227 398.7736 532.5827 410.7736 ] /Subtype /Link /Type /Annot >>
+endobj
 31 0 obj
-<< /Border [ 0
- 0
- 0 ]
- /Contents ()
- /Dest [ 56 0 R
- /XYZ
- 62.69291
- 765.0236
- 0 ]
- /Rect [ 521.4627
- 362.7736
- 532.5827
- 374.7736 ]
- /Subtype /Link
- /Type /Annot >>
-endobj
-% 'Annot.NUMBER27': class LinkAnnotation 
+<< /Border [ 0 0 0 ] /Contents () /Dest [ 59 0 R /XYZ 62.69291 657.0236 0 ] /Rect [ 62.69291 380.7736 83.25291 392.7736 ] /Subtype /Link /Type /Annot >>
+endobj
 32 0 obj
-<< /Border [ 0
- 0
- 0 ]
- /Contents ()
- /Dest [ 56 0 R
- /XYZ
- 62.69291
- 318.4236
- 0 ]
- /Rect [ 62.69291
- 344.7736
- 228.2829
- 356.7736 ]
- /Subtype /Link
- /Type /Annot >>
-endobj
-% 'Annot.NUMBER28': class LinkAnnotation 
+<< /Border [ 0 0 0 ] /Contents () /Dest [ 59 0 R /XYZ 62.69291 657.0236 0 ] /Rect [ 83.25291 380.7736 167.2529 392.7736 ] /Subtype /Link /Type /Annot >>
+endobj
 33 0 obj
-<< /Border [ 0
- 0
- 0 ]
- /Contents ()
- /Dest [ 56 0 R
- /XYZ
- 62.69291
- 318.4236
- 0 ]
- /Rect [ 521.4627
- 344.7736
- 532.5827
- 356.7736 ]
- /Subtype /Link
- /Type /Annot >>
-endobj
-% 'Annot.NUMBER29': class LinkAnnotation 
+<< /Border [ 0 0 0 ] /Contents () /Dest [ 59 0 R /XYZ 62.69291 657.0236 0 ] /Rect [ 167.2529 380.7736 192.2729 392.7736 ] /Subtype /Link /Type /Annot >>
+endobj
 34 0 obj
-<< /Border [ 0
- 0
- 0 ]
- /Contents ()
- /Dest [ 59 0 R
- /XYZ
- 62.69291
- 615.8236
- 0 ]
- /Rect [ 62.69291
- 326.7736
- 174.3929
- 338.7736 ]
- /Subtype /Link
- /Type /Annot >>
-endobj
-% 'Annot.NUMBER30': class LinkAnnotation 
+<< /Border [ 0 0 0 ] /Contents () /Dest [ 59 0 R /XYZ 62.69291 657.0236 0 ] /Rect [ 521.4627 380.7736 532.5827 392.7736 ] /Subtype /Link /Type /Annot >>
+endobj
 35 0 obj
-<< /Border [ 0
- 0
- 0 ]
- /Contents ()
- /Dest [ 59 0 R
- /XYZ
- 62.69291
- 615.8236
- 0 ]
- /Rect [ 521.4627
- 326.7736
- 532.5827
- 338.7736 ]
- /Subtype /Link
- /Type /Annot >>
-endobj
-% 'Annot.NUMBER31': class LinkAnnotation 
+<< /Border [ 0 0 0 ] /Contents () /Dest [ 61 0 R /XYZ 62.69291 681.0236 0 ] /Rect [ 62.69291 362.7736 177.1629 374.7736 ] /Subtype /Link /Type /Annot >>
+endobj
 36 0 obj
-<< /Border [ 0
- 0
- 0 ]
- /Contents ()
- /Dest [ 68 0 R
- /XYZ
- 62.69291
- 765.0236
- 0 ]
- /Rect [ 62.69291
- 308.7736
- 155.4829
- 320.7736 ]
- /Subtype /Link
- /Type /Annot >>
-endobj
-% 'Annot.NUMBER32': class LinkAnnotation 
+<< /Border [ 0 0 0 ] /Contents () /Dest [ 61 0 R /XYZ 62.69291 681.0236 0 ] /Rect [ 521.4627 362.7736 532.5827 374.7736 ] /Subtype /Link /Type /Annot >>
+endobj
 37 0 obj
-<< /Border [ 0
- 0
- 0 ]
- /Contents ()
- /Dest [ 68 0 R
- /XYZ
- 62.69291
- 765.0236
- 0 ]
- /Rect [ 521.4627
- 308.7736
- 532.5827
- 320.7736 ]
- /Subtype /Link
- /Type /Annot >>
-endobj
-% 'Annot.NUMBER33': class LinkAnnotation 
+<< /Border [ 0 0 0 ] /Contents () /Dest [ 61 0 R /XYZ 62.69291 222.4236 0 ] /Rect [ 62.69291 344.7736 228.2829 356.7736 ] /Subtype /Link /Type /Annot >>
+endobj
 38 0 obj
-<< /Border [ 0
- 0
- 0 ]
- /Contents ()
- /Dest [ 68 0 R
- /XYZ
- 62.69291
- 414.0236
- 0 ]
- /Rect [ 62.69291
- 290.7736
- 106.5829
- 302.7736 ]
- /Subtype /Link
- /Type /Annot >>
-endobj
-% 'Annot.NUMBER34': class LinkAnnotation 
+<< /Border [ 0 0 0 ] /Contents () /Dest [ 61 0 R /XYZ 62.69291 222.4236 0 ] /Rect [ 521.4627 344.7736 532.5827 356.7736 ] /Subtype /Link /Type /Annot >>
+endobj
 39 0 obj
-<< /Border [ 0
- 0
- 0 ]
- /Contents ()
- /Dest [ 68 0 R
- /XYZ
- 62.69291
- 414.0236
- 0 ]
- /Rect [ 521.4627
- 290.7736
- 532.5827
- 302.7736 ]
- /Subtype /Link
- /Type /Annot >>
-endobj
-% 'Page1': class PDFPage 
+<< /Border [ 0 0 0 ] /Contents () /Dest [ 64 0 R /XYZ 62.69291 465.4236 0 ] /Rect [ 62.69291 326.7736 174.3929 338.7736 ] /Subtype /Link /Type /Annot >>
+endobj
 40 0 obj
-% Page dictionary
-<< /Annots [ 5 0 R
- 6 0 R
- 8 0 R
- 9 0 R
- 10 0 R
- 11 0 R
- 12 0 R
- 13 0 R
- 14 0 R
- 15 0 R
- 16 0 R
- 17 0 R
- 18 0 R
- 19 0 R
- 20 0 R
- 21 0 R
- 22 0 R
- 23 0 R
- 24 0 R
- 25 0 R
- 26 0 R
- 27 0 R
- 28 0 R
- 29 0 R
- 30 0 R
- 31 0 R
- 32 0 R
- 33 0 R
- 34 0 R
- 35 0 R
- 36 0 R
- 37 0 R
- 38 0 R
- 39 0 R ]
- /Contents 89 0 R
- /MediaBox [ 0
- 0
- 595.2756
- 841.8898 ]
- /Parent 88 0 R
- /Resources << /Font 1 0 R
- /ProcSet [ /PDF
- /Text
- /ImageB
- /ImageC
- /ImageI ] >>
- /Rotate 0
- /Trans <<  >>
- /Type /Page >>
-endobj
-% 'F5': class PDFType1Font 
+<< /Border [ 0 0 0 ] /Contents () /Dest [ 64 0 R /XYZ 62.69291 465.4236 0 ] /Rect [ 521.4627 326.7736 532.5827 338.7736 ] /Subtype /Link /Type /Annot >>
+endobj
 41 0 obj
-% Font Helvetica-Oblique
-<< /BaseFont /Helvetica-Oblique
- /Encoding /WinAnsiEncoding
- /Name /F5
- /Subtype /Type1
- /Type /Font >>
-endobj
-% 'Annot.NUMBER35': class PDFDictionary 
+<< /Border [ 0 0 0 ] /Contents () /Dest [ 71 0 R /XYZ 62.69291 607.8236 0 ] /Rect [ 62.69291 308.7736 155.4829 320.7736 ] /Subtype /Link /Type /Annot >>
+endobj
 42 0 obj
-<< /A << /S /URI
- /Type /Action
- /URI (http://www.python.org/moin/PythonDecoratorLibrary) >>
- /Border [ 0
- 0
- 0 ]
- /Rect [ 219.6428
- 345.7736
- 449.1728
- 357.7736 ]
- /Subtype /Link
- /Type /Annot >>
-endobj
-% 'F6': class PDFType1Font 
+<< /Border [ 0 0 0 ] /Contents () /Dest [ 71 0 R /XYZ 62.69291 607.8236 0 ] /Rect [ 521.4627 308.7736 532.5827 320.7736 ] /Subtype /Link /Type /Annot >>
+endobj
 43 0 obj
-% Font Courier-Oblique
-<< /BaseFont /Courier-Oblique
- /Encoding /WinAnsiEncoding
- /Name /F6
- /Subtype /Type1
- /Type /Font >>
-endobj
-% 'Annot.NUMBER36': class PDFDictionary 
+<< /Border [ 0 0 0 ] /Contents () /Dest [ 71 0 R /XYZ 62.69291 256.8236 0 ] /Rect [ 62.69291 290.7736 106.5829 302.7736 ] /Subtype /Link /Type /Annot >>
+endobj
 44 0 obj
-<< /A << /S /URI
- /Type /Action
- /URI (http://www.python.org/doc/2.5.2/lib/module-functools.html) >>
- /Border [ 0
- 0
- 0 ]
- /Rect [ 151.0486
- 112.5736
- 270.69
- 124.5736 ]
- /Subtype /Link
- /Type /Annot >>
-endobj
-% 'Page2': class PDFPage 
+<< /Border [ 0 0 0 ] /Contents () /Dest [ 71 0 R /XYZ 62.69291 256.8236 0 ] /Rect [ 521.4627 290.7736 532.5827 302.7736 ] /Subtype /Link /Type /Annot >>
+endobj
 45 0 obj
-% Page dictionary
-<< /Annots [ 42 0 R
- 44 0 R ]
- /Contents 90 0 R
- /MediaBox [ 0
- 0
- 595.2756
- 841.8898 ]
- /Parent 88 0 R
- /Resources << /Font 1 0 R
- /ProcSet [ /PDF
- /Text
- /ImageB
- /ImageC
- /ImageI ] >>
- /Rotate 0
- /Trans <<  >>
- /Type /Page >>
-endobj
-% 'Page3': class PDFPage 
+<< /Annots [ 5 0 R 6 0 R 8 0 R 9 0 R 10 0 R 11 0 R 12 0 R 13 0 R 14 0 R 15 0 R 
+  16 0 R 17 0 R 18 0 R 19 0 R 20 0 R 21 0 R 22 0 R 23 0 R 24 0 R 25 0 R 
+  26 0 R 27 0 R 28 0 R 29 0 R 30 0 R 31 0 R 32 0 R 33 0 R 34 0 R 35 0 R 
+  36 0 R 37 0 R 38 0 R 39 0 R 40 0 R 41 0 R 42 0 R 43 0 R 44 0 R ] /Contents 93 0 R /MediaBox [ 0 0 595.2756 841.8898 ] /Parent 92 0 R /Resources << /Font 1 0 R /ProcSet [ /PDF /Text /ImageB /ImageC /ImageI ] >> /Rotate 0 
+  /Trans <<  >> /Type /Page >>
+endobj
 46 0 obj
-% Page dictionary
-<< /Contents 91 0 R
- /MediaBox [ 0
- 0
- 595.2756
- 841.8898 ]
- /Parent 88 0 R
- /Resources << /Font 1 0 R
- /ProcSet [ /PDF
- /Text
- /ImageB
- /ImageC
- /ImageI ] >>
- /Rotate 0
- /Trans <<  >>
- /Type /Page >>
-endobj
-% 'Page4': class PDFPage 
+<< /BaseFont /Helvetica-Oblique /Encoding /WinAnsiEncoding /Name /F5 /Subtype /Type1 /Type /Font >>
+endobj
 47 0 obj
-% Page dictionary
-<< /Contents 92 0 R
- /MediaBox [ 0
- 0
- 595.2756
- 841.8898 ]
- /Parent 88 0 R
- /Resources << /Font 1 0 R
- /ProcSet [ /PDF
- /Text
- /ImageB
- /ImageC
- /ImageI ] >>
- /Rotate 0
- /Trans <<  >>
- /Type /Page >>
-endobj
-% 'Annot.NUMBER37': class PDFDictionary 
+<< /A << /S /URI /Type /Action /URI (http://www.python.org/moin/PythonDecoratorLibrary) >> /Border [ 0 0 0 ] /Rect [ 219.6428 321.7736 449.1728 333.7736 ] /Subtype /Link /Type /Annot >>
+endobj
 48 0 obj
-<< /A << /S /URI
- /Type /Action
- /URI (http://www.python.org/dev/peps/pep-3107/) >>
- /Border [ 0
- 0
- 0 ]
- /Rect [ 231.6368
- 529.728
- 323.0741
- 541.728 ]
- /Subtype /Link
- /Type /Annot >>
-endobj
-% 'Page5': class PDFPage 
+<< /BaseFont /Courier-Oblique /Encoding /WinAnsiEncoding /Name /F6 /Subtype /Type1 /Type /Font >>
+endobj
 49 0 obj
-% Page dictionary
-<< /Annots [ 48 0 R ]
- /Contents 93 0 R
- /MediaBox [ 0
- 0
- 595.2756
- 841.8898 ]
- /Parent 88 0 R
- /Resources << /Font 1 0 R
- /ProcSet [ /PDF
- /Text
- /ImageB
- /ImageC
- /ImageI ] >>
- /Rotate 0
- /Trans <<  >>
- /Type /Page >>
-endobj
-% 'Page6': class PDFPage 
+<< /Annots [ 47 0 R ] /Contents 94 0 R /MediaBox [ 0 0 595.2756 841.8898 ] /Parent 92 0 R /Resources << /Font 1 0 R /ProcSet [ /PDF /Text /ImageB /ImageC /ImageI ] >> /Rotate 0 
+  /Trans <<  >> /Type /Page >>
+endobj
 50 0 obj
-% Page dictionary
-<< /Contents 94 0 R
- /MediaBox [ 0
- 0
- 595.2756
- 841.8898 ]
- /Parent 88 0 R
- /Resources << /Font 1 0 R
- /ProcSet [ /PDF
- /Text
- /ImageB
- /ImageC
- /ImageI ] >>
- /Rotate 0
- /Trans <<  >>
- /Type /Page >>
-endobj
-% 'Page7': class PDFPage 
+<< /A << /S /URI /Type /Action /URI (https://docs.python.org/3/library/functools.html#functools.update_wrapper) >> /Border [ 0 0 0 ] /Rect [ 151.0486 753.7736 270.69 765.7736 ] /Subtype /Link /Type /Annot >>
+endobj
 51 0 obj
-% Page dictionary
-<< /Contents 95 0 R
- /MediaBox [ 0
- 0
- 595.2756
- 841.8898 ]
- /Parent 88 0 R
- /Resources << /Font 1 0 R
- /ProcSet [ /PDF
- /Text
- /ImageB
- /ImageC
- /ImageI ] >>
- /Rotate 0
- /Trans <<  >>
- /Type /Page >>
-endobj
-% 'Page8': class PDFPage 
+<< /Annots [ 50 0 R ] /Contents 95 0 R /MediaBox [ 0 0 595.2756 841.8898 ] /Parent 92 0 R /Resources << /Font 1 0 R /ProcSet [ /PDF /Text /ImageB /ImageC /ImageI ] >> /Rotate 0 
+  /Trans <<  >> /Type /Page >>
+endobj
 52 0 obj
-% Page dictionary
-<< /Contents 96 0 R
- /MediaBox [ 0
- 0
- 595.2756
- 841.8898 ]
- /Parent 88 0 R
- /Resources << /Font 1 0 R
- /ProcSet [ /PDF
- /Text
- /ImageB
- /ImageC
- /ImageI ] >>
- /Rotate 0
- /Trans <<  >>
- /Type /Page >>
-endobj
-% 'Page9': class PDFPage 
+<< /Contents 96 0 R /MediaBox [ 0 0 595.2756 841.8898 ] /Parent 92 0 R /Resources << /Font 1 0 R /ProcSet [ /PDF /Text /ImageB /ImageC /ImageI ] >> /Rotate 0 /Trans <<  >> 
+  /Type /Page >>
+endobj
 53 0 obj
-% Page dictionary
-<< /Contents 97 0 R
- /MediaBox [ 0
- 0
- 595.2756
- 841.8898 ]
- /Parent 88 0 R
- /Resources << /Font 1 0 R
- /ProcSet [ /PDF
- /Text
- /ImageB
- /ImageC
- /ImageI ] >>
- /Rotate 0
- /Trans <<  >>
- /Type /Page >>
-endobj
-% 'Page10': class PDFPage 
+<< /A << /S /URI /Type /Action /URI (http://www.python.org/dev/peps/pep-3107/) >> /Border [ 0 0 0 ] /Rect [ 231.6368 463.1736 323.0741 475.1736 ] /Subtype /Link /Type /Annot >>
+endobj
 54 0 obj
-% Page dictionary
-<< /Contents 98 0 R
- /MediaBox [ 0
- 0
- 595.2756
- 841.8898 ]
- /Parent 88 0 R
- /Resources << /Font 1 0 R
- /ProcSet [ /PDF
- /Text
- /ImageB
- /ImageC
- /ImageI ] >>
- /Rotate 0
- /Trans <<  >>
- /Type /Page >>
-endobj
-% 'Annot.NUMBER38': class PDFDictionary 
+<< /Annots [ 53 0 R ] /Contents 97 0 R /MediaBox [ 0 0 595.2756 841.8898 ] /Parent 92 0 R /Resources << /Font 1 0 R /ProcSet [ /PDF /Text /ImageB /ImageC /ImageI ] >> /Rotate 0 
+  /Trans <<  >> /Type /Page >>
+endobj
 55 0 obj
-<< /A << /S /URI
- /Type /Action
- /URI (http://bugs.python.org/issue1764286) >>
- /Border [ 0
- 0
- 0 ]
- /Rect [ 137.6966
- 472.3736
- 180.8679
- 484.3736 ]
- /Subtype /Link
- /Type /Annot >>
-endobj
-% 'Page11': class PDFPage 
+<< /Contents 98 0 R /MediaBox [ 0 0 595.2756 841.8898 ] /Parent 92 0 R /Resources << /Font 1 0 R /ProcSet [ /PDF /Text /ImageB /ImageC /ImageI ] >> /Rotate 0 /Trans <<  >> 
+  /Type /Page >>
+endobj
 56 0 obj
-% Page dictionary
-<< /Annots [ 55 0 R ]
- /Contents 99 0 R
- /MediaBox [ 0
- 0
- 595.2756
- 841.8898 ]
- /Parent 88 0 R
- /Resources << /Font 1 0 R
- /ProcSet [ /PDF
- /Text
- /ImageB
- /ImageC
- /ImageI ] >>
- /Rotate 0
- /Trans <<  >>
- /Type /Page >>
-endobj
-% 'Annot.NUMBER39': class PDFDictionary 
+<< /Contents 99 0 R /MediaBox [ 0 0 595.2756 841.8898 ] /Parent 92 0 R /Resources << /Font 1 0 R /ProcSet [ /PDF /Text /ImageB /ImageC /ImageI ] >> /Rotate 0 /Trans <<  >> 
+  /Type /Page >>
+endobj
 57 0 obj
-<< /A << /S /URI
- /Type /Action
- /URI (http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/496691) >>
- /Border [ 0
- 0
- 0 ]
- /Rect [ 62.69291
- 675.7736
- 363.4029
- 687.7736 ]
- /Subtype /Link
- /Type /Annot >>
-endobj
-% 'Page12': class PDFPage 
+<< /Contents 100 0 R /MediaBox [ 0 0 595.2756 841.8898 ] /Parent 92 0 R /Resources << /Font 1 0 R /ProcSet [ /PDF /Text /ImageB /ImageC /ImageI ] >> /Rotate 0 /Trans <<  >> 
+  /Type /Page >>
+endobj
 58 0 obj
-% Page dictionary
-<< /Annots [ 57 0 R ]
- /Contents 100 0 R
- /MediaBox [ 0
- 0
- 595.2756
- 841.8898 ]
- /Parent 88 0 R
- /Resources << /Font 1 0 R
- /ProcSet [ /PDF
- /Text
- /ImageB
- /ImageC
- /ImageI ] >>
- /Rotate 0
- /Trans <<  >>
- /Type /Page >>
-endobj
-% 'Page13': class PDFPage 
+<< /Contents 101 0 R /MediaBox [ 0 0 595.2756 841.8898 ] /Parent 92 0 R /Resources << /Font 1 0 R /ProcSet [ /PDF /Text /ImageB /ImageC /ImageI ] >> /Rotate 0 /Trans <<  >> 
+  /Type /Page >>
+endobj
 59 0 obj
-% Page dictionary
-<< /Contents 101 0 R
- /MediaBox [ 0
- 0
- 595.2756
- 841.8898 ]
- /Parent 88 0 R
- /Resources << /Font 1 0 R
- /ProcSet [ /PDF
- /Text
- /ImageB
- /ImageC
- /ImageI ] >>
- /Rotate 0
- /Trans <<  >>
- /Type /Page >>
-endobj
-% 'Annot.NUMBER40': class PDFDictionary 
+<< /Contents 102 0 R /MediaBox [ 0 0 595.2756 841.8898 ] /Parent 92 0 R /Resources << /Font 1 0 R /ProcSet [ /PDF /Text /ImageB /ImageC /ImageI ] >> /Rotate 0 /Trans <<  >> 
+  /Type /Page >>
+endobj
 60 0 obj
-<< /A << /S /URI
- /Type /Action
- /URI (http://www.python.org/dev/peps/pep-0362) >>
- /Border [ 0
- 0
- 0 ]
- /Rect [ 301.1597
- 534.5736
- 317.8397
- 546.5736 ]
- /Subtype /Link
- /Type /Annot >>
-endobj
-% 'Page14': class PDFPage 
+<< /A << /S /URI /Type /Action /URI (http://bugs.python.org/issue1764286) >> /Border [ 0 0 0 ] /Rect [ 137.6966 388.3736 180.8679 400.3736 ] /Subtype /Link /Type /Annot >>
+endobj
 61 0 obj
-% Page dictionary
-<< /Annots [ 60 0 R ]
- /Contents 102 0 R
- /MediaBox [ 0
- 0
- 595.2756
- 841.8898 ]
- /Parent 88 0 R
- /Resources << /Font 1 0 R
- /ProcSet [ /PDF
- /Text
- /ImageB
- /ImageC
- /ImageI ] >>
- /Rotate 0
- /Trans <<  >>
- /Type /Page >>
-endobj
-% 'Annot.NUMBER41': class PDFDictionary 
+<< /Annots [ 60 0 R ] /Contents 103 0 R /MediaBox [ 0 0 595.2756 841.8898 ] /Parent 92 0 R /Resources << /Font 1 0 R /ProcSet [ /PDF /Text /ImageB /ImageC /ImageI ] >> /Rotate 0 
+  /Trans <<  >> /Type /Page >>
+endobj
 62 0 obj
-<< /A << /S /URI
- /Type /Action
- /URI (http://www.python.org/dev/peps/pep-3107/) >>
- /Border [ 0
- 0
- 0 ]
- /Rect [ 497.5627
- 726.7736
- 531.1777
- 738.7736 ]
- /Subtype /Link
- /Type /Annot >>
-endobj
-% 'Annot.NUMBER42': class PDFDictionary 
+<< /A << /S /URI /Type /Action /URI (http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/496691) >> /Border [ 0 0 0 ] /Rect [ 62.69291 576.5736 363.4029 588.5736 ] /Subtype /Link /Type /Annot >>
+endobj
 63 0 obj
-<< /A << /S /URI
- /Type /Action
- /URI (http://www.python.org/dev/peps/pep-3107/) >>
- /Border [ 0
- 0
- 0 ]
- /Rect [ 62.69291
- 714.7736
- 114.3929
- 726.7736 ]
- /Subtype /Link
- /Type /Annot >>
-endobj
-% 'Annot.NUMBER43': class PDFDictionary 
+<< /Annots [ 62 0 R ] /Contents 104 0 R /MediaBox [ 0 0 595.2756 841.8898 ] /Parent 92 0 R /Resources << /Font 1 0 R /ProcSet [ /PDF /Text /ImageB /ImageC /ImageI ] >> /Rotate 0 
+  /Trans <<  >> /Type /Page >>
+endobj
 64 0 obj
-<< /A << /S /URI
- /Type /Action
- /URI (http://packages.python.org/distribute/) >>
- /Border [ 0
- 0
- 0 ]
- /Rect [ 172.9507
- 702.7736
- 216.6742
- 714.7736 ]
- /Subtype /Link
- /Type /Annot >>
-endobj
-% 'Annot.NUMBER44': class PDFDictionary 
+<< /Contents 105 0 R /MediaBox [ 0 0 595.2756 841.8898 ] /Parent 92 0 R /Resources << /Font 1 0 R /ProcSet [ /PDF /Text /ImageB /ImageC /ImageI ] >> /Rotate 0 /Trans <<  >> 
+  /Type /Page >>
+endobj
 65 0 obj
-<< /A << /S /URI
- /Type /Action
- /URI (http://docutils.sourceforge.net/) >>
- /Border [ 0
- 0
- 0 ]
- /Rect [ 82.15291
- 678.7736
- 118.8329
- 690.7736 ]
- /Subtype /Link
- /Type /Annot >>
-endobj
-% 'Annot.NUMBER45': class PDFDictionary 
+<< /A << /S /URI /Type /Action /URI (http://www.python.org/dev/peps/pep-0362) >> /Border [ 0 0 0 ] /Rect [ 301.1597 371.3736 317.8397 383.3736 ] /Subtype /Link /Type /Annot >>
+endobj
 66 0 obj
-<< /A << /S /URI
- /Type /Action
- /URI (http://pygments.org/) >>
- /Border [ 0
- 0
- 0 ]
- /Rect [ 138.2929
- 678.7736
- 184.4229
- 690.7736 ]
- /Subtype /Link
- /Type /Annot >>
-endobj
-% 'Annot.NUMBER46': class PDFDictionary 
+<< /Annots [ 65 0 R ] /Contents 106 0 R /MediaBox [ 0 0 595.2756 841.8898 ] /Parent 92 0 R /Resources << /Font 1 0 R /ProcSet [ /PDF /Text /ImageB /ImageC /ImageI ] >> /Rotate 0 
+  /Trans <<  >> /Type /Page >>
+endobj
 67 0 obj
-<< /A << /S /URI
- /Type /Action
- /URI (http://www.phyast.pitt.edu/~micheles/python/documentation.html#class-decorators-and-decorator-factories) >>
- /Border [ 0
- 0
- 0 ]
- /Rect [ 364.2921
- 540.7736
- 531.64
- 552.7736 ]
- /Subtype /Link
- /Type /Annot >>
-endobj
-% 'Page15': class PDFPage 
+<< /A << /S /URI /Type /Action /URI (http://www.python.org/dev/peps/pep-3107/) >> /Border [ 0 0 0 ] /Rect [ 384.6306 557.5736 474.9013 569.5736 ] /Subtype /Link /Type /Annot >>
+endobj
 68 0 obj
-% Page dictionary
-<< /Annots [ 62 0 R
- 63 0 R
- 64 0 R
- 65 0 R
- 66 0 R
- 67 0 R ]
- /Contents 103 0 R
- /MediaBox [ 0
- 0
- 595.2756
- 841.8898 ]
- /Parent 88 0 R
- /Resources << /Font 1 0 R
- /ProcSet [ /PDF
- /Text
- /ImageB
- /ImageC
- /ImageI ] >>
- /Rotate 0
- /Trans <<  >>
- /Type /Page >>
-endobj
-% 'R69': class PDFCatalog 
+<< /A << /S /URI /Type /Action /URI (http://docutils.sourceforge.net/) >> /Border [ 0 0 0 ] /Rect [ 476.7077 533.5736 515.9027 545.5736 ] /Subtype /Link /Type /Annot >>
+endobj
 69 0 obj
-% Document Root
-<< /Outlines 71 0 R
- /PageLabels 104 0 R
- /PageMode /UseNone
- /Pages 88 0 R
- /Type /Catalog >>
-endobj
-% 'R70': class PDFInfo 
+<< /A << /S /URI /Type /Action /URI (http://pygments.org/) >> /Border [ 0 0 0 ] /Rect [ 62.69291 521.5736 108.8229 533.5736 ] /Subtype /Link /Type /Annot >>
+endobj
 70 0 obj
-<< /Author (Michele Simionato)
- /CreationDate (D:20121018102601-01'00')
- /Creator (\(unspecified\))
- /Keywords ()
- /Producer (ReportLab PDF Library - www.reportlab.com)
- /Subject (\(unspecified\))
- /Title (The decorator module) >>
-endobj
-% 'R71': class PDFOutlines 
+<< /A << /S /URI /Type /Action /URI (http://www.phyast.pitt.edu/~micheles/python/documentation.html#class-decorators-and-decorator-factories) >> /Border [ 0 0 0 ] /Rect [ 364.2921 383.5736 531.64 395.5736 ] /Subtype /Link /Type /Annot >>
+endobj
 71 0 obj
-<< /Count 16
- /First 72 0 R
- /Last 87 0 R
- /Type /Outlines >>
+<< /Annots [ 67 0 R 68 0 R 69 0 R 70 0 R ] /Contents 107 0 R /MediaBox [ 0 0 595.2756 841.8898 ] /Parent 92 0 R /Resources << /Font 1 0 R /ProcSet [ /PDF /Text /ImageB /ImageC /ImageI ] >> /Rotate 0 
+  /Trans <<  >> /Type /Page >>
 endobj
-% 'Outline.0': class OutlineEntryObject 
 72 0 obj
-<< /Dest [ 40 0 R
- /XYZ
- 62.69291
- 275.0236
- 0 ]
- /Next 73 0 R
- /Parent 71 0 R
- /Title (Introduction) >>
-endobj
-% 'Outline.1': class OutlineEntryObject 
+<< /Contents 108 0 R /MediaBox [ 0 0 595.2756 841.8898 ] /Parent 92 0 R /Resources << /Font 1 0 R /ProcSet [ /PDF /Text /ImageB /ImageC /ImageI ] >> /Rotate 0 /Trans <<  >> 
+  /Type /Page >>
+endobj
 73 0 obj
-<< /Dest [ 45 0 R
- /XYZ
- 62.69291
- 657.0236
- 0 ]
- /Next 74 0 R
- /Parent 71 0 R
- /Prev 72 0 R
- /Title (Definitions) >>
-endobj
-% 'Outline.2': class OutlineEntryObject 
+<< /Outlines 75 0 R /PageLabels 109 0 R /PageMode /UseNone /Pages 92 0 R /Type /Catalog >>
+endobj
 74 0 obj
-<< /Dest [ 45 0 R
- /XYZ
- 62.69291
- 420.0236
- 0 ]
- /Next 75 0 R
- /Parent 71 0 R
- /Prev 73 0 R
- /Title (Statement of the problem) >>
-endobj
-% 'Outline.3': class OutlineEntryObject 
+<< /Author (Michele Simionato) /CreationDate (D:20150316121853-01'00') /Creator (\(unspecified\)) /Keywords () /Producer (ReportLab PDF Library - www.reportlab.com) /Subject (\(unspecified\)) 
+  /Title (The decorator module) >>
+endobj
 75 0 obj
-<< /Dest [ 46 0 R
- /XYZ
- 62.69291
- 409.4236
- 0 ]
- /Next 76 0 R
- /Parent 71 0 R
- /Prev 74 0 R
- /Title (The solution) >>
-endobj
-% 'Outline.4': class OutlineEntryObject 
+<< /Count 16 /First 76 0 R /Last 91 0 R /Type /Outlines >>
+endobj
 76 0 obj
-<< /Dest [ 47 0 R
- /XYZ
- 62.69291
- 435.4236
- 0 ]
- /Next 77 0 R
- /Parent 71 0 R
- /Prev 75 0 R
- /Title (A trace decorator) >>
-endobj
-% 'Outline.5': class OutlineEntryObject 
+<< /Dest [ 45 0 R /XYZ 62.69291 275.0236 0 ] /Next 77 0 R /Parent 75 0 R /Title (Introduction) >>
+endobj
 77 0 obj
-<< /Dest [ 49 0 R
- /XYZ
- 62.69291
- 567.978
- 0 ]
- /Next 78 0 R
- /Parent 71 0 R
- /Prev 76 0 R
- /Title (Function annotations) >>
-endobj
-% 'Outline.6': class OutlineEntryObject 
+<< /Dest [ 49 0 R /XYZ 62.69291 633.0236 0 ] /Next 78 0 R /Parent 75 0 R /Prev 76 0 R /Title (Definitions) >>
+endobj
 78 0 obj
-<< /Dest [ 50 0 R
- /XYZ
- 62.69291
- 765.0236
- 0 ]
- /Next 79 0 R
- /Parent 71 0 R
- /Prev 77 0 R
- /Title (decorator is a decorator) >>
-endobj
-% 'Outline.7': class OutlineEntryObject 
+<< /Dest [ 49 0 R /XYZ 62.69291 396.0236 0 ] /Next 79 0 R /Parent 75 0 R /Prev 77 0 R /Title (Statement of the problem) >>
+endobj
 79 0 obj
-<< /Dest [ 50 0 R
- /XYZ
- 62.69291
- 338.4236
- 0 ]
- /Next 80 0 R
- /Parent 71 0 R
- /Prev 78 0 R
- /Title (blocking) >>
-endobj
-% 'Outline.8': class OutlineEntryObject 
+<< /Dest [ 51 0 R /XYZ 62.69291 373.4236 0 ] /Next 80 0 R /Parent 75 0 R /Prev 78 0 R /Title (The solution) >>
+endobj
 80 0 obj
-<< /Dest [ 51 0 R
- /XYZ
- 62.69291
- 479.8236
- 0 ]
- /Next 81 0 R
- /Parent 71 0 R
- /Prev 79 0 R
- /Title (async) >>
-endobj
-% 'Outline.9': class OutlineEntryObject 
+<< /Dest [ 52 0 R /XYZ 62.69291 370.2236 0 ] /Next 81 0 R /Parent 75 0 R /Prev 79 0 R /Title (A trace decorator) >>
+endobj
 81 0 obj
-<< /Dest [ 53 0 R
- /XYZ
- 62.69291
- 643.8236
- 0 ]
- /Next 82 0 R
- /Parent 71 0 R
- /Prev 80 0 R
- /Title (contextmanager) >>
-endobj
-% 'Outline.10': class OutlineEntryObject 
+<< /Dest [ 54 0 R /XYZ 62.69291 501.4236 0 ] /Next 82 0 R /Parent 75 0 R /Prev 80 0 R /Title (Function annotations) >>
+endobj
 82 0 obj
-<< /Dest [ 54 0 R
- /XYZ
- 62.69291
- 729.0236
- 0 ]
- /Next 83 0 R
- /Parent 71 0 R
- /Prev 81 0 R
- /Title (The FunctionMaker class) >>
-endobj
-% 'Outline.11': class OutlineEntryObject 
+<< /Dest [ 55 0 R /XYZ 62.69291 729.0236 0 ] /Next 83 0 R /Parent 75 0 R /Prev 81 0 R /Title (decorator is a decorator) >>
+endobj
 83 0 obj
-<< /Dest [ 56 0 R
- /XYZ
- 62.69291
- 765.0236
- 0 ]
- /Next 84 0 R
- /Parent 71 0 R
- /Prev 82 0 R
- /Title (Getting the source code) >>
-endobj
-% 'Outline.12': class OutlineEntryObject 
+<< /Dest [ 55 0 R /XYZ 62.69291 302.4236 0 ] /Next 84 0 R /Parent 75 0 R /Prev 82 0 R /Title (blocking) >>
+endobj
 84 0 obj
-<< /Dest [ 56 0 R
- /XYZ
- 62.69291
- 318.4236
- 0 ]
- /Next 85 0 R
- /Parent 71 0 R
- /Prev 83 0 R
- /Title (Dealing with third party decorators) >>
-endobj
-% 'Outline.13': class OutlineEntryObject 
+<< /Dest [ 56 0 R /XYZ 62.69291 422.6236 0 ] /Next 85 0 R /Parent 75 0 R /Prev 83 0 R /Title (async) >>
+endobj
 85 0 obj
-<< /Dest [ 59 0 R
- /XYZ
- 62.69291
- 615.8236
- 0 ]
- /Next 86 0 R
- /Parent 71 0 R
- /Prev 84 0 R
- /Title (Caveats and limitations) >>
-endobj
-% 'Outline.14': class OutlineEntryObject 
+<< /Dest [ 58 0 R /XYZ 62.69291 563.8236 0 ] /Next 86 0 R /Parent 75 0 R /Prev 84 0 R /Title (contextmanager) >>
+endobj
 86 0 obj
-<< /Dest [ 68 0 R
- /XYZ
- 62.69291
- 765.0236
- 0 ]
- /Next 87 0 R
- /Parent 71 0 R
- /Prev 85 0 R
- /Title (Compatibility notes) >>
-endobj
-% 'Outline.15': class OutlineEntryObject 
+<< /Dest [ 59 0 R /XYZ 62.69291 657.0236 0 ] /Next 87 0 R /Parent 75 0 R /Prev 85 0 R /Title (The FunctionMaker class) >>
+endobj
 87 0 obj
-<< /Dest [ 68 0 R
- /XYZ
- 62.69291
- 414.0236
- 0 ]
- /Parent 71 0 R
- /Prev 86 0 R
- /Title (LICENCE) >>
-endobj
-% 'R88': class PDFPages 
+<< /Dest [ 61 0 R /XYZ 62.69291 681.0236 0 ] /Next 88 0 R /Parent 75 0 R /Prev 86 0 R /Title (Getting the source code) >>
+endobj
 88 0 obj
-% page tree
-<< /Count 15
- /Kids [ 40 0 R
- 45 0 R
- 46 0 R
- 47 0 R
- 49 0 R
- 50 0 R
- 51 0 R
- 52 0 R
- 53 0 R
- 54 0 R
- 56 0 R
- 58 0 R
- 59 0 R
- 61 0 R
- 68 0 R ]
- /Type /Pages >>
-endobj
-% 'R89': class PDFStream 
+<< /Dest [ 61 0 R /XYZ 62.69291 222.4236 0 ] /Next 89 0 R /Parent 75 0 R /Prev 87 0 R /Title (Dealing with third party decorators) >>
+endobj
 89 0 obj
-% page stream
-<< /Length 9258 >>
+<< /Dest [ 64 0 R /XYZ 62.69291 465.4236 0 ] /Next 90 0 R /Parent 75 0 R /Prev 88 0 R /Title (Caveats and limitations) >>
+endobj
+90 0 obj
+<< /Dest [ 71 0 R /XYZ 62.69291 607.8236 0 ] /Next 91 0 R /Parent 75 0 R /Prev 89 0 R /Title (Compatibility notes) >>
+endobj
+91 0 obj
+<< /Dest [ 71 0 R /XYZ 62.69291 256.8236 0 ] /Parent 75 0 R /Prev 90 0 R /Title (LICENCE) >>
+endobj
+92 0 obj
+<< /Count 16 /Kids [ 45 0 R 49 0 R 51 0 R 52 0 R 54 0 R 55 0 R 56 0 R 57 0 R 58 0 R 59 0 R 
+  61 0 R 63 0 R 64 0 R 66 0 R 71 0 R 72 0 R ] /Type /Pages >>
+endobj
+93 0 obj
+<< /Length 8970 >>
 stream
 1 0 0 1 0 0 cm  BT /F1 12 Tf 14.4 TL ET
 q
 1 0 0 1 62.69291 741.0236 cm
 q
-BT 1 0 0 1 0 4 Tm 118.8249 0 Td 24 TL /F2 20 Tf 0 0 0 rg (The ) Tj /F3 20 Tf (decorator ) Tj /F2 20 Tf (module) Tj T* -118.8249 0 Td ET
+BT 1 0 0 1 0 4 Tm 118.8249 0 Td 24 TL /F2 20 Tf 0 0 0 rg (The ) Tj /F3 20 Tf 0 0 0 rg (decorator ) Tj /F2 20 Tf 0 0 0 rg (module) Tj T* -118.8249 0 Td ET
 Q
 Q
 q
@@ -1486,7 +363,7 @@ q
 1 0 0 1 91.03937 3 cm
 q
 0 0 0 rg
-BT 1 0 0 1 0 2 Tm /F1 10 Tf 12 TL (3.4.0 \(2012-10-18\)) Tj T* ET
+BT 1 0 0 1 0 2 Tm /F1 10 Tf 12 TL (3.4.1 \(2015-03-16\)) Tj T* ET
 Q
 Q
 q
@@ -1529,7 +406,7 @@ q
 q
 0 0 .501961 rg
 0 0 .501961 RG
-BT 1 0 0 1 0 2 Tm /F1 10 Tf 12 TL (http://pypi.python.org/pypi/decorator/3.4.0) Tj T* ET
+BT 1 0 0 1 0 2 Tm /F1 10 Tf 12 TL (http://pypi.python.org/pypi/decorator/3.4.1) Tj T* ET
 Q
 Q
 q
@@ -1645,7 +522,7 @@ Q
 q
 1 0 0 1 0 201 cm
 q
-BT 1 0 0 1 0 2 Tm 12 TL /F2 10 Tf 0 0 .501961 rg (A ) Tj /F3 10 Tf (trace ) Tj /F2 10 Tf (decorator) Tj T* ET
+BT 1 0 0 1 0 2 Tm 12 TL /F2 10 Tf 0 0 .501961 rg (A ) Tj /F3 10 Tf 0 0 0 rg (trace ) Tj /F2 10 Tf 0 0 .501961 rg (decorator) Tj T* ET
 Q
 Q
 q
@@ -1673,7 +550,7 @@ Q
 q
 1 0 0 1 0 165 cm
 q
-BT 1 0 0 1 0 2 Tm 12 TL /F3 10 Tf 0 0 .501961 rg (decorator ) Tj /F2 10 Tf (is a decorator) Tj T* ET
+BT 1 0 0 1 0 2 Tm 12 TL /F3 10 Tf 0 0 0 rg (decorator ) Tj /F2 10 Tf 0 0 .501961 rg (is a decorator) Tj T* ET
 Q
 Q
 q
@@ -1687,7 +564,7 @@ Q
 q
 1 0 0 1 0 147 cm
 q
-BT 1 0 0 1 0 2 Tm 12 TL /F3 10 Tf 0 0 .501961 rg (blocking) Tj T* ET
+BT 1 0 0 1 0 2 Tm 12 TL /F3 10 Tf 0 0 0 rg (blocking) Tj T* ET
 Q
 Q
 q
@@ -1701,7 +578,7 @@ Q
 q
 1 0 0 1 0 129 cm
 q
-BT 1 0 0 1 0 2 Tm 12 TL /F3 10 Tf 0 0 .501961 rg (async) Tj T* ET
+BT 1 0 0 1 0 2 Tm 12 TL /F3 10 Tf 0 0 0 rg (async) Tj T* ET
 Q
 Q
 q
@@ -1729,7 +606,7 @@ Q
 q
 1 0 0 1 0 93 cm
 q
-BT 1 0 0 1 0 2 Tm 12 TL /F2 10 Tf 0 0 .501961 rg (The ) Tj /F3 10 Tf (FunctionMaker ) Tj /F2 10 Tf (class) Tj T* ET
+BT 1 0 0 1 0 2 Tm 12 TL /F2 10 Tf 0 0 .501961 rg (The ) Tj /F3 10 Tf 0 0 0 rg (FunctionMaker ) Tj /F2 10 Tf 0 0 .501961 rg (class) Tj T* ET
 Q
 Q
 q
@@ -1928,62 +805,53 @@ Q
 q
 1 0 0 1 62.69291 116.0236 cm
 Q
-q
-1 0 0 1 62.69291 86.02362 cm
-q
-0 0 0 rg
-BT 1 0 0 1 0 14 Tm /F1 10 Tf 12 TL .848876 Tw (Still, as of now, writing custom decorators correctly requires some experience and it is not as easy as it) Tj T* 0 Tw 1.049269 Tw (could be. For instance, typical implementations of decorators involve nested functions, and we all know) Tj T* 0 Tw ET
-Q
-Q
  
 endstream
 endobj
-% 'R90': class PDFStream 
-90 0 obj
-% page stream
-<< /Length 7660 >>
+94 0 obj
+<< /Length 12226 >>
 stream
 1 0 0 1 0 0 cm  BT /F1 12 Tf 14.4 TL ET
 q
-1 0 0 1 62.69291 753.0236 cm
+1 0 0 1 62.69291 729.0236 cm
 q
 0 0 0 rg
-BT 1 0 0 1 0 2 Tm /F1 10 Tf 12 TL (that flat is better than nested.) Tj T* ET
+BT 1 0 0 1 0 26 Tm /F1 10 Tf 12 TL .848876 Tw (Still, as of now, writing custom decorators correctly requires some experience and it is not as easy as it) Tj T* 0 Tw 1.049269 Tw (could be. For instance, typical implementations of decorators involve nested functions, and we all know) Tj T* 0 Tw (that flat is better than nested.) Tj T* ET
 Q
 Q
 q
-1 0 0 1 62.69291 699.0236 cm
+1 0 0 1 62.69291 675.0236 cm
 q
-BT 1 0 0 1 0 38 Tm 1.093735 Tw 12 TL /F1 10 Tf 0 0 0 rg (The aim of the ) Tj /F4 10 Tf (decorator ) Tj /F1 10 Tf (module it to simplify the usage of decorators for the average programmer,) Tj T* 0 Tw 2.456136 Tw (and to popularize decorators by showing various non-trivial examples. Of course, as all techniques,) Tj T* 0 Tw 2.234987 Tw (decorators can be abused \(I have seen that\) and you should not try to solve every problem with a) Tj T* 0 Tw (decorator, just because you can.) Tj T* ET
+BT 1 0 0 1 0 38 Tm 1.093735 Tw 12 TL /F1 10 Tf 0 0 0 rg (The aim of the ) Tj /F4 10 Tf 0 0 0 rg (decorator ) Tj /F1 10 Tf 0 0 0 rg (module it to simplify the usage of decorators for the average programmer,) Tj T* 0 Tw 2.456136 Tw (and to popularize decorators by showing various non-trivial examples. Of course, as all techniques,) Tj T* 0 Tw 2.234987 Tw (decorators can be abused \(I have seen that\) and you should not try to solve every problem with a) Tj T* 0 Tw (decorator, just because you can.) Tj T* ET
 Q
 Q
 q
-1 0 0 1 62.69291 669.0236 cm
+1 0 0 1 62.69291 645.0236 cm
 q
-BT 1 0 0 1 0 14 Tm .13561 Tw 12 TL /F1 10 Tf 0 0 0 rg (You may find the source code for all the examples discussed here in the ) Tj /F4 10 Tf (documentation.py ) Tj /F1 10 Tf (file, which) Tj T* 0 Tw (contains this documentation in the form of doctests.) Tj T* ET
+BT 1 0 0 1 0 14 Tm .13561 Tw 12 TL /F1 10 Tf 0 0 0 rg (You may find the source code for all the examples discussed here in the ) Tj /F4 10 Tf 0 0 0 rg (documentation.py ) Tj /F1 10 Tf 0 0 0 rg (file, which) Tj T* 0 Tw (contains this documentation in the form of doctests.) Tj T* ET
 Q
 Q
 q
-1 0 0 1 62.69291 636.0236 cm
+1 0 0 1 62.69291 612.0236 cm
 q
 BT 1 0 0 1 0 3.5 Tm 21 TL /F2 17.5 Tf 0 0 0 rg (Definitions) Tj T* ET
 Q
 Q
 q
-1 0 0 1 62.69291 594.0236 cm
+1 0 0 1 62.69291 570.0236 cm
 q
 0 0 0 rg
 BT 1 0 0 1 0 26 Tm /F1 10 Tf 12 TL 2.37561 Tw (Technically speaking, any Python object which can be called with one argument can be used as a) Tj T* 0 Tw .472339 Tw (decorator. However, this definition is somewhat too large to be really useful. It is more convenient to split) Tj T* 0 Tw (the generic class of decorators in two subclasses:) Tj T* ET
 Q
 Q
 q
-1 0 0 1 62.69291 588.0236 cm
+1 0 0 1 62.69291 564.0236 cm
 Q
 q
-1 0 0 1 62.69291 588.0236 cm
+1 0 0 1 62.69291 564.0236 cm
 Q
 q
-1 0 0 1 62.69291 564.0236 cm
+1 0 0 1 62.69291 540.0236 cm
 0 0 0 rg
 BT /F1 10 Tf 12 TL ET
 q
@@ -2003,10 +871,10 @@ q
 Q
 Q
 q
-1 0 0 1 62.69291 558.0236 cm
+1 0 0 1 62.69291 534.0236 cm
 Q
 q
-1 0 0 1 62.69291 534.0236 cm
+1 0 0 1 62.69291 510.0236 cm
 0 0 0 rg
 BT /F1 10 Tf 12 TL ET
 q
@@ -2026,42 +894,42 @@ q
 Q
 Q
 q
-1 0 0 1 62.69291 534.0236 cm
+1 0 0 1 62.69291 510.0236 cm
 Q
 q
-1 0 0 1 62.69291 492.0236 cm
+1 0 0 1 62.69291 468.0236 cm
 q
-BT 1 0 0 1 0 26 Tm 2.832706 Tw 12 TL /F1 10 Tf 0 0 0 rg (Signature-changing decorators have their use: for instance the builtin classes ) Tj /F4 10 Tf (staticmethod ) Tj /F1 10 Tf (and) Tj T* 0 Tw 1.506651 Tw /F4 10 Tf (classmethod ) Tj /F1 10 Tf (are in this group, since they take functions and return descriptor objects which are not) Tj T* 0 Tw (functions, nor callables.) Tj T* ET
+BT 1 0 0 1 0 26 Tm 2.832706 Tw 12 TL /F1 10 Tf 0 0 0 rg (Signature-changing decorators have their use: for instance the builtin classes ) Tj /F4 10 Tf 0 0 0 rg (staticmethod ) Tj /F1 10 Tf 0 0 0 rg (and) Tj T* 0 Tw 1.506651 Tw /F4 10 Tf 0 0 0 rg (classmethod ) Tj /F1 10 Tf 0 0 0 rg (are in this group, since they take functions and return descriptor objects which are not) Tj T* 0 Tw (functions, nor callables.) Tj T* ET
 Q
 Q
 q
-1 0 0 1 62.69291 462.0236 cm
+1 0 0 1 62.69291 438.0236 cm
 q
 0 0 0 rg
 BT 1 0 0 1 0 14 Tm /F1 10 Tf 12 TL 1.735814 Tw (However, signature-preserving decorators are more common and easier to reason about; in particular) Tj T* 0 Tw (signature-preserving decorators can be composed together whereas other decorators in general cannot.) Tj T* ET
 Q
 Q
 q
-1 0 0 1 62.69291 432.0236 cm
+1 0 0 1 62.69291 408.0236 cm
 q
 0 0 0 rg
 BT 1 0 0 1 0 14 Tm /F1 10 Tf 12 TL .494983 Tw (Writing signature-preserving decorators from scratch is not that obvious, especially if one wants to define) Tj T* 0 Tw (proper decorators that can accept functions with any signature. A simple example will clarify the issue.) Tj T* ET
 Q
 Q
 q
-1 0 0 1 62.69291 399.0236 cm
+1 0 0 1 62.69291 375.0236 cm
 q
 BT 1 0 0 1 0 3.5 Tm 21 TL /F2 17.5 Tf 0 0 0 rg (Statement of the problem) Tj T* ET
 Q
 Q
 q
-1 0 0 1 62.69291 321.0236 cm
+1 0 0 1 62.69291 297.0236 cm
 q
-BT 1 0 0 1 0 62 Tm .351235 Tw 12 TL /F1 10 Tf 0 0 0 rg (A very common use case for decorators is the memoization of functions. A ) Tj /F4 10 Tf (memoize ) Tj /F1 10 Tf (decorator works by) Tj T* 0 Tw .871988 Tw (caching the result of the function call in a dictionary, so that the next time the function is called with the) Tj T* 0 Tw 2.350651 Tw (same input parameters the result is retrieved from the cache and not recomputed. There are many) Tj T* 0 Tw 2.92247 Tw (implementations of ) Tj /F4 10 Tf (memoize ) Tj /F1 10 Tf (in ) Tj 0 0 .501961 rg (http://www.python.org/moin/PythonDecoratorLibrary) Tj 0 0 0 rg (, but they do not) Tj T* 0 Tw 2.683984 Tw (preserve the signature. A simple implementation could be the following \(notice that in general it is) Tj T* 0 Tw (impossible to memoize correctly something that depends on non-hashable arguments\):) Tj T* ET
+BT 1 0 0 1 0 62 Tm .351235 Tw 12 TL /F1 10 Tf 0 0 0 rg (A very common use case for decorators is the memoization of functions. A ) Tj /F4 10 Tf 0 0 0 rg (memoize ) Tj /F1 10 Tf 0 0 0 rg (decorator works by) Tj T* 0 Tw .871988 Tw (caching the result of the function call in a dictionary, so that the next time the function is called with the) Tj T* 0 Tw 2.350651 Tw (same input parameters the result is retrieved from the cache and not recomputed. There are many) Tj T* 0 Tw 2.92247 Tw (implementations of ) Tj /F4 10 Tf 0 0 0 rg (memoize ) Tj /F1 10 Tf 0 0 0 rg (in ) Tj 0 0 .501961 rg (http://www.python.org/moin/PythonDecoratorLibrary) Tj 0 0 0 rg (, but they do not) Tj T* 0 Tw 2.683984 Tw (preserve the signature. A simple implementation could be the following \(notice that in general it is) Tj T* 0 Tw (impossible to memoize correctly something that depends on non-hashable arguments\):) Tj T* ET
 Q
 Q
 q
-1 0 0 1 62.69291 131.8236 cm
+1 0 0 1 62.69291 95.82362 cm
 q
 q
 1 0 0 1 0 0 cm
@@ -2071,52 +939,205 @@ q
 .662745 .662745 .662745 RG
 .5 w
 .960784 .960784 .862745 rg
-n -6 -6 468.6898 180 re B*
+n -6 -6 468.6898 192 re B*
 Q
 q
-BT 1 0 0 1 0 158 Tm 12 TL /F3 10 Tf 0 .501961 0 rg (def) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 1 rg (memoize_uw) Tj 0 0 0 rg (\() Tj (func) Tj (\):) Tj  T* (    ) Tj (func) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (cache) Tj ( ) Tj .4 .4 .4 rg (=) Tj 0 0 0 rg ( ) Tj ({}) Tj  T* (    ) Tj /F3 10 Tf 0 .501961 0 rg (def) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 1 rg (memoize) Tj 0 0 0 rg (\() Tj .4 .4 .4 rg (*) Tj 0 0 0 rg (args) Tj (,) Tj ( ) Tj .4 .4 .4 rg (**) Tj 0 0 0 rg (kw) Tj (\):) Tj  T* (        ) Tj /F3 10 Tf 0 .501961 0 rg (if) Tj /F4 10 Tf 0 0 0 rg ( ) Tj (kw) Tj (:) Tj ( ) Tj /F6 10 Tf .25098 .501961 .501961 rg (# frozenset is used to ensure hashability) Tj /F4 10 Tf 0 0 0 rg  T* (            ) Tj (key) Tj ( ) Tj .4 .4 .4 rg (=) Tj 0 0 0 rg ( ) Tj (args) Tj (,) Tj ( ) Tj 0 .501961 0 rg (frozenset) Tj 0 0 0 rg (\() Tj (kw) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (iteritems) Tj (\(\)\)) Tj  T* (        ) Tj /F3 10 Tf 0 .501961 0 rg (else) Tj /F4 10 Tf 0 0 0 rg (:) Tj  T* (            ) Tj (key) Tj ( ) Tj .4 .4 .4 rg (=) Tj 0 0 0 rg ( ) Tj (args) Tj  T* (        ) Tj (cache) Tj ( ) Tj .4 .4 .4 rg (=) Tj 0 0 0 rg ( ) Tj (func) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (cache) Tj  T* (        ) Tj /F3 10 Tf 0 .501961 0 rg (if) Tj /F4 10 Tf 0 0 0 rg ( ) Tj (key) Tj ( ) Tj /F3 10 Tf .666667 .133333 1 rg (in) Tj /F4 10 Tf 0 0 0 rg ( ) Tj (cache) Tj (:) Tj  T* (            ) Tj /F3 10 Tf 0 .501961 0 rg (return) Tj /F4 10 Tf 0 0 0 rg ( ) Tj (cache) Tj ([) Tj (key) Tj (]) Tj  T* (        ) Tj /F3 10 Tf 0 .501961 0 rg (else) Tj /F4 10 Tf 0 0 0 rg (:) Tj  T* (            ) Tj (cache) Tj ([) Tj (key) Tj (]) Tj ( ) Tj .4 .4 .4 rg (=) Tj 0 0 0 rg ( ) Tj (result) Tj ( ) Tj .4 .4 .4 rg (=) Tj 0 0 0 rg ( ) Tj (func) Tj (\() Tj .4 .4 .4 rg (*) Tj 0 0 0 rg (args) Tj (,) Tj ( ) Tj .4 .4 .4 rg (**) Tj 0 0 0 rg (kw) Tj (\)) Tj  T* (            ) Tj /F3 10 Tf 0 .501961 0 rg (return) Tj /F4 10 Tf 0 0 0 rg ( ) Tj (result) Tj  T* (    ) Tj /F3 10 Tf 0 .501961 0 rg (return) Tj /F4 10 Tf 0 0 0 rg ( ) Tj (functools) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (update_wrapper) Tj (\() Tj (memoize) Tj (,) Tj ( ) Tj (func) Tj (\)) Tj T* ET
-Q
-Q
+.960784 .960784 .862745 rg
+n 0 168.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 24 168.75 60 12 re f*
+.960784 .960784 .862745 rg
+n 84 168.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 90 168.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 114 168.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 24 156.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 48 156.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 54 156.75 30 12 re f*
+.960784 .960784 .862745 rg
+n 90 156.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 102 156.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 24 132.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 48 132.75 42 12 re f*
+.960784 .960784 .862745 rg
+n 90 132.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 96 132.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 102 132.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 126 132.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 138 132.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 150 132.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 162 132.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 48 120.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 66 120.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 78 120.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 96 120.75 246 12 re f*
+.960784 .960784 .862745 rg
+n 72 108.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 96 108.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 108 108.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 132 108.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 144 108.75 54 12 re f*
+.960784 .960784 .862745 rg
+n 198 108.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 204 108.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 216 108.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 222 108.75 54 12 re f*
+.960784 .960784 .862745 rg
+n 276 108.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 48 96.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 72 96.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 72 84.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 96 84.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 108 84.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 48 72.75 30 12 re f*
+.960784 .960784 .862745 rg
+n 84 72.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 96 72.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 120 72.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 126 72.75 30 12 re f*
+.960784 .960784 .862745 rg
+n 48 60.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 66 60.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 90 60.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 108 60.75 30 12 re f*
+.960784 .960784 .862745 rg
+n 138 60.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 72 48.75 36 12 re f*
+.960784 .960784 .862745 rg
+n 114 48.75 30 12 re f*
+.960784 .960784 .862745 rg
+n 144 48.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 150 48.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 168 48.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 48 36.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 72 36.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 72 24.75 30 12 re f*
+.960784 .960784 .862745 rg
+n 102 24.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 108 24.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 126 24.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 138 24.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 150 24.75 36 12 re f*
+.960784 .960784 .862745 rg
+n 192 24.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 204 24.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 228 24.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 234 24.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 240 24.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 264 24.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 276 24.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 288 24.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 300 24.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 72 12.75 36 12 re f*
+.960784 .960784 .862745 rg
+n 114 12.75 36 12 re f*
+.960784 .960784 .862745 rg
+n 24 .75 36 12 re f*
+.960784 .960784 .862745 rg
+n 66 .75 54 12 re f*
+.960784 .960784 .862745 rg
+n 120 .75 6 12 re f*
+.960784 .960784 .862745 rg
+n 126 .75 84 12 re f*
+.960784 .960784 .862745 rg
+n 210 .75 6 12 re f*
+.960784 .960784 .862745 rg
+n 216 .75 42 12 re f*
+.960784 .960784 .862745 rg
+n 258 .75 6 12 re f*
+.960784 .960784 .862745 rg
+n 270 .75 24 12 re f*
+.960784 .960784 .862745 rg
+n 294 .75 6 12 re f*
+BT 1 0 0 1 0 170 Tm 12 TL /F3 10 Tf 0 .501961 0 rg (def) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 1 rg (memoize_uw) Tj 0 0 0 rg (\() Tj 0 0 0 rg (func) Tj 0 0 0 rg (\):) Tj 0 0 0 rg  T* (    ) Tj 0 0 0 rg (func) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (cache) Tj 0 0 0 rg ( ) Tj .4 .4 .4 rg (=) Tj 0 0 0 rg ( ) Tj 0 0 0 rg ({}) Tj 0 0 0 rg  T*  T* (    ) Tj /F3 10 Tf 0 .501961 0 rg (def) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 1 rg (memoize) Tj 0 0 0 rg (\() Tj .4 .4 .4 rg (*) Tj 0 0 0 rg (args) Tj 0 0 0 rg (,) Tj 0 0 0 rg ( ) Tj .4 .4 .4 rg (**) Tj 0 0 0 rg (kw) Tj 0 0 0 rg (\):) Tj 0 0 0 rg  T* (        ) Tj /F3 10 Tf 0 .501961 0 rg (if) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 0 rg (kw) Tj 0 0 0 rg (:) Tj 0 0 0 rg (  ) Tj /F6 10 Tf .25098 .501961 .501961 rg (# frozenset is used to ensure hashability) Tj /F4 10 Tf 0 0 0 rg  T* (            ) Tj 0 0 0 rg (key) Tj 0 0 0 rg ( ) Tj .4 .4 .4 rg (=) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (args) Tj 0 0 0 rg (,) Tj 0 0 0 rg ( ) Tj 0 .501961 0 rg (frozenset) Tj 0 0 0 rg (\() Tj 0 0 0 rg (kw) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (iteritems) Tj 0 0 0 rg (\(\)\)) Tj 0 0 0 rg  T* (        ) Tj /F3 10 Tf 0 .501961 0 rg (else) Tj /F4 10 Tf 0 0 0 rg (:) Tj 0 0 0 rg  T* (            ) Tj 0 0 0 rg (key) Tj 0 0 0 rg ( ) Tj .4 .4 .4 rg (=) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (args) Tj 0 0 0 rg  T* (        ) Tj 0 0 0 rg (cache) Tj 0 0 0 rg ( ) Tj .4 .4 .4 rg (=) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (func) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (cache) Tj 0 0 0 rg  T* (        ) Tj /F3 10 Tf 0 .501961 0 rg (if) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 0 rg (key) Tj 0 0 0 rg ( ) Tj /F3 10 Tf .666667 .133333 1 rg (in) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 0 rg (cache) Tj 0 0 0 rg (:) Tj 0 0 0 rg  T* (            ) Tj /F3 10 Tf 0 .501961 0 rg (return) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 0 rg (cache) Tj 0 0 0 rg ([) Tj 0 0 0 rg (key) Tj 0 0 0 rg (]) Tj 0 0 0 rg  T* (        ) Tj /F3 10 Tf 0 .501961 0 rg (else) Tj /F4 10 Tf 0 0 0 rg (:) Tj 0 0 0 rg  T* (            ) Tj 0 0 0 rg (cache) Tj 0 0 0 rg ([) Tj 0 0 0 rg (key) Tj 0 0 0 rg (]) Tj 0 0 0 rg ( ) Tj .4 .4 .4 rg (=) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (result) Tj 0 0 0 rg ( ) Tj .4 .4 .4 rg (=) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (func) Tj 0 0 0 rg (\() Tj .4 .4 .4 rg (*) Tj 0 0 0 rg (args) Tj 0 0 0 rg (,) Tj 0 0 0 rg ( ) Tj .4 .4 .4 rg (**) Tj 0 0 0 rg (kw) Tj 0 0 0 rg (\)) Tj 0 0 0 rg  T* (            ) Tj /F3 10 Tf 0 .501961 0 rg (return) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 0 rg (result) Tj 0 0 0 rg  T* (    ) Tj /F3 10 Tf 0 .501961 0 rg (return) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 0 rg (functools) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (update_wrapper) Tj 0 0 0 rg (\() Tj 0 0 0 rg (memoize) Tj 0 0 0 rg (,) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (func) Tj 0 0 0 rg (\)) Tj T* ET
 Q
 Q
 Q
-q
-1 0 0 1 62.69291 87.82362 cm
-q
-BT 1 0 0 1 0 26 Tm 1.801412 Tw 12 TL /F1 10 Tf 0 0 0 rg (Here we used the ) Tj 0 0 .501961 rg (functools.update_wrapper ) Tj 0 0 0 rg (utility, which has been added in Python 2.5 expressly to ) Tj T* 0 Tw .91686 Tw (simplify the definition of decorators \(in older versions of Python you need to copy the function attributes ) Tj T* 0 Tw .580814 Tw /F4 10 Tf (__name__) Tj /F1 10 Tf (, ) Tj /F4 10 Tf (__doc__) Tj /F1 10 Tf (, ) Tj /F4 10 Tf (__module__ ) Tj /F1 10 Tf (and ) Tj /F4 10 Tf (__dict__ ) Tj /F1 10 Tf (from the original function to the decorated function) Tj T* 0 Tw ET
 Q
 Q
  
 endstream
 endobj
-% 'R91': class PDFStream 
-91 0 obj
-% page stream
-<< /Length 8095 >>
+95 0 obj
+<< /Length 16361 >>
 stream
 1 0 0 1 0 0 cm  BT /F1 12 Tf 14.4 TL ET
 q
-1 0 0 1 62.69291 753.0236 cm
+1 0 0 1 62.69291 717.0236 cm
 q
-0 0 0 rg
-BT 1 0 0 1 0 2 Tm /F1 10 Tf 12 TL (by hand\).) Tj T* ET
+BT 1 0 0 1 0 38 Tm 1.801412 Tw 12 TL /F1 10 Tf 0 0 0 rg (Here we used the ) Tj 0 0 .501961 rg (functools.update_wrapper ) Tj 0 0 0 rg (utility, which has been added in Python 2.5 expressly to) Tj T* 0 Tw .91686 Tw (simplify the definition of decorators \(in older versions of Python you need to copy the function attributes) Tj T* 0 Tw .580814 Tw /F4 10 Tf 0 0 0 rg (__name__) Tj /F1 10 Tf 0 0 0 rg (, ) Tj /F4 10 Tf 0 0 0 rg (__doc__) Tj /F1 10 Tf 0 0 0 rg (, ) Tj /F4 10 Tf 0 0 0 rg (__module__ ) Tj /F1 10 Tf 0 0 0 rg (and ) Tj /F4 10 Tf 0 0 0 rg (__dict__ ) Tj /F1 10 Tf 0 0 0 rg (from the original function to the decorated function) Tj T* 0 Tw (by hand\).) Tj T* ET
 Q
 Q
 q
-1 0 0 1 62.69291 711.0236 cm
+1 0 0 1 62.69291 675.0236 cm
 q
-BT 1 0 0 1 0 26 Tm 2.517126 Tw 12 TL /F1 10 Tf 0 0 0 rg (The implementation above works in the sense that the decorator can accept functions with generic) Tj T* 0 Tw 1.233615 Tw (signatures; unfortunately this implementation does ) Tj /F5 10 Tf (not ) Tj /F1 10 Tf (define a signature-preserving decorator, since in) Tj T* 0 Tw (general ) Tj /F4 10 Tf (memoize_uw ) Tj /F1 10 Tf (returns a function with a ) Tj /F5 10 Tf (different signature ) Tj /F1 10 Tf (from the original function.) Tj T* ET
+BT 1 0 0 1 0 26 Tm 2.517126 Tw 12 TL /F1 10 Tf 0 0 0 rg (The implementation above works in the sense that the decorator can accept functions with generic) Tj T* 0 Tw 1.233615 Tw (signatures; unfortunately this implementation does ) Tj /F5 10 Tf (not ) Tj /F1 10 Tf (define a signature-preserving decorator, since in) Tj T* 0 Tw (general ) Tj /F4 10 Tf 0 0 0 rg (memoize_uw ) Tj /F1 10 Tf 0 0 0 rg (returns a function with a ) Tj /F5 10 Tf (different signature ) Tj /F1 10 Tf (from the original function.) Tj T* ET
 Q
 Q
 q
-1 0 0 1 62.69291 693.0236 cm
+1 0 0 1 62.69291 657.0236 cm
 q
 0 0 0 rg
 BT 1 0 0 1 0 2 Tm /F1 10 Tf 12 TL (Consider for instance the following case:) Tj T* ET
 Q
 Q
 q
-1 0 0 1 62.69291 623.8236 cm
+1 0 0 1 62.69291 587.8236 cm
 q
 q
 1 0 0 1 0 0 cm
@@ -2129,20 +1150,62 @@ q
 n -6 -6 468.6898 60 re B*
 Q
 q
-BT 1 0 0 1 0 38 Tm 12 TL /F4 10 Tf .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj .666667 .133333 1 rg (@memoize_uw) Tj 0 0 0 rg  T* .4 .4 .4 rg (...) Tj 0 0 0 rg ( ) Tj /F3 10 Tf 0 .501961 0 rg (def) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 1 rg (f1) Tj 0 0 0 rg (\() Tj (x) Tj (\):) Tj  T* .4 .4 .4 rg (...) Tj 0 0 0 rg (     ) Tj (time) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (sleep) Tj (\() Tj .4 .4 .4 rg (1) Tj 0 0 0 rg (\)) Tj ( ) Tj /F6 10 Tf .25098 .501961 .501961 rg (# simulate some long computation) Tj /F4 10 Tf 0 0 0 rg  T* .4 .4 .4 rg (...) Tj 0 0 0 rg (     ) Tj /F3 10 Tf 0 .501961 0 rg (return) Tj /F4 10 Tf 0 0 0 rg ( ) Tj (x) Tj T* ET
+.960784 .960784 .862745 rg
+n 0 36.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 6 36.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 12 36.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 24 36.75 66 12 re f*
+.960784 .960784 .862745 rg
+n 0 24.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 24 24.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 48 24.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 60 24.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 66 24.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 72 24.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 0 12.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 48 12.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 72 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 78 12.75 30 12 re f*
+.960784 .960784 .862745 rg
+n 108 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 114 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 120 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 132 12.75 192 12 re f*
+.960784 .960784 .862745 rg
+n 0 .75 18 12 re f*
+.960784 .960784 .862745 rg
+n 48 .75 36 12 re f*
+.960784 .960784 .862745 rg
+n 90 .75 6 12 re f*
+BT 1 0 0 1 0 38 Tm 12 TL /F4 10 Tf .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj .666667 .133333 1 rg (@memoize_uw) Tj 0 0 0 rg  T* .4 .4 .4 rg (...) Tj 0 0 0 rg ( ) Tj /F3 10 Tf 0 .501961 0 rg (def) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 1 rg (f1) Tj 0 0 0 rg (\() Tj 0 0 0 rg (x) Tj 0 0 0 rg (\):) Tj 0 0 0 rg  T* .4 .4 .4 rg (...) Tj 0 0 0 rg (     ) Tj 0 0 0 rg (time) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (sleep) Tj 0 0 0 rg (\() Tj .4 .4 .4 rg (1) Tj 0 0 0 rg (\)) Tj 0 0 0 rg ( ) Tj /F6 10 Tf .25098 .501961 .501961 rg (# simulate some long computation) Tj /F4 10 Tf 0 0 0 rg  T* .4 .4 .4 rg (...) Tj 0 0 0 rg (     ) Tj /F3 10 Tf 0 .501961 0 rg (return) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 0 rg (x) Tj T* ET
 Q
 Q
 Q
 Q
 Q
 q
-1 0 0 1 62.69291 591.8236 cm
+1 0 0 1 62.69291 555.8236 cm
 q
-BT 1 0 0 1 0 14 Tm .26311 Tw 12 TL /F1 10 Tf 0 0 0 rg (Here the original function takes a single argument named ) Tj /F4 10 Tf (x) Tj /F1 10 Tf (, but the decorated function takes any number) Tj T* 0 Tw (of arguments and keyword arguments:) Tj T* ET
+BT 1 0 0 1 0 14 Tm .26311 Tw 12 TL /F1 10 Tf 0 0 0 rg (Here the original function takes a single argument named ) Tj /F4 10 Tf 0 0 0 rg (x) Tj /F1 10 Tf 0 0 0 rg (, but the decorated function takes any number) Tj T* 0 Tw (of arguments and keyword arguments:) Tj T* ET
 Q
 Q
 q
-1 0 0 1 62.69291 534.6236 cm
+1 0 0 1 62.69291 498.6236 cm
 q
 q
 1 0 0 1 0 0 cm
@@ -2155,20 +1218,86 @@ q
 n -6 -6 468.6898 48 re B*
 Q
 q
-BT 1 0 0 1 0 26 Tm 12 TL /F4 10 Tf .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj /F3 10 Tf 0 .501961 0 rg (from) Tj /F4 10 Tf 0 0 0 rg ( ) Tj /F3 10 Tf 0 0 1 rg (inspect) Tj /F4 10 Tf 0 0 0 rg ( ) Tj /F3 10 Tf 0 .501961 0 rg (import) Tj /F4 10 Tf 0 0 0 rg ( ) Tj (getargspec) Tj  T* .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj /F3 10 Tf 0 .501961 0 rg (print) Tj /F4 10 Tf 0 0 0 rg (\() Tj (getargspec) Tj (\() Tj (f1) Tj (\)\)) Tj  T* (ArgSpec) Tj (\() Tj (args) Tj .4 .4 .4 rg (=) Tj 0 0 0 rg ([],) Tj ( ) Tj (varargs) Tj .4 .4 .4 rg (=) Tj .729412 .129412 .129412 rg ('args') Tj 0 0 0 rg (,) Tj ( ) Tj (keywords) Tj .4 .4 .4 rg (=) Tj .729412 .129412 .129412 rg ('kw') Tj 0 0 0 rg (,) Tj ( ) Tj (defaults) Tj .4 .4 .4 rg (=) Tj 0 .501961 0 rg (None) Tj 0 0 0 rg (\)) Tj T* ET
+.960784 .960784 .862745 rg
+n 0 24.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 6 24.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 12 24.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 24 24.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 54 24.75 42 12 re f*
+.960784 .960784 .862745 rg
+n 102 24.75 36 12 re f*
+.960784 .960784 .862745 rg
+n 144 24.75 60 12 re f*
+.960784 .960784 .862745 rg
+n 0 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 6 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 12 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 24 12.75 30 12 re f*
+.960784 .960784 .862745 rg
+n 54 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 60 12.75 60 12 re f*
+.960784 .960784 .862745 rg
+n 120 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 126 12.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 138 12.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 0 .75 42 12 re f*
+.960784 .960784 .862745 rg
+n 42 .75 6 12 re f*
+.960784 .960784 .862745 rg
+n 48 .75 24 12 re f*
+.960784 .960784 .862745 rg
+n 72 .75 6 12 re f*
+.960784 .960784 .862745 rg
+n 78 .75 18 12 re f*
+.960784 .960784 .862745 rg
+n 102 .75 42 12 re f*
+.960784 .960784 .862745 rg
+n 144 .75 6 12 re f*
+.960784 .960784 .862745 rg
+n 150 .75 36 12 re f*
+.960784 .960784 .862745 rg
+n 186 .75 6 12 re f*
+.960784 .960784 .862745 rg
+n 198 .75 48 12 re f*
+.960784 .960784 .862745 rg
+n 246 .75 6 12 re f*
+.960784 .960784 .862745 rg
+n 252 .75 24 12 re f*
+.960784 .960784 .862745 rg
+n 276 .75 6 12 re f*
+.960784 .960784 .862745 rg
+n 288 .75 48 12 re f*
+.960784 .960784 .862745 rg
+n 336 .75 6 12 re f*
+.960784 .960784 .862745 rg
+n 342 .75 24 12 re f*
+.960784 .960784 .862745 rg
+n 366 .75 6 12 re f*
+BT 1 0 0 1 0 26 Tm 12 TL /F4 10 Tf .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj /F3 10 Tf 0 .501961 0 rg (from) Tj /F4 10 Tf 0 0 0 rg ( ) Tj /F3 10 Tf 0 0 1 rg (inspect) Tj /F4 10 Tf 0 0 0 rg ( ) Tj /F3 10 Tf 0 .501961 0 rg (import) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 0 rg (getargspec) Tj 0 0 0 rg  T* .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj /F3 10 Tf 0 .501961 0 rg (print) Tj /F4 10 Tf 0 0 0 rg (\() Tj 0 0 0 rg (getargspec) Tj 0 0 0 rg (\() Tj 0 0 0 rg (f1) Tj 0 0 0 rg (\)\)) Tj 0 0 0 rg  T* 0 0 0 rg (ArgSpec) Tj 0 0 0 rg (\() Tj 0 0 0 rg (args) Tj .4 .4 .4 rg (=) Tj 0 0 0 rg ([],) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (varargs) Tj .4 .4 .4 rg (=) Tj .729412 .129412 .129412 rg ('args') Tj 0 0 0 rg (,) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (keywords) Tj .4 .4 .4 rg (=) Tj .729412 .129412 .129412 rg ('kw') Tj 0 0 0 rg (,) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (defaults) Tj .4 .4 .4 rg (=) Tj 0 .501961 0 rg (None) Tj 0 0 0 rg (\)) Tj T* ET
 Q
 Q
 Q
 Q
 Q
 q
-1 0 0 1 62.69291 490.6236 cm
+1 0 0 1 62.69291 454.6236 cm
 q
-BT 1 0 0 1 0 26 Tm .411235 Tw 12 TL /F1 10 Tf 0 0 0 rg (This means that introspection tools such as pydoc will give wrong informations about the signature of ) Tj /F4 10 Tf (f1) Tj /F1 10 Tf (.) Tj T* 0 Tw .161654 Tw (This is pretty bad: pydoc will tell you that the function accepts a generic signature ) Tj /F4 10 Tf (*args) Tj /F1 10 Tf (, ) Tj /F4 10 Tf (**kw) Tj /F1 10 Tf (, but when) Tj T* 0 Tw (you try to call the function with more than an argument, you will get an error:) Tj T* ET
+BT 1 0 0 1 0 26 Tm .411235 Tw 12 TL /F1 10 Tf 0 0 0 rg (This means that introspection tools such as pydoc will give wrong informations about the signature of ) Tj /F4 10 Tf 0 0 0 rg (f1) Tj /F1 10 Tf 0 0 0 rg (.) Tj T* 0 Tw .161654 Tw (This is pretty bad: pydoc will tell you that the function accepts a generic signature ) Tj /F4 10 Tf 0 0 0 rg (*args) Tj /F1 10 Tf 0 0 0 rg (, ) Tj /F4 10 Tf 0 0 0 rg (**kw) Tj /F1 10 Tf 0 0 0 rg (, but when) Tj T* 0 Tw (you try to call the function with more than an argument, you will get an error:) Tj T* ET
 Q
 Q
 q
-1 0 0 1 62.69291 421.4236 cm
+1 0 0 1 62.69291 385.4236 cm
 q
 q
 1 0 0 1 0 0 cm
@@ -2181,26 +1310,86 @@ q
 n -6 -6 468.6898 60 re B*
 Q
 q
-BT 1 0 0 1 0 38 Tm 12 TL /F4 10 Tf .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj (f1) Tj (\() Tj .4 .4 .4 rg (0) Tj 0 0 0 rg (,) Tj ( ) Tj .4 .4 .4 rg (1) Tj 0 0 0 rg (\)) Tj  T* (Traceback) Tj ( ) Tj (\() Tj (most) Tj ( ) Tj (recent) Tj ( ) Tj (call) Tj ( ) Tj (last) Tj (\):) Tj  T* (   ) Tj .4 .4 .4 rg (...) Tj 0 0 0 rg  T* /F3 10 Tf .823529 .254902 .227451 rg (TypeError) Tj /F4 10 Tf 0 0 0 rg (:) Tj ( ) Tj (f1) Tj (\(\)) Tj ( ) Tj (takes) Tj ( ) Tj (exactly) Tj ( ) Tj .4 .4 .4 rg (1) Tj 0 0 0 rg ( ) Tj (positional) Tj ( ) Tj (argument) Tj ( ) Tj (\() Tj .4 .4 .4 rg (2) Tj 0 0 0 rg ( ) Tj (given) Tj (\)) Tj T* ET
+.960784 .960784 .862745 rg
+n 0 36.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 6 36.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 12 36.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 24 36.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 36 36.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 42 36.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 48 36.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 60 36.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 66 36.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 0 24.75 54 12 re f*
+.960784 .960784 .862745 rg
+n 60 24.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 66 24.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 96 24.75 36 12 re f*
+.960784 .960784 .862745 rg
+n 138 24.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 168 24.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 192 24.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 18 12.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 0 .75 54 12 re f*
+.960784 .960784 .862745 rg
+n 54 .75 6 12 re f*
+.960784 .960784 .862745 rg
+n 66 .75 12 12 re f*
+.960784 .960784 .862745 rg
+n 78 .75 12 12 re f*
+.960784 .960784 .862745 rg
+n 96 .75 30 12 re f*
+.960784 .960784 .862745 rg
+n 132 .75 42 12 re f*
+.960784 .960784 .862745 rg
+n 180 .75 6 12 re f*
+.960784 .960784 .862745 rg
+n 192 .75 60 12 re f*
+.960784 .960784 .862745 rg
+n 258 .75 48 12 re f*
+.960784 .960784 .862745 rg
+n 312 .75 6 12 re f*
+.960784 .960784 .862745 rg
+n 318 .75 6 12 re f*
+.960784 .960784 .862745 rg
+n 330 .75 30 12 re f*
+.960784 .960784 .862745 rg
+n 360 .75 6 12 re f*
+BT 1 0 0 1 0 38 Tm 12 TL /F4 10 Tf .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (f1) Tj 0 0 0 rg (\() Tj .4 .4 .4 rg (0) Tj 0 0 0 rg (,) Tj 0 0 0 rg ( ) Tj .4 .4 .4 rg (1) Tj 0 0 0 rg (\)) Tj 0 0 0 rg  T* 0 0 0 rg (Traceback) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (\() Tj 0 0 0 rg (most) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (recent) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (call) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (last) Tj 0 0 0 rg (\):) Tj 0 0 0 rg  T* (   ) Tj .4 .4 .4 rg (...) Tj 0 0 0 rg  T* /F3 10 Tf .823529 .254902 .227451 rg (TypeError) Tj /F4 10 Tf 0 0 0 rg (:) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (f1) Tj 0 0 0 rg (\(\)) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (takes) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (exactly) Tj 0 0 0 rg ( ) Tj .4 .4 .4 rg (1) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (positional) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (argument) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (\() Tj .4 .4 .4 rg (2) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (given) Tj 0 0 0 rg (\)) Tj T* ET
 Q
 Q
 Q
 Q
 Q
 q
-1 0 0 1 62.69291 388.4236 cm
+1 0 0 1 62.69291 352.4236 cm
 q
 BT 1 0 0 1 0 3.5 Tm 21 TL /F2 17.5 Tf 0 0 0 rg (The solution) Tj T* ET
 Q
 Q
 q
-1 0 0 1 62.69291 346.4236 cm
+1 0 0 1 62.69291 310.4236 cm
 q
-BT 1 0 0 1 0 26 Tm 3.313984 Tw 12 TL /F1 10 Tf 0 0 0 rg (The solution is to provide a generic factory of generators, which hides the complexity of making) Tj T* 0 Tw 3.362976 Tw (signature-preserving decorators from the application programmer. The ) Tj /F4 10 Tf (decorator ) Tj /F1 10 Tf (function in the) Tj T* 0 Tw /F4 10 Tf (decorator ) Tj /F1 10 Tf (module is such a factory:) Tj T* ET
+BT 1 0 0 1 0 26 Tm 3.313984 Tw 12 TL /F1 10 Tf 0 0 0 rg (The solution is to provide a generic factory of generators, which hides the complexity of making) Tj T* 0 Tw 3.362976 Tw (signature-preserving decorators from the application programmer. The ) Tj /F4 10 Tf 0 0 0 rg (decorator ) Tj /F1 10 Tf 0 0 0 rg (function in the) Tj T* 0 Tw /F4 10 Tf 0 0 0 rg (decorator ) Tj /F1 10 Tf 0 0 0 rg (module is such a factory:) Tj T* ET
 Q
 Q
 q
-1 0 0 1 62.69291 313.2236 cm
+1 0 0 1 62.69291 277.2236 cm
 q
 q
 1 0 0 1 0 0 cm
@@ -2213,20 +1402,34 @@ q
 n -6 -6 468.6898 24 re B*
 Q
 q
-BT 1 0 0 1 0 2 Tm 12 TL /F4 10 Tf .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj /F3 10 Tf 0 .501961 0 rg (from) Tj /F4 10 Tf 0 0 0 rg ( ) Tj /F3 10 Tf 0 0 1 rg (decorator) Tj /F4 10 Tf 0 0 0 rg ( ) Tj /F3 10 Tf 0 .501961 0 rg (import) Tj /F4 10 Tf 0 0 0 rg ( ) Tj (decorator) Tj T* ET
+.960784 .960784 .862745 rg
+n 0 .75 6 12 re f*
+.960784 .960784 .862745 rg
+n 6 .75 6 12 re f*
+.960784 .960784 .862745 rg
+n 12 .75 6 12 re f*
+.960784 .960784 .862745 rg
+n 24 .75 24 12 re f*
+.960784 .960784 .862745 rg
+n 54 .75 54 12 re f*
+.960784 .960784 .862745 rg
+n 114 .75 36 12 re f*
+.960784 .960784 .862745 rg
+n 156 .75 54 12 re f*
+BT 1 0 0 1 0 2 Tm 12 TL /F4 10 Tf .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj /F3 10 Tf 0 .501961 0 rg (from) Tj /F4 10 Tf 0 0 0 rg ( ) Tj /F3 10 Tf 0 0 1 rg (decorator) Tj /F4 10 Tf 0 0 0 rg ( ) Tj /F3 10 Tf 0 .501961 0 rg (import) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 0 rg (decorator) Tj T* ET
 Q
 Q
 Q
 Q
 Q
 q
-1 0 0 1 62.69291 257.2236 cm
+1 0 0 1 62.69291 221.2236 cm
 q
-BT 1 0 0 1 0 38 Tm 1.716412 Tw 12 TL /F4 10 Tf 0 0 0 rg (decorator ) Tj /F1 10 Tf (takes two arguments, a caller function describing the functionality of the decorator and a) Tj T* 0 Tw 2.594983 Tw (function to be decorated; it returns the decorated function. The caller function must have signature) Tj T* 0 Tw .19311 Tw /F4 10 Tf (\(f,) Tj ( ) Tj (*args,) Tj ( ) Tj (**kw\) ) Tj /F1 10 Tf (and it must call the original function ) Tj /F4 10 Tf (f ) Tj /F1 10 Tf (with arguments ) Tj /F4 10 Tf (args ) Tj /F1 10 Tf (and ) Tj /F4 10 Tf (kw) Tj /F1 10 Tf (, implementing) Tj T* 0 Tw (the wanted capability, i.e. memoization in this case:) Tj T* ET
+BT 1 0 0 1 0 38 Tm 1.716412 Tw 12 TL /F4 10 Tf 0 0 0 rg (decorator ) Tj /F1 10 Tf 0 0 0 rg (takes two arguments, a caller function describing the functionality of the decorator and a) Tj T* 0 Tw 2.594983 Tw (function to be decorated; it returns the decorated function. The caller function must have signature) Tj T* 0 Tw .19311 Tw /F4 10 Tf 0 0 0 rg (\(f,) Tj ( ) Tj (*args,) Tj ( ) Tj (**kw\) ) Tj /F1 10 Tf 0 0 0 rg (and it must call the original function ) Tj /F4 10 Tf 0 0 0 rg (f ) Tj /F1 10 Tf 0 0 0 rg (with arguments ) Tj /F4 10 Tf 0 0 0 rg (args ) Tj /F1 10 Tf 0 0 0 rg (and ) Tj /F4 10 Tf 0 0 0 rg (kw) Tj /F1 10 Tf 0 0 0 rg (, implementing) Tj T* 0 Tw (the wanted capability, i.e. memoization in this case:) Tj T* ET
 Q
 Q
 q
-1 0 0 1 62.69291 104.0236 cm
+1 0 0 1 62.69291 92.02362 cm
 q
 q
 1 0 0 1 0 0 cm
@@ -2236,33 +1439,181 @@ q
 .662745 .662745 .662745 RG
 .5 w
 .960784 .960784 .862745 rg
-n -6 -6 468.6898 144 re B*
+n -6 -6 468.6898 120 re B*
 Q
 q
-BT 1 0 0 1 0 122 Tm 12 TL /F3 10 Tf 0 .501961 0 rg (def) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 1 rg (_memoize) Tj 0 0 0 rg (\() Tj (func) Tj (,) Tj ( ) Tj .4 .4 .4 rg (*) Tj 0 0 0 rg (args) Tj (,) Tj ( ) Tj .4 .4 .4 rg (**) Tj 0 0 0 rg (kw) Tj (\):) Tj  T* (    ) Tj /F3 10 Tf 0 .501961 0 rg (if) Tj /F4 10 Tf 0 0 0 rg ( ) Tj (kw) Tj (:) Tj ( ) Tj /F6 10 Tf .25098 .501961 .501961 rg (# frozenset is used to ensure hashability) Tj /F4 10 Tf 0 0 0 rg  T* (        ) Tj (key) Tj ( ) Tj .4 .4 .4 rg (=) Tj 0 0 0 rg ( ) Tj (args) Tj (,) Tj ( ) Tj 0 .501961 0 rg (frozenset) Tj 0 0 0 rg (\() Tj (kw) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (iteritems) Tj (\(\)\)) Tj  T* (    ) Tj /F3 10 Tf 0 .501961 0 rg (else) Tj /F4 10 Tf 0 0 0 rg (:) Tj  T* (        ) Tj (key) Tj ( ) Tj .4 .4 .4 rg (=) Tj 0 0 0 rg ( ) Tj (args) Tj  T* (    ) Tj (cache) Tj ( ) Tj .4 .4 .4 rg (=) Tj 0 0 0 rg ( ) Tj (func) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (cache) Tj ( ) Tj /F6 10 Tf .25098 .501961 .501961 rg (# attributed added by memoize) Tj /F4 10 Tf 0 0 0 rg  T* (    ) Tj /F3 10 Tf 0 .501961 0 rg (if) Tj /F4 10 Tf 0 0 0 rg ( ) Tj (key) Tj ( ) Tj /F3 10 Tf .666667 .133333 1 rg (in) Tj /F4 10 Tf 0 0 0 rg ( ) Tj (cache) Tj (:) Tj  T* (        ) Tj /F3 10 Tf 0 .501961 0 rg (return) Tj /F4 10 Tf 0 0 0 rg ( ) Tj (cache) Tj ([) Tj (key) Tj (]) Tj  T* (    ) Tj /F3 10 Tf 0 .501961 0 rg (else) Tj /F4 10 Tf 0 0 0 rg (:) Tj  T* (        ) Tj (cache) Tj ([) Tj (key) Tj (]) Tj ( ) Tj .4 .4 .4 rg (=) Tj 0 0 0 rg ( ) Tj (result) Tj ( ) Tj .4 .4 .4 rg (=) Tj 0 0 0 rg ( ) Tj (func) Tj (\() Tj .4 .4 .4 rg (*) Tj 0 0 0 rg (args) Tj (,) Tj ( ) Tj .4 .4 .4 rg (**) Tj 0 0 0 rg (kw) Tj (\)) Tj  T* (        ) Tj /F3 10 Tf 0 .501961 0 rg (return) Tj /F4 10 Tf 0 0 0 rg ( ) Tj (result) Tj T* ET
+.960784 .960784 .862745 rg
+n 0 96.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 24 96.75 48 12 re f*
+.960784 .960784 .862745 rg
+n 72 96.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 78 96.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 102 96.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 114 96.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 120 96.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 144 96.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 156 96.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 168 96.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 180 96.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 24 84.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 42 84.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 54 84.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 72 84.75 246 12 re f*
+.960784 .960784 .862745 rg
+n 48 72.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 72 72.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 84 72.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 108 72.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 120 72.75 54 12 re f*
+.960784 .960784 .862745 rg
+n 174 72.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 180 72.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 192 72.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 198 72.75 54 12 re f*
+.960784 .960784 .862745 rg
+n 252 72.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 24 60.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 48 60.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 48 48.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 72 48.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 84 48.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 24 36.75 30 12 re f*
+.960784 .960784 .862745 rg
+n 60 36.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 72 36.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 96 36.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 102 36.75 30 12 re f*
+.960784 .960784 .862745 rg
+n 144 36.75 174 12 re f*
+.960784 .960784 .862745 rg
+n 24 24.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 42 24.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 66 24.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 84 24.75 30 12 re f*
+.960784 .960784 .862745 rg
+n 114 24.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 48 12.75 36 12 re f*
+.960784 .960784 .862745 rg
+n 90 12.75 30 12 re f*
+.960784 .960784 .862745 rg
+n 120 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 126 12.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 144 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 24 .75 24 12 re f*
+.960784 .960784 .862745 rg
+n 48 .75 6 12 re f*
+BT 1 0 0 1 0 98 Tm 12 TL /F3 10 Tf 0 .501961 0 rg (def) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 1 rg (_memoize) Tj 0 0 0 rg (\() Tj 0 0 0 rg (func) Tj 0 0 0 rg (,) Tj 0 0 0 rg ( ) Tj .4 .4 .4 rg (*) Tj 0 0 0 rg (args) Tj 0 0 0 rg (,) Tj 0 0 0 rg ( ) Tj .4 .4 .4 rg (**) Tj 0 0 0 rg (kw) Tj 0 0 0 rg (\):) Tj 0 0 0 rg  T* (    ) Tj /F3 10 Tf 0 .501961 0 rg (if) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 0 rg (kw) Tj 0 0 0 rg (:) Tj 0 0 0 rg (  ) Tj /F6 10 Tf .25098 .501961 .501961 rg (# frozenset is used to ensure hashability) Tj /F4 10 Tf 0 0 0 rg  T* (        ) Tj 0 0 0 rg (key) Tj 0 0 0 rg ( ) Tj .4 .4 .4 rg (=) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (args) Tj 0 0 0 rg (,) Tj 0 0 0 rg ( ) Tj 0 .501961 0 rg (frozenset) Tj 0 0 0 rg (\() Tj 0 0 0 rg (kw) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (iteritems) Tj 0 0 0 rg (\(\)\)) Tj 0 0 0 rg  T* (    ) Tj /F3 10 Tf 0 .501961 0 rg (else) Tj /F4 10 Tf 0 0 0 rg (:) Tj 0 0 0 rg  T* (        ) Tj 0 0 0 rg (key) Tj 0 0 0 rg ( ) Tj .4 .4 .4 rg (=) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (args) Tj 0 0 0 rg  T* (    ) Tj 0 0 0 rg (cache) Tj 0 0 0 rg ( ) Tj .4 .4 .4 rg (=) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (func) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (cache) Tj 0 0 0 rg (  ) Tj /F6 10 Tf .25098 .501961 .501961 rg (# attributed added by memoize) Tj /F4 10 Tf 0 0 0 rg  T* (    ) Tj /F3 10 Tf 0 .501961 0 rg (if) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 0 rg (key) Tj 0 0 0 rg ( ) Tj /F3 10 Tf .666667 .133333 1 rg (in) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 0 rg (cache) Tj 0 0 0 rg (:) Tj 0 0 0 rg  T* (        ) Tj /F3 10 Tf 0 .501961 0 rg (return) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 0 rg (cache) Tj 0 0 0 rg ([) Tj 0 0 0 rg (key) Tj 0 0 0 rg (]) Tj 0 0 0 rg  T* (    ) Tj /F3 10 Tf 0 .501961 0 rg (else) Tj /F4 10 Tf 0 0 0 rg (:) Tj 0 0 0 rg  T* ET
 Q
 Q
 Q
 Q
 Q
+ 
+endstream
+endobj
+96 0 obj
+<< /Length 18477 >>
+stream
+1 0 0 1 0 0 cm  BT /F1 12 Tf 14.4 TL ET
+q
+1 0 0 1 62.69291 727.8236 cm
+q
+q
+1 0 0 1 0 0 cm
+q
+1 0 0 1 6.6 6.6 cm
 q
-1 0 0 1 62.69291 84.02362 cm
+.662745 .662745 .662745 RG
+.5 w
+.960784 .960784 .862745 rg
+n -6 -6 468.6898 36 re B*
+Q
+q
+.960784 .960784 .862745 rg
+n 48 12.75 30 12 re f*
+.960784 .960784 .862745 rg
+n 78 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 84 12.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 102 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 114 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 126 12.75 36 12 re f*
+.960784 .960784 .862745 rg
+n 168 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 180 12.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 204 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 210 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 216 12.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 240 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 252 12.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 264 12.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 276 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 48 .75 36 12 re f*
+.960784 .960784 .862745 rg
+n 90 .75 36 12 re f*
+BT 1 0 0 1 0 14 Tm 12 TL /F4 10 Tf 0 0 0 rg (        ) Tj 0 0 0 rg (cache) Tj 0 0 0 rg ([) Tj 0 0 0 rg (key) Tj 0 0 0 rg (]) Tj 0 0 0 rg ( ) Tj .4 .4 .4 rg (=) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (result) Tj 0 0 0 rg ( ) Tj .4 .4 .4 rg (=) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (func) Tj 0 0 0 rg (\() Tj .4 .4 .4 rg (*) Tj 0 0 0 rg (args) Tj 0 0 0 rg (,) Tj 0 0 0 rg ( ) Tj .4 .4 .4 rg (**) Tj 0 0 0 rg (kw) Tj 0 0 0 rg (\)) Tj 0 0 0 rg  T* (        ) Tj /F3 10 Tf 0 .501961 0 rg (return) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 0 rg (result) Tj T* ET
+Q
+Q
+Q
+Q
+Q
+q
+1 0 0 1 62.69291 707.8236 cm
 q
 0 0 0 rg
 BT 1 0 0 1 0 2 Tm /F1 10 Tf 12 TL (At this point you can define your decorator as follows:) Tj T* ET
 Q
 Q
- 
-endstream
-endobj
-% 'R92': class PDFStream 
-92 0 obj
-% page stream
-<< /Length 7804 >>
-stream
-1 0 0 1 0 0 cm  BT /F1 12 Tf 14.4 TL ET
 q
-1 0 0 1 62.69291 715.8236 cm
+1 0 0 1 62.69291 650.6236 cm
 q
 q
 1 0 0 1 0 0 cm
@@ -2275,27 +1626,61 @@ q
 n -6 -6 468.6898 48 re B*
 Q
 q
-BT 1 0 0 1 0 26 Tm 12 TL /F3 10 Tf 0 .501961 0 rg (def) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 1 rg (memoize) Tj 0 0 0 rg (\() Tj (f) Tj (\):) Tj  T* (    ) Tj (f) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (cache) Tj ( ) Tj .4 .4 .4 rg (=) Tj 0 0 0 rg ( ) Tj ({}) Tj  T* (    ) Tj /F3 10 Tf 0 .501961 0 rg (return) Tj /F4 10 Tf 0 0 0 rg ( ) Tj (decorator) Tj (\() Tj (_memoize) Tj (,) Tj ( ) Tj (f) Tj (\)) Tj T* ET
+.960784 .960784 .862745 rg
+n 0 24.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 24 24.75 42 12 re f*
+.960784 .960784 .862745 rg
+n 66 24.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 72 24.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 78 24.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 24 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 30 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 36 12.75 30 12 re f*
+.960784 .960784 .862745 rg
+n 72 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 84 12.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 24 .75 36 12 re f*
+.960784 .960784 .862745 rg
+n 66 .75 54 12 re f*
+.960784 .960784 .862745 rg
+n 120 .75 6 12 re f*
+.960784 .960784 .862745 rg
+n 126 .75 48 12 re f*
+.960784 .960784 .862745 rg
+n 174 .75 6 12 re f*
+.960784 .960784 .862745 rg
+n 186 .75 6 12 re f*
+.960784 .960784 .862745 rg
+n 192 .75 6 12 re f*
+BT 1 0 0 1 0 26 Tm 12 TL /F3 10 Tf 0 .501961 0 rg (def) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 1 rg (memoize) Tj 0 0 0 rg (\() Tj 0 0 0 rg (f) Tj 0 0 0 rg (\):) Tj 0 0 0 rg  T* (    ) Tj 0 0 0 rg (f) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (cache) Tj 0 0 0 rg ( ) Tj .4 .4 .4 rg (=) Tj 0 0 0 rg ( ) Tj 0 0 0 rg ({}) Tj 0 0 0 rg  T* (    ) Tj /F3 10 Tf 0 .501961 0 rg (return) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 0 rg (decorator) Tj 0 0 0 rg (\() Tj 0 0 0 rg (_memoize) Tj 0 0 0 rg (,) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (f) Tj 0 0 0 rg (\)) Tj T* ET
 Q
 Q
 Q
 Q
 Q
 q
-1 0 0 1 62.69291 671.8236 cm
+1 0 0 1 62.69291 606.6236 cm
 q
-BT 1 0 0 1 0 26 Tm .12561 Tw 12 TL /F1 10 Tf 0 0 0 rg (The difference with respect to the ) Tj /F4 10 Tf (memoize_uw ) Tj /F1 10 Tf (approach, which is based on nested functions, is that the) Tj T* 0 Tw 2.59528 Tw (decorator module forces you to lift the inner function at the outer level \() Tj /F5 10 Tf (flat is better than nested) Tj /F1 10 Tf (\).) Tj T* 0 Tw (Moreover, you are forced to pass explicitly the function you want to decorate to the caller function.) Tj T* ET
+BT 1 0 0 1 0 26 Tm .12561 Tw 12 TL /F1 10 Tf 0 0 0 rg (The difference with respect to the ) Tj /F4 10 Tf 0 0 0 rg (memoize_uw ) Tj /F1 10 Tf 0 0 0 rg (approach, which is based on nested functions, is that the) Tj T* 0 Tw 2.59528 Tw (decorator module forces you to lift the inner function at the outer level \() Tj /F5 10 Tf (flat is better than nested) Tj /F1 10 Tf (\).) Tj T* 0 Tw (Moreover, you are forced to pass explicitly the function you want to decorate to the caller function.) Tj T* ET
 Q
 Q
 q
-1 0 0 1 62.69291 653.8236 cm
+1 0 0 1 62.69291 588.6236 cm
 q
 0 0 0 rg
 BT 1 0 0 1 0 2 Tm /F1 10 Tf 12 TL (Here is a test of usage:) Tj T* ET
 Q
 Q
 q
-1 0 0 1 62.69291 512.6236 cm
+1 0 0 1 62.69291 447.4236 cm
 q
 q
 1 0 0 1 0 0 cm
@@ -2308,20 +1693,92 @@ q
 n -6 -6 468.6898 132 re B*
 Q
 q
-BT 1 0 0 1 0 110 Tm 12 TL /F4 10 Tf .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj .666667 .133333 1 rg (@memoize) Tj 0 0 0 rg  T* .4 .4 .4 rg (...) Tj 0 0 0 rg ( ) Tj /F3 10 Tf 0 .501961 0 rg (def) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 1 rg (heavy_computation) Tj 0 0 0 rg (\(\):) Tj  T* .4 .4 .4 rg (...) Tj 0 0 0 rg (     ) Tj (time) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (sleep) Tj (\() Tj .4 .4 .4 rg (2) Tj 0 0 0 rg (\)) Tj  T* .4 .4 .4 rg (...) Tj 0 0 0 rg (     ) Tj /F3 10 Tf 0 .501961 0 rg (return) Tj /F4 10 Tf 0 0 0 rg ( ) Tj .729412 .129412 .129412 rg ("done") Tj 0 0 0 rg  T*  T* .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj /F3 10 Tf 0 .501961 0 rg (print) Tj /F4 10 Tf 0 0 0 rg (\() Tj (heavy_computation) Tj (\(\)\)) Tj ( ) Tj /F6 10 Tf .25098 .501961 .501961 rg (# the first time it will take 2 seconds) Tj /F4 10 Tf 0 0 0 rg  T* (done) Tj  T*  T* .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj /F3 10 Tf 0 .501961 0 rg (print) Tj /F4 10 Tf 0 0 0 rg (\() Tj (heavy_computation) Tj (\(\)\)) Tj ( ) Tj /F6 10 Tf .25098 .501961 .501961 rg (# the second time it will be instantaneous) Tj /F4 10 Tf 0 0 0 rg  T* (done) Tj T* ET
+.960784 .960784 .862745 rg
+n 0 108.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 6 108.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 12 108.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 24 108.75 48 12 re f*
+.960784 .960784 .862745 rg
+n 0 96.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 24 96.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 48 96.75 102 12 re f*
+.960784 .960784 .862745 rg
+n 150 96.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 0 84.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 48 84.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 72 84.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 78 84.75 30 12 re f*
+.960784 .960784 .862745 rg
+n 108 84.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 114 84.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 120 84.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 0 72.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 48 72.75 36 12 re f*
+.960784 .960784 .862745 rg
+n 90 72.75 36 12 re f*
+.960784 .960784 .862745 rg
+n 0 48.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 6 48.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 12 48.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 24 48.75 30 12 re f*
+.960784 .960784 .862745 rg
+n 54 48.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 60 48.75 102 12 re f*
+.960784 .960784 .862745 rg
+n 162 48.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 186 48.75 234 12 re f*
+.960784 .960784 .862745 rg
+n 0 36.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 0 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 6 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 12 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 24 12.75 30 12 re f*
+.960784 .960784 .862745 rg
+n 54 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 60 12.75 102 12 re f*
+.960784 .960784 .862745 rg
+n 162 12.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 186 12.75 252 12 re f*
+.960784 .960784 .862745 rg
+n 0 .75 24 12 re f*
+BT 1 0 0 1 0 110 Tm 12 TL /F4 10 Tf .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj .666667 .133333 1 rg (@memoize) Tj 0 0 0 rg  T* .4 .4 .4 rg (...) Tj 0 0 0 rg ( ) Tj /F3 10 Tf 0 .501961 0 rg (def) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 1 rg (heavy_computation) Tj 0 0 0 rg (\(\):) Tj 0 0 0 rg  T* .4 .4 .4 rg (...) Tj 0 0 0 rg (     ) Tj 0 0 0 rg (time) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (sleep) Tj 0 0 0 rg (\() Tj .4 .4 .4 rg (2) Tj 0 0 0 rg (\)) Tj 0 0 0 rg  T* .4 .4 .4 rg (...) Tj 0 0 0 rg (     ) Tj /F3 10 Tf 0 .501961 0 rg (return) Tj /F4 10 Tf 0 0 0 rg ( ) Tj .729412 .129412 .129412 rg ("done") Tj 0 0 0 rg  T*  T* .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj /F3 10 Tf 0 .501961 0 rg (print) Tj /F4 10 Tf 0 0 0 rg (\() Tj 0 0 0 rg (heavy_computation) Tj 0 0 0 rg (\(\)\)) Tj 0 0 0 rg ( ) Tj /F6 10 Tf .25098 .501961 .501961 rg (# the first time it will take 2 seconds) Tj /F4 10 Tf 0 0 0 rg  T* 0 0 0 rg (done) Tj 0 0 0 rg  T*  T* .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj /F3 10 Tf 0 .501961 0 rg (print) Tj /F4 10 Tf 0 0 0 rg (\() Tj 0 0 0 rg (heavy_computation) Tj 0 0 0 rg (\(\)\)) Tj 0 0 0 rg ( ) Tj /F6 10 Tf .25098 .501961 .501961 rg (# the second time it will be instantaneous) Tj /F4 10 Tf 0 0 0 rg  T* 0 0 0 rg (done) Tj T* ET
 Q
 Q
 Q
 Q
 Q
 q
-1 0 0 1 62.69291 492.6236 cm
+1 0 0 1 62.69291 427.4236 cm
 q
-BT 1 0 0 1 0 2 Tm 12 TL /F1 10 Tf 0 0 0 rg (The signature of ) Tj /F4 10 Tf (heavy_computation ) Tj /F1 10 Tf (is the one you would expect:) Tj T* ET
+BT 1 0 0 1 0 2 Tm 12 TL /F1 10 Tf 0 0 0 rg (The signature of ) Tj /F4 10 Tf 0 0 0 rg (heavy_computation ) Tj /F1 10 Tf 0 0 0 rg (is the one you would expect:) Tj T* ET
 Q
 Q
 q
-1 0 0 1 62.69291 447.4236 cm
+1 0 0 1 62.69291 382.2236 cm
 q
 q
 1 0 0 1 0 0 cm
@@ -2334,26 +1791,78 @@ q
 n -6 -6 468.6898 36 re B*
 Q
 q
-BT 1 0 0 1 0 14 Tm 12 TL /F4 10 Tf .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj /F3 10 Tf 0 .501961 0 rg (print) Tj /F4 10 Tf 0 0 0 rg (\() Tj (getargspec) Tj (\() Tj (heavy_computation) Tj (\)\)) Tj  T* (ArgSpec) Tj (\() Tj (args) Tj .4 .4 .4 rg (=) Tj 0 0 0 rg ([],) Tj ( ) Tj (varargs) Tj .4 .4 .4 rg (=) Tj 0 .501961 0 rg (None) Tj 0 0 0 rg (,) Tj ( ) Tj (keywords) Tj .4 .4 .4 rg (=) Tj 0 .501961 0 rg (None) Tj 0 0 0 rg (,) Tj ( ) Tj (defaults) Tj .4 .4 .4 rg (=) Tj 0 .501961 0 rg (None) Tj 0 0 0 rg (\)) Tj T* ET
+.960784 .960784 .862745 rg
+n 0 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 6 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 12 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 24 12.75 30 12 re f*
+.960784 .960784 .862745 rg
+n 54 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 60 12.75 60 12 re f*
+.960784 .960784 .862745 rg
+n 120 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 126 12.75 102 12 re f*
+.960784 .960784 .862745 rg
+n 228 12.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 0 .75 42 12 re f*
+.960784 .960784 .862745 rg
+n 42 .75 6 12 re f*
+.960784 .960784 .862745 rg
+n 48 .75 24 12 re f*
+.960784 .960784 .862745 rg
+n 72 .75 6 12 re f*
+.960784 .960784 .862745 rg
+n 78 .75 18 12 re f*
+.960784 .960784 .862745 rg
+n 102 .75 42 12 re f*
+.960784 .960784 .862745 rg
+n 144 .75 6 12 re f*
+.960784 .960784 .862745 rg
+n 150 .75 24 12 re f*
+.960784 .960784 .862745 rg
+n 174 .75 6 12 re f*
+.960784 .960784 .862745 rg
+n 186 .75 48 12 re f*
+.960784 .960784 .862745 rg
+n 234 .75 6 12 re f*
+.960784 .960784 .862745 rg
+n 240 .75 24 12 re f*
+.960784 .960784 .862745 rg
+n 264 .75 6 12 re f*
+.960784 .960784 .862745 rg
+n 276 .75 48 12 re f*
+.960784 .960784 .862745 rg
+n 324 .75 6 12 re f*
+.960784 .960784 .862745 rg
+n 330 .75 24 12 re f*
+.960784 .960784 .862745 rg
+n 354 .75 6 12 re f*
+BT 1 0 0 1 0 14 Tm 12 TL /F4 10 Tf .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj /F3 10 Tf 0 .501961 0 rg (print) Tj /F4 10 Tf 0 0 0 rg (\() Tj 0 0 0 rg (getargspec) Tj 0 0 0 rg (\() Tj 0 0 0 rg (heavy_computation) Tj 0 0 0 rg (\)\)) Tj 0 0 0 rg  T* 0 0 0 rg (ArgSpec) Tj 0 0 0 rg (\() Tj 0 0 0 rg (args) Tj .4 .4 .4 rg (=) Tj 0 0 0 rg ([],) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (varargs) Tj .4 .4 .4 rg (=) Tj 0 .501961 0 rg (None) Tj 0 0 0 rg (,) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (keywords) Tj .4 .4 .4 rg (=) Tj 0 .501961 0 rg (None) Tj 0 0 0 rg (,) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (defaults) Tj .4 .4 .4 rg (=) Tj 0 .501961 0 rg (None) Tj 0 0 0 rg (\)) Tj T* ET
 Q
 Q
 Q
 Q
 Q
 q
-1 0 0 1 62.69291 414.4236 cm
+1 0 0 1 62.69291 349.2236 cm
 q
-BT 1 0 0 1 0 3.5 Tm 21 TL /F2 17.5 Tf 0 0 0 rg (A ) Tj /F3 17.5 Tf (trace ) Tj /F2 17.5 Tf (decorator) Tj T* ET
+BT 1 0 0 1 0 3.5 Tm 21 TL /F2 17.5 Tf 0 0 0 rg (A ) Tj /F3 17.5 Tf 0 0 0 rg (trace ) Tj /F2 17.5 Tf 0 0 0 rg (decorator) Tj T* ET
 Q
 Q
 q
-1 0 0 1 62.69291 384.4236 cm
+1 0 0 1 62.69291 319.2236 cm
 q
-BT 1 0 0 1 0 14 Tm .479398 Tw 12 TL /F1 10 Tf 0 0 0 rg (As an additional example, here is how you can define a trivial ) Tj /F4 10 Tf (trace ) Tj /F1 10 Tf (decorator, which prints a message) Tj T* 0 Tw (everytime the traced function is called:) Tj T* ET
+BT 1 0 0 1 0 14 Tm .479398 Tw 12 TL /F1 10 Tf 0 0 0 rg (As an additional example, here is how you can define a trivial ) Tj /F4 10 Tf 0 0 0 rg (trace ) Tj /F1 10 Tf 0 0 0 rg (decorator, which prints a message) Tj T* 0 Tw (everytime the traced function is called:) Tj T* ET
 Q
 Q
 q
-1 0 0 1 62.69291 315.2236 cm
+1 0 0 1 62.69291 250.0236 cm
 q
 q
 1 0 0 1 0 0 cm
@@ -2366,14 +1875,144 @@ q
 n -6 -6 468.6898 60 re B*
 Q
 q
-BT 1 0 0 1 0 38 Tm 12 TL /F3 10 Tf 0 .501961 0 rg (def) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 1 rg (_trace) Tj 0 0 0 rg (\() Tj (f) Tj (,) Tj ( ) Tj .4 .4 .4 rg (*) Tj 0 0 0 rg (args) Tj (,) Tj ( ) Tj .4 .4 .4 rg (**) Tj 0 0 0 rg (kw) Tj (\):) Tj  T* (    ) Tj (kwstr) Tj ( ) Tj .4 .4 .4 rg (=) Tj 0 0 0 rg ( ) Tj .729412 .129412 .129412 rg (', ') Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (join) Tj (\() Tj .729412 .129412 .129412 rg (') Tj /F3 10 Tf .733333 .4 .533333 rg (%r) Tj /F4 10 Tf .729412 .129412 .129412 rg (: ) Tj /F3 10 Tf .733333 .4 .533333 rg (%r) Tj /F4 10 Tf .729412 .129412 .129412 rg (') Tj 0 0 0 rg ( ) Tj .4 .4 .4 rg (%) Tj 0 0 0 rg ( ) Tj (\() Tj (k) Tj (,) Tj ( ) Tj (kw) Tj ([) Tj (k) Tj (]\)) Tj ( ) Tj /F3 10 Tf 0 .501961 0 rg (for) Tj /F4 10 Tf 0 0 0 rg ( ) Tj (k) Tj ( ) Tj /F3 10 Tf .666667 .133333 1 rg (in) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 .501961 0 rg (sorted) Tj 0 0 0 rg (\() Tj (kw) Tj (\)\)) Tj  T* (    ) Tj /F3 10 Tf 0 .501961 0 rg (print) Tj /F4 10 Tf 0 0 0 rg (\() Tj .729412 .129412 .129412 rg ("calling ) Tj /F3 10 Tf .733333 .4 .533333 rg (%s) Tj /F4 10 Tf .729412 .129412 .129412 rg ( with args ) Tj /F3 10 Tf .733333 .4 .533333 rg (%s) Tj /F4 10 Tf .729412 .129412 .129412 rg (, {) Tj /F3 10 Tf .733333 .4 .533333 rg (%s) Tj /F4 10 Tf .729412 .129412 .129412 rg (}") Tj 0 0 0 rg ( ) Tj .4 .4 .4 rg (%) Tj 0 0 0 rg ( ) Tj (\() Tj (f) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (__name__) Tj (,) Tj ( ) Tj (args) Tj (,) Tj ( ) Tj (kwstr) Tj (\)\)) Tj  T* (    ) Tj /F3 10 Tf 0 .501961 0 rg (return) Tj /F4 10 Tf 0 0 0 rg ( ) Tj (f) Tj (\() Tj .4 .4 .4 rg (*) Tj 0 0 0 rg (args) Tj (,) Tj ( ) Tj .4 .4 .4 rg (**) Tj 0 0 0 rg (kw) Tj (\)) Tj T* ET
+.960784 .960784 .862745 rg
+n 0 36.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 24 36.75 36 12 re f*
+.960784 .960784 .862745 rg
+n 60 36.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 66 36.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 72 36.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 84 36.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 90 36.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 114 36.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 126 36.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 138 36.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 150 36.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 24 24.75 30 12 re f*
+.960784 .960784 .862745 rg
+n 60 24.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 72 24.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 96 24.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 102 24.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 126 24.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 132 24.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 138 24.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 150 24.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 162 24.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 174 24.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 186 24.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 198 24.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 204 24.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 210 24.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 222 24.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 234 24.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 240 24.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 246 24.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 264 24.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 288 24.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 300 24.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 318 24.75 36 12 re f*
+.960784 .960784 .862745 rg
+n 354 24.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 360 24.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 372 24.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 24 12.75 30 12 re f*
+.960784 .960784 .862745 rg
+n 54 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 60 12.75 54 12 re f*
+.960784 .960784 .862745 rg
+n 114 12.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 126 12.75 66 12 re f*
+.960784 .960784 .862745 rg
+n 192 12.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 204 12.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 222 12.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 234 12.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 252 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 264 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 270 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 276 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 282 12.75 48 12 re f*
+.960784 .960784 .862745 rg
+n 330 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 342 12.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 366 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 378 12.75 30 12 re f*
+.960784 .960784 .862745 rg
+n 408 12.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 24 .75 36 12 re f*
+.960784 .960784 .862745 rg
+n 66 .75 6 12 re f*
+.960784 .960784 .862745 rg
+n 72 .75 6 12 re f*
+.960784 .960784 .862745 rg
+n 78 .75 6 12 re f*
+.960784 .960784 .862745 rg
+n 84 .75 24 12 re f*
+.960784 .960784 .862745 rg
+n 108 .75 6 12 re f*
+.960784 .960784 .862745 rg
+n 120 .75 12 12 re f*
+.960784 .960784 .862745 rg
+n 132 .75 12 12 re f*
+.960784 .960784 .862745 rg
+n 144 .75 6 12 re f*
+BT 1 0 0 1 0 38 Tm 12 TL /F3 10 Tf 0 .501961 0 rg (def) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 1 rg (_trace) Tj 0 0 0 rg (\() Tj 0 0 0 rg (f) Tj 0 0 0 rg (,) Tj 0 0 0 rg ( ) Tj .4 .4 .4 rg (*) Tj 0 0 0 rg (args) Tj 0 0 0 rg (,) Tj 0 0 0 rg ( ) Tj .4 .4 .4 rg (**) Tj 0 0 0 rg (kw) Tj 0 0 0 rg (\):) Tj 0 0 0 rg  T* (    ) Tj 0 0 0 rg (kwstr) Tj 0 0 0 rg ( ) Tj .4 .4 .4 rg (=) Tj 0 0 0 rg ( ) Tj .729412 .129412 .129412 rg (', ') Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (join) Tj 0 0 0 rg (\() Tj .729412 .129412 .129412 rg (') Tj /F3 10 Tf .733333 .4 .533333 rg (%r) Tj /F4 10 Tf .729412 .129412 .129412 rg (: ) Tj /F3 10 Tf .733333 .4 .533333 rg (%r) Tj /F4 10 Tf .729412 .129412 .129412 rg (') Tj 0 0 0 rg ( ) Tj .4 .4 .4 rg (%) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (\() Tj 0 0 0 rg (k) Tj 0 0 0 rg (,) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (kw) Tj 0 0 0 rg ([) Tj 0 0 0 rg (k) Tj 0 0 0 rg (]\)) Tj 0 0 0 rg ( ) Tj /F3 10 Tf 0 .501961 0 rg (for) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 0 rg (k) Tj 0 0 0 rg ( ) Tj /F3 10 Tf .666667 .133333 1 rg (in) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 .501961 0 rg (sorted) Tj 0 0 0 rg (\() Tj 0 0 0 rg (kw) Tj 0 0 0 rg (\)\)) Tj 0 0 0 rg  T* (    ) Tj /F3 10 Tf 0 .501961 0 rg (print) Tj /F4 10 Tf 0 0 0 rg (\() Tj .729412 .129412 .129412 rg ("calling ) Tj /F3 10 Tf .733333 .4 .533333 rg (%s) Tj /F4 10 Tf .729412 .129412 .129412 rg ( with args ) Tj /F3 10 Tf .733333 .4 .533333 rg (%s) Tj /F4 10 Tf .729412 .129412 .129412 rg (, {) Tj /F3 10 Tf .733333 .4 .533333 rg (%s) Tj /F4 10 Tf .729412 .129412 .129412 rg (}") Tj 0 0 0 rg ( ) Tj .4 .4 .4 rg (%) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (\() Tj 0 0 0 rg (f) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (__name__) Tj 0 0 0 rg (,) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (args) Tj 0 0 0 rg (,) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (kwstr) Tj 0 0 0 rg (\)\)) Tj 0 0 0 rg  T* (    ) Tj /F3 10 Tf 0 .501961 0 rg (return) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 0 rg (f) Tj 0 0 0 rg (\() Tj .4 .4 .4 rg (*) Tj 0 0 0 rg (args) Tj 0 0 0 rg (,) Tj 0 0 0 rg ( ) Tj .4 .4 .4 rg (**) Tj 0 0 0 rg (kw) Tj 0 0 0 rg (\)) Tj T* ET
 Q
 Q
 Q
 Q
 Q
 q
-1 0 0 1 62.69291 270.0236 cm
+1 0 0 1 62.69291 204.8236 cm
 q
 q
 1 0 0 1 0 0 cm
@@ -2386,21 +2025,45 @@ q
 n -6 -6 468.6898 36 re B*
 Q
 q
-BT 1 0 0 1 0 14 Tm 12 TL /F3 10 Tf 0 .501961 0 rg (def) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 1 rg (trace) Tj 0 0 0 rg (\() Tj (f) Tj (\):) Tj  T* (    ) Tj /F3 10 Tf 0 .501961 0 rg (return) Tj /F4 10 Tf 0 0 0 rg ( ) Tj (decorator) Tj (\() Tj (_trace) Tj (,) Tj ( ) Tj (f) Tj (\)) Tj T* ET
+.960784 .960784 .862745 rg
+n 0 12.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 24 12.75 30 12 re f*
+.960784 .960784 .862745 rg
+n 54 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 60 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 66 12.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 24 .75 36 12 re f*
+.960784 .960784 .862745 rg
+n 66 .75 54 12 re f*
+.960784 .960784 .862745 rg
+n 120 .75 6 12 re f*
+.960784 .960784 .862745 rg
+n 126 .75 36 12 re f*
+.960784 .960784 .862745 rg
+n 162 .75 6 12 re f*
+.960784 .960784 .862745 rg
+n 174 .75 6 12 re f*
+.960784 .960784 .862745 rg
+n 180 .75 6 12 re f*
+BT 1 0 0 1 0 14 Tm 12 TL /F3 10 Tf 0 .501961 0 rg (def) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 1 rg (trace) Tj 0 0 0 rg (\() Tj 0 0 0 rg (f) Tj 0 0 0 rg (\):) Tj 0 0 0 rg  T* (    ) Tj /F3 10 Tf 0 .501961 0 rg (return) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 0 rg (decorator) Tj 0 0 0 rg (\() Tj 0 0 0 rg (_trace) Tj 0 0 0 rg (,) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (f) Tj 0 0 0 rg (\)) Tj T* ET
 Q
 Q
 Q
 Q
 Q
 q
-1 0 0 1 62.69291 250.0236 cm
+1 0 0 1 62.69291 184.8236 cm
 q
 0 0 0 rg
 BT 1 0 0 1 0 2 Tm /F1 10 Tf 12 TL (Here is an example of usage:) Tj T* ET
 Q
 Q
 q
-1 0 0 1 62.69291 192.8236 cm
+1 0 0 1 62.69291 127.6236 cm
 q
 q
 1 0 0 1 0 0 cm
@@ -2413,20 +2076,51 @@ q
 n -6 -6 468.6898 48 re B*
 Q
 q
-BT 1 0 0 1 0 26 Tm 12 TL /F4 10 Tf .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj .666667 .133333 1 rg (@trace) Tj 0 0 0 rg  T* .4 .4 .4 rg (...) Tj 0 0 0 rg ( ) Tj /F3 10 Tf 0 .501961 0 rg (def) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 1 rg (f1) Tj 0 0 0 rg (\() Tj (x) Tj (\):) Tj  T* .4 .4 .4 rg (...) Tj 0 0 0 rg (     ) Tj /F3 10 Tf 0 .501961 0 rg (pass) Tj T* ET
+.960784 .960784 .862745 rg
+n 0 24.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 6 24.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 12 24.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 24 24.75 36 12 re f*
+.960784 .960784 .862745 rg
+n 0 12.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 24 12.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 48 12.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 60 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 66 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 72 12.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 0 .75 18 12 re f*
+.960784 .960784 .862745 rg
+n 48 .75 24 12 re f*
+BT 1 0 0 1 0 26 Tm 12 TL /F4 10 Tf .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj .666667 .133333 1 rg (@trace) Tj 0 0 0 rg  T* .4 .4 .4 rg (...) Tj 0 0 0 rg ( ) Tj /F3 10 Tf 0 .501961 0 rg (def) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 1 rg (f1) Tj 0 0 0 rg (\() Tj 0 0 0 rg (x) Tj 0 0 0 rg (\):) Tj 0 0 0 rg  T* .4 .4 .4 rg (...) Tj 0 0 0 rg (     ) Tj /F3 10 Tf 0 .501961 0 rg (pass) Tj T* ET
 Q
 Q
 Q
 Q
 Q
 q
-1 0 0 1 62.69291 172.8236 cm
+1 0 0 1 62.69291 107.6236 cm
 q
-BT 1 0 0 1 0 2 Tm 12 TL /F1 10 Tf 0 0 0 rg (It is immediate to verify that ) Tj /F4 10 Tf (f1 ) Tj /F1 10 Tf (works) Tj T* ET
+BT 1 0 0 1 0 2 Tm 12 TL /F1 10 Tf 0 0 0 rg (It is immediate to verify that ) Tj /F4 10 Tf 0 0 0 rg (f1 ) Tj /F1 10 Tf 0 0 0 rg (works) Tj T* ET
 Q
 Q
+ 
+endstream
+endobj
+97 0 obj
+<< /Length 21381 >>
+stream
+1 0 0 1 0 0 cm  BT /F1 12 Tf 14.4 TL ET
 q
-1 0 0 1 62.69291 127.6236 cm
+1 0 0 1 62.69291 727.8236 cm
 q
 q
 1 0 0 1 0 0 cm
@@ -2439,30 +2133,51 @@ q
 n -6 -6 468.6898 36 re B*
 Q
 q
-BT 1 0 0 1 0 14 Tm 12 TL /F4 10 Tf .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj (f1) Tj (\() Tj .4 .4 .4 rg (0) Tj 0 0 0 rg (\)) Tj  T* (calling) Tj ( ) Tj (f1) Tj ( ) Tj /F3 10 Tf 0 .501961 0 rg (with) Tj /F4 10 Tf 0 0 0 rg ( ) Tj (args) Tj ( ) Tj (\() Tj .4 .4 .4 rg (0) Tj 0 0 0 rg (,\),) Tj ( ) Tj ({}) Tj T* ET
+.960784 .960784 .862745 rg
+n 0 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 6 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 12 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 24 12.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 36 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 42 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 48 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 0 .75 42 12 re f*
+.960784 .960784 .862745 rg
+n 48 .75 12 12 re f*
+.960784 .960784 .862745 rg
+n 66 .75 24 12 re f*
+.960784 .960784 .862745 rg
+n 96 .75 24 12 re f*
+.960784 .960784 .862745 rg
+n 126 .75 6 12 re f*
+.960784 .960784 .862745 rg
+n 132 .75 6 12 re f*
+.960784 .960784 .862745 rg
+n 138 .75 18 12 re f*
+.960784 .960784 .862745 rg
+n 162 .75 12 12 re f*
+BT 1 0 0 1 0 14 Tm 12 TL /F4 10 Tf .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (f1) Tj 0 0 0 rg (\() Tj .4 .4 .4 rg (0) Tj 0 0 0 rg (\)) Tj 0 0 0 rg  T* 0 0 0 rg (calling) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (f1) Tj 0 0 0 rg ( ) Tj /F3 10 Tf 0 .501961 0 rg (with) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 0 rg (args) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (\() Tj .4 .4 .4 rg (0) Tj 0 0 0 rg (,\),) Tj 0 0 0 rg ( ) Tj 0 0 0 rg ({}) Tj T* ET
 Q
 Q
 Q
 Q
 Q
 q
-1 0 0 1 62.69291 107.6236 cm
+1 0 0 1 62.69291 707.8236 cm
 q
 0 0 0 rg
 BT 1 0 0 1 0 2 Tm /F1 10 Tf 12 TL (and it that it has the correct signature:) Tj T* ET
 Q
 Q
- 
-endstream
-endobj
-% 'R93': class PDFStream 
-93 0 obj
-% page stream
-<< /Length 7590 >>
-stream
-1 0 0 1 0 0 cm  BT /F1 12 Tf 14.4 TL ET
 q
-1 0 0 1 62.69291 727.8236 cm
+1 0 0 1 62.69291 662.6236 cm
 q
 q
 1 0 0 1 0 0 cm
@@ -2475,26 +2190,82 @@ q
 n -6 -6 468.6898 36 re B*
 Q
 q
-BT 1 0 0 1 0 14 Tm 12 TL /F4 10 Tf .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj /F3 10 Tf 0 .501961 0 rg (print) Tj /F4 10 Tf 0 0 0 rg (\() Tj (getargspec) Tj (\() Tj (f1) Tj (\)\)) Tj  T* (ArgSpec) Tj (\() Tj (args) Tj .4 .4 .4 rg (=) Tj 0 0 0 rg ([) Tj .729412 .129412 .129412 rg ('x') Tj 0 0 0 rg (],) Tj ( ) Tj (varargs) Tj .4 .4 .4 rg (=) Tj 0 .501961 0 rg (None) Tj 0 0 0 rg (,) Tj ( ) Tj (keywords) Tj .4 .4 .4 rg (=) Tj 0 .501961 0 rg (None) Tj 0 0 0 rg (,) Tj ( ) Tj (defaults) Tj .4 .4 .4 rg (=) Tj 0 .501961 0 rg (None) Tj 0 0 0 rg (\)) Tj T* ET
+.960784 .960784 .862745 rg
+n 0 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 6 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 12 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 24 12.75 30 12 re f*
+.960784 .960784 .862745 rg
+n 54 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 60 12.75 60 12 re f*
+.960784 .960784 .862745 rg
+n 120 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 126 12.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 138 12.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 0 .75 42 12 re f*
+.960784 .960784 .862745 rg
+n 42 .75 6 12 re f*
+.960784 .960784 .862745 rg
+n 48 .75 24 12 re f*
+.960784 .960784 .862745 rg
+n 72 .75 6 12 re f*
+.960784 .960784 .862745 rg
+n 78 .75 6 12 re f*
+.960784 .960784 .862745 rg
+n 84 .75 18 12 re f*
+.960784 .960784 .862745 rg
+n 102 .75 12 12 re f*
+.960784 .960784 .862745 rg
+n 120 .75 42 12 re f*
+.960784 .960784 .862745 rg
+n 162 .75 6 12 re f*
+.960784 .960784 .862745 rg
+n 168 .75 24 12 re f*
+.960784 .960784 .862745 rg
+n 192 .75 6 12 re f*
+.960784 .960784 .862745 rg
+n 204 .75 48 12 re f*
+.960784 .960784 .862745 rg
+n 252 .75 6 12 re f*
+.960784 .960784 .862745 rg
+n 258 .75 24 12 re f*
+.960784 .960784 .862745 rg
+n 282 .75 6 12 re f*
+.960784 .960784 .862745 rg
+n 294 .75 48 12 re f*
+.960784 .960784 .862745 rg
+n 342 .75 6 12 re f*
+.960784 .960784 .862745 rg
+n 348 .75 24 12 re f*
+.960784 .960784 .862745 rg
+n 372 .75 6 12 re f*
+BT 1 0 0 1 0 14 Tm 12 TL /F4 10 Tf .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj /F3 10 Tf 0 .501961 0 rg (print) Tj /F4 10 Tf 0 0 0 rg (\() Tj 0 0 0 rg (getargspec) Tj 0 0 0 rg (\() Tj 0 0 0 rg (f1) Tj 0 0 0 rg (\)\)) Tj 0 0 0 rg  T* 0 0 0 rg (ArgSpec) Tj 0 0 0 rg (\() Tj 0 0 0 rg (args) Tj .4 .4 .4 rg (=) Tj 0 0 0 rg ([) Tj .729412 .129412 .129412 rg ('x') Tj 0 0 0 rg (],) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (varargs) Tj .4 .4 .4 rg (=) Tj 0 .501961 0 rg (None) Tj 0 0 0 rg (,) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (keywords) Tj .4 .4 .4 rg (=) Tj 0 .501961 0 rg (None) Tj 0 0 0 rg (,) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (defaults) Tj .4 .4 .4 rg (=) Tj 0 .501961 0 rg (None) Tj 0 0 0 rg (\)) Tj T* ET
 Q
 Q
 Q
 Q
 Q
 q
-1 0 0 1 62.69291 707.8236 cm
+1 0 0 1 62.69291 642.6236 cm
 q
 0 0 0 rg
 BT 1 0 0 1 0 2 Tm /F1 10 Tf 12 TL (The same decorator works with functions of any signature:) Tj T* ET
 Q
 Q
 q
-1 0 0 1 62.69291 579.978 cm
+1 0 0 1 62.69291 513.4236 cm
 q
 q
-.988825 0 0 .988825 0 0 cm
+1 0 0 1 0 0 cm
 q
-1 0 0 1 6.6 6.674587 cm
+1 0 0 1 6.6 6.6 cm
 q
 .662745 .662745 .662745 RG
 .5 w
@@ -2502,26 +2273,190 @@ q
 n -6 -6 474 120 re B*
 Q
 q
-BT 1 0 0 1 0 98 Tm 12 TL /F4 10 Tf .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj .666667 .133333 1 rg (@trace) Tj 0 0 0 rg  T* .4 .4 .4 rg (...) Tj 0 0 0 rg ( ) Tj /F3 10 Tf 0 .501961 0 rg (def) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 1 rg (f) Tj 0 0 0 rg (\() Tj (x) Tj (,) Tj ( ) Tj (y) Tj .4 .4 .4 rg (=) Tj (1) Tj 0 0 0 rg (,) Tj ( ) Tj (z) Tj .4 .4 .4 rg (=) Tj (2) Tj 0 0 0 rg (,) Tj ( ) Tj .4 .4 .4 rg (*) Tj 0 0 0 rg (args) Tj (,) Tj ( ) Tj .4 .4 .4 rg (**) Tj 0 0 0 rg (kw) Tj (\):) Tj  T* .4 .4 .4 rg (...) Tj 0 0 0 rg (     ) Tj /F3 10 Tf 0 .501961 0 rg (pass) Tj /F4 10 Tf 0 0 0 rg  T*  T* .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj (f) Tj (\() Tj .4 .4 .4 rg (0) Tj 0 0 0 rg (,) Tj ( ) Tj .4 .4 .4 rg (3) Tj 0 0 0 rg (\)) Tj  T* (calling) Tj ( ) Tj (f) Tj ( ) Tj /F3 10 Tf 0 .501961 0 rg (with) Tj /F4 10 Tf 0 0 0 rg ( ) Tj (args) Tj ( ) Tj (\() Tj .4 .4 .4 rg (0) Tj 0 0 0 rg (,) Tj ( ) Tj .4 .4 .4 rg (3) Tj 0 0 0 rg (,) Tj ( ) Tj .4 .4 .4 rg (2) Tj 0 0 0 rg (\),) Tj ( ) Tj ({}) Tj  T*  T* .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj /F3 10 Tf 0 .501961 0 rg (print) Tj /F4 10 Tf 0 0 0 rg (\() Tj (getargspec) Tj (\() Tj (f) Tj (\)\)) Tj  T* (ArgSpec) Tj (\() Tj (args) Tj .4 .4 .4 rg (=) Tj 0 0 0 rg ([) Tj .729412 .129412 .129412 rg ('x') Tj 0 0 0 rg (,) Tj ( ) Tj .729412 .129412 .129412 rg ('y') Tj 0 0 0 rg (,) Tj ( ) Tj .729412 .129412 .129412 rg ('z') Tj 0 0 0 rg (],) Tj ( ) Tj (varargs) Tj .4 .4 .4 rg (=) Tj .729412 .129412 .129412 rg ('args') Tj 0 0 0 rg (,) Tj ( ) Tj (keywords) Tj .4 .4 .4 rg (=) Tj .729412 .129412 .129412 rg ('kw') Tj 0 0 0 rg (,) Tj ( ) Tj (defaults) Tj .4 .4 .4 rg (=) Tj 0 0 0 rg (\() Tj .4 .4 .4 rg (1) Tj 0 0 0 rg (,) Tj ( ) Tj .4 .4 .4 rg (2) Tj 0 0 0 rg (\)\)) Tj T* ET
+.960784 .960784 .862745 rg
+n 0 96.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 6 96.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 12 96.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 24 96.75 36 12 re f*
+.960784 .960784 .862745 rg
+n 0 84.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 24 84.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 48 84.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 54 84.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 60 84.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 66 84.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 78 84.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 84 84.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 90 84.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 96 84.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 108 84.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 114 84.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 120 84.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 126 84.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 138 84.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 144 84.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 168 84.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 180 84.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 192 84.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 204 84.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 0 72.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 48 72.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 0 48.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 6 48.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 12 48.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 24 48.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 30 48.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 36 48.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 42 48.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 54 48.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 60 48.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 0 36.75 42 12 re f*
+.960784 .960784 .862745 rg
+n 48 36.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 60 36.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 90 36.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 120 36.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 126 36.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 132 36.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 144 36.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 150 36.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 162 36.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 168 36.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 186 36.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 0 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 6 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 12 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 24 12.75 30 12 re f*
+.960784 .960784 .862745 rg
+n 54 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 60 12.75 60 12 re f*
+.960784 .960784 .862745 rg
+n 120 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 126 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 132 12.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 0 .75 42 12 re f*
+.960784 .960784 .862745 rg
+n 42 .75 6 12 re f*
+.960784 .960784 .862745 rg
+n 48 .75 24 12 re f*
+.960784 .960784 .862745 rg
+n 72 .75 6 12 re f*
+.960784 .960784 .862745 rg
+n 78 .75 6 12 re f*
+.960784 .960784 .862745 rg
+n 84 .75 18 12 re f*
+.960784 .960784 .862745 rg
+n 102 .75 6 12 re f*
+.960784 .960784 .862745 rg
+n 114 .75 18 12 re f*
+.960784 .960784 .862745 rg
+n 132 .75 6 12 re f*
+.960784 .960784 .862745 rg
+n 144 .75 18 12 re f*
+.960784 .960784 .862745 rg
+n 162 .75 12 12 re f*
+.960784 .960784 .862745 rg
+n 180 .75 42 12 re f*
+.960784 .960784 .862745 rg
+n 222 .75 6 12 re f*
+.960784 .960784 .862745 rg
+n 228 .75 36 12 re f*
+.960784 .960784 .862745 rg
+n 264 .75 6 12 re f*
+.960784 .960784 .862745 rg
+n 276 .75 48 12 re f*
+.960784 .960784 .862745 rg
+n 324 .75 6 12 re f*
+.960784 .960784 .862745 rg
+n 330 .75 24 12 re f*
+.960784 .960784 .862745 rg
+n 354 .75 6 12 re f*
+.960784 .960784 .862745 rg
+n 366 .75 48 12 re f*
+.960784 .960784 .862745 rg
+n 414 .75 6 12 re f*
+.960784 .960784 .862745 rg
+n 420 .75 6 12 re f*
+.960784 .960784 .862745 rg
+n 426 .75 6 12 re f*
+.960784 .960784 .862745 rg
+n 432 .75 6 12 re f*
+.960784 .960784 .862745 rg
+n 444 .75 6 12 re f*
+.960784 .960784 .862745 rg
+n 450 .75 12 12 re f*
+BT 1 0 0 1 0 98 Tm 12 TL /F4 10 Tf .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj .666667 .133333 1 rg (@trace) Tj 0 0 0 rg  T* .4 .4 .4 rg (...) Tj 0 0 0 rg ( ) Tj /F3 10 Tf 0 .501961 0 rg (def) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 1 rg (f) Tj 0 0 0 rg (\() Tj 0 0 0 rg (x) Tj 0 0 0 rg (,) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (y) Tj .4 .4 .4 rg (=) Tj .4 .4 .4 rg (1) Tj 0 0 0 rg (,) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (z) Tj .4 .4 .4 rg (=) Tj .4 .4 .4 rg (2) Tj 0 0 0 rg (,) Tj 0 0 0 rg ( ) Tj .4 .4 .4 rg (*) Tj 0 0 0 rg (args) Tj 0 0 0 rg (,) Tj 0 0 0 rg ( ) Tj .4 .4 .4 rg (**) Tj 0 0 0 rg (kw) Tj 0 0 0 rg (\):) Tj 0 0 0 rg  T* .4 .4 .4 rg (...) Tj 0 0 0 rg (     ) Tj /F3 10 Tf 0 .501961 0 rg (pass) Tj /F4 10 Tf 0 0 0 rg  T*  T* .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (f) Tj 0 0 0 rg (\() Tj .4 .4 .4 rg (0) Tj 0 0 0 rg (,) Tj 0 0 0 rg ( ) Tj .4 .4 .4 rg (3) Tj 0 0 0 rg (\)) Tj 0 0 0 rg  T* 0 0 0 rg (calling) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (f) Tj 0 0 0 rg ( ) Tj /F3 10 Tf 0 .501961 0 rg (with) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 0 rg (args) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (\() Tj .4 .4 .4 rg (0) Tj 0 0 0 rg (,) Tj 0 0 0 rg ( ) Tj .4 .4 .4 rg (3) Tj 0 0 0 rg (,) Tj 0 0 0 rg ( ) Tj .4 .4 .4 rg (2) Tj 0 0 0 rg (\),) Tj 0 0 0 rg ( ) Tj 0 0 0 rg ({}) Tj 0 0 0 rg  T*  T* .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj /F3 10 Tf 0 .501961 0 rg (print) Tj /F4 10 Tf 0 0 0 rg (\() Tj 0 0 0 rg (getargspec) Tj 0 0 0 rg (\() Tj 0 0 0 rg (f) Tj 0 0 0 rg (\)\)) Tj 0 0 0 rg  T* 0 0 0 rg (ArgSpec) Tj 0 0 0 rg (\() Tj 0 0 0 rg (args) Tj .4 .4 .4 rg (=) Tj 0 0 0 rg ([) Tj .729412 .129412 .129412 rg ('x') Tj 0 0 0 rg (,) Tj 0 0 0 rg ( ) Tj .729412 .129412 .129412 rg ('y') Tj 0 0 0 rg (,) Tj 0 0 0 rg ( ) Tj .729412 .129412 .129412 rg ('z') Tj 0 0 0 rg (],) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (varargs) Tj .4 .4 .4 rg (=) Tj .729412 .129412 .129412 rg ('args') Tj 0 0 0 rg (,) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (keywords) Tj .4 .4 .4 rg (=) Tj .729412 .129412 .129412 rg ('kw') Tj 0 0 0 rg (,) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (defaults) Tj .4 .4 .4 rg (=) Tj 0 0 0 rg (\() Tj .4 .4 .4 rg (1) Tj 0 0 0 rg (,) Tj 0 0 0 rg ( ) Tj .4 .4 .4 rg (2) Tj 0 0 0 rg (\)\)) Tj T* ET
 Q
 Q
 Q
 Q
 Q
 q
-1 0 0 1 62.69291 546.978 cm
+1 0 0 1 62.69291 480.4236 cm
 q
 BT 1 0 0 1 0 3.5 Tm 21 TL /F2 17.5 Tf 0 0 0 rg (Function annotations) Tj T* ET
 Q
 Q
 q
-1 0 0 1 62.69291 492.978 cm
+1 0 0 1 62.69291 426.4236 cm
 q
-BT 1 0 0 1 0 38 Tm 1.937318 Tw 12 TL /F1 10 Tf 0 0 0 rg (Python 3 introduced the concept of ) Tj 0 0 .501961 rg (function annotations) Tj 0 0 0 rg (,i.e. the ability to annotate the signature of a) Tj T* 0 Tw 2.24816 Tw (function with additional information, stored in a dictionary named ) Tj /F4 10 Tf (__annotations__) Tj /F1 10 Tf (. The decorator) Tj T* 0 Tw 1.923735 Tw (module, starting from release 3.3, is able to understand and to preserve the annotations. Here is an) Tj T* 0 Tw (example:) Tj T* ET
+BT 1 0 0 1 0 38 Tm 1.937318 Tw 12 TL /F1 10 Tf 0 0 0 rg (Python 3 introduced the concept of ) Tj 0 0 .501961 rg (function annotations) Tj 0 0 0 rg (,i.e. the ability to annotate the signature of a) Tj T* 0 Tw 2.24816 Tw (function with additional information, stored in a dictionary named ) Tj /F4 10 Tf 0 0 0 rg (__annotations__) Tj /F1 10 Tf 0 0 0 rg (. The decorator) Tj T* 0 Tw 1.923735 Tw (module, starting from release 3.3, is able to understand and to preserve the annotations. Here is an) Tj T* 0 Tw (example:) Tj T* ET
 Q
 Q
 q
-1 0 0 1 62.69291 423.778 cm
+1 0 0 1 62.69291 357.2236 cm
 q
 q
 1 0 0 1 0 0 cm
@@ -2534,20 +2469,90 @@ q
 n -6 -6 468.6898 60 re B*
 Q
 q
-BT 1 0 0 1 0 38 Tm 12 TL /F4 10 Tf .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj .666667 .133333 1 rg (@trace) Tj 0 0 0 rg  T* .4 .4 .4 rg (...) Tj 0 0 0 rg ( ) Tj /F3 10 Tf 0 .501961 0 rg (def) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 1 rg (f) Tj 0 0 0 rg (\() Tj (x) Tj (:) Tj ( ) Tj .729412 .129412 .129412 rg ('the first argument') Tj 0 0 0 rg (,) Tj ( ) Tj (y) Tj (:) Tj ( ) Tj .729412 .129412 .129412 rg ('default argument') Tj .4 .4 .4 rg (=) Tj (1) Tj 0 0 0 rg (,) Tj ( ) Tj (z) Tj .4 .4 .4 rg (=) Tj (2) Tj 0 0 0 rg (,) Tj  T* .4 .4 .4 rg (...) Tj 0 0 0 rg (       ) Tj .4 .4 .4 rg (*) Tj 0 0 0 rg (args) Tj (:) Tj ( ) Tj .729412 .129412 .129412 rg ('varargs') Tj 0 0 0 rg (,) Tj ( ) Tj .4 .4 .4 rg (**) Tj 0 0 0 rg (kw) Tj (:) Tj ( ) Tj .729412 .129412 .129412 rg ('kwargs') Tj 0 0 0 rg (\):) Tj  T* .4 .4 .4 rg (...) Tj 0 0 0 rg (     ) Tj /F3 10 Tf 0 .501961 0 rg (pass) Tj T* ET
+.960784 .960784 .862745 rg
+n 0 36.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 6 36.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 12 36.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 24 36.75 36 12 re f*
+.960784 .960784 .862745 rg
+n 0 24.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 24 24.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 48 24.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 54 24.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 60 24.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 66 24.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 78 24.75 120 12 re f*
+.960784 .960784 .862745 rg
+n 198 24.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 210 24.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 216 24.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 228 24.75 108 12 re f*
+.960784 .960784 .862745 rg
+n 336 24.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 342 24.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 348 24.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 360 24.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 366 24.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 372 24.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 378 24.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 0 12.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 60 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 66 12.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 90 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 102 12.75 54 12 re f*
+.960784 .960784 .862745 rg
+n 156 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 168 12.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 180 12.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 192 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 204 12.75 48 12 re f*
+.960784 .960784 .862745 rg
+n 252 12.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 0 .75 18 12 re f*
+.960784 .960784 .862745 rg
+n 48 .75 24 12 re f*
+BT 1 0 0 1 0 38 Tm 12 TL /F4 10 Tf .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj .666667 .133333 1 rg (@trace) Tj 0 0 0 rg  T* .4 .4 .4 rg (...) Tj 0 0 0 rg ( ) Tj /F3 10 Tf 0 .501961 0 rg (def) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 1 rg (f) Tj 0 0 0 rg (\() Tj 0 0 0 rg (x) Tj 0 0 0 rg (:) Tj 0 0 0 rg ( ) Tj .729412 .129412 .129412 rg ('the first argument') Tj 0 0 0 rg (,) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (y) Tj 0 0 0 rg (:) Tj 0 0 0 rg ( ) Tj .729412 .129412 .129412 rg ('default argument') Tj .4 .4 .4 rg (=) Tj .4 .4 .4 rg (1) Tj 0 0 0 rg (,) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (z) Tj .4 .4 .4 rg (=) Tj .4 .4 .4 rg (2) Tj 0 0 0 rg (,) Tj 0 0 0 rg  T* .4 .4 .4 rg (...) Tj 0 0 0 rg (       ) Tj .4 .4 .4 rg (*) Tj 0 0 0 rg (args) Tj 0 0 0 rg (:) Tj 0 0 0 rg ( ) Tj .729412 .129412 .129412 rg ('varargs') Tj 0 0 0 rg (,) Tj 0 0 0 rg ( ) Tj .4 .4 .4 rg (**) Tj 0 0 0 rg (kw) Tj 0 0 0 rg (:) Tj 0 0 0 rg ( ) Tj .729412 .129412 .129412 rg ('kwargs') Tj 0 0 0 rg (\):) Tj 0 0 0 rg  T* .4 .4 .4 rg (...) Tj 0 0 0 rg (     ) Tj /F3 10 Tf 0 .501961 0 rg (pass) Tj T* ET
 Q
 Q
 Q
 Q
 Q
 q
-1 0 0 1 62.69291 391.778 cm
+1 0 0 1 62.69291 325.2236 cm
 q
-BT 1 0 0 1 0 14 Tm .596647 Tw 12 TL /F1 10 Tf 0 0 0 rg (In order to introspect functions with annotations, one needs the utility ) Tj /F4 10 Tf (inspect.getfullargspec) Tj /F1 10 Tf (, new) Tj T* 0 Tw (in Python 3:) Tj T* ET
+BT 1 0 0 1 0 14 Tm .596647 Tw 12 TL /F1 10 Tf 0 0 0 rg (In order to introspect functions with annotations, one needs the utility ) Tj /F4 10 Tf 0 0 0 rg (inspect.getfullargspec) Tj /F1 10 Tf 0 0 0 rg (, new) Tj T* 0 Tw (in Python 3:) Tj T* ET
 Q
 Q
 q
-1 0 0 1 62.69291 214.578 cm
+1 0 0 1 62.69291 148.0236 cm
 q
 q
 1 0 0 1 0 0 cm
@@ -2560,20 +2565,154 @@ q
 n -6 -6 468.6898 168 re B*
 Q
 q
-BT 1 0 0 1 0 146 Tm 12 TL /F4 10 Tf .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj /F3 10 Tf 0 .501961 0 rg (from) Tj /F4 10 Tf 0 0 0 rg ( ) Tj /F3 10 Tf 0 0 1 rg (inspect) Tj /F4 10 Tf 0 0 0 rg ( ) Tj /F3 10 Tf 0 .501961 0 rg (import) Tj /F4 10 Tf 0 0 0 rg ( ) Tj (getfullargspec) Tj  T* .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj (argspec) Tj ( ) Tj .4 .4 .4 rg (=) Tj 0 0 0 rg ( ) Tj (getfullargspec) Tj (\() Tj (f) Tj (\)) Tj  T* .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj (argspec) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (args) Tj  T* ([) Tj .729412 .129412 .129412 rg ('x') Tj 0 0 0 rg (,) Tj ( ) Tj .729412 .129412 .129412 rg ('y') Tj 0 0 0 rg (,) Tj ( ) Tj .729412 .129412 .129412 rg ('z') Tj 0 0 0 rg (]) Tj  T* .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj (argspec) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (varargs) Tj  T* .729412 .129412 .129412 rg ('args') Tj 0 0 0 rg  T* .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj (argspec) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (varkw) Tj  T* .729412 .129412 .129412 rg ('kw') Tj 0 0 0 rg  T* .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj (argspec) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (defaults) Tj  T* (\() Tj .4 .4 .4 rg (1) Tj 0 0 0 rg (,) Tj ( ) Tj .4 .4 .4 rg (2) Tj 0 0 0 rg (\)) Tj  T* .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj (argspec) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (kwonlyargs) Tj  T* ([]) Tj  T* .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj (argspec) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (kwonlydefaults) Tj T* ET
+.960784 .960784 .862745 rg
+n 0 144.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 6 144.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 12 144.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 24 144.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 54 144.75 42 12 re f*
+.960784 .960784 .862745 rg
+n 102 144.75 36 12 re f*
+.960784 .960784 .862745 rg
+n 144 144.75 84 12 re f*
+.960784 .960784 .862745 rg
+n 0 132.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 6 132.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 12 132.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 24 132.75 42 12 re f*
+.960784 .960784 .862745 rg
+n 72 132.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 84 132.75 84 12 re f*
+.960784 .960784 .862745 rg
+n 168 132.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 174 132.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 180 132.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 0 120.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 6 120.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 12 120.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 24 120.75 42 12 re f*
+.960784 .960784 .862745 rg
+n 66 120.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 72 120.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 0 108.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 6 108.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 24 108.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 36 108.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 54 108.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 66 108.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 84 108.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 0 96.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 6 96.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 12 96.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 24 96.75 42 12 re f*
+.960784 .960784 .862745 rg
+n 66 96.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 72 96.75 42 12 re f*
+.960784 .960784 .862745 rg
+n 0 84.75 36 12 re f*
+.960784 .960784 .862745 rg
+n 0 72.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 6 72.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 12 72.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 24 72.75 42 12 re f*
+.960784 .960784 .862745 rg
+n 66 72.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 72 72.75 30 12 re f*
+.960784 .960784 .862745 rg
+n 0 60.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 0 48.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 6 48.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 12 48.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 24 48.75 42 12 re f*
+.960784 .960784 .862745 rg
+n 66 48.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 72 48.75 48 12 re f*
+.960784 .960784 .862745 rg
+n 0 36.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 6 36.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 12 36.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 24 36.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 30 36.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 0 24.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 6 24.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 12 24.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 24 24.75 42 12 re f*
+.960784 .960784 .862745 rg
+n 66 24.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 72 24.75 60 12 re f*
+.960784 .960784 .862745 rg
+n 0 12.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 0 .75 6 12 re f*
+.960784 .960784 .862745 rg
+n 6 .75 6 12 re f*
+.960784 .960784 .862745 rg
+n 12 .75 6 12 re f*
+.960784 .960784 .862745 rg
+n 24 .75 42 12 re f*
+.960784 .960784 .862745 rg
+n 66 .75 6 12 re f*
+.960784 .960784 .862745 rg
+n 72 .75 84 12 re f*
+BT 1 0 0 1 0 146 Tm 12 TL /F4 10 Tf .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj /F3 10 Tf 0 .501961 0 rg (from) Tj /F4 10 Tf 0 0 0 rg ( ) Tj /F3 10 Tf 0 0 1 rg (inspect) Tj /F4 10 Tf 0 0 0 rg ( ) Tj /F3 10 Tf 0 .501961 0 rg (import) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 0 rg (getfullargspec) Tj 0 0 0 rg  T* .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (argspec) Tj 0 0 0 rg ( ) Tj .4 .4 .4 rg (=) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (getfullargspec) Tj 0 0 0 rg (\() Tj 0 0 0 rg (f) Tj 0 0 0 rg (\)) Tj 0 0 0 rg  T* .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (argspec) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (args) Tj 0 0 0 rg  T* 0 0 0 rg ([) Tj .729412 .129412 .129412 rg ('x') Tj 0 0 0 rg (,) Tj 0 0 0 rg ( ) Tj .729412 .129412 .129412 rg ('y') Tj 0 0 0 rg (,) Tj 0 0 0 rg ( ) Tj .729412 .129412 .129412 rg ('z') Tj 0 0 0 rg (]) Tj 0 0 0 rg  T* .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (argspec) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (varargs) Tj 0 0 0 rg  T* .729412 .129412 .129412 rg ('args') Tj 0 0 0 rg  T* .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (argspec) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (varkw) Tj 0 0 0 rg  T* .729412 .129412 .129412 rg ('kw') Tj 0 0 0 rg  T* .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (argspec) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (defaults) Tj 0 0 0 rg  T* 0 0 0 rg (\() Tj .4 .4 .4 rg (1) Tj 0 0 0 rg (,) Tj 0 0 0 rg ( ) Tj .4 .4 .4 rg (2) Tj 0 0 0 rg (\)) Tj 0 0 0 rg  T* .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (argspec) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (kwonlyargs) Tj 0 0 0 rg  T* 0 0 0 rg ([]) Tj 0 0 0 rg  T* .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (argspec) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (kwonlydefaults) Tj T* ET
 Q
 Q
 Q
 Q
 Q
 q
-1 0 0 1 62.69291 194.578 cm
+1 0 0 1 62.69291 128.0236 cm
 q
-BT 1 0 0 1 0 2 Tm 12 TL /F1 10 Tf 0 0 0 rg (You can also check that the ) Tj /F4 10 Tf (__annotations__ ) Tj /F1 10 Tf (dictionary is preserved:) Tj T* ET
+BT 1 0 0 1 0 2 Tm 12 TL /F1 10 Tf 0 0 0 rg (You can also check that the ) Tj /F4 10 Tf 0 0 0 rg (__annotations__ ) Tj /F1 10 Tf 0 0 0 rg (dictionary is preserved:) Tj T* ET
 Q
 Q
 q
-1 0 0 1 62.69291 149.378 cm
+1 0 0 1 62.69291 82.82362 cm
 q
 q
 1 0 0 1 0 0 cm
@@ -2586,42 +2725,66 @@ q
 n -6 -6 468.6898 36 re B*
 Q
 q
-BT 1 0 0 1 0 14 Tm 12 TL /F4 10 Tf .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj (f) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (__annotations__) Tj ( ) Tj .4 .4 .4 rg (==) Tj 0 0 0 rg ( ) Tj (f) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (__wrapped__) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (__annotations__) Tj  T* 0 .501961 0 rg (True) Tj T* ET
+.960784 .960784 .862745 rg
+n 0 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 6 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 12 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 24 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 30 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 36 12.75 90 12 re f*
+.960784 .960784 .862745 rg
+n 132 12.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 150 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 156 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 162 12.75 66 12 re f*
+.960784 .960784 .862745 rg
+n 228 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 234 12.75 90 12 re f*
+.960784 .960784 .862745 rg
+n 0 .75 24 12 re f*
+BT 1 0 0 1 0 14 Tm 12 TL /F4 10 Tf .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (f) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (__annotations__) Tj 0 0 0 rg ( ) Tj .4 .4 .4 rg (==) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (f) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (__wrapped__) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (__annotations__) Tj 0 0 0 rg  T* 0 .501961 0 rg (True) Tj T* ET
 Q
 Q
 Q
 Q
 Q
+ 
+endstream
+endobj
+98 0 obj
+<< /Length 19143 >>
+stream
+1 0 0 1 0 0 cm  BT /F1 12 Tf 14.4 TL ET
 q
-1 0 0 1 62.69291 117.378 cm
+1 0 0 1 62.69291 741.0236 cm
 q
 0 0 0 rg
 BT 1 0 0 1 0 14 Tm /F1 10 Tf 12 TL .011098 Tw (Depending on the version of the decorator module, the two dictionaries can be the same object or not: you) Tj T* 0 Tw (cannot rely on object identity, but you can rely on the content being the same.) Tj T* ET
 Q
 Q
- 
-endstream
-endobj
-% 'R94': class PDFStream 
-94 0 obj
-% page stream
-<< /Length 8795 >>
-stream
-1 0 0 1 0 0 cm  BT /F1 12 Tf 14.4 TL ET
 q
-1 0 0 1 62.69291 744.0236 cm
+1 0 0 1 62.69291 708.0236 cm
 q
-BT 1 0 0 1 0 3.5 Tm 21 TL /F3 17.5 Tf 0 0 0 rg (decorator ) Tj /F2 17.5 Tf (is a decorator) Tj T* ET
+BT 1 0 0 1 0 3.5 Tm 21 TL /F3 17.5 Tf 0 0 0 rg (decorator ) Tj /F2 17.5 Tf 0 0 0 rg (is a decorator) Tj T* ET
 Q
 Q
 q
-1 0 0 1 62.69291 642.0236 cm
+1 0 0 1 62.69291 606.0236 cm
 q
-BT 1 0 0 1 0 86 Tm .643876 Tw 12 TL /F1 10 Tf 0 0 0 rg (It may be annoying to write a caller function \(like the ) Tj /F4 10 Tf (_trace ) Tj /F1 10 Tf (function above\) and then a trivial wrapper) Tj T* 0 Tw 1.510888 Tw (\() Tj /F4 10 Tf (def) Tj ( ) Tj (trace\(f\):) Tj ( ) Tj (return) Tj ( ) Tj (decorator\(_trace,) Tj ( ) Tj (f\)) Tj /F1 10 Tf (\) every time. For this reason, the ) Tj /F4 10 Tf (decorator) Tj T* 0 Tw .334269 Tw /F1 10 Tf (module provides an easy shortcut to convert the caller function into a signature-preserving decorator: you) Tj T* 0 Tw 7.364269 Tw (can just call ) Tj /F4 10 Tf (decorator ) Tj /F1 10 Tf (with a single argument. In our example you can just write) Tj T* 0 Tw .951647 Tw /F4 10 Tf (trace) Tj ( ) Tj (=) Tj ( ) Tj (decorator\(_trace\)) Tj /F1 10 Tf (. The ) Tj /F4 10 Tf (decorator ) Tj /F1 10 Tf (function can also be used as a signature-changing) Tj T* 0 Tw 1.077752 Tw (decorator, just as ) Tj /F4 10 Tf (classmethod ) Tj /F1 10 Tf (and ) Tj /F4 10 Tf (staticmethod) Tj /F1 10 Tf (. However, ) Tj /F4 10 Tf (classmethod ) Tj /F1 10 Tf (and ) Tj /F4 10 Tf (staticmethod) Tj T* 0 Tw .531797 Tw /F1 10 Tf (return generic objects which are not callable, while ) Tj /F4 10 Tf (decorator ) Tj /F1 10 Tf (returns signature-preserving decorators,) Tj T* 0 Tw (i.e. functions of a single argument. For instance, you can write directly) Tj T* ET
+BT 1 0 0 1 0 86 Tm .643876 Tw 12 TL /F1 10 Tf 0 0 0 rg (It may be annoying to write a caller function \(like the ) Tj /F4 10 Tf 0 0 0 rg (_trace ) Tj /F1 10 Tf 0 0 0 rg (function above\) and then a trivial wrapper) Tj T* 0 Tw 1.510888 Tw (\() Tj /F4 10 Tf 0 0 0 rg (def) Tj ( ) Tj (trace\(f\):) Tj ( ) Tj (return) Tj ( ) Tj (decorator\(_trace,) Tj ( ) Tj (f\)) Tj /F1 10 Tf 0 0 0 rg (\) every time. For this reason, the ) Tj /F4 10 Tf 0 0 0 rg (decorator) Tj T* 0 Tw .334269 Tw /F1 10 Tf 0 0 0 rg (module provides an easy shortcut to convert the caller function into a signature-preserving decorator: you) Tj T* 0 Tw 7.364269 Tw (can just call ) Tj /F4 10 Tf 0 0 0 rg (decorator ) Tj /F1 10 Tf 0 0 0 rg (with a single argument. In our example you can just write) Tj T* 0 Tw .951647 Tw /F4 10 Tf 0 0 0 rg (trace) Tj ( ) Tj (=) Tj ( ) Tj (decorator\(_trace\)) Tj /F1 10 Tf 0 0 0 rg (. The ) Tj /F4 10 Tf 0 0 0 rg (decorator ) Tj /F1 10 Tf 0 0 0 rg (function can also be used as a signature-changing) Tj T* 0 Tw 1.077752 Tw (decorator, just as ) Tj /F4 10 Tf 0 0 0 rg (classmethod ) Tj /F1 10 Tf 0 0 0 rg (and ) Tj /F4 10 Tf 0 0 0 rg (staticmethod) Tj /F1 10 Tf 0 0 0 rg (. However, ) Tj /F4 10 Tf 0 0 0 rg (classmethod ) Tj /F1 10 Tf 0 0 0 rg (and ) Tj /F4 10 Tf 0 0 0 rg (staticmethod) Tj T* 0 Tw .531797 Tw /F1 10 Tf 0 0 0 rg (return generic objects which are not callable, while ) Tj /F4 10 Tf 0 0 0 rg (decorator ) Tj /F1 10 Tf 0 0 0 rg (returns signature-preserving decorators,) Tj T* 0 Tw (i.e. functions of a single argument. For instance, you can write directly) Tj T* ET
 Q
 Q
 q
-1 0 0 1 62.69291 560.8236 cm
+1 0 0 1 62.69291 524.8236 cm
 q
 q
 1 0 0 1 0 0 cm
@@ -2634,20 +2797,166 @@ q
 n -6 -6 468.6898 72 re B*
 Q
 q
-BT 1 0 0 1 0 50 Tm 12 TL /F4 10 Tf .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj .666667 .133333 1 rg (@decorator) Tj 0 0 0 rg  T* .4 .4 .4 rg (...) Tj 0 0 0 rg ( ) Tj /F3 10 Tf 0 .501961 0 rg (def) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 1 rg (trace) Tj 0 0 0 rg (\() Tj (f) Tj (,) Tj ( ) Tj .4 .4 .4 rg (*) Tj 0 0 0 rg (args) Tj (,) Tj ( ) Tj .4 .4 .4 rg (**) Tj 0 0 0 rg (kw) Tj (\):) Tj  T* .4 .4 .4 rg (...) Tj 0 0 0 rg (     ) Tj (kwstr) Tj ( ) Tj .4 .4 .4 rg (=) Tj 0 0 0 rg ( ) Tj .729412 .129412 .129412 rg (', ') Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (join) Tj (\() Tj .729412 .129412 .129412 rg (') Tj /F3 10 Tf .733333 .4 .533333 rg (%r) Tj /F4 10 Tf .729412 .129412 .129412 rg (: ) Tj /F3 10 Tf .733333 .4 .533333 rg (%r) Tj /F4 10 Tf .729412 .129412 .129412 rg (') Tj 0 0 0 rg ( ) Tj .4 .4 .4 rg (%) Tj 0 0 0 rg ( ) Tj (\() Tj (k) Tj (,) Tj ( ) Tj (kw) Tj ([) Tj (k) Tj (]\)) Tj ( ) Tj /F3 10 Tf 0 .501961 0 rg (for) Tj /F4 10 Tf 0 0 0 rg ( ) Tj (k) Tj ( ) Tj /F3 10 Tf .666667 .133333 1 rg (in) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 .501961 0 rg (sorted) Tj 0 0 0 rg (\() Tj (kw) Tj (\)\)) Tj  T* .4 .4 .4 rg (...) Tj 0 0 0 rg (     ) Tj /F3 10 Tf 0 .501961 0 rg (print) Tj /F4 10 Tf 0 0 0 rg (\() Tj .729412 .129412 .129412 rg ("calling ) Tj /F3 10 Tf .733333 .4 .533333 rg (%s) Tj /F4 10 Tf .729412 .129412 .129412 rg ( with args ) Tj /F3 10 Tf .733333 .4 .533333 rg (%s) Tj /F4 10 Tf .729412 .129412 .129412 rg (, {) Tj /F3 10 Tf .733333 .4 .533333 rg (%s) Tj /F4 10 Tf .729412 .129412 .129412 rg (}") Tj 0 0 0 rg ( ) Tj .4 .4 .4 rg (%) Tj 0 0 0 rg ( ) Tj (\() Tj (f) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (__name__) Tj (,) Tj ( ) Tj (args) Tj (,) Tj ( ) Tj (kwstr) Tj (\)\)) Tj  T* .4 .4 .4 rg (...) Tj 0 0 0 rg (     ) Tj /F3 10 Tf 0 .501961 0 rg (return) Tj /F4 10 Tf 0 0 0 rg ( ) Tj (f) Tj (\() Tj .4 .4 .4 rg (*) Tj 0 0 0 rg (args) Tj (,) Tj ( ) Tj .4 .4 .4 rg (**) Tj 0 0 0 rg (kw) Tj (\)) Tj T* ET
+.960784 .960784 .862745 rg
+n 0 48.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 6 48.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 12 48.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 24 48.75 60 12 re f*
+.960784 .960784 .862745 rg
+n 0 36.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 24 36.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 48 36.75 30 12 re f*
+.960784 .960784 .862745 rg
+n 78 36.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 84 36.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 90 36.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 102 36.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 108 36.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 132 36.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 144 36.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 156 36.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 168 36.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 0 24.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 48 24.75 30 12 re f*
+.960784 .960784 .862745 rg
+n 84 24.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 96 24.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 120 24.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 126 24.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 150 24.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 156 24.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 162 24.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 174 24.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 186 24.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 198 24.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 210 24.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 222 24.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 228 24.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 234 24.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 246 24.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 258 24.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 264 24.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 270 24.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 288 24.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 312 24.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 324 24.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 342 24.75 36 12 re f*
+.960784 .960784 .862745 rg
+n 378 24.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 384 24.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 396 24.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 0 12.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 48 12.75 30 12 re f*
+.960784 .960784 .862745 rg
+n 78 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 84 12.75 54 12 re f*
+.960784 .960784 .862745 rg
+n 138 12.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 150 12.75 66 12 re f*
+.960784 .960784 .862745 rg
+n 216 12.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 228 12.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 246 12.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 258 12.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 276 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 288 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 294 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 300 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 306 12.75 48 12 re f*
+.960784 .960784 .862745 rg
+n 354 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 366 12.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 390 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 402 12.75 30 12 re f*
+.960784 .960784 .862745 rg
+n 432 12.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 0 .75 18 12 re f*
+.960784 .960784 .862745 rg
+n 48 .75 36 12 re f*
+.960784 .960784 .862745 rg
+n 90 .75 6 12 re f*
+.960784 .960784 .862745 rg
+n 96 .75 6 12 re f*
+.960784 .960784 .862745 rg
+n 102 .75 6 12 re f*
+.960784 .960784 .862745 rg
+n 108 .75 24 12 re f*
+.960784 .960784 .862745 rg
+n 132 .75 6 12 re f*
+.960784 .960784 .862745 rg
+n 144 .75 12 12 re f*
+.960784 .960784 .862745 rg
+n 156 .75 12 12 re f*
+.960784 .960784 .862745 rg
+n 168 .75 6 12 re f*
+BT 1 0 0 1 0 50 Tm 12 TL /F4 10 Tf .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj .666667 .133333 1 rg (@decorator) Tj 0 0 0 rg  T* .4 .4 .4 rg (...) Tj 0 0 0 rg ( ) Tj /F3 10 Tf 0 .501961 0 rg (def) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 1 rg (trace) Tj 0 0 0 rg (\() Tj 0 0 0 rg (f) Tj 0 0 0 rg (,) Tj 0 0 0 rg ( ) Tj .4 .4 .4 rg (*) Tj 0 0 0 rg (args) Tj 0 0 0 rg (,) Tj 0 0 0 rg ( ) Tj .4 .4 .4 rg (**) Tj 0 0 0 rg (kw) Tj 0 0 0 rg (\):) Tj 0 0 0 rg  T* .4 .4 .4 rg (...) Tj 0 0 0 rg (     ) Tj 0 0 0 rg (kwstr) Tj 0 0 0 rg ( ) Tj .4 .4 .4 rg (=) Tj 0 0 0 rg ( ) Tj .729412 .129412 .129412 rg (', ') Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (join) Tj 0 0 0 rg (\() Tj .729412 .129412 .129412 rg (') Tj /F3 10 Tf .733333 .4 .533333 rg (%r) Tj /F4 10 Tf .729412 .129412 .129412 rg (: ) Tj /F3 10 Tf .733333 .4 .533333 rg (%r) Tj /F4 10 Tf .729412 .129412 .129412 rg (') Tj 0 0 0 rg ( ) Tj .4 .4 .4 rg (%) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (\() Tj 0 0 0 rg (k) Tj 0 0 0 rg (,) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (kw) Tj 0 0 0 rg ([) Tj 0 0 0 rg (k) Tj 0 0 0 rg (]\)) Tj 0 0 0 rg ( ) Tj /F3 10 Tf 0 .501961 0 rg (for) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 0 rg (k) Tj 0 0 0 rg ( ) Tj /F3 10 Tf .666667 .133333 1 rg (in) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 .501961 0 rg (sorted) Tj 0 0 0 rg (\() Tj 0 0 0 rg (kw) Tj 0 0 0 rg (\)\)) Tj 0 0 0 rg  T* .4 .4 .4 rg (...) Tj 0 0 0 rg (     ) Tj /F3 10 Tf 0 .501961 0 rg (print) Tj /F4 10 Tf 0 0 0 rg (\() Tj .729412 .129412 .129412 rg ("calling ) Tj /F3 10 Tf .733333 .4 .533333 rg (%s) Tj /F4 10 Tf .729412 .129412 .129412 rg ( with args ) Tj /F3 10 Tf .733333 .4 .533333 rg (%s) Tj /F4 10 Tf .729412 .129412 .129412 rg (, {) Tj /F3 10 Tf .733333 .4 .533333 rg (%s) Tj /F4 10 Tf .729412 .129412 .129412 rg (}") Tj 0 0 0 rg ( ) Tj .4 .4 .4 rg (%) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (\() Tj 0 0 0 rg (f) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (__name__) Tj 0 0 0 rg (,) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (args) Tj 0 0 0 rg (,) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (kwstr) Tj 0 0 0 rg (\)\)) Tj 0 0 0 rg  T* .4 .4 .4 rg (...) Tj 0 0 0 rg (     ) Tj /F3 10 Tf 0 .501961 0 rg (return) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 0 rg (f) Tj 0 0 0 rg (\() Tj .4 .4 .4 rg (*) Tj 0 0 0 rg (args) Tj 0 0 0 rg (,) Tj 0 0 0 rg ( ) Tj .4 .4 .4 rg (**) Tj 0 0 0 rg (kw) Tj 0 0 0 rg (\)) Tj T* ET
 Q
 Q
 Q
 Q
 Q
 q
-1 0 0 1 62.69291 528.8236 cm
+1 0 0 1 62.69291 492.8236 cm
 q
-BT 1 0 0 1 0 14 Tm 1.806654 Tw 12 TL /F1 10 Tf 0 0 0 rg (and now ) Tj /F4 10 Tf (trace ) Tj /F1 10 Tf (will be a decorator. Actually ) Tj /F4 10 Tf (trace ) Tj /F1 10 Tf (is a ) Tj /F4 10 Tf (partial ) Tj /F1 10 Tf (object which can be used as a) Tj T* 0 Tw (decorator:) Tj T* ET
+BT 1 0 0 1 0 14 Tm 1.806654 Tw 12 TL /F1 10 Tf 0 0 0 rg (and now ) Tj /F4 10 Tf 0 0 0 rg (trace ) Tj /F1 10 Tf 0 0 0 rg (will be a decorator. Actually ) Tj /F4 10 Tf 0 0 0 rg (trace ) Tj /F1 10 Tf 0 0 0 rg (is a ) Tj /F4 10 Tf 0 0 0 rg (partial ) Tj /F1 10 Tf 0 0 0 rg (object which can be used as a) Tj T* 0 Tw (decorator:) Tj T* ET
 Q
 Q
 q
-1 0 0 1 62.69291 483.6236 cm
+1 0 0 1 62.69291 447.6236 cm
 q
 q
 1 0 0 1 0 0 cm
@@ -2660,21 +2969,45 @@ q
 n -6 -6 468.6898 36 re B*
 Q
 q
-BT 1 0 0 1 0 14 Tm 12 TL /F4 10 Tf .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj (trace) Tj  T* .4 .4 .4 rg (<) Tj 0 0 0 rg (function) Tj ( ) Tj (trace) Tj ( ) Tj (at) Tj ( ) Tj .4 .4 .4 rg (0) Tj 0 0 0 rg (x) Tj .4 .4 .4 rg (...) Tj (>) Tj T* ET
+.960784 .960784 .862745 rg
+n 0 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 6 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 12 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 24 12.75 30 12 re f*
+.960784 .960784 .862745 rg
+n 0 .75 6 12 re f*
+.960784 .960784 .862745 rg
+n 6 .75 48 12 re f*
+.960784 .960784 .862745 rg
+n 60 .75 30 12 re f*
+.960784 .960784 .862745 rg
+n 96 .75 12 12 re f*
+.960784 .960784 .862745 rg
+n 114 .75 6 12 re f*
+.960784 .960784 .862745 rg
+n 120 .75 6 12 re f*
+.960784 .960784 .862745 rg
+n 126 .75 18 12 re f*
+.960784 .960784 .862745 rg
+n 144 .75 6 12 re f*
+BT 1 0 0 1 0 14 Tm 12 TL /F4 10 Tf .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (trace) Tj 0 0 0 rg  T* .4 .4 .4 rg (<) Tj 0 0 0 rg (function) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (trace) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (at) Tj 0 0 0 rg ( ) Tj .4 .4 .4 rg (0) Tj 0 0 0 rg (x) Tj .4 .4 .4 rg (...) Tj (>) Tj T* ET
 Q
 Q
 Q
 Q
 Q
 q
-1 0 0 1 62.69291 463.6236 cm
+1 0 0 1 62.69291 427.6236 cm
 q
 0 0 0 rg
 BT 1 0 0 1 0 2 Tm /F1 10 Tf 12 TL (Here is an example of usage:) Tj T* ET
 Q
 Q
 q
-1 0 0 1 62.69291 382.4236 cm
+1 0 0 1 62.69291 346.4236 cm
 q
 q
 1 0 0 1 0 0 cm
@@ -2687,32 +3020,72 @@ q
 n -6 -6 468.6898 72 re B*
 Q
 q
-BT 1 0 0 1 0 50 Tm 12 TL /F4 10 Tf .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj .666667 .133333 1 rg (@trace) Tj 0 0 0 rg  T* .4 .4 .4 rg (...) Tj 0 0 0 rg ( ) Tj /F3 10 Tf 0 .501961 0 rg (def) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 1 rg (func) Tj 0 0 0 rg (\(\):) Tj ( ) Tj /F3 10 Tf 0 .501961 0 rg (pass) Tj /F4 10 Tf 0 0 0 rg  T*  T* .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj (func) Tj (\(\)) Tj  T* (calling) Tj ( ) Tj (func) Tj ( ) Tj /F3 10 Tf 0 .501961 0 rg (with) Tj /F4 10 Tf 0 0 0 rg ( ) Tj (args) Tj ( ) Tj (\(\),) Tj ( ) Tj ({}) Tj T* ET
+.960784 .960784 .862745 rg
+n 0 48.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 6 48.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 12 48.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 24 48.75 36 12 re f*
+.960784 .960784 .862745 rg
+n 0 36.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 24 36.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 48 36.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 72 36.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 96 36.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 0 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 6 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 12 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 24 12.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 48 12.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 0 .75 42 12 re f*
+.960784 .960784 .862745 rg
+n 48 .75 24 12 re f*
+.960784 .960784 .862745 rg
+n 78 .75 24 12 re f*
+.960784 .960784 .862745 rg
+n 108 .75 24 12 re f*
+.960784 .960784 .862745 rg
+n 138 .75 18 12 re f*
+.960784 .960784 .862745 rg
+n 162 .75 12 12 re f*
+BT 1 0 0 1 0 50 Tm 12 TL /F4 10 Tf .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj .666667 .133333 1 rg (@trace) Tj 0 0 0 rg  T* .4 .4 .4 rg (...) Tj 0 0 0 rg ( ) Tj /F3 10 Tf 0 .501961 0 rg (def) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 1 rg (func) Tj 0 0 0 rg (\(\):) Tj 0 0 0 rg ( ) Tj /F3 10 Tf 0 .501961 0 rg (pass) Tj /F4 10 Tf 0 0 0 rg  T*  T* .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (func) Tj 0 0 0 rg (\(\)) Tj 0 0 0 rg  T* 0 0 0 rg (calling) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (func) Tj 0 0 0 rg ( ) Tj /F3 10 Tf 0 .501961 0 rg (with) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 0 rg (args) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (\(\),) Tj 0 0 0 rg ( ) Tj 0 0 0 rg ({}) Tj T* ET
 Q
 Q
 Q
 Q
 Q
 q
-1 0 0 1 62.69291 350.4236 cm
+1 0 0 1 62.69291 314.4236 cm
 q
-BT 1 0 0 1 0 14 Tm 2.44686 Tw 12 TL /F1 10 Tf 0 0 0 rg (If you are using an old Python version \(Python 2.4\) the ) Tj /F4 10 Tf (decorator ) Tj /F1 10 Tf (module provides a poor man) Tj T* 0 Tw (replacement for ) Tj /F4 10 Tf (functools.partial) Tj /F1 10 Tf (.) Tj T* ET
+BT 1 0 0 1 0 14 Tm 2.44686 Tw 12 TL /F1 10 Tf 0 0 0 rg (If you are using an old Python version \(Python 2.4\) the ) Tj /F4 10 Tf 0 0 0 rg (decorator ) Tj /F1 10 Tf 0 0 0 rg (module provides a poor man) Tj T* 0 Tw (replacement for ) Tj /F4 10 Tf 0 0 0 rg (functools.partial) Tj /F1 10 Tf 0 0 0 rg (.) Tj T* ET
 Q
 Q
 q
-1 0 0 1 62.69291 317.4236 cm
+1 0 0 1 62.69291 281.4236 cm
 q
 BT 1 0 0 1 0 3.5 Tm 21 TL /F3 17.5 Tf 0 0 0 rg (blocking) Tj T* ET
 Q
 Q
 q
-1 0 0 1 62.69291 275.4236 cm
+1 0 0 1 62.69291 239.4236 cm
 q
-BT 1 0 0 1 0 26 Tm 1.224692 Tw 12 TL /F1 10 Tf 0 0 0 rg (Sometimes one has to deal with blocking resources, such as ) Tj /F4 10 Tf (stdin) Tj /F1 10 Tf (, and sometimes it is best to have) Tj T* 0 Tw .266235 Tw (back a "busy" message than to block everything. This behavior can be implemented with a suitable family) Tj T* 0 Tw (of decorators, where the parameter is the busy message:) Tj T* ET
+BT 1 0 0 1 0 26 Tm 1.224692 Tw 12 TL /F1 10 Tf 0 0 0 rg (Sometimes one has to deal with blocking resources, such as ) Tj /F4 10 Tf 0 0 0 rg (stdin) Tj /F1 10 Tf 0 0 0 rg (, and sometimes it is best to have) Tj T* 0 Tw .266235 Tw (back a "busy" message than to block everything. This behavior can be implemented with a suitable family) Tj T* 0 Tw (of decorators, where the parameter is the busy message:) Tj T* ET
 Q
 Q
 q
-1 0 0 1 62.69291 98.22362 cm
+1 0 0 1 62.69291 86.22362 cm
 q
 q
 1 0 0 1 0 0 cm
@@ -2722,10 +3095,154 @@ q
 .662745 .662745 .662745 RG
 .5 w
 .960784 .960784 .862745 rg
-n -6 -6 468.6898 168 re B*
+n -6 -6 468.6898 144 re B*
 Q
 q
-BT 1 0 0 1 0 146 Tm 12 TL /F3 10 Tf 0 .501961 0 rg (def) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 1 rg (blocking) Tj 0 0 0 rg (\() Tj (not_avail) Tj (\):) Tj  T* (    ) Tj /F3 10 Tf 0 .501961 0 rg (def) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 1 rg (blocking) Tj 0 0 0 rg (\() Tj (f) Tj (,) Tj ( ) Tj .4 .4 .4 rg (*) Tj 0 0 0 rg (args) Tj (,) Tj ( ) Tj .4 .4 .4 rg (**) Tj 0 0 0 rg (kw) Tj (\):) Tj  T* (        ) Tj /F3 10 Tf 0 .501961 0 rg (if) Tj /F4 10 Tf 0 0 0 rg ( ) Tj /F3 10 Tf .666667 .133333 1 rg (not) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 .501961 0 rg (hasattr) Tj 0 0 0 rg (\() Tj (f) Tj (,) Tj ( ) Tj .729412 .129412 .129412 rg ("thread") Tj 0 0 0 rg (\):) Tj ( ) Tj /F6 10 Tf .25098 .501961 .501961 rg (# no thread running) Tj /F4 10 Tf 0 0 0 rg  T* (            ) Tj /F3 10 Tf 0 .501961 0 rg (def) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 1 rg (set_result) Tj 0 0 0 rg (\(\):) Tj ( ) Tj (f) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (result) Tj ( ) Tj .4 .4 .4 rg (=) Tj 0 0 0 rg ( ) Tj (f) Tj (\() Tj .4 .4 .4 rg (*) Tj 0 0 0 rg (args) Tj (,) Tj ( ) Tj .4 .4 .4 rg (**) Tj 0 0 0 rg (kw) Tj (\)) Tj  T* (            ) Tj (f) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (thread) Tj ( ) Tj .4 .4 .4 rg (=) Tj 0 0 0 rg ( ) Tj (threading) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (Thread) Tj (\() Tj 0 .501961 0 rg (None) Tj 0 0 0 rg (,) Tj ( ) Tj (set_result) Tj (\)) Tj  T* (            ) Tj (f) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (thread) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (start) Tj (\(\)) Tj  T* (            ) Tj /F3 10 Tf 0 .501961 0 rg (return) Tj /F4 10 Tf 0 0 0 rg ( ) Tj (not_avail) Tj  T* (        ) Tj /F3 10 Tf 0 .501961 0 rg (elif) Tj /F4 10 Tf 0 0 0 rg ( ) Tj (f) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (thread) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (isAlive) Tj (\(\):) Tj  T* (            ) Tj /F3 10 Tf 0 .501961 0 rg (return) Tj /F4 10 Tf 0 0 0 rg ( ) Tj (not_avail) Tj  T* (        ) Tj /F3 10 Tf 0 .501961 0 rg (else) Tj /F4 10 Tf 0 0 0 rg (:) Tj ( ) Tj /F6 10 Tf .25098 .501961 .501961 rg (# the thread is ended, return the stored result) Tj /F4 10 Tf 0 0 0 rg  T* (            ) Tj /F3 10 Tf 0 .501961 0 rg (del) Tj /F4 10 Tf 0 0 0 rg ( ) Tj (f) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (thread) Tj  T* (            ) Tj /F3 10 Tf 0 .501961 0 rg (return) Tj /F4 10 Tf 0 0 0 rg ( ) Tj (f) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (result) Tj  T* (    ) Tj /F3 10 Tf 0 .501961 0 rg (return) Tj /F4 10 Tf 0 0 0 rg ( ) Tj (decorator) Tj (\() Tj (blocking) Tj (\)) Tj T* ET
+.960784 .960784 .862745 rg
+n 0 120.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 24 120.75 48 12 re f*
+.960784 .960784 .862745 rg
+n 72 120.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 78 120.75 54 12 re f*
+.960784 .960784 .862745 rg
+n 132 120.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 24 108.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 48 108.75 48 12 re f*
+.960784 .960784 .862745 rg
+n 96 108.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 102 108.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 108 108.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 120 108.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 126 108.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 150 108.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 162 108.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 174 108.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 186 108.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 48 96.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 66 96.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 90 96.75 42 12 re f*
+.960784 .960784 .862745 rg
+n 132 96.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 138 96.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 144 96.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 156 96.75 48 12 re f*
+.960784 .960784 .862745 rg
+n 204 96.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 228 96.75 114 12 re f*
+.960784 .960784 .862745 rg
+n 72 84.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 96 84.75 60 12 re f*
+.960784 .960784 .862745 rg
+n 156 84.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 96 72.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 102 72.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 108 72.75 36 12 re f*
+.960784 .960784 .862745 rg
+n 150 72.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 162 72.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 168 72.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 174 72.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 180 72.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 204 72.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 216 72.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 228 72.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 240 72.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 72 60.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 78 60.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 84 60.75 36 12 re f*
+.960784 .960784 .862745 rg
+n 126 60.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 138 60.75 54 12 re f*
+.960784 .960784 .862745 rg
+n 192 60.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 198 60.75 36 12 re f*
+.960784 .960784 .862745 rg
+n 234 60.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 240 60.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 264 60.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 276 60.75 60 12 re f*
+.960784 .960784 .862745 rg
+n 336 60.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 72 48.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 78 48.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 84 48.75 36 12 re f*
+.960784 .960784 .862745 rg
+n 120 48.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 126 48.75 30 12 re f*
+.960784 .960784 .862745 rg
+n 156 48.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 72 36.75 36 12 re f*
+.960784 .960784 .862745 rg
+n 114 36.75 54 12 re f*
+.960784 .960784 .862745 rg
+n 48 24.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 78 24.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 84 24.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 90 24.75 36 12 re f*
+.960784 .960784 .862745 rg
+n 126 24.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 132 24.75 42 12 re f*
+.960784 .960784 .862745 rg
+n 174 24.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 72 12.75 36 12 re f*
+.960784 .960784 .862745 rg
+n 114 12.75 54 12 re f*
+.960784 .960784 .862745 rg
+n 48 .75 24 12 re f*
+.960784 .960784 .862745 rg
+n 72 .75 6 12 re f*
+.960784 .960784 .862745 rg
+n 90 .75 282 12 re f*
+BT 1 0 0 1 0 122 Tm 12 TL /F3 10 Tf 0 .501961 0 rg (def) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 1 rg (blocking) Tj 0 0 0 rg (\() Tj 0 0 0 rg (not_avail) Tj 0 0 0 rg (\):) Tj 0 0 0 rg  T* (    ) Tj /F3 10 Tf 0 .501961 0 rg (def) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 1 rg (blocking) Tj 0 0 0 rg (\() Tj 0 0 0 rg (f) Tj 0 0 0 rg (,) Tj 0 0 0 rg ( ) Tj .4 .4 .4 rg (*) Tj 0 0 0 rg (args) Tj 0 0 0 rg (,) Tj 0 0 0 rg ( ) Tj .4 .4 .4 rg (**) Tj 0 0 0 rg (kw) Tj 0 0 0 rg (\):) Tj 0 0 0 rg  T* (        ) Tj /F3 10 Tf 0 .501961 0 rg (if) Tj /F4 10 Tf 0 0 0 rg ( ) Tj /F3 10 Tf .666667 .133333 1 rg (not) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 .501961 0 rg (hasattr) Tj 0 0 0 rg (\() Tj 0 0 0 rg (f) Tj 0 0 0 rg (,) Tj 0 0 0 rg ( ) Tj .729412 .129412 .129412 rg ("thread") Tj 0 0 0 rg (\):) Tj 0 0 0 rg (  ) Tj /F6 10 Tf .25098 .501961 .501961 rg (# no thread running) Tj /F4 10 Tf 0 0 0 rg  T* (            ) Tj /F3 10 Tf 0 .501961 0 rg (def) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 1 rg (set_result) Tj 0 0 0 rg (\(\):) Tj 0 0 0 rg  T* (                ) Tj 0 0 0 rg (f) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (result) Tj 0 0 0 rg ( ) Tj .4 .4 .4 rg (=) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (f) Tj 0 0 0 rg (\() Tj .4 .4 .4 rg (*) Tj 0 0 0 rg (args) Tj 0 0 0 rg (,) Tj 0 0 0 rg ( ) Tj .4 .4 .4 rg (**) Tj 0 0 0 rg (kw) Tj 0 0 0 rg (\)) Tj 0 0 0 rg  T* (            ) Tj 0 0 0 rg (f) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (thread) Tj 0 0 0 rg ( ) Tj .4 .4 .4 rg (=) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (threading) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (Thread) Tj 0 0 0 rg (\() Tj 0 .501961 0 rg (None) Tj 0 0 0 rg (,) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (set_result) Tj 0 0 0 rg (\)) Tj 0 0 0 rg  T* (            ) Tj 0 0 0 rg (f) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (thread) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (start) Tj 0 0 0 rg (\(\)) Tj 0 0 0 rg  T* (            ) Tj /F3 10 Tf 0 .501961 0 rg (return) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 0 rg (not_avail) Tj 0 0 0 rg  T* (        ) Tj /F3 10 Tf 0 .501961 0 rg (elif) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 0 rg (f) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (thread) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (isAlive) Tj 0 0 0 rg (\(\):) Tj 0 0 0 rg  T* (            ) Tj /F3 10 Tf 0 .501961 0 rg (return) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 0 rg (not_avail) Tj 0 0 0 rg  T* (        ) Tj /F3 10 Tf 0 .501961 0 rg (else) Tj /F4 10 Tf 0 0 0 rg (:) Tj 0 0 0 rg (  ) Tj /F6 10 Tf .25098 .501961 .501961 rg (# the thread is ended, return the stored result) Tj /F4 10 Tf 0 0 0 rg  T* ET
 Q
 Q
 Q
@@ -2734,20 +3251,12 @@ Q
  
 endstream
 endobj
-% 'R95': class PDFStream 
-95 0 obj
-% page stream
-<< /Length 6669 >>
+99 0 obj
+<< /Length 13880 >>
 stream
 1 0 0 1 0 0 cm  BT /F1 12 Tf 14.4 TL ET
 q
-1 0 0 1 62.69291 741.0236 cm
-q
-BT 1 0 0 1 0 14 Tm 1.010651 Tw 12 TL /F1 10 Tf 0 0 0 rg (Functions decorated with ) Tj /F4 10 Tf (blocking ) Tj /F1 10 Tf (will return a busy message if the resource is unavailable, and the) Tj T* 0 Tw (intended result if the resource is available. For instance:) Tj T* ET
-Q
-Q
-q
-1 0 0 1 62.69291 491.8236 cm
+1 0 0 1 62.69291 715.8236 cm
 q
 q
 1 0 0 1 0 0 cm
@@ -2757,36 +3266,49 @@ q
 .662745 .662745 .662745 RG
 .5 w
 .960784 .960784 .862745 rg
-n -6 -6 468.6898 240 re B*
+n -6 -6 468.6898 48 re B*
 Q
 q
-BT 1 0 0 1 0 218 Tm 12 TL /F4 10 Tf .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj .666667 .133333 1 rg (@blocking) Tj 0 0 0 rg (\() Tj .729412 .129412 .129412 rg ("Please wait ...") Tj 0 0 0 rg (\)) Tj  T* .4 .4 .4 rg (...) Tj 0 0 0 rg ( ) Tj /F3 10 Tf 0 .501961 0 rg (def) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 1 rg (read_data) Tj 0 0 0 rg (\(\):) Tj  T* .4 .4 .4 rg (...) Tj 0 0 0 rg (     ) Tj (time) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (sleep) Tj (\() Tj .4 .4 .4 rg (3) Tj 0 0 0 rg (\)) Tj ( ) Tj /F6 10 Tf .25098 .501961 .501961 rg (# simulate a blocking resource) Tj /F4 10 Tf 0 0 0 rg  T* .4 .4 .4 rg (...) Tj 0 0 0 rg (     ) Tj /F3 10 Tf 0 .501961 0 rg (return) Tj /F4 10 Tf 0 0 0 rg ( ) Tj .729412 .129412 .129412 rg ("some data") Tj 0 0 0 rg  T*  T* .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj /F3 10 Tf 0 .501961 0 rg (print) Tj /F4 10 Tf 0 0 0 rg (\() Tj (read_data) Tj (\(\)\)) Tj ( ) Tj /F6 10 Tf .25098 .501961 .501961 rg (# data is not available yet) Tj /F4 10 Tf 0 0 0 rg  T* (Please) Tj ( ) Tj (wait) Tj ( ) Tj .4 .4 .4 rg (...) Tj 0 0 0 rg  T*  T* .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj (time) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (sleep) Tj (\() Tj .4 .4 .4 rg (1) Tj 0 0 0 rg (\)) Tj  T* .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj /F3 10 Tf 0 .501961 0 rg (print) Tj /F4 10 Tf 0 0 0 rg (\() Tj (read_data) Tj (\(\)\)) Tj ( ) Tj /F6 10 Tf .25098 .501961 .501961 rg (# data is not available yet) Tj /F4 10 Tf 0 0 0 rg  T* (Please) Tj ( ) Tj (wait) Tj ( ) Tj .4 .4 .4 rg (...) Tj 0 0 0 rg  T*  T* .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj (time) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (sleep) Tj (\() Tj .4 .4 .4 rg (1) Tj 0 0 0 rg (\)) Tj  T* .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj /F3 10 Tf 0 .501961 0 rg (print) Tj /F4 10 Tf 0 0 0 rg (\() Tj (read_data) Tj (\(\)\)) Tj ( ) Tj /F6 10 Tf .25098 .501961 .501961 rg (# data is not available yet) Tj /F4 10 Tf 0 0 0 rg  T* (Please) Tj ( ) Tj (wait) Tj ( ) Tj .4 .4 .4 rg (...) Tj 0 0 0 rg  T*  T* .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj (time) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (sleep) Tj (\() Tj .4 .4 .4 rg (1.1) Tj 0 0 0 rg (\)) Tj ( ) Tj /F6 10 Tf .25098 .501961 .501961 rg (# after 3.1 seconds, data is available) Tj /F4 10 Tf 0 0 0 rg  T* .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj /F3 10 Tf 0 .501961 0 rg (print) Tj /F4 10 Tf 0 0 0 rg (\() Tj (read_data) Tj (\(\)\)) Tj  T* (some) Tj ( ) Tj (data) Tj T* ET
-Q
-Q
-Q
-Q
+.960784 .960784 .862745 rg
+n 72 24.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 96 24.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 102 24.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 108 24.75 36 12 re f*
+.960784 .960784 .862745 rg
+n 72 12.75 36 12 re f*
+.960784 .960784 .862745 rg
+n 114 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 120 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 126 12.75 36 12 re f*
+.960784 .960784 .862745 rg
+n 24 .75 36 12 re f*
+.960784 .960784 .862745 rg
+n 66 .75 54 12 re f*
+.960784 .960784 .862745 rg
+n 120 .75 6 12 re f*
+.960784 .960784 .862745 rg
+n 126 .75 48 12 re f*
+.960784 .960784 .862745 rg
+n 174 .75 6 12 re f*
+BT 1 0 0 1 0 26 Tm 12 TL /F4 10 Tf 0 0 0 rg (            ) Tj /F3 10 Tf 0 .501961 0 rg (del) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 0 rg (f) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (thread) Tj 0 0 0 rg  T* (            ) Tj /F3 10 Tf 0 .501961 0 rg (return) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 0 rg (f) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (result) Tj 0 0 0 rg  T* (    ) Tj /F3 10 Tf 0 .501961 0 rg (return) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 0 rg (decorator) Tj 0 0 0 rg (\() Tj 0 0 0 rg (blocking) Tj 0 0 0 rg (\)) Tj T* ET
 Q
-q
-1 0 0 1 62.69291 458.8236 cm
-q
-BT 1 0 0 1 0 3.5 Tm 21 TL /F3 17.5 Tf 0 0 0 rg (async) Tj T* ET
 Q
 Q
-q
-1 0 0 1 62.69291 416.8236 cm
-q
-0 0 0 rg
-BT 1 0 0 1 0 26 Tm /F1 10 Tf 12 TL 1.647485 Tw (We have just seen an examples of a simple decorator factory, implemented as a function returning a) Tj T* 0 Tw .29784 Tw (decorator. For more complex situations, it is more convenient to implement decorator factories as classes) Tj T* 0 Tw (returning callable objects that can be converted into decorators.) Tj T* ET
 Q
 Q
 q
-1 0 0 1 62.69291 350.8236 cm
+1 0 0 1 62.69291 683.8236 cm
 q
-BT 1 0 0 1 0 50 Tm 2.853876 Tw 12 TL /F1 10 Tf 0 0 0 rg (As an example, here will I show a decorator which is able to convert a blocking function into an) Tj T* 0 Tw 2.477126 Tw (asynchronous function. The function, when called, is executed in a separate thread. Moreover, it is) Tj T* 0 Tw .288443 Tw (possible to set three callbacks ) Tj /F4 10 Tf (on_success) Tj /F1 10 Tf (, ) Tj /F4 10 Tf (on_failure ) Tj /F1 10 Tf (and ) Tj /F4 10 Tf (on_closing) Tj /F1 10 Tf (, to specify how to manage) Tj T* 0 Tw 1.854724 Tw (the function call \(of course the code here is just an example, it is not a recommended way of doing) Tj T* 0 Tw (multi-threaded programming\). The implementation is the following:) Tj T* ET
+BT 1 0 0 1 0 14 Tm 1.010651 Tw 12 TL /F1 10 Tf 0 0 0 rg (Functions decorated with ) Tj /F4 10 Tf 0 0 0 rg (blocking ) Tj /F1 10 Tf 0 0 0 rg (will return a busy message if the resource is unavailable, and the) Tj T* 0 Tw (intended result if the resource is available. For instance:) Tj T* ET
 Q
 Q
 q
-1 0 0 1 62.69291 293.6236 cm
+1 0 0 1 62.69291 434.6236 cm
 q
 q
 1 0 0 1 0 0 cm
@@ -2796,14 +3318,217 @@ q
 .662745 .662745 .662745 RG
 .5 w
 .960784 .960784 .862745 rg
-n -6 -6 468.6898 48 re B*
+n -6 -6 468.6898 240 re B*
+Q
+q
+.960784 .960784 .862745 rg
+n 0 216.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 6 216.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 12 216.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 24 216.75 54 12 re f*
+.960784 .960784 .862745 rg
+n 78 216.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 84 216.75 102 12 re f*
+.960784 .960784 .862745 rg
+n 186 216.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 0 204.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 24 204.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 48 204.75 54 12 re f*
+.960784 .960784 .862745 rg
+n 102 204.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 0 192.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 48 192.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 72 192.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 78 192.75 30 12 re f*
+.960784 .960784 .862745 rg
+n 108 192.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 114 192.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 120 192.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 132 192.75 180 12 re f*
+.960784 .960784 .862745 rg
+n 0 180.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 48 180.75 36 12 re f*
+.960784 .960784 .862745 rg
+n 90 180.75 66 12 re f*
+.960784 .960784 .862745 rg
+n 0 156.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 6 156.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 12 156.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 24 156.75 30 12 re f*
+.960784 .960784 .862745 rg
+n 54 156.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 60 156.75 54 12 re f*
+.960784 .960784 .862745 rg
+n 114 156.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 144 156.75 162 12 re f*
+.960784 .960784 .862745 rg
+n 0 144.75 36 12 re f*
+.960784 .960784 .862745 rg
+n 42 144.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 72 144.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 0 120.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 6 120.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 12 120.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 24 120.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 48 120.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 54 120.75 30 12 re f*
+.960784 .960784 .862745 rg
+n 84 120.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 90 120.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 96 120.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 0 108.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 6 108.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 12 108.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 24 108.75 30 12 re f*
+.960784 .960784 .862745 rg
+n 54 108.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 60 108.75 54 12 re f*
+.960784 .960784 .862745 rg
+n 114 108.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 144 108.75 162 12 re f*
+.960784 .960784 .862745 rg
+n 0 96.75 36 12 re f*
+.960784 .960784 .862745 rg
+n 42 96.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 72 96.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 0 72.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 6 72.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 12 72.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 24 72.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 48 72.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 54 72.75 30 12 re f*
+.960784 .960784 .862745 rg
+n 84 72.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 90 72.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 96 72.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 0 60.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 6 60.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 12 60.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 24 60.75 30 12 re f*
+.960784 .960784 .862745 rg
+n 54 60.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 60 60.75 54 12 re f*
+.960784 .960784 .862745 rg
+n 114 60.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 144 60.75 162 12 re f*
+.960784 .960784 .862745 rg
+n 0 48.75 36 12 re f*
+.960784 .960784 .862745 rg
+n 42 48.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 72 48.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 0 24.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 6 24.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 12 24.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 24 24.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 48 24.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 54 24.75 30 12 re f*
+.960784 .960784 .862745 rg
+n 84 24.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 90 24.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 108 24.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 126 24.75 228 12 re f*
+.960784 .960784 .862745 rg
+n 0 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 6 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 12 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 24 12.75 30 12 re f*
+.960784 .960784 .862745 rg
+n 54 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 60 12.75 54 12 re f*
+.960784 .960784 .862745 rg
+n 114 12.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 0 .75 24 12 re f*
+.960784 .960784 .862745 rg
+n 30 .75 24 12 re f*
+BT 1 0 0 1 0 218 Tm 12 TL /F4 10 Tf .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj .666667 .133333 1 rg (@blocking) Tj 0 0 0 rg (\() Tj .729412 .129412 .129412 rg ("Please wait ...") Tj 0 0 0 rg (\)) Tj 0 0 0 rg  T* .4 .4 .4 rg (...) Tj 0 0 0 rg ( ) Tj /F3 10 Tf 0 .501961 0 rg (def) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 1 rg (read_data) Tj 0 0 0 rg (\(\):) Tj 0 0 0 rg  T* .4 .4 .4 rg (...) Tj 0 0 0 rg (     ) Tj 0 0 0 rg (time) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (sleep) Tj 0 0 0 rg (\() Tj .4 .4 .4 rg (3) Tj 0 0 0 rg (\)) Tj 0 0 0 rg ( ) Tj /F6 10 Tf .25098 .501961 .501961 rg (# simulate a blocking resource) Tj /F4 10 Tf 0 0 0 rg  T* .4 .4 .4 rg (...) Tj 0 0 0 rg (     ) Tj /F3 10 Tf 0 .501961 0 rg (return) Tj /F4 10 Tf 0 0 0 rg ( ) Tj .729412 .129412 .129412 rg ("some data") Tj 0 0 0 rg  T*  T* .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj /F3 10 Tf 0 .501961 0 rg (print) Tj /F4 10 Tf 0 0 0 rg (\() Tj 0 0 0 rg (read_data) Tj 0 0 0 rg (\(\)\)) Tj 0 0 0 rg (  ) Tj /F6 10 Tf .25098 .501961 .501961 rg (# data is not available yet) Tj /F4 10 Tf 0 0 0 rg  T* 0 0 0 rg (Please) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (wait) Tj 0 0 0 rg ( ) Tj .4 .4 .4 rg (...) Tj 0 0 0 rg  T*  T* .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (time) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (sleep) Tj 0 0 0 rg (\() Tj .4 .4 .4 rg (1) Tj 0 0 0 rg (\)) Tj 0 0 0 rg  T* .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj /F3 10 Tf 0 .501961 0 rg (print) Tj /F4 10 Tf 0 0 0 rg (\() Tj 0 0 0 rg (read_data) Tj 0 0 0 rg (\(\)\)) Tj 0 0 0 rg (  ) Tj /F6 10 Tf .25098 .501961 .501961 rg (# data is not available yet) Tj /F4 10 Tf 0 0 0 rg  T* 0 0 0 rg (Please) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (wait) Tj 0 0 0 rg ( ) Tj .4 .4 .4 rg (...) Tj 0 0 0 rg  T*  T* .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (time) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (sleep) Tj 0 0 0 rg (\() Tj .4 .4 .4 rg (1) Tj 0 0 0 rg (\)) Tj 0 0 0 rg  T* .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj /F3 10 Tf 0 .501961 0 rg (print) Tj /F4 10 Tf 0 0 0 rg (\() Tj 0 0 0 rg (read_data) Tj 0 0 0 rg (\(\)\)) Tj 0 0 0 rg (  ) Tj /F6 10 Tf .25098 .501961 .501961 rg (# data is not available yet) Tj /F4 10 Tf 0 0 0 rg  T* 0 0 0 rg (Please) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (wait) Tj 0 0 0 rg ( ) Tj .4 .4 .4 rg (...) Tj 0 0 0 rg  T*  T* .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (time) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (sleep) Tj 0 0 0 rg (\() Tj .4 .4 .4 rg (1.1) Tj 0 0 0 rg (\)) Tj 0 0 0 rg (  ) Tj /F6 10 Tf .25098 .501961 .501961 rg (# after 3.1 seconds, data is available) Tj /F4 10 Tf 0 0 0 rg  T* .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj /F3 10 Tf 0 .501961 0 rg (print) Tj /F4 10 Tf 0 0 0 rg (\() Tj 0 0 0 rg (read_data) Tj 0 0 0 rg (\(\)\)) Tj 0 0 0 rg  T* 0 0 0 rg (some) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (data) Tj T* ET
+Q
+Q
+Q
+Q
 Q
 q
-BT 1 0 0 1 0 26 Tm 12 TL /F3 10 Tf 0 .501961 0 rg (def) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 1 rg (on_success) Tj 0 0 0 rg (\() Tj (result) Tj (\):) Tj ( ) Tj /F6 10 Tf .25098 .501961 .501961 rg (# default implementation) Tj /F4 10 Tf 0 0 0 rg  T* (    ) Tj .729412 .129412 .129412 rg ("Called on the result of the function") Tj 0 0 0 rg  T* (    ) Tj /F3 10 Tf 0 .501961 0 rg (return) Tj /F4 10 Tf 0 0 0 rg ( ) Tj (result) Tj T* ET
+1 0 0 1 62.69291 401.6236 cm
+q
+BT 1 0 0 1 0 3.5 Tm 21 TL /F3 17.5 Tf 0 0 0 rg (async) Tj T* ET
 Q
 Q
+q
+1 0 0 1 62.69291 359.6236 cm
+q
+0 0 0 rg
+BT 1 0 0 1 0 26 Tm /F1 10 Tf 12 TL 1.647485 Tw (We have just seen an examples of a simple decorator factory, implemented as a function returning a) Tj T* 0 Tw .29784 Tw (decorator. For more complex situations, it is more convenient to implement decorator factories as classes) Tj T* 0 Tw (returning callable objects that can be converted into decorators.) Tj T* ET
 Q
 Q
+q
+1 0 0 1 62.69291 293.6236 cm
+q
+BT 1 0 0 1 0 50 Tm 2.853876 Tw 12 TL /F1 10 Tf 0 0 0 rg (As an example, here will I show a decorator which is able to convert a blocking function into an) Tj T* 0 Tw 2.477126 Tw (asynchronous function. The function, when called, is executed in a separate thread. Moreover, it is) Tj T* 0 Tw .288443 Tw (possible to set three callbacks ) Tj /F4 10 Tf 0 0 0 rg (on_success) Tj /F1 10 Tf 0 0 0 rg (, ) Tj /F4 10 Tf 0 0 0 rg (on_failure ) Tj /F1 10 Tf 0 0 0 rg (and ) Tj /F4 10 Tf 0 0 0 rg (on_closing) Tj /F1 10 Tf 0 0 0 rg (, to specify how to manage) Tj T* 0 Tw 1.854724 Tw (the function call \(of course the code here is just an example, it is not a recommended way of doing) Tj T* 0 Tw (multi-threaded programming\). The implementation is the following:) Tj T* ET
+Q
 Q
 q
 1 0 0 1 62.69291 236.4236 cm
@@ -2819,7 +3544,25 @@ q
 n -6 -6 468.6898 48 re B*
 Q
 q
-BT 1 0 0 1 0 26 Tm 12 TL /F3 10 Tf 0 .501961 0 rg (def) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 1 rg (on_failure) Tj 0 0 0 rg (\() Tj (exc_info) Tj (\):) Tj ( ) Tj /F6 10 Tf .25098 .501961 .501961 rg (# default implementation) Tj /F4 10 Tf 0 0 0 rg  T* (    ) Tj .729412 .129412 .129412 rg ("Called if the function fails") Tj 0 0 0 rg  T* (    ) Tj /F3 10 Tf 0 .501961 0 rg (pass) Tj T* ET
+.960784 .960784 .862745 rg
+n 0 24.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 24 24.75 60 12 re f*
+.960784 .960784 .862745 rg
+n 84 24.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 90 24.75 36 12 re f*
+.960784 .960784 .862745 rg
+n 126 24.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 150 24.75 144 12 re f*
+.960784 .960784 .862745 rg
+n 24 12.75 228 12 re f*
+.960784 .960784 .862745 rg
+n 24 .75 36 12 re f*
+.960784 .960784 .862745 rg
+n 66 .75 36 12 re f*
+BT 1 0 0 1 0 26 Tm 12 TL /F3 10 Tf 0 .501961 0 rg (def) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 1 rg (on_success) Tj 0 0 0 rg (\() Tj 0 0 0 rg (result) Tj 0 0 0 rg (\):) Tj 0 0 0 rg (  ) Tj /F6 10 Tf .25098 .501961 .501961 rg (# default implementation) Tj /F4 10 Tf 0 0 0 rg  T* (    ) Tj .729412 .129412 .129412 rg ("Called on the result of the function") Tj 0 0 0 rg  T* (    ) Tj /F3 10 Tf 0 .501961 0 rg (return) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 0 rg (result) Tj T* ET
 Q
 Q
 Q
@@ -2839,14 +3582,30 @@ q
 n -6 -6 468.6898 48 re B*
 Q
 q
-BT 1 0 0 1 0 26 Tm 12 TL /F3 10 Tf 0 .501961 0 rg (def) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 1 rg (on_closing) Tj 0 0 0 rg (\(\):) Tj ( ) Tj /F6 10 Tf .25098 .501961 .501961 rg (# default implementation) Tj /F4 10 Tf 0 0 0 rg  T* (    ) Tj .729412 .129412 .129412 rg ("Called at the end, both in case of success and failure") Tj 0 0 0 rg  T* (    ) Tj /F3 10 Tf 0 .501961 0 rg (pass) Tj T* ET
+.960784 .960784 .862745 rg
+n 0 24.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 24 24.75 60 12 re f*
+.960784 .960784 .862745 rg
+n 84 24.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 90 24.75 48 12 re f*
+.960784 .960784 .862745 rg
+n 138 24.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 162 24.75 144 12 re f*
+.960784 .960784 .862745 rg
+n 24 12.75 180 12 re f*
+.960784 .960784 .862745 rg
+n 24 .75 24 12 re f*
+BT 1 0 0 1 0 26 Tm 12 TL /F3 10 Tf 0 .501961 0 rg (def) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 1 rg (on_failure) Tj 0 0 0 rg (\() Tj 0 0 0 rg (exc_info) Tj 0 0 0 rg (\):) Tj 0 0 0 rg (  ) Tj /F6 10 Tf .25098 .501961 .501961 rg (# default implementation) Tj /F4 10 Tf 0 0 0 rg  T* (    ) Tj .729412 .129412 .129412 rg ("Called if the function fails") Tj 0 0 0 rg  T* (    ) Tj /F3 10 Tf 0 .501961 0 rg (pass) Tj T* ET
 Q
 Q
 Q
 Q
 Q
 q
-1 0 0 1 62.69291 86.02362 cm
+1 0 0 1 62.69291 122.0236 cm
 q
 q
 1 0 0 1 0 0 cm
@@ -2856,10 +3615,22 @@ q
 .662745 .662745 .662745 RG
 .5 w
 .960784 .960784 .862745 rg
-n -6 -6 468.6898 84 re B*
+n -6 -6 468.6898 48 re B*
 Q
 q
-BT 1 0 0 1 0 62 Tm 12 TL /F3 10 Tf 0 .501961 0 rg (class) Tj /F4 10 Tf 0 0 0 rg ( ) Tj /F3 10 Tf 0 0 1 rg (Async) Tj /F4 10 Tf 0 0 0 rg (\() Tj 0 .501961 0 rg (object) Tj 0 0 0 rg (\):) Tj  T* (    ) Tj /F6 10 Tf .729412 .129412 .129412 rg (""") Tj T* (    A decorator converting blocking functions into asynchronous) Tj T* (    functions, by using threads or processes. Examples:) Tj T*  T* (    async_with_threads =  Async\(threading.Thread\)) Tj T* ET
+.960784 .960784 .862745 rg
+n 0 24.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 24 24.75 60 12 re f*
+.960784 .960784 .862745 rg
+n 84 24.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 114 24.75 144 12 re f*
+.960784 .960784 .862745 rg
+n 24 12.75 336 12 re f*
+.960784 .960784 .862745 rg
+n 24 .75 24 12 re f*
+BT 1 0 0 1 0 26 Tm 12 TL /F3 10 Tf 0 .501961 0 rg (def) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 1 rg (on_closing) Tj 0 0 0 rg (\(\):) Tj 0 0 0 rg (  ) Tj /F6 10 Tf .25098 .501961 .501961 rg (# default implementation) Tj /F4 10 Tf 0 0 0 rg  T* (    ) Tj .729412 .129412 .129412 rg ("Called at the end, both in case of success and failure") Tj 0 0 0 rg  T* (    ) Tj /F3 10 Tf 0 .501961 0 rg (pass) Tj T* ET
 Q
 Q
 Q
@@ -2868,14 +3639,12 @@ Q
  
 endstream
 endobj
-% 'R96': class PDFStream 
-96 0 obj
-% page stream
-<< /Length 8071 >>
+100 0 obj
+<< /Length 19866 >>
 stream
 1 0 0 1 0 0 cm  BT /F1 12 Tf 14.4 TL ET
 q
-1 0 0 1 62.69291 415.8236 cm
+1 0 0 1 62.69291 331.8236 cm
 q
 q
 1 0 0 1 0 0 cm
@@ -2885,30 +3654,354 @@ q
 .662745 .662745 .662745 RG
 .5 w
 .960784 .960784 .862745 rg
-n -6 -6 468.6898 348 re B*
+n -6 -6 468.6898 432 re B*
 Q
 q
-BT 1 0 0 1 0 326 Tm 12 TL /F6 10 Tf .729412 .129412 .129412 rg (    async_with_processes =  Async\(multiprocessing.Process\)) Tj T* (    """) Tj /F4 10 Tf 0 0 0 rg  T*  T* (    ) Tj /F3 10 Tf 0 .501961 0 rg (def) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 1 rg (__init__) Tj 0 0 0 rg (\() Tj 0 .501961 0 rg (self) Tj 0 0 0 rg (,) Tj ( ) Tj (threadfactory) Tj (,) Tj ( ) Tj (on_success) Tj .4 .4 .4 rg (=) Tj 0 0 0 rg (on_success) Tj (,) Tj  T* (                 ) Tj (on_failure) Tj .4 .4 .4 rg (=) Tj 0 0 0 rg (on_failure) Tj (,) Tj ( ) Tj (on_closing) Tj .4 .4 .4 rg (=) Tj 0 0 0 rg (on_closing) Tj (\):) Tj  T* (        ) Tj 0 .501961 0 rg (self) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (threadfactory) Tj ( ) Tj .4 .4 .4 rg (=) Tj 0 0 0 rg ( ) Tj (threadfactory) Tj  T* (        ) Tj 0 .501961 0 rg (self) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (on_success) Tj ( ) Tj .4 .4 .4 rg (=) Tj 0 0 0 rg ( ) Tj (on_success) Tj  T* (        ) Tj 0 .501961 0 rg (self) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (on_failure) Tj ( ) Tj .4 .4 .4 rg (=) Tj 0 0 0 rg ( ) Tj (on_failure) Tj  T* (        ) Tj 0 .501961 0 rg (self) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (on_closing) Tj ( ) Tj .4 .4 .4 rg (=) Tj 0 0 0 rg ( ) Tj (on_closing) Tj  T*  T* (    ) Tj /F3 10 Tf 0 .501961 0 rg (def) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 1 rg (__call__) Tj 0 0 0 rg (\() Tj 0 .501961 0 rg (self) Tj 0 0 0 rg (,) Tj ( ) Tj (func) Tj (,) Tj ( ) Tj .4 .4 .4 rg (*) Tj 0 0 0 rg (args) Tj (,) Tj ( ) Tj .4 .4 .4 rg (**) Tj 0 0 0 rg (kw) Tj (\):) Tj  T* (        ) Tj /F3 10 Tf 0 .501961 0 rg (try) Tj /F4 10 Tf 0 0 0 rg (:) Tj  T* (            ) Tj (counter) Tj ( ) Tj .4 .4 .4 rg (=) Tj 0 0 0 rg ( ) Tj (func) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (counter) Tj  T* (        ) Tj /F3 10 Tf 0 .501961 0 rg (except) Tj /F4 10 Tf 0 0 0 rg ( ) Tj /F3 10 Tf .823529 .254902 .227451 rg (AttributeError) Tj /F4 10 Tf 0 0 0 rg (:) Tj ( ) Tj /F6 10 Tf .25098 .501961 .501961 rg (# instantiate the counter at the first call) Tj /F4 10 Tf 0 0 0 rg  T* (            ) Tj (counter) Tj ( ) Tj .4 .4 .4 rg (=) Tj 0 0 0 rg ( ) Tj (func) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (counter) Tj ( ) Tj .4 .4 .4 rg (=) Tj 0 0 0 rg ( ) Tj (itertools) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (count) Tj (\() Tj .4 .4 .4 rg (1) Tj 0 0 0 rg (\)) Tj  T* (        ) Tj (name) Tj ( ) Tj .4 .4 .4 rg (=) Tj 0 0 0 rg ( ) Tj .729412 .129412 .129412 rg (') Tj /F3 10 Tf .733333 .4 .533333 rg (%s) Tj /F4 10 Tf .729412 .129412 .129412 rg (-) Tj /F3 10 Tf .733333 .4 .533333 rg (%s) Tj /F4 10 Tf .729412 .129412 .129412 rg (') Tj 0 0 0 rg ( ) Tj .4 .4 .4 rg (%) Tj 0 0 0 rg ( ) Tj (\() Tj (func) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (__name__) Tj (,) Tj ( ) Tj 0 .501961 0 rg (next) Tj 0 0 0 rg (\() Tj (counter) Tj (\)\)) Tj  T* (        ) Tj /F3 10 Tf 0 .501961 0 rg (def) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 1 rg (func_wrapper) Tj 0 0 0 rg (\(\):) Tj  T* (            ) Tj /F3 10 Tf 0 .501961 0 rg (try) Tj /F4 10 Tf 0 0 0 rg (:) Tj  T* (                ) Tj (result) Tj ( ) Tj .4 .4 .4 rg (=) Tj 0 0 0 rg ( ) Tj (func) Tj (\() Tj .4 .4 .4 rg (*) Tj 0 0 0 rg (args) Tj (,) Tj ( ) Tj .4 .4 .4 rg (**) Tj 0 0 0 rg (kw) Tj (\)) Tj  T* (            ) Tj /F3 10 Tf 0 .501961 0 rg (except) Tj /F4 10 Tf 0 0 0 rg (:) Tj  T* (                ) Tj 0 .501961 0 rg (self) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (on_failure) Tj (\() Tj (sys) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (exc_info) Tj (\(\)\)) Tj  T* (            ) Tj /F3 10 Tf 0 .501961 0 rg (else) Tj /F4 10 Tf 0 0 0 rg (:) Tj  T* (                ) Tj /F3 10 Tf 0 .501961 0 rg (return) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 .501961 0 rg (self) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (on_success) Tj (\() Tj (result) Tj (\)) Tj  T* (            ) Tj /F3 10 Tf 0 .501961 0 rg (finally) Tj /F4 10 Tf 0 0 0 rg (:) Tj  T* (                ) Tj 0 .501961 0 rg (self) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (on_closing) Tj (\(\)) Tj  T* (        ) Tj (thread) Tj ( ) Tj .4 .4 .4 rg (=) Tj 0 0 0 rg ( ) Tj 0 .501961 0 rg (self) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (threadfactory) Tj (\() Tj 0 .501961 0 rg (None) Tj 0 0 0 rg (,) Tj ( ) Tj (func_wrapper) Tj (,) Tj ( ) Tj (name) Tj (\)) Tj  T* (        ) Tj (thread) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (start) Tj (\(\)) Tj  T* (        ) Tj /F3 10 Tf 0 .501961 0 rg (return) Tj /F4 10 Tf 0 0 0 rg ( ) Tj (thread) Tj T* ET
+.960784 .960784 .862745 rg
+n 0 408.75 30 12 re f*
+.960784 .960784 .862745 rg
+n 36 408.75 30 12 re f*
+.960784 .960784 .862745 rg
+n 66 408.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 72 408.75 36 12 re f*
+.960784 .960784 .862745 rg
+n 108 408.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 24 396.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 0 384.75 378 12 re f*
+.960784 .960784 .862745 rg
+n 0 372.75 330 12 re f*
+.960784 .960784 .862745 rg
+n 0 360.75 0 12 re f*
+.960784 .960784 .862745 rg
+n 0 348.75 294 12 re f*
+.960784 .960784 .862745 rg
+n 0 336.75 348 12 re f*
+.960784 .960784 .862745 rg
+n 0 324.75 42 12 re f*
+.960784 .960784 .862745 rg
+n 24 300.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 48 300.75 48 12 re f*
+.960784 .960784 .862745 rg
+n 96 300.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 102 300.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 126 300.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 138 300.75 78 12 re f*
+.960784 .960784 .862745 rg
+n 216 300.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 228 300.75 60 12 re f*
+.960784 .960784 .862745 rg
+n 288 300.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 294 300.75 60 12 re f*
+.960784 .960784 .862745 rg
+n 354 300.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 102 288.75 60 12 re f*
+.960784 .960784 .862745 rg
+n 162 288.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 168 288.75 60 12 re f*
+.960784 .960784 .862745 rg
+n 228 288.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 240 288.75 60 12 re f*
+.960784 .960784 .862745 rg
+n 300 288.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 306 288.75 60 12 re f*
+.960784 .960784 .862745 rg
+n 366 288.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 48 276.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 72 276.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 78 276.75 78 12 re f*
+.960784 .960784 .862745 rg
+n 162 276.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 174 276.75 78 12 re f*
+.960784 .960784 .862745 rg
+n 48 264.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 72 264.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 78 264.75 60 12 re f*
+.960784 .960784 .862745 rg
+n 144 264.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 156 264.75 60 12 re f*
+.960784 .960784 .862745 rg
+n 48 252.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 72 252.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 78 252.75 60 12 re f*
+.960784 .960784 .862745 rg
+n 144 252.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 156 252.75 60 12 re f*
+.960784 .960784 .862745 rg
+n 48 240.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 72 240.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 78 240.75 60 12 re f*
+.960784 .960784 .862745 rg
+n 144 240.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 156 240.75 60 12 re f*
+.960784 .960784 .862745 rg
+n 24 216.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 48 216.75 48 12 re f*
+.960784 .960784 .862745 rg
+n 96 216.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 102 216.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 126 216.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 138 216.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 162 216.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 174 216.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 180 216.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 204 216.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 216 216.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 228 216.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 240 216.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 48 204.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 66 204.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 72 192.75 42 12 re f*
+.960784 .960784 .862745 rg
+n 120 192.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 132 192.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 156 192.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 162 192.75 42 12 re f*
+.960784 .960784 .862745 rg
+n 48 180.75 36 12 re f*
+.960784 .960784 .862745 rg
+n 90 180.75 84 12 re f*
+.960784 .960784 .862745 rg
+n 174 180.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 192 180.75 258 12 re f*
+.960784 .960784 .862745 rg
+n 72 168.75 42 12 re f*
+.960784 .960784 .862745 rg
+n 120 168.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 132 168.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 156 168.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 162 168.75 42 12 re f*
+.960784 .960784 .862745 rg
+n 210 168.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 222 168.75 54 12 re f*
+.960784 .960784 .862745 rg
+n 276 168.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 282 168.75 30 12 re f*
+.960784 .960784 .862745 rg
+n 312 168.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 318 168.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 324 168.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 48 156.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 78 156.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 90 156.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 96 156.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 108 156.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 114 156.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 126 156.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 138 156.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 150 156.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 156 156.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 180 156.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 186 156.75 48 12 re f*
+.960784 .960784 .862745 rg
+n 234 156.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 246 156.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 270 156.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 276 156.75 42 12 re f*
+.960784 .960784 .862745 rg
+n 318 156.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 48 132.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 72 132.75 72 12 re f*
+.960784 .960784 .862745 rg
+n 144 132.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 72 120.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 90 120.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 96 108.75 36 12 re f*
+.960784 .960784 .862745 rg
+n 138 108.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 150 108.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 174 108.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 180 108.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 186 108.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 210 108.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 222 108.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 234 108.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 246 108.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 72 96.75 36 12 re f*
+.960784 .960784 .862745 rg
+n 108 96.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 96 84.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 120 84.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 126 84.75 60 12 re f*
+.960784 .960784 .862745 rg
+n 186 84.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 192 84.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 210 84.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 216 84.75 48 12 re f*
+.960784 .960784 .862745 rg
+n 264 84.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 72 72.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 96 72.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 96 60.75 36 12 re f*
+.960784 .960784 .862745 rg
+n 138 60.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 162 60.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 168 60.75 60 12 re f*
+.960784 .960784 .862745 rg
+n 228 60.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 234 60.75 36 12 re f*
+.960784 .960784 .862745 rg
+n 270 60.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 72 48.75 42 12 re f*
+.960784 .960784 .862745 rg
+n 114 48.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 96 36.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 120 36.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 126 36.75 60 12 re f*
+.960784 .960784 .862745 rg
+n 186 36.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 48 24.75 36 12 re f*
+.960784 .960784 .862745 rg
+n 90 24.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 102 24.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 126 24.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 132 24.75 78 12 re f*
+.960784 .960784 .862745 rg
+n 210 24.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 216 24.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 240 24.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 252 24.75 72 12 re f*
+.960784 .960784 .862745 rg
+n 324 24.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 336 24.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 360 24.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 48 12.75 36 12 re f*
+.960784 .960784 .862745 rg
+n 84 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 90 12.75 30 12 re f*
+.960784 .960784 .862745 rg
+n 120 12.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 48 .75 36 12 re f*
+.960784 .960784 .862745 rg
+n 90 .75 36 12 re f*
+BT 1 0 0 1 0 410 Tm 12 TL /F3 10 Tf 0 .501961 0 rg (class) Tj /F4 10 Tf 0 0 0 rg ( ) Tj /F3 10 Tf 0 0 1 rg (Async) Tj /F4 10 Tf 0 0 0 rg (\() Tj 0 .501961 0 rg (object) Tj 0 0 0 rg (\):) Tj 0 0 0 rg  T* (    ) Tj /F6 10 Tf .729412 .129412 .129412 rg (""") Tj T* (    A decorator converting blocking functions into asynchronous) Tj T* (    functions, by using threads or processes. Examples:) Tj T*  T* (    async_with_threads =  Async\(threading.Thread\)) Tj T* (    async_with_processes =  Async\(multiprocessing.Process\)) Tj T* (    """) Tj /F4 10 Tf 0 0 0 rg  T*  T* (    ) Tj /F3 10 Tf 0 .501961 0 rg (def) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 1 rg (__init__) Tj 0 0 0 rg (\() Tj 0 .501961 0 rg (self) Tj 0 0 0 rg (,) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (threadfactory) Tj 0 0 0 rg (,) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (on_success) Tj .4 .4 .4 rg (=) Tj 0 0 0 rg (on_success) Tj 0 0 0 rg (,) Tj 0 0 0 rg  T* (                 ) Tj 0 0 0 rg (on_failure) Tj .4 .4 .4 rg (=) Tj 0 0 0 rg (on_failure) Tj 0 0 0 rg (,) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (on_closing) Tj .4 .4 .4 rg (=) Tj 0 0 0 rg (on_closing) Tj 0 0 0 rg (\):) Tj 0 0 0 rg  T* (        ) Tj 0 .501961 0 rg (self) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (threadfactory) Tj 0 0 0 rg ( ) Tj .4 .4 .4 rg (=) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (threadfactory) Tj 0 0 0 rg  T* (        ) Tj 0 .501961 0 rg (self) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (on_success) Tj 0 0 0 rg ( ) Tj .4 .4 .4 rg (=) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (on_success) Tj 0 0 0 rg  T* (        ) Tj 0 .501961 0 rg (self) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (on_failure) Tj 0 0 0 rg ( ) Tj .4 .4 .4 rg (=) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (on_failure) Tj 0 0 0 rg  T* (        ) Tj 0 .501961 0 rg (self) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (on_closing) Tj 0 0 0 rg ( ) Tj .4 .4 .4 rg (=) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (on_closing) Tj 0 0 0 rg  T*  T* (    ) Tj /F3 10 Tf 0 .501961 0 rg (def) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 1 rg (__call__) Tj 0 0 0 rg (\() Tj 0 .501961 0 rg (self) Tj 0 0 0 rg (,) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (func) Tj 0 0 0 rg (,) Tj 0 0 0 rg ( ) Tj .4 .4 .4 rg (*) Tj 0 0 0 rg (args) Tj 0 0 0 rg (,) Tj 0 0 0 rg ( ) Tj .4 .4 .4 rg (**) Tj 0 0 0 rg (kw) Tj 0 0 0 rg (\):) Tj 0 0 0 rg  T* (        ) Tj /F3 10 Tf 0 .501961 0 rg (try) Tj /F4 10 Tf 0 0 0 rg (:) Tj 0 0 0 rg  T* (            ) Tj 0 0 0 rg (counter) Tj 0 0 0 rg ( ) Tj .4 .4 .4 rg (=) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (func) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (counter) Tj 0 0 0 rg  T* (        ) Tj /F3 10 Tf 0 .501961 0 rg (except) Tj /F4 10 Tf 0 0 0 rg ( ) Tj /F3 10 Tf .823529 .254902 .227451 rg (AttributeError) Tj /F4 10 Tf 0 0 0 rg (:) Tj 0 0 0 rg (  ) Tj /F6 10 Tf .25098 .501961 .501961 rg (# instantiate the counter at the first call) Tj /F4 10 Tf 0 0 0 rg  T* (            ) Tj 0 0 0 rg (counter) Tj 0 0 0 rg ( ) Tj .4 .4 .4 rg (=) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (func) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (counter) Tj 0 0 0 rg ( ) Tj .4 .4 .4 rg (=) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (itertools) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (count) Tj 0 0 0 rg (\() Tj .4 .4 .4 rg (1) Tj 0 0 0 rg (\)) Tj 0 0 0 rg  T* (        ) Tj 0 0 0 rg (name) Tj 0 0 0 rg ( ) Tj .4 .4 .4 rg (=) Tj 0 0 0 rg ( ) Tj .729412 .129412 .129412 rg (') Tj /F3 10 Tf .733333 .4 .533333 rg (%s) Tj /F4 10 Tf .729412 .129412 .129412 rg (-) Tj /F3 10 Tf .733333 .4 .533333 rg (%s) Tj /F4 10 Tf .729412 .129412 .129412 rg (') Tj 0 0 0 rg ( ) Tj .4 .4 .4 rg (%) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (\() Tj 0 0 0 rg (func) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (__name__) Tj 0 0 0 rg (,) Tj 0 0 0 rg ( ) Tj 0 .501961 0 rg (next) Tj 0 0 0 rg (\() Tj 0 0 0 rg (counter) Tj 0 0 0 rg (\)\)) Tj 0 0 0 rg  T*  T* (        ) Tj /F3 10 Tf 0 .501961 0 rg (def) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 1 rg (func_wrapper) Tj 0 0 0 rg (\(\):) Tj 0 0 0 rg  T* (            ) Tj /F3 10 Tf 0 .501961 0 rg (try) Tj /F4 10 Tf 0 0 0 rg (:) Tj 0 0 0 rg  T* (                ) Tj 0 0 0 rg (result) Tj 0 0 0 rg ( ) Tj .4 .4 .4 rg (=) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (func) Tj 0 0 0 rg (\() Tj .4 .4 .4 rg (*) Tj 0 0 0 rg (args) Tj 0 0 0 rg (,) Tj 0 0 0 rg ( ) Tj .4 .4 .4 rg (**) Tj 0 0 0 rg (kw) Tj 0 0 0 rg (\)) Tj 0 0 0 rg  T* (            ) Tj /F3 10 Tf 0 .501961 0 rg (except) Tj /F4 10 Tf 0 0 0 rg (:) Tj 0 0 0 rg  T* (                ) Tj 0 .501961 0 rg (self) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (on_failure) Tj 0 0 0 rg (\() Tj 0 0 0 rg (sys) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (exc_info) Tj 0 0 0 rg (\(\)\)) Tj 0 0 0 rg  T* (            ) Tj /F3 10 Tf 0 .501961 0 rg (else) Tj /F4 10 Tf 0 0 0 rg (:) Tj 0 0 0 rg  T* (                ) Tj /F3 10 Tf 0 .501961 0 rg (return) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 .501961 0 rg (self) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (on_success) Tj 0 0 0 rg (\() Tj 0 0 0 rg (result) Tj 0 0 0 rg (\)) Tj 0 0 0 rg  T* (            ) Tj /F3 10 Tf 0 .501961 0 rg (finally) Tj /F4 10 Tf 0 0 0 rg (:) Tj 0 0 0 rg  T* (                ) Tj 0 .501961 0 rg (self) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (on_closing) Tj 0 0 0 rg (\(\)) Tj 0 0 0 rg  T* (        ) Tj 0 0 0 rg (thread) Tj 0 0 0 rg ( ) Tj .4 .4 .4 rg (=) Tj 0 0 0 rg ( ) Tj 0 .501961 0 rg (self) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (threadfactory) Tj 0 0 0 rg (\() Tj 0 .501961 0 rg (None) Tj 0 0 0 rg (,) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (func_wrapper) Tj 0 0 0 rg (,) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (name) Tj 0 0 0 rg (\)) Tj 0 0 0 rg  T* (        ) Tj 0 0 0 rg (thread) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (start) Tj 0 0 0 rg (\(\)) Tj 0 0 0 rg  T* (        ) Tj /F3 10 Tf 0 .501961 0 rg (return) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 0 rg (thread) Tj T* ET
 Q
 Q
 Q
 Q
 Q
 q
-1 0 0 1 62.69291 383.8236 cm
+1 0 0 1 62.69291 299.8236 cm
 q
-BT 1 0 0 1 0 14 Tm .865984 Tw 12 TL /F1 10 Tf 0 0 0 rg (The decorated function returns the current execution thread, which can be stored and checked later, for) Tj T* 0 Tw (instance to verify that the thread ) Tj /F4 10 Tf (.isAlive\(\)) Tj /F1 10 Tf (.) Tj T* ET
+BT 1 0 0 1 0 14 Tm .865984 Tw 12 TL /F1 10 Tf 0 0 0 rg (The decorated function returns the current execution thread, which can be stored and checked later, for) Tj T* 0 Tw (instance to verify that the thread ) Tj /F4 10 Tf 0 0 0 rg (.isAlive\(\)) Tj /F1 10 Tf 0 0 0 rg (.) Tj T* ET
 Q
 Q
 q
-1 0 0 1 62.69291 341.8236 cm
+1 0 0 1 62.69291 257.8236 cm
 q
 0 0 0 rg
 BT 1 0 0 1 0 26 Tm /F1 10 Tf 12 TL .691654 Tw (Here is an example of usage. Suppose one wants to write some data to an external resource which can) Tj T* 0 Tw .21683 Tw (be accessed by a single user at once \(for instance a printer\). Then the access to the writing function must) Tj T* 0 Tw (be locked. Here is a minimalistic example:) Tj T* ET
 Q
 Q
 q
-1 0 0 1 62.69291 188.6236 cm
+1 0 0 1 62.69291 104.6236 cm
 q
 q
 1 0 0 1 0 0 cm
@@ -2921,33 +4014,117 @@ q
 n -6 -6 468.6898 144 re B*
 Q
 q
-BT 1 0 0 1 0 122 Tm 12 TL /F4 10 Tf .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj (async) Tj ( ) Tj .4 .4 .4 rg (=) Tj 0 0 0 rg ( ) Tj (decorator) Tj (\() Tj (Async) Tj (\() Tj (threading) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (Thread) Tj (\)\)) Tj  T*  T* .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj (datalist) Tj ( ) Tj .4 .4 .4 rg (=) Tj 0 0 0 rg ( ) Tj ([]) Tj ( ) Tj /F6 10 Tf .25098 .501961 .501961 rg (# for simplicity the written data are stored into a list.) Tj /F4 10 Tf 0 0 0 rg  T*  T* .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj .666667 .133333 1 rg (@async) Tj 0 0 0 rg  T* .4 .4 .4 rg (...) Tj 0 0 0 rg ( ) Tj /F3 10 Tf 0 .501961 0 rg (def) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 1 rg (write) Tj 0 0 0 rg (\() Tj (data) Tj (\):) Tj  T* .4 .4 .4 rg (...) Tj 0 0 0 rg (     ) Tj /F6 10 Tf .25098 .501961 .501961 rg (# append data to the datalist by locking) Tj /F4 10 Tf 0 0 0 rg  T* .4 .4 .4 rg (...) Tj 0 0 0 rg (     ) Tj /F3 10 Tf 0 .501961 0 rg (with) Tj /F4 10 Tf 0 0 0 rg ( ) Tj (threading) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (Lock) Tj (\(\):) Tj  T* .4 .4 .4 rg (...) Tj 0 0 0 rg (         ) Tj (time) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (sleep) Tj (\() Tj .4 .4 .4 rg (1) Tj 0 0 0 rg (\)) Tj ( ) Tj /F6 10 Tf .25098 .501961 .501961 rg (# emulate some long running operation) Tj /F4 10 Tf 0 0 0 rg  T* .4 .4 .4 rg (...) Tj 0 0 0 rg (         ) Tj (datalist) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (append) Tj (\() Tj (data) Tj (\)) Tj  T* .4 .4 .4 rg (...) Tj 0 0 0 rg (     ) Tj /F6 10 Tf .25098 .501961 .501961 rg (# other operations not requiring a lock here) Tj T* ET
-Q
-Q
-Q
-Q
-Q
-q
-1 0 0 1 62.69291 156.6236 cm
-q
-BT 1 0 0 1 0 14 Tm .905868 Tw 12 TL /F1 10 Tf 0 0 0 rg (Each call to ) Tj /F4 10 Tf (write ) Tj /F1 10 Tf (will create a new writer thread, but there will be no synchronization problems since) Tj T* 0 Tw /F4 10 Tf (write ) Tj /F1 10 Tf (is locked.) Tj T* ET
-Q
-Q
-q
-1 0 0 1 62.69291 87.42362 cm
-q
-q
-1 0 0 1 0 0 cm
-q
-1 0 0 1 6.6 6.6 cm
-q
-.662745 .662745 .662745 RG
-.5 w
 .960784 .960784 .862745 rg
-n -6 -6 468.6898 60 re B*
-Q
-q
-BT 1 0 0 1 0 38 Tm 12 TL /F4 10 Tf .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj (write) Tj (\() Tj .729412 .129412 .129412 rg ("data1") Tj 0 0 0 rg (\)) Tj  T* .4 .4 .4 rg (<) Tj 0 0 0 rg (Thread) Tj (\() Tj (write) Tj .4 .4 .4 rg (-) Tj (1) Tj 0 0 0 rg (,) Tj ( ) Tj (started) Tj .4 .4 .4 rg (...) Tj 0 0 0 rg (\)) Tj .4 .4 .4 rg (>) Tj 0 0 0 rg  T*  T* .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj (time) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (sleep) Tj (\() Tj .4 .4 .4 rg (.) Tj (1) Tj 0 0 0 rg (\)) Tj ( ) Tj /F6 10 Tf .25098 .501961 .501961 rg (# wait a bit, so we are sure data2 is written after data1) Tj /F4 10 Tf 0 0 0 rg  T* ET
+n 0 120.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 6 120.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 12 120.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 24 120.75 30 12 re f*
+.960784 .960784 .862745 rg
+n 60 120.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 72 120.75 54 12 re f*
+.960784 .960784 .862745 rg
+n 126 120.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 132 120.75 30 12 re f*
+.960784 .960784 .862745 rg
+n 162 120.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 168 120.75 54 12 re f*
+.960784 .960784 .862745 rg
+n 222 120.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 228 120.75 36 12 re f*
+.960784 .960784 .862745 rg
+n 264 120.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 0 96.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 6 96.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 12 96.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 24 96.75 48 12 re f*
+.960784 .960784 .862745 rg
+n 78 96.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 90 96.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 108 96.75 342 12 re f*
+.960784 .960784 .862745 rg
+n 0 72.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 6 72.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 12 72.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 24 72.75 36 12 re f*
+.960784 .960784 .862745 rg
+n 0 60.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 24 60.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 48 60.75 30 12 re f*
+.960784 .960784 .862745 rg
+n 78 60.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 84 60.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 108 60.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 0 48.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 48 48.75 240 12 re f*
+.960784 .960784 .862745 rg
+n 0 36.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 48 36.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 78 36.75 54 12 re f*
+.960784 .960784 .862745 rg
+n 132 36.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 138 36.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 162 36.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 0 24.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 72 24.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 96 24.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 102 24.75 30 12 re f*
+.960784 .960784 .862745 rg
+n 132 24.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 138 24.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 144 24.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 156 24.75 222 12 re f*
+.960784 .960784 .862745 rg
+n 0 12.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 72 12.75 48 12 re f*
+.960784 .960784 .862745 rg
+n 120 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 126 12.75 36 12 re f*
+.960784 .960784 .862745 rg
+n 162 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 168 12.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 192 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 0 .75 18 12 re f*
+.960784 .960784 .862745 rg
+n 48 .75 264 12 re f*
+BT 1 0 0 1 0 122 Tm 12 TL /F4 10 Tf .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (async) Tj 0 0 0 rg ( ) Tj .4 .4 .4 rg (=) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (decorator) Tj 0 0 0 rg (\() Tj 0 0 0 rg (Async) Tj 0 0 0 rg (\() Tj 0 0 0 rg (threading) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (Thread) Tj 0 0 0 rg (\)\)) Tj 0 0 0 rg  T*  T* .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (datalist) Tj 0 0 0 rg ( ) Tj .4 .4 .4 rg (=) Tj 0 0 0 rg ( ) Tj 0 0 0 rg ([]) Tj 0 0 0 rg ( ) Tj /F6 10 Tf .25098 .501961 .501961 rg (# for simplicity the written data are stored into a list.) Tj /F4 10 Tf 0 0 0 rg  T*  T* .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj .666667 .133333 1 rg (@async) Tj 0 0 0 rg  T* .4 .4 .4 rg (...) Tj 0 0 0 rg ( ) Tj /F3 10 Tf 0 .501961 0 rg (def) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 1 rg (write) Tj 0 0 0 rg (\() Tj 0 0 0 rg (data) Tj 0 0 0 rg (\):) Tj 0 0 0 rg  T* .4 .4 .4 rg (...) Tj 0 0 0 rg (     ) Tj /F6 10 Tf .25098 .501961 .501961 rg (# append data to the datalist by locking) Tj /F4 10 Tf 0 0 0 rg  T* .4 .4 .4 rg (...) Tj 0 0 0 rg (     ) Tj /F3 10 Tf 0 .501961 0 rg (with) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 0 rg (threading) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (Lock) Tj 0 0 0 rg (\(\):) Tj 0 0 0 rg  T* .4 .4 .4 rg (...) Tj 0 0 0 rg (         ) Tj 0 0 0 rg (time) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (sleep) Tj 0 0 0 rg (\() Tj .4 .4 .4 rg (1) Tj 0 0 0 rg (\)) Tj 0 0 0 rg ( ) Tj /F6 10 Tf .25098 .501961 .501961 rg (# emulate some long running operation) Tj /F4 10 Tf 0 0 0 rg  T* .4 .4 .4 rg (...) Tj 0 0 0 rg (         ) Tj 0 0 0 rg (datalist) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (append) Tj 0 0 0 rg (\() Tj 0 0 0 rg (data) Tj 0 0 0 rg (\)) Tj 0 0 0 rg  T* .4 .4 .4 rg (...) Tj 0 0 0 rg (     ) Tj /F6 10 Tf .25098 .501961 .501961 rg (# other operations not requiring a lock here) Tj T* ET
 Q
 Q
 Q
@@ -2956,14 +4133,18 @@ Q
  
 endstream
 endobj
-% 'R97': class PDFStream 
-97 0 obj
-% page stream
-<< /Length 6932 >>
+101 0 obj
+<< /Length 16154 >>
 stream
 1 0 0 1 0 0 cm  BT /F1 12 Tf 14.4 TL ET
 q
-1 0 0 1 62.69291 655.8236 cm
+1 0 0 1 62.69291 741.0236 cm
+q
+BT 1 0 0 1 0 14 Tm .905868 Tw 12 TL /F1 10 Tf 0 0 0 rg (Each call to ) Tj /F4 10 Tf 0 0 0 rg (write ) Tj /F1 10 Tf 0 0 0 rg (will create a new writer thread, but there will be no synchronization problems since) Tj T* 0 Tw /F4 10 Tf 0 0 0 rg (write ) Tj /F1 10 Tf 0 0 0 rg (is locked.) Tj T* ET
+Q
+Q
+q
+1 0 0 1 62.69291 575.8236 cm
 q
 q
 1 0 0 1 0 0 cm
@@ -2973,29 +4154,167 @@ q
 .662745 .662745 .662745 RG
 .5 w
 .960784 .960784 .862745 rg
-n -6 -6 468.6898 108 re B*
+n -6 -6 468.6898 156 re B*
 Q
 q
-BT 1 0 0 1 0 86 Tm 12 TL /F4 10 Tf 0 0 0 rg  T* .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj (write) Tj (\() Tj .729412 .129412 .129412 rg ("data2") Tj 0 0 0 rg (\)) Tj  T* .4 .4 .4 rg (<) Tj 0 0 0 rg (Thread) Tj (\() Tj (write) Tj .4 .4 .4 rg (-) Tj (2) Tj 0 0 0 rg (,) Tj ( ) Tj (started) Tj .4 .4 .4 rg (...) Tj 0 0 0 rg (\)) Tj .4 .4 .4 rg (>) Tj 0 0 0 rg  T*  T* .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj (time) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (sleep) Tj (\() Tj .4 .4 .4 rg (2) Tj 0 0 0 rg (\)) Tj ( ) Tj /F6 10 Tf .25098 .501961 .501961 rg (# wait for the writers to complete) Tj /F4 10 Tf 0 0 0 rg  T*  T* .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj /F3 10 Tf 0 .501961 0 rg (print) Tj /F4 10 Tf 0 0 0 rg (\() Tj (datalist) Tj (\)) Tj  T* ([) Tj .729412 .129412 .129412 rg ('data1') Tj 0 0 0 rg (,) Tj ( ) Tj .729412 .129412 .129412 rg ('data2') Tj 0 0 0 rg (]) Tj T* ET
+.960784 .960784 .862745 rg
+n 0 132.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 6 132.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 12 132.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 24 132.75 30 12 re f*
+.960784 .960784 .862745 rg
+n 54 132.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 60 132.75 42 12 re f*
+.960784 .960784 .862745 rg
+n 102 132.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 0 120.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 6 120.75 36 12 re f*
+.960784 .960784 .862745 rg
+n 42 120.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 48 120.75 30 12 re f*
+.960784 .960784 .862745 rg
+n 78 120.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 84 120.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 90 120.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 102 120.75 42 12 re f*
+.960784 .960784 .862745 rg
+n 144 120.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 162 120.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 168 120.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 0 96.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 6 96.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 12 96.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 24 96.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 48 96.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 54 96.75 30 12 re f*
+.960784 .960784 .862745 rg
+n 84 96.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 90 96.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 96 96.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 102 96.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 114 96.75 342 12 re f*
+.960784 .960784 .862745 rg
+n 0 72.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 6 72.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 12 72.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 24 72.75 30 12 re f*
+.960784 .960784 .862745 rg
+n 54 72.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 60 72.75 42 12 re f*
+.960784 .960784 .862745 rg
+n 102 72.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 0 60.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 6 60.75 36 12 re f*
+.960784 .960784 .862745 rg
+n 42 60.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 48 60.75 30 12 re f*
+.960784 .960784 .862745 rg
+n 78 60.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 84 60.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 90 60.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 102 60.75 42 12 re f*
+.960784 .960784 .862745 rg
+n 144 60.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 162 60.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 168 60.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 0 36.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 6 36.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 12 36.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 24 36.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 48 36.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 54 36.75 30 12 re f*
+.960784 .960784 .862745 rg
+n 84 36.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 90 36.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 96 36.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 108 36.75 204 12 re f*
+.960784 .960784 .862745 rg
+n 0 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 6 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 12 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 24 12.75 30 12 re f*
+.960784 .960784 .862745 rg
+n 54 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 60 12.75 48 12 re f*
+.960784 .960784 .862745 rg
+n 108 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 0 .75 6 12 re f*
+.960784 .960784 .862745 rg
+n 6 .75 42 12 re f*
+.960784 .960784 .862745 rg
+n 48 .75 6 12 re f*
+.960784 .960784 .862745 rg
+n 60 .75 42 12 re f*
+.960784 .960784 .862745 rg
+n 102 .75 6 12 re f*
+BT 1 0 0 1 0 134 Tm 12 TL /F4 10 Tf .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (write) Tj 0 0 0 rg (\() Tj .729412 .129412 .129412 rg ("data1") Tj 0 0 0 rg (\)) Tj 0 0 0 rg  T* .4 .4 .4 rg (<) Tj 0 0 0 rg (Thread) Tj 0 0 0 rg (\() Tj 0 0 0 rg (write) Tj .4 .4 .4 rg (-) Tj .4 .4 .4 rg (1) Tj 0 0 0 rg (,) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (started) Tj .4 .4 .4 rg (...) Tj 0 0 0 rg (\)) Tj .4 .4 .4 rg (>) Tj 0 0 0 rg  T*  T* .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (time) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (sleep) Tj 0 0 0 rg (\() Tj .4 .4 .4 rg (.) Tj .4 .4 .4 rg (1) Tj 0 0 0 rg (\)) Tj 0 0 0 rg ( ) Tj /F6 10 Tf .25098 .501961 .501961 rg (# wait a bit, so we are sure data2 is written after data1) Tj /F4 10 Tf 0 0 0 rg  T*  T* .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (write) Tj 0 0 0 rg (\() Tj .729412 .129412 .129412 rg ("data2") Tj 0 0 0 rg (\)) Tj 0 0 0 rg  T* .4 .4 .4 rg (<) Tj 0 0 0 rg (Thread) Tj 0 0 0 rg (\() Tj 0 0 0 rg (write) Tj .4 .4 .4 rg (-) Tj .4 .4 .4 rg (2) Tj 0 0 0 rg (,) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (started) Tj .4 .4 .4 rg (...) Tj 0 0 0 rg (\)) Tj .4 .4 .4 rg (>) Tj 0 0 0 rg  T*  T* .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (time) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (sleep) Tj 0 0 0 rg (\() Tj .4 .4 .4 rg (2) Tj 0 0 0 rg (\)) Tj 0 0 0 rg ( ) Tj /F6 10 Tf .25098 .501961 .501961 rg (# wait for the writers to complete) Tj /F4 10 Tf 0 0 0 rg  T*  T* .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj /F3 10 Tf 0 .501961 0 rg (print) Tj /F4 10 Tf 0 0 0 rg (\() Tj 0 0 0 rg (datalist) Tj 0 0 0 rg (\)) Tj 0 0 0 rg  T* 0 0 0 rg ([) Tj .729412 .129412 .129412 rg ('data1') Tj 0 0 0 rg (,) Tj 0 0 0 rg ( ) Tj .729412 .129412 .129412 rg ('data2') Tj 0 0 0 rg (]) Tj T* ET
 Q
 Q
 Q
 Q
 Q
 q
-1 0 0 1 62.69291 622.8236 cm
+1 0 0 1 62.69291 542.8236 cm
 q
 BT 1 0 0 1 0 3.5 Tm 21 TL /F2 17.5 Tf 0 0 0 rg (contextmanager) Tj T* ET
 Q
 Q
 q
-1 0 0 1 62.69291 592.8236 cm
+1 0 0 1 62.69291 512.8236 cm
 q
-BT 1 0 0 1 0 14 Tm 2.685984 Tw 12 TL /F1 10 Tf 0 0 0 rg (For a long time Python had in its standard library a ) Tj /F4 10 Tf (contextmanager ) Tj /F1 10 Tf (decorator, able to convert) Tj T* 0 Tw (generator functions into ) Tj /F4 10 Tf (_GeneratorContextManager ) Tj /F1 10 Tf (factories. For instance if you write) Tj T* ET
+BT 1 0 0 1 0 14 Tm 2.685984 Tw 12 TL /F1 10 Tf 0 0 0 rg (For a long time Python had in its standard library a ) Tj /F4 10 Tf 0 0 0 rg (contextmanager ) Tj /F1 10 Tf 0 0 0 rg (decorator, able to convert) Tj T* 0 Tw (generator functions into ) Tj /F4 10 Tf 0 0 0 rg (_GeneratorContextManager ) Tj /F1 10 Tf 0 0 0 rg (factories. For instance if you write) Tj T* ET
 Q
 Q
 q
-1 0 0 1 62.69291 499.6236 cm
+1 0 0 1 62.69291 419.6236 cm
 q
 q
 1 0 0 1 0 0 cm
@@ -3008,20 +4327,82 @@ q
 n -6 -6 468.6898 84 re B*
 Q
 q
-BT 1 0 0 1 0 62 Tm 12 TL /F4 10 Tf .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj /F3 10 Tf 0 .501961 0 rg (from) Tj /F4 10 Tf 0 0 0 rg ( ) Tj /F3 10 Tf 0 0 1 rg (contextlib) Tj /F4 10 Tf 0 0 0 rg ( ) Tj /F3 10 Tf 0 .501961 0 rg (import) Tj /F4 10 Tf 0 0 0 rg ( ) Tj (contextmanager) Tj  T* .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj .666667 .133333 1 rg (@contextmanager) Tj 0 0 0 rg  T* .4 .4 .4 rg (...) Tj 0 0 0 rg ( ) Tj /F3 10 Tf 0 .501961 0 rg (def) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 1 rg (before_after) Tj 0 0 0 rg (\() Tj (before) Tj (,) Tj ( ) Tj (after) Tj (\):) Tj  T* .4 .4 .4 rg (...) Tj 0 0 0 rg (     ) Tj /F3 10 Tf 0 .501961 0 rg (print) Tj /F4 10 Tf 0 0 0 rg (\() Tj (before) Tj (\)) Tj  T* .4 .4 .4 rg (...) Tj 0 0 0 rg (     ) Tj /F3 10 Tf 0 .501961 0 rg (yield) Tj /F4 10 Tf 0 0 0 rg  T* .4 .4 .4 rg (...) Tj 0 0 0 rg (     ) Tj /F3 10 Tf 0 .501961 0 rg (print) Tj /F4 10 Tf 0 0 0 rg (\() Tj (after) Tj (\)) Tj T* ET
+.960784 .960784 .862745 rg
+n 0 60.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 6 60.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 12 60.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 24 60.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 54 60.75 60 12 re f*
+.960784 .960784 .862745 rg
+n 120 60.75 36 12 re f*
+.960784 .960784 .862745 rg
+n 162 60.75 84 12 re f*
+.960784 .960784 .862745 rg
+n 0 48.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 6 48.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 12 48.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 24 48.75 90 12 re f*
+.960784 .960784 .862745 rg
+n 0 36.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 24 36.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 48 36.75 72 12 re f*
+.960784 .960784 .862745 rg
+n 120 36.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 126 36.75 36 12 re f*
+.960784 .960784 .862745 rg
+n 162 36.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 174 36.75 30 12 re f*
+.960784 .960784 .862745 rg
+n 204 36.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 0 24.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 48 24.75 30 12 re f*
+.960784 .960784 .862745 rg
+n 78 24.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 84 24.75 36 12 re f*
+.960784 .960784 .862745 rg
+n 120 24.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 0 12.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 48 12.75 30 12 re f*
+.960784 .960784 .862745 rg
+n 0 .75 18 12 re f*
+.960784 .960784 .862745 rg
+n 48 .75 30 12 re f*
+.960784 .960784 .862745 rg
+n 78 .75 6 12 re f*
+.960784 .960784 .862745 rg
+n 84 .75 30 12 re f*
+.960784 .960784 .862745 rg
+n 114 .75 6 12 re f*
+BT 1 0 0 1 0 62 Tm 12 TL /F4 10 Tf .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj /F3 10 Tf 0 .501961 0 rg (from) Tj /F4 10 Tf 0 0 0 rg ( ) Tj /F3 10 Tf 0 0 1 rg (contextlib) Tj /F4 10 Tf 0 0 0 rg ( ) Tj /F3 10 Tf 0 .501961 0 rg (import) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 0 rg (contextmanager) Tj 0 0 0 rg  T* .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj .666667 .133333 1 rg (@contextmanager) Tj 0 0 0 rg  T* .4 .4 .4 rg (...) Tj 0 0 0 rg ( ) Tj /F3 10 Tf 0 .501961 0 rg (def) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 1 rg (before_after) Tj 0 0 0 rg (\() Tj 0 0 0 rg (before) Tj 0 0 0 rg (,) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (after) Tj 0 0 0 rg (\):) Tj 0 0 0 rg  T* .4 .4 .4 rg (...) Tj 0 0 0 rg (     ) Tj /F3 10 Tf 0 .501961 0 rg (print) Tj /F4 10 Tf 0 0 0 rg (\() Tj 0 0 0 rg (before) Tj 0 0 0 rg (\)) Tj 0 0 0 rg  T* .4 .4 .4 rg (...) Tj 0 0 0 rg (     ) Tj /F3 10 Tf 0 .501961 0 rg (yield) Tj /F4 10 Tf 0 0 0 rg  T* .4 .4 .4 rg (...) Tj 0 0 0 rg (     ) Tj /F3 10 Tf 0 .501961 0 rg (print) Tj /F4 10 Tf 0 0 0 rg (\() Tj 0 0 0 rg (after) Tj 0 0 0 rg (\)) Tj T* ET
 Q
 Q
 Q
 Q
 Q
 q
-1 0 0 1 62.69291 467.6236 cm
+1 0 0 1 62.69291 387.6236 cm
 q
-BT 1 0 0 1 0 14 Tm .955976 Tw 12 TL /F1 10 Tf 0 0 0 rg (then ) Tj /F4 10 Tf (before_after ) Tj /F1 10 Tf (is a factory function returning ) Tj /F4 10 Tf (_GeneratorContextManager ) Tj /F1 10 Tf (objects which can) Tj T* 0 Tw (be used with the ) Tj /F4 10 Tf (with ) Tj /F1 10 Tf (statement:) Tj T* ET
+BT 1 0 0 1 0 14 Tm .955976 Tw 12 TL /F1 10 Tf 0 0 0 rg (then ) Tj /F4 10 Tf 0 0 0 rg (before_after ) Tj /F1 10 Tf 0 0 0 rg (is a factory function returning ) Tj /F4 10 Tf 0 0 0 rg (_GeneratorContextManager ) Tj /F1 10 Tf 0 0 0 rg (objects which can) Tj T* 0 Tw (be used with the ) Tj /F4 10 Tf 0 0 0 rg (with ) Tj /F1 10 Tf 0 0 0 rg (statement:) Tj T* ET
 Q
 Q
 q
-1 0 0 1 62.69291 350.4236 cm
+1 0 0 1 62.69291 270.4236 cm
 q
 q
 1 0 0 1 0 0 cm
@@ -3034,20 +4415,100 @@ q
 n -6 -6 468.6898 108 re B*
 Q
 q
-BT 1 0 0 1 0 86 Tm 12 TL /F4 10 Tf .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj (ba) Tj ( ) Tj .4 .4 .4 rg (=) Tj 0 0 0 rg ( ) Tj (before_after) Tj (\() Tj .729412 .129412 .129412 rg ('BEFORE') Tj 0 0 0 rg (,) Tj ( ) Tj .729412 .129412 .129412 rg ('AFTER') Tj 0 0 0 rg (\)) Tj  T* .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj 0 .501961 0 rg (type) Tj 0 0 0 rg (\() Tj (ba) Tj (\)) Tj  T* .4 .4 .4 rg (<) Tj /F3 10 Tf 0 .501961 0 rg (class) Tj /F4 10 Tf 0 0 0 rg ( ) Tj (') Tj /F3 10 Tf 0 0 1 rg (contextlib) Tj /F4 10 Tf .4 .4 .4 rg (.) Tj 0 0 0 rg (_GeneratorContextManager) Tj .729412 .129412 .129412 rg (') Tj (>) Tj 0 0 0 rg  T* .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj /F3 10 Tf 0 .501961 0 rg (with) Tj /F4 10 Tf 0 0 0 rg ( ) Tj (ba) Tj (:) Tj  T* .4 .4 .4 rg (...) Tj 0 0 0 rg (     ) Tj /F3 10 Tf 0 .501961 0 rg (print) Tj /F4 10 Tf 0 0 0 rg (\() Tj .729412 .129412 .129412 rg ('hello') Tj 0 0 0 rg (\)) Tj  T* (BEFORE) Tj  T* (hello) Tj  T* (AFTER) Tj T* ET
+.960784 .960784 .862745 rg
+n 0 84.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 6 84.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 12 84.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 24 84.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 42 84.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 54 84.75 72 12 re f*
+.960784 .960784 .862745 rg
+n 126 84.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 132 84.75 48 12 re f*
+.960784 .960784 .862745 rg
+n 180 84.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 192 84.75 42 12 re f*
+.960784 .960784 .862745 rg
+n 234 84.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 0 72.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 6 72.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 12 72.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 24 72.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 48 72.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 54 72.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 66 72.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 0 60.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 6 60.75 30 12 re f*
+.960784 .960784 .862745 rg
+n 42 60.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 48 60.75 60 12 re f*
+.960784 .960784 .862745 rg
+n 108 60.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 114 60.75 144 12 re f*
+.960784 .960784 .862745 rg
+n 258 60.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 264 60.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 0 48.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 6 48.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 12 48.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 24 48.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 54 48.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 66 48.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 0 36.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 48 36.75 30 12 re f*
+.960784 .960784 .862745 rg
+n 78 36.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 84 36.75 42 12 re f*
+.960784 .960784 .862745 rg
+n 126 36.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 0 24.75 36 12 re f*
+.960784 .960784 .862745 rg
+n 0 12.75 30 12 re f*
+.960784 .960784 .862745 rg
+n 0 .75 30 12 re f*
+BT 1 0 0 1 0 86 Tm 12 TL /F4 10 Tf .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (ba) Tj 0 0 0 rg ( ) Tj .4 .4 .4 rg (=) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (before_after) Tj 0 0 0 rg (\() Tj .729412 .129412 .129412 rg ('BEFORE') Tj 0 0 0 rg (,) Tj 0 0 0 rg ( ) Tj .729412 .129412 .129412 rg ('AFTER') Tj 0 0 0 rg (\)) Tj 0 0 0 rg  T* .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj 0 .501961 0 rg (type) Tj 0 0 0 rg (\() Tj 0 0 0 rg (ba) Tj 0 0 0 rg (\)) Tj 0 0 0 rg  T* .4 .4 .4 rg (<) Tj /F3 10 Tf 0 .501961 0 rg (class) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 0 rg (') Tj /F3 10 Tf 0 0 1 rg (contextlib) Tj /F4 10 Tf .4 .4 .4 rg (.) Tj 0 0 0 rg (_GeneratorContextManager) Tj .729412 .129412 .129412 rg (') Tj (>) Tj 0 0 0 rg  T* .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj /F3 10 Tf 0 .501961 0 rg (with) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 0 rg (ba) Tj 0 0 0 rg (:) Tj 0 0 0 rg  T* .4 .4 .4 rg (...) Tj 0 0 0 rg (     ) Tj /F3 10 Tf 0 .501961 0 rg (print) Tj /F4 10 Tf 0 0 0 rg (\() Tj .729412 .129412 .129412 rg ('hello') Tj 0 0 0 rg (\)) Tj 0 0 0 rg  T* 0 0 0 rg (BEFORE) Tj 0 0 0 rg  T* 0 0 0 rg (hello) Tj 0 0 0 rg  T* 0 0 0 rg (AFTER) Tj T* ET
 Q
 Q
 Q
 Q
 Q
 q
-1 0 0 1 62.69291 306.4236 cm
+1 0 0 1 62.69291 226.4236 cm
 q
-BT 1 0 0 1 0 26 Tm .462488 Tw 12 TL /F1 10 Tf 0 0 0 rg (Basically, it is as if the content of the ) Tj /F4 10 Tf (with ) Tj /F1 10 Tf (block was executed in the place of the ) Tj /F4 10 Tf (yield ) Tj /F1 10 Tf (expression in) Tj T* 0 Tw 2.146342 Tw (the generator function. In Python 3.2 ) Tj /F4 10 Tf (_GeneratorContextManager ) Tj /F1 10 Tf (objects were enhanced with a) Tj T* 0 Tw /F4 10 Tf (__call__ ) Tj /F1 10 Tf (method, so that they can be used as decorators as in this example:) Tj T* ET
+BT 1 0 0 1 0 26 Tm .462488 Tw 12 TL /F1 10 Tf 0 0 0 rg (Basically, it is as if the content of the ) Tj /F4 10 Tf 0 0 0 rg (with ) Tj /F1 10 Tf 0 0 0 rg (block was executed in the place of the ) Tj /F4 10 Tf 0 0 0 rg (yield ) Tj /F1 10 Tf 0 0 0 rg (expression in) Tj T* 0 Tw 2.146342 Tw (the generator function. In Python 3.2 ) Tj /F4 10 Tf 0 0 0 rg (_GeneratorContextManager ) Tj /F1 10 Tf 0 0 0 rg (objects were enhanced with a) Tj T* 0 Tw /F4 10 Tf 0 0 0 rg (__call__ ) Tj /F1 10 Tf 0 0 0 rg (method, so that they can be used as decorators as in this example:) Tj T* ET
 Q
 Q
 q
-1 0 0 1 62.69291 189.2236 cm
+1 0 0 1 62.69291 109.2236 cm
 q
 q
 1 0 0 1 0 0 cm
@@ -3060,53 +4521,95 @@ q
 n -6 -6 468.6898 108 re B*
 Q
 q
-BT 1 0 0 1 0 86 Tm 12 TL /F4 10 Tf .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj .666667 .133333 1 rg (@ba) Tj 0 0 0 rg  T* .4 .4 .4 rg (...) Tj 0 0 0 rg ( ) Tj /F3 10 Tf 0 .501961 0 rg (def) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 1 rg (hello) Tj 0 0 0 rg (\(\):) Tj  T* .4 .4 .4 rg (...) Tj 0 0 0 rg (     ) Tj /F3 10 Tf 0 .501961 0 rg (print) Tj /F4 10 Tf 0 0 0 rg (\() Tj .729412 .129412 .129412 rg ('hello') Tj 0 0 0 rg (\)) Tj  T* .4 .4 .4 rg (...) Tj 0 0 0 rg  T* .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj (hello) Tj (\(\)) Tj  T* (BEFORE) Tj  T* (hello) Tj  T* (AFTER) Tj T* ET
+.960784 .960784 .862745 rg
+n 0 84.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 6 84.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 12 84.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 24 84.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 0 72.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 24 72.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 48 72.75 30 12 re f*
+.960784 .960784 .862745 rg
+n 78 72.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 0 60.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 48 60.75 30 12 re f*
+.960784 .960784 .862745 rg
+n 78 60.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 84 60.75 42 12 re f*
+.960784 .960784 .862745 rg
+n 126 60.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 0 48.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 0 36.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 6 36.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 12 36.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 24 36.75 30 12 re f*
+.960784 .960784 .862745 rg
+n 54 36.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 0 24.75 36 12 re f*
+.960784 .960784 .862745 rg
+n 0 12.75 30 12 re f*
+.960784 .960784 .862745 rg
+n 0 .75 30 12 re f*
+BT 1 0 0 1 0 86 Tm 12 TL /F4 10 Tf .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj .666667 .133333 1 rg (@ba) Tj 0 0 0 rg  T* .4 .4 .4 rg (...) Tj 0 0 0 rg ( ) Tj /F3 10 Tf 0 .501961 0 rg (def) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 1 rg (hello) Tj 0 0 0 rg (\(\):) Tj 0 0 0 rg  T* .4 .4 .4 rg (...) Tj 0 0 0 rg (     ) Tj /F3 10 Tf 0 .501961 0 rg (print) Tj /F4 10 Tf 0 0 0 rg (\() Tj .729412 .129412 .129412 rg ('hello') Tj 0 0 0 rg (\)) Tj 0 0 0 rg  T* .4 .4 .4 rg (...) Tj 0 0 0 rg  T* .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (hello) Tj 0 0 0 rg (\(\)) Tj 0 0 0 rg  T* 0 0 0 rg (BEFORE) Tj 0 0 0 rg  T* 0 0 0 rg (hello) Tj 0 0 0 rg  T* 0 0 0 rg (AFTER) Tj T* ET
 Q
 Q
 Q
 Q
 Q
 q
-1 0 0 1 62.69291 85.22362 cm
+1 0 0 1 62.69291 77.22362 cm
 q
-BT 1 0 0 1 0 86 Tm .20561 Tw 12 TL /F1 10 Tf 0 0 0 rg (The ) Tj /F4 10 Tf (ba ) Tj /F1 10 Tf (decorator is basically inserting a ) Tj /F4 10 Tf (with) Tj ( ) Tj (ba: ) Tj /F1 10 Tf (block inside the function. However there two issues: ) Tj T* 0 Tw .973555 Tw (the first is that ) Tj /F4 10 Tf (_GeneratorContextManager ) Tj /F1 10 Tf (objects are callable only in Python 3.2, so the previous ) Tj T* 0 Tw 2.758314 Tw (example will break in older versions of Python; the second is that ) Tj /F4 10 Tf (_GeneratorContextManager ) Tj T* 0 Tw .503318 Tw /F1 10 Tf (objects do not preserve the signature of the decorated functions: the decorated ) Tj /F4 10 Tf (hello ) Tj /F1 10 Tf (function here will ) Tj T* 0 Tw 1.07784 Tw (have a generic signature ) Tj /F4 10 Tf (hello\(*args,) Tj ( ) Tj (**kwargs\) ) Tj /F1 10 Tf (but will break when called with more than zero ) Tj T* 0 Tw 7.708314 Tw (arguments. For such reasons the decorator module, starting with release 3.4, offers a ) Tj T* 0 Tw .616647 Tw /F4 10 Tf (decorator.contextmanager ) Tj /F1 10 Tf (decorator that solves both problems and works even in Python 2.5. The ) Tj T* 0 Tw .34998 Tw (usage is the same and factories decorated with ) Tj /F4 10 Tf (decorator.contextmanager ) Tj /F1 10 Tf (will returns instances of) Tj T* 0 Tw ET
+BT 1 0 0 1 0 14 Tm .20561 Tw 12 TL /F1 10 Tf 0 0 0 rg (The ) Tj /F4 10 Tf 0 0 0 rg (ba ) Tj /F1 10 Tf 0 0 0 rg (decorator is basically inserting a ) Tj /F4 10 Tf 0 0 0 rg (with) Tj ( ) Tj (ba: ) Tj /F1 10 Tf 0 0 0 rg (block inside the function. However there two issues: ) Tj T* 0 Tw .973555 Tw (the first is that ) Tj /F4 10 Tf 0 0 0 rg (_GeneratorContextManager ) Tj /F1 10 Tf 0 0 0 rg (objects are callable only in Python 3.2, so the previous) Tj T* 0 Tw ET
 Q
 Q
  
 endstream
 endobj
-% 'R98': class PDFStream 
-98 0 obj
-% page stream
-<< /Length 8146 >>
+102 0 obj
+<< /Length 14666 >>
 stream
 1 0 0 1 0 0 cm  BT /F1 12 Tf 14.4 TL ET
 q
-1 0 0 1 62.69291 741.0236 cm
+1 0 0 1 62.69291 669.0236 cm
 q
-BT 1 0 0 1 0 14 Tm 3.295681 Tw 12 TL /F4 10 Tf 0 0 0 rg (ContextManager) Tj /F1 10 Tf (, a subclass of ) Tj /F4 10 Tf (contextlib._GeneratorContextManager ) Tj /F1 10 Tf (with a ) Tj /F4 10 Tf (__call__) Tj T* 0 Tw /F1 10 Tf (method acting as a signature-preserving decorator.) Tj T* ET
+BT 1 0 0 1 0 86 Tm 2.758314 Tw 12 TL /F1 10 Tf 0 0 0 rg (example will break in older versions of Python; the second is that ) Tj /F4 10 Tf 0 0 0 rg (_GeneratorContextManager) Tj T* 0 Tw .503318 Tw /F1 10 Tf 0 0 0 rg (objects do not preserve the signature of the decorated functions: the decorated ) Tj /F4 10 Tf 0 0 0 rg (hello ) Tj /F1 10 Tf 0 0 0 rg (function here will) Tj T* 0 Tw 1.07784 Tw (have a generic signature ) Tj /F4 10 Tf 0 0 0 rg (hello\(*args,) Tj ( ) Tj (**kwargs\) ) Tj /F1 10 Tf 0 0 0 rg (but will break when called with more than zero) Tj T* 0 Tw 7.708314 Tw (arguments. For such reasons the decorator module, starting with release 3.4, offers a) Tj T* 0 Tw .616647 Tw /F4 10 Tf 0 0 0 rg (decorator.contextmanager ) Tj /F1 10 Tf 0 0 0 rg (decorator that solves both problems and works even in Python 2.5. The) Tj T* 0 Tw .34998 Tw (usage is the same and factories decorated with ) Tj /F4 10 Tf 0 0 0 rg (decorator.contextmanager ) Tj /F1 10 Tf 0 0 0 rg (will returns instances of) Tj T* 0 Tw 3.295681 Tw /F4 10 Tf 0 0 0 rg (ContextManager) Tj /F1 10 Tf 0 0 0 rg (, a subclass of ) Tj /F4 10 Tf 0 0 0 rg (contextlib._GeneratorContextManager ) Tj /F1 10 Tf 0 0 0 rg (with a ) Tj /F4 10 Tf 0 0 0 rg (__call__) Tj T* 0 Tw /F1 10 Tf 0 0 0 rg (method acting as a signature-preserving decorator.) Tj T* ET
 Q
 Q
 q
-1 0 0 1 62.69291 708.0236 cm
+1 0 0 1 62.69291 636.0236 cm
 q
-BT 1 0 0 1 0 3.5 Tm 21 TL /F2 17.5 Tf 0 0 0 rg (The ) Tj /F3 17.5 Tf (FunctionMaker ) Tj /F2 17.5 Tf (class) Tj T* ET
+BT 1 0 0 1 0 3.5 Tm 21 TL /F2 17.5 Tf 0 0 0 rg (The ) Tj /F3 17.5 Tf 0 0 0 rg (FunctionMaker ) Tj /F2 17.5 Tf 0 0 0 rg (class) Tj T* ET
 Q
 Q
 q
-1 0 0 1 62.69291 642.0236 cm
+1 0 0 1 62.69291 570.0236 cm
 q
-BT 1 0 0 1 0 50 Tm 2.241412 Tw 12 TL /F1 10 Tf 0 0 0 rg (You may wonder about how the functionality of the ) Tj /F4 10 Tf (decorator ) Tj /F1 10 Tf (module is implemented. The basic) Tj T* 0 Tw 1.545868 Tw (building block is a ) Tj /F4 10 Tf (FunctionMaker ) Tj /F1 10 Tf (class which is able to generate on the fly functions with a given) Tj T* 0 Tw .047485 Tw (name and signature from a function template passed as a string. Generally speaking, you should not need) Tj T* 0 Tw 1.164983 Tw (to resort to ) Tj /F4 10 Tf (FunctionMaker ) Tj /F1 10 Tf (when writing ordinary decorators, but it is handy in some circumstances.) Tj T* 0 Tw (You will see an example shortly, in the implementation of a cool decorator utility \() Tj /F4 10 Tf (decorator_apply) Tj /F1 10 Tf (\).) Tj T* ET
+BT 1 0 0 1 0 50 Tm 2.241412 Tw 12 TL /F1 10 Tf 0 0 0 rg (You may wonder about how the functionality of the ) Tj /F4 10 Tf 0 0 0 rg (decorator ) Tj /F1 10 Tf 0 0 0 rg (module is implemented. The basic) Tj T* 0 Tw 1.545868 Tw (building block is a ) Tj /F4 10 Tf 0 0 0 rg (FunctionMaker ) Tj /F1 10 Tf 0 0 0 rg (class which is able to generate on the fly functions with a given) Tj T* 0 Tw .047485 Tw (name and signature from a function template passed as a string. Generally speaking, you should not need) Tj T* 0 Tw 1.164983 Tw (to resort to ) Tj /F4 10 Tf 0 0 0 rg (FunctionMaker ) Tj /F1 10 Tf 0 0 0 rg (when writing ordinary decorators, but it is handy in some circumstances.) Tj T* 0 Tw (You will see an example shortly, in the implementation of a cool decorator utility \() Tj /F4 10 Tf 0 0 0 rg (decorator_apply) Tj /F1 10 Tf 0 0 0 rg (\).) Tj T* ET
 Q
 Q
 q
-1 0 0 1 62.69291 600.0236 cm
+1 0 0 1 62.69291 528.0236 cm
 q
-BT 1 0 0 1 0 26 Tm .414597 Tw 12 TL /F4 10 Tf 0 0 0 rg (FunctionMaker ) Tj /F1 10 Tf (provides a ) Tj /F4 10 Tf (.create ) Tj /F1 10 Tf (classmethod which takes as input the name, signature, and body) Tj T* 0 Tw .632927 Tw (of the function we want to generate as well as the execution environment were the function is generated) Tj T* 0 Tw (by ) Tj /F4 10 Tf (exec) Tj /F1 10 Tf (. Here is an example:) Tj T* ET
+BT 1 0 0 1 0 26 Tm .414597 Tw 12 TL /F4 10 Tf 0 0 0 rg (FunctionMaker ) Tj /F1 10 Tf 0 0 0 rg (provides a ) Tj /F4 10 Tf 0 0 0 rg (.create ) Tj /F1 10 Tf 0 0 0 rg (classmethod which takes as input the name, signature, and body) Tj T* 0 Tw .632927 Tw (of the function we want to generate as well as the execution environment were the function is generated) Tj T* 0 Tw (by ) Tj /F4 10 Tf 0 0 0 rg (exec) Tj /F1 10 Tf 0 0 0 rg (. Here is an example:) Tj T* ET
 Q
 Q
 q
-1 0 0 1 62.69291 506.8236 cm
+1 0 0 1 62.69291 434.8236 cm
 q
 q
 1 0 0 1 0 0 cm
@@ -3119,32 +4622,140 @@ q
 n -6 -6 468.6898 84 re B*
 Q
 q
-BT 1 0 0 1 0 62 Tm 12 TL /F4 10 Tf .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj /F3 10 Tf 0 .501961 0 rg (def) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 1 rg (f) Tj 0 0 0 rg (\() Tj .4 .4 .4 rg (*) Tj 0 0 0 rg (args) Tj (,) Tj ( ) Tj .4 .4 .4 rg (**) Tj 0 0 0 rg (kw) Tj (\):) Tj ( ) Tj /F6 10 Tf .25098 .501961 .501961 rg (# a function with a generic signature) Tj /F4 10 Tf 0 0 0 rg  T* .4 .4 .4 rg (...) Tj 0 0 0 rg (     ) Tj /F3 10 Tf 0 .501961 0 rg (print) Tj /F4 10 Tf 0 0 0 rg (\() Tj (args) Tj (,) Tj ( ) Tj (kw) Tj (\)) Tj  T*  T* .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj (f1) Tj ( ) Tj .4 .4 .4 rg (=) Tj 0 0 0 rg ( ) Tj (FunctionMaker) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (create) Tj (\() Tj .729412 .129412 .129412 rg ('f1\(a, b\)') Tj 0 0 0 rg (,) Tj ( ) Tj .729412 .129412 .129412 rg ('f\(a, b\)') Tj 0 0 0 rg (,) Tj ( ) Tj 0 .501961 0 rg (dict) Tj 0 0 0 rg (\() Tj (f) Tj .4 .4 .4 rg (=) Tj 0 0 0 rg (f) Tj (\)\)) Tj  T* .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj (f1) Tj (\() Tj .4 .4 .4 rg (1) Tj 0 0 0 rg (,) Tj .4 .4 .4 rg (2) Tj 0 0 0 rg (\)) Tj  T* (\() Tj .4 .4 .4 rg (1) Tj 0 0 0 rg (,) Tj ( ) Tj .4 .4 .4 rg (2) Tj 0 0 0 rg (\)) Tj ( ) Tj ({}) Tj T* ET
+.960784 .960784 .862745 rg
+n 0 60.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 6 60.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 12 60.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 24 60.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 48 60.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 54 60.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 60 60.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 66 60.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 90 60.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 102 60.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 114 60.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 126 60.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 144 60.75 222 12 re f*
+.960784 .960784 .862745 rg
+n 0 48.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 48 48.75 30 12 re f*
+.960784 .960784 .862745 rg
+n 78 48.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 84 48.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 108 48.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 120 48.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 132 48.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 0 24.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 6 24.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 12 24.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 24 24.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 42 24.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 54 24.75 78 12 re f*
+.960784 .960784 .862745 rg
+n 132 24.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 138 24.75 36 12 re f*
+.960784 .960784 .862745 rg
+n 174 24.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 180 24.75 60 12 re f*
+.960784 .960784 .862745 rg
+n 240 24.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 252 24.75 54 12 re f*
+.960784 .960784 .862745 rg
+n 306 24.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 318 24.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 342 24.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 348 24.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 354 24.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 360 24.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 366 24.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 0 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 6 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 12 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 24 12.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 36 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 42 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 48 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 54 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 60 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 0 .75 6 12 re f*
+.960784 .960784 .862745 rg
+n 6 .75 6 12 re f*
+.960784 .960784 .862745 rg
+n 12 .75 6 12 re f*
+.960784 .960784 .862745 rg
+n 24 .75 6 12 re f*
+.960784 .960784 .862745 rg
+n 30 .75 6 12 re f*
+.960784 .960784 .862745 rg
+n 42 .75 12 12 re f*
+BT 1 0 0 1 0 62 Tm 12 TL /F4 10 Tf .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj /F3 10 Tf 0 .501961 0 rg (def) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 1 rg (f) Tj 0 0 0 rg (\() Tj .4 .4 .4 rg (*) Tj 0 0 0 rg (args) Tj 0 0 0 rg (,) Tj 0 0 0 rg ( ) Tj .4 .4 .4 rg (**) Tj 0 0 0 rg (kw) Tj 0 0 0 rg (\):) Tj 0 0 0 rg ( ) Tj /F6 10 Tf .25098 .501961 .501961 rg (# a function with a generic signature) Tj /F4 10 Tf 0 0 0 rg  T* .4 .4 .4 rg (...) Tj 0 0 0 rg (     ) Tj /F3 10 Tf 0 .501961 0 rg (print) Tj /F4 10 Tf 0 0 0 rg (\() Tj 0 0 0 rg (args) Tj 0 0 0 rg (,) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (kw) Tj 0 0 0 rg (\)) Tj 0 0 0 rg  T*  T* .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (f1) Tj 0 0 0 rg ( ) Tj .4 .4 .4 rg (=) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (FunctionMaker) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (create) Tj 0 0 0 rg (\() Tj .729412 .129412 .129412 rg ('f1\(a, b\)') Tj 0 0 0 rg (,) Tj 0 0 0 rg ( ) Tj .729412 .129412 .129412 rg ('f\(a, b\)') Tj 0 0 0 rg (,) Tj 0 0 0 rg ( ) Tj 0 .501961 0 rg (dict) Tj 0 0 0 rg (\() Tj 0 0 0 rg (f) Tj .4 .4 .4 rg (=) Tj 0 0 0 rg (f) Tj 0 0 0 rg (\)\)) Tj 0 0 0 rg  T* .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (f1) Tj 0 0 0 rg (\() Tj .4 .4 .4 rg (1) Tj 0 0 0 rg (,) Tj .4 .4 .4 rg (2) Tj 0 0 0 rg (\)) Tj 0 0 0 rg  T* 0 0 0 rg (\() Tj .4 .4 .4 rg (1) Tj 0 0 0 rg (,) Tj 0 0 0 rg ( ) Tj .4 .4 .4 rg (2) Tj 0 0 0 rg (\)) Tj 0 0 0 rg ( ) Tj 0 0 0 rg ({}) Tj T* ET
 Q
 Q
 Q
 Q
 Q
 q
-1 0 0 1 62.69291 474.8236 cm
+1 0 0 1 62.69291 402.8236 cm
 q
-BT 1 0 0 1 0 14 Tm .226654 Tw 12 TL /F1 10 Tf 0 0 0 rg (It is important to notice that the function body is interpolated before being executed, so be careful with the) Tj T* 0 Tw /F4 10 Tf (% ) Tj /F1 10 Tf (sign!) Tj T* ET
+BT 1 0 0 1 0 14 Tm .226654 Tw 12 TL /F1 10 Tf 0 0 0 rg (It is important to notice that the function body is interpolated before being executed, so be careful with the) Tj T* 0 Tw /F4 10 Tf 0 0 0 rg (% ) Tj /F1 10 Tf 0 0 0 rg (sign!) Tj T* ET
 Q
 Q
 q
-1 0 0 1 62.69291 432.8236 cm
+1 0 0 1 62.69291 360.8236 cm
 q
-BT 1 0 0 1 0 26 Tm 1.995433 Tw 12 TL /F4 10 Tf 0 0 0 rg (FunctionMaker.create ) Tj /F1 10 Tf (also accepts keyword arguments and such arguments are attached to the) Tj T* 0 Tw 1.64686 Tw (resulting function. This is useful if you want to set some function attributes, for instance the docstring) Tj T* 0 Tw /F4 10 Tf (__doc__) Tj /F1 10 Tf (.) Tj T* ET
+BT 1 0 0 1 0 26 Tm 1.995433 Tw 12 TL /F4 10 Tf 0 0 0 rg (FunctionMaker.create ) Tj /F1 10 Tf 0 0 0 rg (also accepts keyword arguments and such arguments are attached to the) Tj T* 0 Tw 1.64686 Tw (resulting function. This is useful if you want to set some function attributes, for instance the docstring) Tj T* 0 Tw /F4 10 Tf 0 0 0 rg (__doc__) Tj /F1 10 Tf 0 0 0 rg (.) Tj T* ET
 Q
 Q
 q
-1 0 0 1 62.69291 390.8236 cm
+1 0 0 1 62.69291 318.8236 cm
 q
-BT 1 0 0 1 0 26 Tm .605318 Tw 12 TL /F1 10 Tf 0 0 0 rg (For debugging/introspection purposes it may be useful to see the source code of the generated function;) Tj T* 0 Tw 2.246235 Tw (to do that, just pass the flag ) Tj /F4 10 Tf (addsource=True ) Tj /F1 10 Tf (and a ) Tj /F4 10 Tf (__source__ ) Tj /F1 10 Tf (attribute will be added to the) Tj T* 0 Tw (generated function:) Tj T* ET
+BT 1 0 0 1 0 26 Tm .605318 Tw 12 TL /F1 10 Tf 0 0 0 rg (For debugging/introspection purposes it may be useful to see the source code of the generated function;) Tj T* 0 Tw 2.246235 Tw (to do that, just pass the flag ) Tj /F4 10 Tf 0 0 0 rg (addsource=True ) Tj /F1 10 Tf 0 0 0 rg (and a ) Tj /F4 10 Tf 0 0 0 rg (__source__ ) Tj /F1 10 Tf 0 0 0 rg (attribute will be added to the) Tj T* 0 Tw (generated function:) Tj T* ET
 Q
 Q
 q
-1 0 0 1 62.69291 297.6236 cm
+1 0 0 1 62.69291 225.6236 cm
 q
 q
 1 0 0 1 0 0 cm
@@ -3157,47 +4768,143 @@ q
 n -6 -6 468.6898 84 re B*
 Q
 q
-BT 1 0 0 1 0 62 Tm 12 TL /F4 10 Tf .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj (f1) Tj ( ) Tj .4 .4 .4 rg (=) Tj 0 0 0 rg ( ) Tj (FunctionMaker) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (create) Tj (\() Tj  T* .4 .4 .4 rg (...) Tj 0 0 0 rg (     ) Tj .729412 .129412 .129412 rg ('f1\(a, b\)') Tj 0 0 0 rg (,) Tj ( ) Tj .729412 .129412 .129412 rg ('f\(a, b\)') Tj 0 0 0 rg (,) Tj ( ) Tj 0 .501961 0 rg (dict) Tj 0 0 0 rg (\() Tj (f) Tj .4 .4 .4 rg (=) Tj 0 0 0 rg (f) Tj (\),) Tj ( ) Tj (addsource) Tj .4 .4 .4 rg (=) Tj 0 .501961 0 rg (True) Tj 0 0 0 rg (\)) Tj  T* .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj /F3 10 Tf 0 .501961 0 rg (print) Tj /F4 10 Tf 0 0 0 rg (\() Tj (f1) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (__source__) Tj (\)) Tj  T* /F3 10 Tf 0 .501961 0 rg (def) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 1 rg (f1) Tj 0 0 0 rg (\() Tj (a) Tj (,) Tj ( ) Tj (b) Tj (\):) Tj  T* (    ) Tj (f) Tj (\() Tj (a) Tj (,) Tj ( ) Tj (b) Tj (\)) Tj  T* .4 .4 .4 rg (<) Tj 0 0 0 rg (BLANKLINE) Tj .4 .4 .4 rg (>) Tj T* ET
-Q
-Q
+.960784 .960784 .862745 rg
+n 0 60.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 6 60.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 12 60.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 24 60.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 42 60.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 54 60.75 78 12 re f*
+.960784 .960784 .862745 rg
+n 132 60.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 138 60.75 36 12 re f*
+.960784 .960784 .862745 rg
+n 174 60.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 0 48.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 48 48.75 60 12 re f*
+.960784 .960784 .862745 rg
+n 108 48.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 120 48.75 54 12 re f*
+.960784 .960784 .862745 rg
+n 174 48.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 186 48.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 210 48.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 216 48.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 222 48.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 228 48.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 234 48.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 252 48.75 54 12 re f*
+.960784 .960784 .862745 rg
+n 306 48.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 312 48.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 336 48.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 0 36.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 6 36.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 12 36.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 24 36.75 30 12 re f*
+.960784 .960784 .862745 rg
+n 54 36.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 60 36.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 72 36.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 78 36.75 60 12 re f*
+.960784 .960784 .862745 rg
+n 138 36.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 0 24.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 24 24.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 36 24.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 42 24.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 48 24.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 60 24.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 66 24.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 24 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 30 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 36 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 42 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 54 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 60 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 0 .75 6 12 re f*
+.960784 .960784 .862745 rg
+n 6 .75 54 12 re f*
+.960784 .960784 .862745 rg
+n 60 .75 6 12 re f*
+BT 1 0 0 1 0 62 Tm 12 TL /F4 10 Tf .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (f1) Tj 0 0 0 rg ( ) Tj .4 .4 .4 rg (=) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (FunctionMaker) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (create) Tj 0 0 0 rg (\() Tj 0 0 0 rg  T* .4 .4 .4 rg (...) Tj 0 0 0 rg (     ) Tj .729412 .129412 .129412 rg ('f1\(a, b\)') Tj 0 0 0 rg (,) Tj 0 0 0 rg ( ) Tj .729412 .129412 .129412 rg ('f\(a, b\)') Tj 0 0 0 rg (,) Tj 0 0 0 rg ( ) Tj 0 .501961 0 rg (dict) Tj 0 0 0 rg (\() Tj 0 0 0 rg (f) Tj .4 .4 .4 rg (=) Tj 0 0 0 rg (f) Tj 0 0 0 rg (\),) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (addsource) Tj .4 .4 .4 rg (=) Tj 0 .501961 0 rg (True) Tj 0 0 0 rg (\)) Tj 0 0 0 rg  T* .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj /F3 10 Tf 0 .501961 0 rg (print) Tj /F4 10 Tf 0 0 0 rg (\() Tj 0 0 0 rg (f1) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (__source__) Tj 0 0 0 rg (\)) Tj 0 0 0 rg  T* /F3 10 Tf 0 .501961 0 rg (def) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 1 rg (f1) Tj 0 0 0 rg (\() Tj 0 0 0 rg (a) Tj 0 0 0 rg (,) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (b) Tj 0 0 0 rg (\):) Tj 0 0 0 rg  T* (    ) Tj 0 0 0 rg (f) Tj 0 0 0 rg (\() Tj 0 0 0 rg (a) Tj 0 0 0 rg (,) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (b) Tj 0 0 0 rg (\)) Tj 0 0 0 rg  T* .4 .4 .4 rg (<) Tj 0 0 0 rg (BLANKLINE) Tj .4 .4 .4 rg (>) Tj T* ET
 Q
 Q
 Q
-q
-1 0 0 1 62.69291 157.6236 cm
-q
-BT 1 0 0 1 0 122 Tm .870651 Tw 12 TL /F4 10 Tf 0 0 0 rg (FunctionMaker.create ) Tj /F1 10 Tf (can take as first argument a string, as in the examples before, or a function.) Tj T* 0 Tw .224985 Tw (This is the most common usage, since typically you want to decorate a pre-existing function. A framework) Tj T* 0 Tw 1.606136 Tw (author may want to use directly ) Tj /F4 10 Tf (FunctionMaker.create ) Tj /F1 10 Tf (instead of ) Tj /F4 10 Tf (decorator) Tj /F1 10 Tf (, since it gives you) Tj T* 0 Tw 1.36686 Tw (direct access to the body of the generated function. For instance, suppose you want to instrument the) Tj T* 0 Tw .372209 Tw /F4 10 Tf (__init__ ) Tj /F1 10 Tf (methods of a set of classes, by preserving their signature \(such use case is not made up; this) Tj T* 0 Tw .673828 Tw (is done in SQAlchemy and in other frameworks\). When the first argument of ) Tj /F4 10 Tf (FunctionMaker.create) Tj T* 0 Tw 3.405814 Tw /F1 10 Tf (is a function, a ) Tj /F4 10 Tf (FunctionMaker ) Tj /F1 10 Tf (object is instantiated internally, with attributes ) Tj /F4 10 Tf (args) Tj /F1 10 Tf (, ) Tj /F4 10 Tf (varargs) Tj /F1 10 Tf (,) Tj T* 0 Tw 5.509982 Tw /F4 10 Tf (keywords ) Tj /F1 10 Tf (and ) Tj /F4 10 Tf (defaults ) Tj /F1 10 Tf (which are the the return values of the standard library function) Tj T* 0 Tw .561318 Tw /F4 10 Tf (inspect.getargspec) Tj /F1 10 Tf (. For each argument in the ) Tj /F4 10 Tf (args ) Tj /F1 10 Tf (\(which is a list of strings containing the names) Tj T* 0 Tw 1.599985 Tw (of the mandatory arguments\) an attribute ) Tj /F4 10 Tf (arg0) Tj /F1 10 Tf (, ) Tj /F4 10 Tf (arg1) Tj /F1 10 Tf (, ..., ) Tj /F4 10 Tf (argN ) Tj /F1 10 Tf (is also generated. Finally, there is a) Tj T* 0 Tw /F4 10 Tf (signature ) Tj /F1 10 Tf (attribute, a string with the signature of the original function.) Tj T* ET
 Q
 Q
 q
-1 0 0 1 62.69291 79.62362 cm
+1 0 0 1 62.69291 85.62362 cm
 q
-BT 1 0 0 1 0 62 Tm 4.63311 Tw 12 TL /F1 10 Tf 0 0 0 rg (Notice that while I do not have plans to change or remove the functionality provided in the) Tj T* 0 Tw 1.00936 Tw /F4 10 Tf (FunctionMaker ) Tj /F1 10 Tf (class, I do not guarantee that it will stay unchanged forever. For instance, right now I) Tj T* 0 Tw .791318 Tw (am using the traditional string interpolation syntax for function templates, but Python 2.6 and Python 3.0) Tj T* 0 Tw .712093 Tw (provide a newer interpolation syntax and I may use the new syntax in the future. On the other hand, the) Tj T* 0 Tw .639985 Tw (functionality provided by ) Tj /F4 10 Tf (decorator ) Tj /F1 10 Tf (has been there from version 0.1 and it is guaranteed to stay there) Tj T* 0 Tw (forever.) Tj T* ET
+BT 1 0 0 1 0 122 Tm .870651 Tw 12 TL /F4 10 Tf 0 0 0 rg (FunctionMaker.create ) Tj /F1 10 Tf 0 0 0 rg (can take as first argument a string, as in the examples before, or a function.) Tj T* 0 Tw .224985 Tw (This is the most common usage, since typically you want to decorate a pre-existing function. A framework) Tj T* 0 Tw 1.606136 Tw (author may want to use directly ) Tj /F4 10 Tf 0 0 0 rg (FunctionMaker.create ) Tj /F1 10 Tf 0 0 0 rg (instead of ) Tj /F4 10 Tf 0 0 0 rg (decorator) Tj /F1 10 Tf 0 0 0 rg (, since it gives you) Tj T* 0 Tw 1.36686 Tw (direct access to the body of the generated function. For instance, suppose you want to instrument the) Tj T* 0 Tw .372209 Tw /F4 10 Tf 0 0 0 rg (__init__ ) Tj /F1 10 Tf 0 0 0 rg (methods of a set of classes, by preserving their signature \(such use case is not made up; this) Tj T* 0 Tw .673828 Tw (is done in SQAlchemy and in other frameworks\). When the first argument of ) Tj /F4 10 Tf 0 0 0 rg (FunctionMaker.create) Tj T* 0 Tw 3.405814 Tw /F1 10 Tf 0 0 0 rg (is a function, a ) Tj /F4 10 Tf 0 0 0 rg (FunctionMaker ) Tj /F1 10 Tf 0 0 0 rg (object is instantiated internally, with attributes ) Tj /F4 10 Tf 0 0 0 rg (args) Tj /F1 10 Tf 0 0 0 rg (, ) Tj /F4 10 Tf 0 0 0 rg (varargs) Tj /F1 10 Tf 0 0 0 rg (,) Tj T* 0 Tw 5.509982 Tw /F4 10 Tf 0 0 0 rg (keywords ) Tj /F1 10 Tf 0 0 0 rg (and ) Tj /F4 10 Tf 0 0 0 rg (defaults ) Tj /F1 10 Tf 0 0 0 rg (which are the the return values of the standard library function) Tj T* 0 Tw .561318 Tw /F4 10 Tf 0 0 0 rg (inspect.getargspec) Tj /F1 10 Tf 0 0 0 rg (. For each argument in the ) Tj /F4 10 Tf 0 0 0 rg (args ) Tj /F1 10 Tf 0 0 0 rg (\(which is a list of strings containing the names) Tj T* 0 Tw 1.599985 Tw (of the mandatory arguments\) an attribute ) Tj /F4 10 Tf 0 0 0 rg (arg0) Tj /F1 10 Tf 0 0 0 rg (, ) Tj /F4 10 Tf 0 0 0 rg (arg1) Tj /F1 10 Tf 0 0 0 rg (, ..., ) Tj /F4 10 Tf 0 0 0 rg (argN ) Tj /F1 10 Tf 0 0 0 rg (is also generated. Finally, there is a) Tj T* 0 Tw /F4 10 Tf 0 0 0 rg (signature ) Tj /F1 10 Tf 0 0 0 rg (attribute, a string with the signature of the original function.) Tj T* ET
 Q
 Q
  
 endstream
 endobj
-% 'R99': class PDFStream 
-99 0 obj
-% page stream
-<< /Length 7325 >>
+103 0 obj
+<< /Length 14039 >>
 stream
 1 0 0 1 0 0 cm  BT /F1 12 Tf 14.4 TL ET
 q
-1 0 0 1 62.69291 744.0236 cm
+1 0 0 1 62.69291 693.0236 cm
+q
+BT 1 0 0 1 0 62 Tm 4.63311 Tw 12 TL /F1 10 Tf 0 0 0 rg (Notice that while I do not have plans to change or remove the functionality provided in the) Tj T* 0 Tw 1.00936 Tw /F4 10 Tf 0 0 0 rg (FunctionMaker ) Tj /F1 10 Tf 0 0 0 rg (class, I do not guarantee that it will stay unchanged forever. For instance, right now I) Tj T* 0 Tw .791318 Tw (am using the traditional string interpolation syntax for function templates, but Python 2.6 and Python 3.0) Tj T* 0 Tw .712093 Tw (provide a newer interpolation syntax and I may use the new syntax in the future. On the other hand, the) Tj T* 0 Tw .639985 Tw (functionality provided by ) Tj /F4 10 Tf 0 0 0 rg (decorator ) Tj /F1 10 Tf 0 0 0 rg (has been there from version 0.1 and it is guaranteed to stay there) Tj T* 0 Tw (forever.) Tj T* ET
+Q
+Q
+q
+1 0 0 1 62.69291 660.0236 cm
 q
 BT 1 0 0 1 0 3.5 Tm 21 TL /F2 17.5 Tf 0 0 0 rg (Getting the source code) Tj T* ET
 Q
 Q
 q
-1 0 0 1 62.69291 666.0236 cm
+1 0 0 1 62.69291 582.0236 cm
 q
-BT 1 0 0 1 0 62 Tm 5.045529 Tw 12 TL /F1 10 Tf 0 0 0 rg (Internally ) Tj /F4 10 Tf (FunctionMaker.create ) Tj /F1 10 Tf (uses ) Tj /F4 10 Tf (exec ) Tj /F1 10 Tf (to generate the decorated function. Therefore) Tj T* 0 Tw 2.542126 Tw /F4 10 Tf (inspect.getsource ) Tj /F1 10 Tf (will not work for decorated functions. That means that the usual '??' trick in) Tj T* 0 Tw 26.45775 Tw (IPython will give you the \(right on the spot\) message) Tj T* 0 Tw .261647 Tw /F4 10 Tf (Dynamically) Tj ( ) Tj (generated) Tj ( ) Tj (function.) Tj ( ) Tj (No) Tj ( ) Tj (source) Tj ( ) Tj (code available) Tj /F1 10 Tf (. In the past I have considered) Tj T* 0 Tw .945366 Tw (this acceptable, since ) Tj /F4 10 Tf (inspect.getsource ) Tj /F1 10 Tf (does not really work even with regular decorators. In that) Tj T* 0 Tw (case ) Tj /F4 10 Tf (inspect.getsource ) Tj /F1 10 Tf (gives you the wrapper source code which is probably not what you want:) Tj T* ET
+BT 1 0 0 1 0 62 Tm 5.045529 Tw 12 TL /F1 10 Tf 0 0 0 rg (Internally ) Tj /F4 10 Tf 0 0 0 rg (FunctionMaker.create ) Tj /F1 10 Tf 0 0 0 rg (uses ) Tj /F4 10 Tf 0 0 0 rg (exec ) Tj /F1 10 Tf 0 0 0 rg (to generate the decorated function. Therefore) Tj T* 0 Tw 2.542126 Tw /F4 10 Tf 0 0 0 rg (inspect.getsource ) Tj /F1 10 Tf 0 0 0 rg (will not work for decorated functions. That means that the usual '??' trick in) Tj T* 0 Tw 26.45775 Tw (IPython will give you the \(right on the spot\) message) Tj T* 0 Tw .261647 Tw /F4 10 Tf 0 0 0 rg (Dynamically) Tj ( ) Tj (generated) Tj ( ) Tj (function.) Tj ( ) Tj (No) Tj ( ) Tj (source) Tj ( ) Tj (code available) Tj /F1 10 Tf 0 0 0 rg (. In the past I have considered) Tj T* 0 Tw .945366 Tw (this acceptable, since ) Tj /F4 10 Tf 0 0 0 rg (inspect.getsource ) Tj /F1 10 Tf 0 0 0 rg (does not really work even with regular decorators. In that) Tj T* 0 Tw (case ) Tj /F4 10 Tf 0 0 0 rg (inspect.getsource ) Tj /F1 10 Tf 0 0 0 rg (gives you the wrapper source code which is probably not what you want:) Tj T* ET
 Q
 Q
 q
-1 0 0 1 62.69291 596.8236 cm
+1 0 0 1 62.69291 512.8236 cm
 q
 q
 1 0 0 1 0 0 cm
@@ -3210,14 +4917,64 @@ q
 n -6 -6 468.6898 60 re B*
 Q
 q
-BT 1 0 0 1 0 38 Tm 12 TL /F3 10 Tf 0 .501961 0 rg (def) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 1 rg (identity_dec) Tj 0 0 0 rg (\() Tj (func) Tj (\):) Tj  T* (    ) Tj /F3 10 Tf 0 .501961 0 rg (def) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 1 rg (wrapper) Tj 0 0 0 rg (\() Tj .4 .4 .4 rg (*) Tj 0 0 0 rg (args) Tj (,) Tj ( ) Tj .4 .4 .4 rg (**) Tj 0 0 0 rg (kw) Tj (\):) Tj  T* (        ) Tj /F3 10 Tf 0 .501961 0 rg (return) Tj /F4 10 Tf 0 0 0 rg ( ) Tj (func) Tj (\() Tj .4 .4 .4 rg (*) Tj 0 0 0 rg (args) Tj (,) Tj ( ) Tj .4 .4 .4 rg (**) Tj 0 0 0 rg (kw) Tj (\)) Tj  T* (    ) Tj /F3 10 Tf 0 .501961 0 rg (return) Tj /F4 10 Tf 0 0 0 rg ( ) Tj (wrapper) Tj T* ET
+.960784 .960784 .862745 rg
+n 0 36.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 24 36.75 72 12 re f*
+.960784 .960784 .862745 rg
+n 96 36.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 102 36.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 126 36.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 24 24.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 48 24.75 42 12 re f*
+.960784 .960784 .862745 rg
+n 90 24.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 96 24.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 102 24.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 126 24.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 138 24.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 150 24.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 162 24.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 48 12.75 36 12 re f*
+.960784 .960784 .862745 rg
+n 90 12.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 114 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 120 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 126 12.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 150 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 162 12.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 174 12.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 186 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 24 .75 36 12 re f*
+.960784 .960784 .862745 rg
+n 66 .75 42 12 re f*
+BT 1 0 0 1 0 38 Tm 12 TL /F3 10 Tf 0 .501961 0 rg (def) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 1 rg (identity_dec) Tj 0 0 0 rg (\() Tj 0 0 0 rg (func) Tj 0 0 0 rg (\):) Tj 0 0 0 rg  T* (    ) Tj /F3 10 Tf 0 .501961 0 rg (def) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 1 rg (wrapper) Tj 0 0 0 rg (\() Tj .4 .4 .4 rg (*) Tj 0 0 0 rg (args) Tj 0 0 0 rg (,) Tj 0 0 0 rg ( ) Tj .4 .4 .4 rg (**) Tj 0 0 0 rg (kw) Tj 0 0 0 rg (\):) Tj 0 0 0 rg  T* (        ) Tj /F3 10 Tf 0 .501961 0 rg (return) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 0 rg (func) Tj 0 0 0 rg (\() Tj .4 .4 .4 rg (*) Tj 0 0 0 rg (args) Tj 0 0 0 rg (,) Tj 0 0 0 rg ( ) Tj .4 .4 .4 rg (**) Tj 0 0 0 rg (kw) Tj 0 0 0 rg (\)) Tj 0 0 0 rg  T* (    ) Tj /F3 10 Tf 0 .501961 0 rg (return) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 0 rg (wrapper) Tj T* ET
 Q
 Q
 Q
 Q
 Q
 q
-1 0 0 1 62.69291 491.6236 cm
+1 0 0 1 62.69291 407.6236 cm
 q
 q
 1 0 0 1 0 0 cm
@@ -3230,20 +4987,94 @@ q
 n -6 -6 468.6898 96 re B*
 Q
 q
-BT 1 0 0 1 0 74 Tm 12 TL /F4 10 Tf .666667 .133333 1 rg (@identity_dec) Tj 0 0 0 rg  T* /F3 10 Tf 0 .501961 0 rg (def) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 1 rg (example) Tj 0 0 0 rg (\(\):) Tj ( ) Tj /F3 10 Tf 0 .501961 0 rg (pass) Tj /F4 10 Tf 0 0 0 rg  T*  T* .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj /F3 10 Tf 0 .501961 0 rg (print) Tj /F4 10 Tf 0 0 0 rg (\() Tj (inspect) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (getsource) Tj (\() Tj (example) Tj (\)\)) Tj  T* (    ) Tj /F3 10 Tf 0 .501961 0 rg (def) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 1 rg (wrapper) Tj 0 0 0 rg (\() Tj .4 .4 .4 rg (*) Tj 0 0 0 rg (args) Tj (,) Tj ( ) Tj .4 .4 .4 rg (**) Tj 0 0 0 rg (kw) Tj (\):) Tj  T* (        ) Tj /F3 10 Tf 0 .501961 0 rg (return) Tj /F4 10 Tf 0 0 0 rg ( ) Tj (func) Tj (\() Tj .4 .4 .4 rg (*) Tj 0 0 0 rg (args) Tj (,) Tj ( ) Tj .4 .4 .4 rg (**) Tj 0 0 0 rg (kw) Tj (\)) Tj  T* .4 .4 .4 rg (<) Tj 0 0 0 rg (BLANKLINE) Tj .4 .4 .4 rg (>) Tj T* ET
+.960784 .960784 .862745 rg
+n 0 72.75 78 12 re f*
+.960784 .960784 .862745 rg
+n 0 60.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 24 60.75 42 12 re f*
+.960784 .960784 .862745 rg
+n 66 60.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 90 60.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 0 36.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 6 36.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 12 36.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 24 36.75 30 12 re f*
+.960784 .960784 .862745 rg
+n 54 36.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 60 36.75 42 12 re f*
+.960784 .960784 .862745 rg
+n 102 36.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 108 36.75 54 12 re f*
+.960784 .960784 .862745 rg
+n 162 36.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 168 36.75 42 12 re f*
+.960784 .960784 .862745 rg
+n 210 36.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 24 24.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 48 24.75 42 12 re f*
+.960784 .960784 .862745 rg
+n 90 24.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 96 24.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 102 24.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 126 24.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 138 24.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 150 24.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 162 24.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 48 12.75 36 12 re f*
+.960784 .960784 .862745 rg
+n 90 12.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 114 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 120 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 126 12.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 150 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 162 12.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 174 12.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 186 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 0 .75 6 12 re f*
+.960784 .960784 .862745 rg
+n 6 .75 54 12 re f*
+.960784 .960784 .862745 rg
+n 60 .75 6 12 re f*
+BT 1 0 0 1 0 74 Tm 12 TL /F4 10 Tf .666667 .133333 1 rg (@identity_dec) Tj 0 0 0 rg  T* /F3 10 Tf 0 .501961 0 rg (def) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 1 rg (example) Tj 0 0 0 rg (\(\):) Tj 0 0 0 rg ( ) Tj /F3 10 Tf 0 .501961 0 rg (pass) Tj /F4 10 Tf 0 0 0 rg  T*  T* .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj /F3 10 Tf 0 .501961 0 rg (print) Tj /F4 10 Tf 0 0 0 rg (\() Tj 0 0 0 rg (inspect) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (getsource) Tj 0 0 0 rg (\() Tj 0 0 0 rg (example) Tj 0 0 0 rg (\)\)) Tj 0 0 0 rg  T* (    ) Tj /F3 10 Tf 0 .501961 0 rg (def) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 1 rg (wrapper) Tj 0 0 0 rg (\() Tj .4 .4 .4 rg (*) Tj 0 0 0 rg (args) Tj 0 0 0 rg (,) Tj 0 0 0 rg ( ) Tj .4 .4 .4 rg (**) Tj 0 0 0 rg (kw) Tj 0 0 0 rg (\):) Tj 0 0 0 rg  T* (        ) Tj /F3 10 Tf 0 .501961 0 rg (return) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 0 rg (func) Tj 0 0 0 rg (\() Tj .4 .4 .4 rg (*) Tj 0 0 0 rg (args) Tj 0 0 0 rg (,) Tj 0 0 0 rg ( ) Tj .4 .4 .4 rg (**) Tj 0 0 0 rg (kw) Tj 0 0 0 rg (\)) Tj 0 0 0 rg  T* .4 .4 .4 rg (<) Tj 0 0 0 rg (BLANKLINE) Tj .4 .4 .4 rg (>) Tj T* ET
 Q
 Q
 Q
 Q
 Q
 q
-1 0 0 1 62.69291 435.6236 cm
+1 0 0 1 62.69291 351.6236 cm
 q
-BT 1 0 0 1 0 38 Tm 1.471235 Tw 12 TL /F1 10 Tf 0 0 0 rg (\(see bug report ) Tj 0 0 .501961 rg (1764286 ) Tj 0 0 0 rg (for an explanation of what is happening\). Unfortunately the bug is still there,) Tj T* 0 Tw 1.541235 Tw (even in Python 2.7 and 3.1. There is however a workaround. The decorator module adds an attribute) Tj T* 0 Tw .103984 Tw /F4 10 Tf (.__wrapped__ ) Tj /F1 10 Tf (to the decorated function, containing a reference to the original function. The easy way to) Tj T* 0 Tw (get the source code is to call ) Tj /F4 10 Tf (inspect.getsource ) Tj /F1 10 Tf (on the undecorated function:) Tj T* ET
+BT 1 0 0 1 0 38 Tm 1.471235 Tw 12 TL /F1 10 Tf 0 0 0 rg (\(see bug report ) Tj 0 0 .501961 rg (1764286 ) Tj 0 0 0 rg (for an explanation of what is happening\). Unfortunately the bug is still there,) Tj T* 0 Tw 1.541235 Tw (even in Python 2.7 and 3.1. There is however a workaround. The decorator module adds an attribute) Tj T* 0 Tw .103984 Tw /F4 10 Tf 0 0 0 rg (.__wrapped__ ) Tj /F1 10 Tf 0 0 0 rg (to the decorated function, containing a reference to the original function. The easy way to) Tj T* 0 Tw (get the source code is to call ) Tj /F4 10 Tf 0 0 0 rg (inspect.getsource ) Tj /F1 10 Tf 0 0 0 rg (on the undecorated function:) Tj T* ET
 Q
 Q
 q
-1 0 0 1 62.69291 330.4236 cm
+1 0 0 1 62.69291 234.4236 cm
 q
 q
 1 0 0 1 0 0 cm
@@ -3253,29 +5084,119 @@ q
 .662745 .662745 .662745 RG
 .5 w
 .960784 .960784 .862745 rg
-n -6 -6 468.6898 96 re B*
+n -6 -6 468.6898 108 re B*
 Q
 q
-BT 1 0 0 1 0 74 Tm 12 TL /F4 10 Tf .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj /F3 10 Tf 0 .501961 0 rg (print) Tj /F4 10 Tf 0 0 0 rg (\() Tj (inspect) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (getsource) Tj (\() Tj (factorial) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (__wrapped__) Tj (\)\)) Tj  T* .666667 .133333 1 rg (@tail_recursive) Tj 0 0 0 rg  T* /F3 10 Tf 0 .501961 0 rg (def) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 1 rg (factorial) Tj 0 0 0 rg (\() Tj (n) Tj (,) Tj ( ) Tj (acc) Tj .4 .4 .4 rg (=) Tj (1) Tj 0 0 0 rg (\):) Tj  T* (    ) Tj .729412 .129412 .129412 rg ("The good old factorial") Tj 0 0 0 rg  T* (    ) Tj /F3 10 Tf 0 .501961 0 rg (if) Tj /F4 10 Tf 0 0 0 rg ( ) Tj (n) Tj ( ) Tj .4 .4 .4 rg (==) Tj 0 0 0 rg ( ) Tj .4 .4 .4 rg (0) Tj 0 0 0 rg (:) Tj ( ) Tj /F3 10 Tf 0 .501961 0 rg (return) Tj /F4 10 Tf 0 0 0 rg ( ) Tj (acc) Tj  T* (    ) Tj /F3 10 Tf 0 .501961 0 rg (return) Tj /F4 10 Tf 0 0 0 rg ( ) Tj (factorial) Tj (\() Tj (n) Tj .4 .4 .4 rg (-) Tj (1) Tj 0 0 0 rg (,) Tj ( ) Tj (n) Tj .4 .4 .4 rg (*) Tj 0 0 0 rg (acc) Tj (\)) Tj  T* .4 .4 .4 rg (<) Tj 0 0 0 rg (BLANKLINE) Tj .4 .4 .4 rg (>) Tj T* ET
+.960784 .960784 .862745 rg
+n 0 84.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 6 84.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 12 84.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 24 84.75 30 12 re f*
+.960784 .960784 .862745 rg
+n 54 84.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 60 84.75 42 12 re f*
+.960784 .960784 .862745 rg
+n 102 84.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 108 84.75 54 12 re f*
+.960784 .960784 .862745 rg
+n 162 84.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 168 84.75 54 12 re f*
+.960784 .960784 .862745 rg
+n 222 84.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 228 84.75 66 12 re f*
+.960784 .960784 .862745 rg
+n 294 84.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 0 72.75 90 12 re f*
+.960784 .960784 .862745 rg
+n 0 60.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 24 60.75 54 12 re f*
+.960784 .960784 .862745 rg
+n 78 60.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 84 60.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 90 60.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 102 60.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 120 60.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 126 60.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 132 60.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 24 48.75 144 12 re f*
+.960784 .960784 .862745 rg
+n 24 36.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 42 36.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 54 36.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 72 36.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 78 36.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 48 24.75 36 12 re f*
+.960784 .960784 .862745 rg
+n 90 24.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 24 12.75 36 12 re f*
+.960784 .960784 .862745 rg
+n 66 12.75 54 12 re f*
+.960784 .960784 .862745 rg
+n 120 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 126 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 132 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 138 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 144 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 156 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 162 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 168 12.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 186 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 0 .75 6 12 re f*
+.960784 .960784 .862745 rg
+n 6 .75 54 12 re f*
+.960784 .960784 .862745 rg
+n 60 .75 6 12 re f*
+BT 1 0 0 1 0 86 Tm 12 TL /F4 10 Tf .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj /F3 10 Tf 0 .501961 0 rg (print) Tj /F4 10 Tf 0 0 0 rg (\() Tj 0 0 0 rg (inspect) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (getsource) Tj 0 0 0 rg (\() Tj 0 0 0 rg (factorial) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (__wrapped__) Tj 0 0 0 rg (\)\)) Tj 0 0 0 rg  T* .666667 .133333 1 rg (@tail_recursive) Tj 0 0 0 rg  T* /F3 10 Tf 0 .501961 0 rg (def) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 1 rg (factorial) Tj 0 0 0 rg (\() Tj 0 0 0 rg (n) Tj 0 0 0 rg (,) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (acc) Tj .4 .4 .4 rg (=) Tj .4 .4 .4 rg (1) Tj 0 0 0 rg (\):) Tj 0 0 0 rg  T* (    ) Tj .729412 .129412 .129412 rg ("The good old factorial") Tj 0 0 0 rg  T* (    ) Tj /F3 10 Tf 0 .501961 0 rg (if) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 0 rg (n) Tj 0 0 0 rg ( ) Tj .4 .4 .4 rg (==) Tj 0 0 0 rg ( ) Tj .4 .4 .4 rg (0) Tj 0 0 0 rg (:) Tj 0 0 0 rg  T* (        ) Tj /F3 10 Tf 0 .501961 0 rg (return) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 0 rg (acc) Tj 0 0 0 rg  T* (    ) Tj /F3 10 Tf 0 .501961 0 rg (return) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 0 rg (factorial) Tj 0 0 0 rg (\() Tj 0 0 0 rg (n) Tj .4 .4 .4 rg (-) Tj .4 .4 .4 rg (1) Tj 0 0 0 rg (,) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (n) Tj .4 .4 .4 rg (*) Tj 0 0 0 rg (acc) Tj 0 0 0 rg (\)) Tj 0 0 0 rg  T* .4 .4 .4 rg (<) Tj 0 0 0 rg (BLANKLINE) Tj .4 .4 .4 rg (>) Tj T* ET
 Q
 Q
 Q
 Q
 Q
 q
-1 0 0 1 62.69291 297.4236 cm
+1 0 0 1 62.69291 201.4236 cm
 q
 BT 1 0 0 1 0 3.5 Tm 21 TL /F2 17.5 Tf 0 0 0 rg (Dealing with third party decorators) Tj T* ET
 Q
 Q
 q
-1 0 0 1 62.69291 243.4236 cm
+1 0 0 1 62.69291 147.4236 cm
 q
-BT 1 0 0 1 0 38 Tm .321654 Tw 12 TL /F1 10 Tf 0 0 0 rg (Sometimes you find on the net some cool decorator that you would like to include in your code. However,) Tj T* 0 Tw .50061 Tw (more often than not the cool decorator is not signature-preserving. Therefore you may want an easy way) Tj T* 0 Tw 1.814597 Tw (to upgrade third party decorators to signature-preserving decorators without having to rewrite them in) Tj T* 0 Tw (terms of ) Tj /F4 10 Tf (decorator) Tj /F1 10 Tf (. You can use a ) Tj /F4 10 Tf (FunctionMaker ) Tj /F1 10 Tf (to implement that functionality as follows:) Tj T* ET
+BT 1 0 0 1 0 38 Tm .321654 Tw 12 TL /F1 10 Tf 0 0 0 rg (Sometimes you find on the net some cool decorator that you would like to include in your code. However,) Tj T* 0 Tw .50061 Tw (more often than not the cool decorator is not signature-preserving. Therefore you may want an easy way) Tj T* 0 Tw 1.814597 Tw (to upgrade third party decorators to signature-preserving decorators without having to rewrite them in) Tj T* 0 Tw (terms of ) Tj /F4 10 Tf 0 0 0 rg (decorator) Tj /F1 10 Tf 0 0 0 rg (. You can use a ) Tj /F4 10 Tf 0 0 0 rg (FunctionMaker ) Tj /F1 10 Tf 0 0 0 rg (to implement that functionality as follows:) Tj T* ET
 Q
 Q
 q
-1 0 0 1 62.69291 126.2236 cm
+1 0 0 1 62.69291 78.22362 cm
 q
 q
 1 0 0 1 0 0 cm
@@ -3285,44 +5206,130 @@ q
 .662745 .662745 .662745 RG
 .5 w
 .960784 .960784 .862745 rg
-n -6 -6 468.6898 108 re B*
+n -6 -6 468.6898 60 re B*
 Q
 q
-BT 1 0 0 1 0 86 Tm 12 TL /F3 10 Tf 0 .501961 0 rg (def) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 1 rg (decorator_apply) Tj 0 0 0 rg (\() Tj (dec) Tj (,) Tj ( ) Tj (func) Tj (\):) Tj  T* (    ) Tj /F6 10 Tf .729412 .129412 .129412 rg (""") Tj T* (    Decorate a function by preserving the signature even if dec) Tj T* (    is not a signature-preserving decorator.) Tj T* (    """) Tj /F4 10 Tf 0 0 0 rg  T* (    ) Tj /F3 10 Tf 0 .501961 0 rg (return) Tj /F4 10 Tf 0 0 0 rg ( ) Tj (FunctionMaker) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (create) Tj (\() Tj  T* (        ) Tj (func) Tj (,) Tj ( ) Tj .729412 .129412 .129412 rg ('return decorated\() Tj /F3 10 Tf .733333 .4 .533333 rg (%\(signature\)s) Tj /F4 10 Tf .729412 .129412 .129412 rg (\)') Tj 0 0 0 rg (,) Tj  T* (        ) Tj 0 .501961 0 rg (dict) Tj 0 0 0 rg (\() Tj (decorated) Tj .4 .4 .4 rg (=) Tj 0 0 0 rg (dec) Tj (\() Tj (func) Tj (\)\),) Tj ( ) Tj (__wrapped__) Tj .4 .4 .4 rg (=) Tj 0 0 0 rg (func) Tj (\)) Tj T* ET
-Q
-Q
+.960784 .960784 .862745 rg
+n 0 36.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 24 36.75 90 12 re f*
+.960784 .960784 .862745 rg
+n 114 36.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 120 36.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 138 36.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 150 36.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 174 36.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 24 24.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 0 12.75 378 12 re f*
+.960784 .960784 .862745 rg
+n 0 .75 264 12 re f*
+BT 1 0 0 1 0 38 Tm 12 TL /F3 10 Tf 0 .501961 0 rg (def) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 1 rg (decorator_apply) Tj 0 0 0 rg (\() Tj 0 0 0 rg (dec) Tj 0 0 0 rg (,) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (func) Tj 0 0 0 rg (\):) Tj 0 0 0 rg  T* (    ) Tj /F6 10 Tf .729412 .129412 .129412 rg (""") Tj T* (    Decorate a function by preserving the signature even if dec) Tj T* (    is not a signature-preserving decorator.) Tj T* ET
 Q
 Q
 Q
-q
-1 0 0 1 62.69291 94.22362 cm
-q
-BT 1 0 0 1 0 14 Tm .698314 Tw 12 TL /F4 10 Tf 0 0 0 rg (decorator_apply ) Tj /F1 10 Tf (sets the attribute ) Tj /F4 10 Tf (.__wrapped__ ) Tj /F1 10 Tf (of the generated function to the original function,) Tj T* 0 Tw (so that you can get the right source code.) Tj T* ET
 Q
 Q
  
 endstream
 endobj
-% 'R100': class PDFStream 
-100 0 obj
-% page stream
-<< /Length 7498 >>
+104 0 obj
+<< /Length 16120 >>
 stream
 1 0 0 1 0 0 cm  BT /F1 12 Tf 14.4 TL ET
 q
-1 0 0 1 62.69291 729.0236 cm
+1 0 0 1 62.69291 703.8236 cm
 q
-BT 1 0 0 1 0 26 Tm .13104 Tw 12 TL /F1 10 Tf 0 0 0 rg (Notice that I am not providing this functionality in the ) Tj /F4 10 Tf (decorator ) Tj /F1 10 Tf (module directly since I think it is best to) Tj T* 0 Tw 2.070751 Tw (rewrite the decorator rather than adding an additional level of indirection. However, practicality beats) Tj T* 0 Tw (purity, so you can add ) Tj /F4 10 Tf (decorator_apply ) Tj /F1 10 Tf (to your toolbox and use it if you need to.) Tj T* ET
+q
+1 0 0 1 0 0 cm
+q
+1 0 0 1 6.6 6.6 cm
+q
+.662745 .662745 .662745 RG
+.5 w
+.960784 .960784 .862745 rg
+n -6 -6 468.6898 60 re B*
+Q
+q
+.960784 .960784 .862745 rg
+n 0 36.75 42 12 re f*
+.960784 .960784 .862745 rg
+n 24 24.75 36 12 re f*
+.960784 .960784 .862745 rg
+n 66 24.75 78 12 re f*
+.960784 .960784 .862745 rg
+n 144 24.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 150 24.75 36 12 re f*
+.960784 .960784 .862745 rg
+n 186 24.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 48 12.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 72 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 84 12.75 108 12 re f*
+.960784 .960784 .862745 rg
+n 192 12.75 78 12 re f*
+.960784 .960784 .862745 rg
+n 270 12.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 282 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 48 .75 24 12 re f*
+.960784 .960784 .862745 rg
+n 72 .75 6 12 re f*
+.960784 .960784 .862745 rg
+n 78 .75 54 12 re f*
+.960784 .960784 .862745 rg
+n 132 .75 6 12 re f*
+.960784 .960784 .862745 rg
+n 138 .75 18 12 re f*
+.960784 .960784 .862745 rg
+n 156 .75 6 12 re f*
+.960784 .960784 .862745 rg
+n 162 .75 24 12 re f*
+.960784 .960784 .862745 rg
+n 186 .75 18 12 re f*
+.960784 .960784 .862745 rg
+n 210 .75 66 12 re f*
+.960784 .960784 .862745 rg
+n 276 .75 6 12 re f*
+.960784 .960784 .862745 rg
+n 282 .75 24 12 re f*
+.960784 .960784 .862745 rg
+n 306 .75 6 12 re f*
+BT 1 0 0 1 0 38 Tm 12 TL /F6 10 Tf .729412 .129412 .129412 rg (    """) Tj /F4 10 Tf 0 0 0 rg  T* (    ) Tj /F3 10 Tf 0 .501961 0 rg (return) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 0 rg (FunctionMaker) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (create) Tj 0 0 0 rg (\() Tj 0 0 0 rg  T* (        ) Tj 0 0 0 rg (func) Tj 0 0 0 rg (,) Tj 0 0 0 rg ( ) Tj .729412 .129412 .129412 rg ('return decorated\() Tj /F3 10 Tf .733333 .4 .533333 rg (%\(signature\)s) Tj /F4 10 Tf .729412 .129412 .129412 rg (\)') Tj 0 0 0 rg (,) Tj 0 0 0 rg  T* (        ) Tj 0 .501961 0 rg (dict) Tj 0 0 0 rg (\() Tj 0 0 0 rg (decorated) Tj .4 .4 .4 rg (=) Tj 0 0 0 rg (dec) Tj 0 0 0 rg (\() Tj 0 0 0 rg (func) Tj 0 0 0 rg (\)\),) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (__wrapped__) Tj .4 .4 .4 rg (=) Tj 0 0 0 rg (func) Tj 0 0 0 rg (\)) Tj T* ET
+Q
+Q
+Q
 Q
 Q
 q
-1 0 0 1 62.69291 675.0236 cm
+1 0 0 1 62.69291 671.8236 cm
+q
+BT 1 0 0 1 0 14 Tm .698314 Tw 12 TL /F4 10 Tf 0 0 0 rg (decorator_apply ) Tj /F1 10 Tf 0 0 0 rg (sets the attribute ) Tj /F4 10 Tf 0 0 0 rg (.__wrapped__ ) Tj /F1 10 Tf 0 0 0 rg (of the generated function to the original function,) Tj T* 0 Tw (so that you can get the right source code.) Tj T* ET
+Q
+Q
+q
+1 0 0 1 62.69291 629.8236 cm
 q
-BT 1 0 0 1 0 38 Tm 1.74881 Tw 12 TL /F1 10 Tf 0 0 0 rg (In order to give an example of usage of ) Tj /F4 10 Tf (decorator_apply) Tj /F1 10 Tf (, I will show a pretty slick decorator that) Tj T* 0 Tw 1.276651 Tw (converts a tail-recursive function in an iterative function. I have shamelessly stolen the basic idea from) Tj T* 0 Tw 43.62829 Tw (Kay Schluehr's recipe in the Python Cookbook,) Tj T* 0 Tw 0 0 .501961 rg (http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/496691) Tj 0 0 0 rg (.) Tj T* ET
+BT 1 0 0 1 0 26 Tm .13104 Tw 12 TL /F1 10 Tf 0 0 0 rg (Notice that I am not providing this functionality in the ) Tj /F4 10 Tf 0 0 0 rg (decorator ) Tj /F1 10 Tf 0 0 0 rg (module directly since I think it is best to) Tj T* 0 Tw 2.070751 Tw (rewrite the decorator rather than adding an additional level of indirection. However, practicality beats) Tj T* 0 Tw (purity, so you can add ) Tj /F4 10 Tf 0 0 0 rg (decorator_apply ) Tj /F1 10 Tf 0 0 0 rg (to your toolbox and use it if you need to.) Tj T* ET
 Q
 Q
 q
-1 0 0 1 62.69291 305.8236 cm
+1 0 0 1 62.69291 575.8236 cm
+q
+BT 1 0 0 1 0 38 Tm 1.74881 Tw 12 TL /F1 10 Tf 0 0 0 rg (In order to give an example of usage of ) Tj /F4 10 Tf 0 0 0 rg (decorator_apply) Tj /F1 10 Tf 0 0 0 rg (, I will show a pretty slick decorator that) Tj T* 0 Tw 1.276651 Tw (converts a tail-recursive function in an iterative function. I have shamelessly stolen the basic idea from) Tj T* 0 Tw 43.62829 Tw (Kay Schluehr's recipe in the Python Cookbook,) Tj T* 0 Tw 0 0 .501961 rg (http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/496691) Tj 0 0 0 rg (.) Tj T* ET
+Q
+Q
+q
+1 0 0 1 62.69291 206.6236 cm
 q
 q
 1 0 0 1 0 0 cm
@@ -3335,21 +5342,255 @@ q
 n -6 -6 468.6898 360 re B*
 Q
 q
-BT 1 0 0 1 0 338 Tm 12 TL /F3 10 Tf 0 .501961 0 rg (class) Tj /F4 10 Tf 0 0 0 rg ( ) Tj /F3 10 Tf 0 0 1 rg (TailRecursive) Tj /F4 10 Tf 0 0 0 rg (\() Tj 0 .501961 0 rg (object) Tj 0 0 0 rg (\):) Tj  T* (    ) Tj /F6 10 Tf .729412 .129412 .129412 rg (""") Tj T* (    tail_recursive decorator based on Kay Schluehr's recipe) Tj T* (    http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/496691) Tj T* (    with improvements by me and George Sakkis.) Tj T* (    """) Tj /F4 10 Tf 0 0 0 rg  T*  T* (    ) Tj /F3 10 Tf 0 .501961 0 rg (def) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 1 rg (__init__) Tj 0 0 0 rg (\() Tj 0 .501961 0 rg (self) Tj 0 0 0 rg (,) Tj ( ) Tj (func) Tj (\):) Tj  T* (        ) Tj 0 .501961 0 rg (self) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (func) Tj ( ) Tj .4 .4 .4 rg (=) Tj 0 0 0 rg ( ) Tj (func) Tj  T* (        ) Tj 0 .501961 0 rg (self) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (firstcall) Tj ( ) Tj .4 .4 .4 rg (=) Tj 0 0 0 rg ( ) Tj 0 .501961 0 rg (True) Tj 0 0 0 rg  T* (        ) Tj 0 .501961 0 rg (self) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (CONTINUE) Tj ( ) Tj .4 .4 .4 rg (=) Tj 0 0 0 rg ( ) Tj 0 .501961 0 rg (object) Tj 0 0 0 rg (\(\)) Tj ( ) Tj /F6 10 Tf .25098 .501961 .501961 rg (# sentinel) Tj /F4 10 Tf 0 0 0 rg  T*  T* (    ) Tj /F3 10 Tf 0 .501961 0 rg (def) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 1 rg (__call__) Tj 0 0 0 rg (\() Tj 0 .501961 0 rg (self) Tj 0 0 0 rg (,) Tj ( ) Tj .4 .4 .4 rg (*) Tj 0 0 0 rg (args) Tj (,) Tj ( ) Tj .4 .4 .4 rg (**) Tj 0 0 0 rg (kwd) Tj (\):) Tj  T* (        ) Tj (CONTINUE) Tj ( ) Tj .4 .4 .4 rg (=) Tj 0 0 0 rg ( ) Tj 0 .501961 0 rg (self) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (CONTINUE) Tj  T* (        ) Tj /F3 10 Tf 0 .501961 0 rg (if) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 .501961 0 rg (self) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (firstcall) Tj (:) Tj  T* (            ) Tj (func) Tj ( ) Tj .4 .4 .4 rg (=) Tj 0 0 0 rg ( ) Tj 0 .501961 0 rg (self) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (func) Tj  T* (            ) Tj 0 .501961 0 rg (self) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (firstcall) Tj ( ) Tj .4 .4 .4 rg (=) Tj 0 0 0 rg ( ) Tj 0 .501961 0 rg (False) Tj 0 0 0 rg  T* (            ) Tj /F3 10 Tf 0 .501961 0 rg (try) Tj /F4 10 Tf 0 0 0 rg (:) Tj  T* (                ) Tj /F3 10 Tf 0 .501961 0 rg (while) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 .501961 0 rg (True) Tj 0 0 0 rg (:) Tj  T* (                    ) Tj (result) Tj ( ) Tj .4 .4 .4 rg (=) Tj 0 0 0 rg ( ) Tj (func) Tj (\() Tj .4 .4 .4 rg (*) Tj 0 0 0 rg (args) Tj (,) Tj ( ) Tj .4 .4 .4 rg (**) Tj 0 0 0 rg (kwd) Tj (\)) Tj  T* (                    ) Tj /F3 10 Tf 0 .501961 0 rg (if) Tj /F4 10 Tf 0 0 0 rg ( ) Tj (result) Tj ( ) Tj /F3 10 Tf .666667 .133333 1 rg (is) Tj /F4 10 Tf 0 0 0 rg ( ) Tj (CONTINUE) Tj (:) Tj ( ) Tj /F6 10 Tf .25098 .501961 .501961 rg (# update arguments) Tj /F4 10 Tf 0 0 0 rg  T* (                        ) Tj (args) Tj (,) Tj ( ) Tj (kwd) Tj ( ) Tj .4 .4 .4 rg (=) Tj 0 0 0 rg ( ) Tj 0 .501961 0 rg (self) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (argskwd) Tj  T* (                    ) Tj /F3 10 Tf 0 .501961 0 rg (else) Tj /F4 10 Tf 0 0 0 rg (:) Tj ( ) Tj /F6 10 Tf .25098 .501961 .501961 rg (# last call) Tj /F4 10 Tf 0 0 0 rg  T* (                        ) Tj /F3 10 Tf 0 .501961 0 rg (return) Tj /F4 10 Tf 0 0 0 rg ( ) Tj (result) Tj  T* (            ) Tj /F3 10 Tf 0 .501961 0 rg (finally) Tj /F4 10 Tf 0 0 0 rg (:) Tj  T* (                ) Tj 0 .501961 0 rg (self) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (firstcall) Tj ( ) Tj .4 .4 .4 rg (=) Tj 0 0 0 rg ( ) Tj 0 .501961 0 rg (True) Tj 0 0 0 rg  T* (        ) Tj /F3 10 Tf 0 .501961 0 rg (else) Tj /F4 10 Tf 0 0 0 rg (:) Tj ( ) Tj /F6 10 Tf .25098 .501961 .501961 rg (# return the arguments of the tail call) Tj /F4 10 Tf 0 0 0 rg  T* (            ) Tj 0 .501961 0 rg (self) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (argskwd) Tj ( ) Tj .4 .4 .4 rg (=) Tj 0 0 0 rg ( ) Tj (args) Tj (,) Tj ( ) Tj (kwd) Tj  T* (            ) Tj /F3 10 Tf 0 .501961 0 rg (return) Tj /F4 10 Tf 0 0 0 rg ( ) Tj (CONTINUE) Tj T* ET
+.960784 .960784 .862745 rg
+n 0 336.75 30 12 re f*
+.960784 .960784 .862745 rg
+n 36 336.75 78 12 re f*
+.960784 .960784 .862745 rg
+n 114 336.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 120 336.75 36 12 re f*
+.960784 .960784 .862745 rg
+n 156 336.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 24 324.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 0 312.75 354 12 re f*
+.960784 .960784 .862745 rg
+n 0 300.75 396 12 re f*
+.960784 .960784 .862745 rg
+n 0 288.75 276 12 re f*
+.960784 .960784 .862745 rg
+n 0 276.75 42 12 re f*
+.960784 .960784 .862745 rg
+n 24 252.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 48 252.75 48 12 re f*
+.960784 .960784 .862745 rg
+n 96 252.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 102 252.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 126 252.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 138 252.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 162 252.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 48 240.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 72 240.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 78 240.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 108 240.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 120 240.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 48 228.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 72 228.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 78 228.75 54 12 re f*
+.960784 .960784 .862745 rg
+n 138 228.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 150 228.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 48 216.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 72 216.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 78 216.75 48 12 re f*
+.960784 .960784 .862745 rg
+n 132 216.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 144 216.75 36 12 re f*
+.960784 .960784 .862745 rg
+n 180 216.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 204 216.75 60 12 re f*
+.960784 .960784 .862745 rg
+n 24 192.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 48 192.75 48 12 re f*
+.960784 .960784 .862745 rg
+n 96 192.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 102 192.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 126 192.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 138 192.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 144 192.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 168 192.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 180 192.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 192 192.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 210 192.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 48 180.75 48 12 re f*
+.960784 .960784 .862745 rg
+n 102 180.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 114 180.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 138 180.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 144 180.75 48 12 re f*
+.960784 .960784 .862745 rg
+n 48 168.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 66 168.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 90 168.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 96 168.75 54 12 re f*
+.960784 .960784 .862745 rg
+n 150 168.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 72 156.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 102 156.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 114 156.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 138 156.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 144 156.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 72 144.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 96 144.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 102 144.75 54 12 re f*
+.960784 .960784 .862745 rg
+n 162 144.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 174 144.75 30 12 re f*
+.960784 .960784 .862745 rg
+n 72 132.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 90 132.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 96 120.75 30 12 re f*
+.960784 .960784 .862745 rg
+n 132 120.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 156 120.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 120 108.75 36 12 re f*
+.960784 .960784 .862745 rg
+n 162 108.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 174 108.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 198 108.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 204 108.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 210 108.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 234 108.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 246 108.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 258 108.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 276 108.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 120 96.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 138 96.75 36 12 re f*
+.960784 .960784 .862745 rg
+n 180 96.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 198 96.75 48 12 re f*
+.960784 .960784 .862745 rg
+n 246 96.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 264 96.75 108 12 re f*
+.960784 .960784 .862745 rg
+n 144 84.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 168 84.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 180 84.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 204 84.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 216 84.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 240 84.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 246 84.75 42 12 re f*
+.960784 .960784 .862745 rg
+n 120 72.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 144 72.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 162 72.75 66 12 re f*
+.960784 .960784 .862745 rg
+n 144 60.75 36 12 re f*
+.960784 .960784 .862745 rg
+n 186 60.75 36 12 re f*
+.960784 .960784 .862745 rg
+n 72 48.75 42 12 re f*
+.960784 .960784 .862745 rg
+n 114 48.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 96 36.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 120 36.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 126 36.75 54 12 re f*
+.960784 .960784 .862745 rg
+n 186 36.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 198 36.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 48 24.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 72 24.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 90 24.75 234 12 re f*
+.960784 .960784 .862745 rg
+n 72 12.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 96 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 102 12.75 42 12 re f*
+.960784 .960784 .862745 rg
+n 150 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 162 12.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 186 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 198 12.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 72 .75 36 12 re f*
+.960784 .960784 .862745 rg
+n 114 .75 48 12 re f*
+BT 1 0 0 1 0 338 Tm 12 TL /F3 10 Tf 0 .501961 0 rg (class) Tj /F4 10 Tf 0 0 0 rg ( ) Tj /F3 10 Tf 0 0 1 rg (TailRecursive) Tj /F4 10 Tf 0 0 0 rg (\() Tj 0 .501961 0 rg (object) Tj 0 0 0 rg (\):) Tj 0 0 0 rg  T* (    ) Tj /F6 10 Tf .729412 .129412 .129412 rg (""") Tj T* (    tail_recursive decorator based on Kay Schluehr's recipe) Tj T* (    http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/496691) Tj T* (    with improvements by me and George Sakkis.) Tj T* (    """) Tj /F4 10 Tf 0 0 0 rg  T*  T* (    ) Tj /F3 10 Tf 0 .501961 0 rg (def) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 1 rg (__init__) Tj 0 0 0 rg (\() Tj 0 .501961 0 rg (self) Tj 0 0 0 rg (,) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (func) Tj 0 0 0 rg (\):) Tj 0 0 0 rg  T* (        ) Tj 0 .501961 0 rg (self) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (func) Tj 0 0 0 rg ( ) Tj .4 .4 .4 rg (=) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (func) Tj 0 0 0 rg  T* (        ) Tj 0 .501961 0 rg (self) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (firstcall) Tj 0 0 0 rg ( ) Tj .4 .4 .4 rg (=) Tj 0 0 0 rg ( ) Tj 0 .501961 0 rg (True) Tj 0 0 0 rg  T* (        ) Tj 0 .501961 0 rg (self) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (CONTINUE) Tj 0 0 0 rg ( ) Tj .4 .4 .4 rg (=) Tj 0 0 0 rg ( ) Tj 0 .501961 0 rg (object) Tj 0 0 0 rg (\(\)) Tj 0 0 0 rg (  ) Tj /F6 10 Tf .25098 .501961 .501961 rg (# sentinel) Tj /F4 10 Tf 0 0 0 rg  T*  T* (    ) Tj /F3 10 Tf 0 .501961 0 rg (def) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 1 rg (__call__) Tj 0 0 0 rg (\() Tj 0 .501961 0 rg (self) Tj 0 0 0 rg (,) Tj 0 0 0 rg ( ) Tj .4 .4 .4 rg (*) Tj 0 0 0 rg (args) Tj 0 0 0 rg (,) Tj 0 0 0 rg ( ) Tj .4 .4 .4 rg (**) Tj 0 0 0 rg (kwd) Tj 0 0 0 rg (\):) Tj 0 0 0 rg  T* (        ) Tj 0 0 0 rg (CONTINUE) Tj 0 0 0 rg ( ) Tj .4 .4 .4 rg (=) Tj 0 0 0 rg ( ) Tj 0 .501961 0 rg (self) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (CONTINUE) Tj 0 0 0 rg  T* (        ) Tj /F3 10 Tf 0 .501961 0 rg (if) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 .501961 0 rg (self) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (firstcall) Tj 0 0 0 rg (:) Tj 0 0 0 rg  T* (            ) Tj 0 0 0 rg (func) Tj 0 0 0 rg ( ) Tj .4 .4 .4 rg (=) Tj 0 0 0 rg ( ) Tj 0 .501961 0 rg (self) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (func) Tj 0 0 0 rg  T* (            ) Tj 0 .501961 0 rg (self) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (firstcall) Tj 0 0 0 rg ( ) Tj .4 .4 .4 rg (=) Tj 0 0 0 rg ( ) Tj 0 .501961 0 rg (False) Tj 0 0 0 rg  T* (            ) Tj /F3 10 Tf 0 .501961 0 rg (try) Tj /F4 10 Tf 0 0 0 rg (:) Tj 0 0 0 rg  T* (                ) Tj /F3 10 Tf 0 .501961 0 rg (while) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 .501961 0 rg (True) Tj 0 0 0 rg (:) Tj 0 0 0 rg  T* (                    ) Tj 0 0 0 rg (result) Tj 0 0 0 rg ( ) Tj .4 .4 .4 rg (=) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (func) Tj 0 0 0 rg (\() Tj .4 .4 .4 rg (*) Tj 0 0 0 rg (args) Tj 0 0 0 rg (,) Tj 0 0 0 rg ( ) Tj .4 .4 .4 rg (**) Tj 0 0 0 rg (kwd) Tj 0 0 0 rg (\)) Tj 0 0 0 rg  T* (                    ) Tj /F3 10 Tf 0 .501961 0 rg (if) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 0 rg (result) Tj 0 0 0 rg ( ) Tj /F3 10 Tf .666667 .133333 1 rg (is) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 0 rg (CONTINUE) Tj 0 0 0 rg (:) Tj 0 0 0 rg (  ) Tj /F6 10 Tf .25098 .501961 .501961 rg (# update arguments) Tj /F4 10 Tf 0 0 0 rg  T* (                        ) Tj 0 0 0 rg (args) Tj 0 0 0 rg (,) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (kwd) Tj 0 0 0 rg ( ) Tj .4 .4 .4 rg (=) Tj 0 0 0 rg ( ) Tj 0 .501961 0 rg (self) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (argskwd) Tj 0 0 0 rg  T* (                    ) Tj /F3 10 Tf 0 .501961 0 rg (else) Tj /F4 10 Tf 0 0 0 rg (:) Tj 0 0 0 rg (  ) Tj /F6 10 Tf .25098 .501961 .501961 rg (# last call) Tj /F4 10 Tf 0 0 0 rg  T* (                        ) Tj /F3 10 Tf 0 .501961 0 rg (return) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 0 rg (result) Tj 0 0 0 rg  T* (            ) Tj /F3 10 Tf 0 .501961 0 rg (finally) Tj /F4 10 Tf 0 0 0 rg (:) Tj 0 0 0 rg  T* (                ) Tj 0 .501961 0 rg (self) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (firstcall) Tj 0 0 0 rg ( ) Tj .4 .4 .4 rg (=) Tj 0 0 0 rg ( ) Tj 0 .501961 0 rg (True) Tj 0 0 0 rg  T* (        ) Tj /F3 10 Tf 0 .501961 0 rg (else) Tj /F4 10 Tf 0 0 0 rg (:) Tj 0 0 0 rg (  ) Tj /F6 10 Tf .25098 .501961 .501961 rg (# return the arguments of the tail call) Tj /F4 10 Tf 0 0 0 rg  T* (            ) Tj 0 .501961 0 rg (self) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (argskwd) Tj 0 0 0 rg ( ) Tj .4 .4 .4 rg (=) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (args) Tj 0 0 0 rg (,) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (kwd) Tj 0 0 0 rg  T* (            ) Tj /F3 10 Tf 0 .501961 0 rg (return) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 0 rg (CONTINUE) Tj T* ET
 Q
 Q
 Q
 Q
 Q
 q
-1 0 0 1 62.69291 285.8236 cm
+1 0 0 1 62.69291 186.6236 cm
 q
 0 0 0 rg
 BT 1 0 0 1 0 2 Tm /F1 10 Tf 12 TL (Here the decorator is implemented as a class returning callable objects.) Tj T* ET
 Q
 Q
 q
-1 0 0 1 62.69291 240.6236 cm
+1 0 0 1 62.69291 141.4236 cm
 q
 q
 1 0 0 1 0 0 cm
@@ -3362,21 +5603,52 @@ q
 n -6 -6 468.6898 36 re B*
 Q
 q
-BT 1 0 0 1 0 14 Tm 12 TL /F3 10 Tf 0 .501961 0 rg (def) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 1 rg (tail_recursive) Tj 0 0 0 rg (\() Tj (func) Tj (\):) Tj  T* (    ) Tj /F3 10 Tf 0 .501961 0 rg (return) Tj /F4 10 Tf 0 0 0 rg ( ) Tj (decorator_apply) Tj (\() Tj (TailRecursive) Tj (,) Tj ( ) Tj (func) Tj (\)) Tj T* ET
+.960784 .960784 .862745 rg
+n 0 12.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 24 12.75 84 12 re f*
+.960784 .960784 .862745 rg
+n 108 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 114 12.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 138 12.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 24 .75 36 12 re f*
+.960784 .960784 .862745 rg
+n 66 .75 90 12 re f*
+.960784 .960784 .862745 rg
+n 156 .75 6 12 re f*
+.960784 .960784 .862745 rg
+n 162 .75 78 12 re f*
+.960784 .960784 .862745 rg
+n 240 .75 6 12 re f*
+.960784 .960784 .862745 rg
+n 252 .75 24 12 re f*
+.960784 .960784 .862745 rg
+n 276 .75 6 12 re f*
+BT 1 0 0 1 0 14 Tm 12 TL /F3 10 Tf 0 .501961 0 rg (def) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 1 rg (tail_recursive) Tj 0 0 0 rg (\() Tj 0 0 0 rg (func) Tj 0 0 0 rg (\):) Tj 0 0 0 rg  T* (    ) Tj /F3 10 Tf 0 .501961 0 rg (return) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 0 rg (decorator_apply) Tj 0 0 0 rg (\() Tj 0 0 0 rg (TailRecursive) Tj 0 0 0 rg (,) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (func) Tj 0 0 0 rg (\)) Tj T* ET
 Q
 Q
 Q
 Q
 Q
 q
-1 0 0 1 62.69291 220.6236 cm
+1 0 0 1 62.69291 121.4236 cm
 q
 0 0 0 rg
 BT 1 0 0 1 0 2 Tm /F1 10 Tf 12 TL (Here is how you apply the upgraded decorator to the good old factorial:) Tj T* ET
 Q
 Q
+ 
+endstream
+endobj
+105 0 obj
+<< /Length 8282 >>
+stream
+1 0 0 1 0 0 cm  BT /F1 12 Tf 14.4 TL ET
 q
-1 0 0 1 62.69291 139.4236 cm
+1 0 0 1 62.69291 679.8236 cm
 q
 q
 1 0 0 1 0 0 cm
@@ -3386,17 +5658,75 @@ q
 .662745 .662745 .662745 RG
 .5 w
 .960784 .960784 .862745 rg
-n -6 -6 468.6898 72 re B*
+n -6 -6 468.6898 84 re B*
 Q
 q
-BT 1 0 0 1 0 50 Tm 12 TL /F4 10 Tf .666667 .133333 1 rg (@tail_recursive) Tj 0 0 0 rg  T* /F3 10 Tf 0 .501961 0 rg (def) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 1 rg (factorial) Tj 0 0 0 rg (\() Tj (n) Tj (,) Tj ( ) Tj (acc) Tj .4 .4 .4 rg (=) Tj (1) Tj 0 0 0 rg (\):) Tj  T* (    ) Tj .729412 .129412 .129412 rg ("The good old factorial") Tj 0 0 0 rg  T* (    ) Tj /F3 10 Tf 0 .501961 0 rg (if) Tj /F4 10 Tf 0 0 0 rg ( ) Tj (n) Tj ( ) Tj .4 .4 .4 rg (==) Tj 0 0 0 rg ( ) Tj .4 .4 .4 rg (0) Tj 0 0 0 rg (:) Tj ( ) Tj /F3 10 Tf 0 .501961 0 rg (return) Tj /F4 10 Tf 0 0 0 rg ( ) Tj (acc) Tj  T* (    ) Tj /F3 10 Tf 0 .501961 0 rg (return) Tj /F4 10 Tf 0 0 0 rg ( ) Tj (factorial) Tj (\() Tj (n) Tj .4 .4 .4 rg (-) Tj (1) Tj 0 0 0 rg (,) Tj ( ) Tj (n) Tj .4 .4 .4 rg (*) Tj 0 0 0 rg (acc) Tj (\)) Tj T* ET
+.960784 .960784 .862745 rg
+n 0 60.75 90 12 re f*
+.960784 .960784 .862745 rg
+n 0 48.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 24 48.75 54 12 re f*
+.960784 .960784 .862745 rg
+n 78 48.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 84 48.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 90 48.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 102 48.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 120 48.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 126 48.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 132 48.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 24 36.75 144 12 re f*
+.960784 .960784 .862745 rg
+n 24 24.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 42 24.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 54 24.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 72 24.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 78 24.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 48 12.75 36 12 re f*
+.960784 .960784 .862745 rg
+n 90 12.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 24 .75 36 12 re f*
+.960784 .960784 .862745 rg
+n 66 .75 54 12 re f*
+.960784 .960784 .862745 rg
+n 120 .75 6 12 re f*
+.960784 .960784 .862745 rg
+n 126 .75 6 12 re f*
+.960784 .960784 .862745 rg
+n 132 .75 6 12 re f*
+.960784 .960784 .862745 rg
+n 138 .75 6 12 re f*
+.960784 .960784 .862745 rg
+n 144 .75 6 12 re f*
+.960784 .960784 .862745 rg
+n 156 .75 6 12 re f*
+.960784 .960784 .862745 rg
+n 162 .75 6 12 re f*
+.960784 .960784 .862745 rg
+n 168 .75 18 12 re f*
+.960784 .960784 .862745 rg
+n 186 .75 6 12 re f*
+BT 1 0 0 1 0 62 Tm 12 TL /F4 10 Tf .666667 .133333 1 rg (@tail_recursive) Tj 0 0 0 rg  T* /F3 10 Tf 0 .501961 0 rg (def) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 1 rg (factorial) Tj 0 0 0 rg (\() Tj 0 0 0 rg (n) Tj 0 0 0 rg (,) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (acc) Tj .4 .4 .4 rg (=) Tj .4 .4 .4 rg (1) Tj 0 0 0 rg (\):) Tj 0 0 0 rg  T* (    ) Tj .729412 .129412 .129412 rg ("The good old factorial") Tj 0 0 0 rg  T* (    ) Tj /F3 10 Tf 0 .501961 0 rg (if) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 0 rg (n) Tj 0 0 0 rg ( ) Tj .4 .4 .4 rg (==) Tj 0 0 0 rg ( ) Tj .4 .4 .4 rg (0) Tj 0 0 0 rg (:) Tj 0 0 0 rg  T* (        ) Tj /F3 10 Tf 0 .501961 0 rg (return) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 0 rg (acc) Tj 0 0 0 rg  T* (    ) Tj /F3 10 Tf 0 .501961 0 rg (return) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 0 rg (factorial) Tj 0 0 0 rg (\() Tj 0 0 0 rg (n) Tj .4 .4 .4 rg (-) Tj .4 .4 .4 rg (1) Tj 0 0 0 rg (,) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (n) Tj .4 .4 .4 rg (*) Tj 0 0 0 rg (acc) Tj 0 0 0 rg (\)) Tj T* ET
 Q
 Q
 Q
 Q
 Q
 q
-1 0 0 1 62.69291 94.22362 cm
+1 0 0 1 62.69291 634.6236 cm
 q
 q
 1 0 0 1 0 0 cm
@@ -3409,29 +5739,40 @@ q
 n -6 -6 468.6898 36 re B*
 Q
 q
-BT 1 0 0 1 0 14 Tm 12 TL /F4 10 Tf .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj /F3 10 Tf 0 .501961 0 rg (print) Tj /F4 10 Tf 0 0 0 rg (\() Tj (factorial) Tj (\() Tj .4 .4 .4 rg (4) Tj 0 0 0 rg (\)\)) Tj  T* .4 .4 .4 rg (24) Tj T* ET
+.960784 .960784 .862745 rg
+n 0 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 6 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 12 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 24 12.75 30 12 re f*
+.960784 .960784 .862745 rg
+n 54 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 60 12.75 54 12 re f*
+.960784 .960784 .862745 rg
+n 114 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 120 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 126 12.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 0 .75 12 12 re f*
+BT 1 0 0 1 0 14 Tm 12 TL /F4 10 Tf .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj /F3 10 Tf 0 .501961 0 rg (print) Tj /F4 10 Tf 0 0 0 rg (\() Tj 0 0 0 rg (factorial) Tj 0 0 0 rg (\() Tj .4 .4 .4 rg (4) Tj 0 0 0 rg (\)\)) Tj 0 0 0 rg  T* .4 .4 .4 rg (24) Tj T* ET
 Q
 Q
 Q
 Q
 Q
- 
-endstream
-endobj
-% 'R101': class PDFStream 
-101 0 obj
-% page stream
-<< /Length 4932 >>
-stream
-1 0 0 1 0 0 cm  BT /F1 12 Tf 14.4 TL ET
 q
-1 0 0 1 62.69291 717.0236 cm
+1 0 0 1 62.69291 578.6236 cm
 q
-BT 1 0 0 1 0 38 Tm .188935 Tw 12 TL /F1 10 Tf 0 0 0 rg (This decorator is pretty impressive, and should give you some food for your mind ;\) Notice that there is no) Tj T* 0 Tw 1.339983 Tw (recursion limit now, and you can easily compute ) Tj /F4 10 Tf (factorial\(1001\) ) Tj /F1 10 Tf (or larger without filling the stack) Tj T* 0 Tw .909431 Tw (frame. Notice also that the decorator will not work on functions which are not tail recursive, such as the) Tj T* 0 Tw (following) Tj T* ET
+BT 1 0 0 1 0 38 Tm .188935 Tw 12 TL /F1 10 Tf 0 0 0 rg (This decorator is pretty impressive, and should give you some food for your mind ;\) Notice that there is no) Tj T* 0 Tw 1.339983 Tw (recursion limit now, and you can easily compute ) Tj /F4 10 Tf 0 0 0 rg (factorial\(1001\) ) Tj /F1 10 Tf 0 0 0 rg (or larger without filling the stack) Tj T* 0 Tw .909431 Tw (frame. Notice also that the decorator will not work on functions which are not tail recursive, such as the) Tj T* 0 Tw (following) Tj T* ET
 Q
 Q
 q
-1 0 0 1 62.69291 659.8236 cm
+1 0 0 1 62.69291 509.4236 cm
 q
 q
 1 0 0 1 0 0 cm
@@ -3441,37 +5782,81 @@ q
 .662745 .662745 .662745 RG
 .5 w
 .960784 .960784 .862745 rg
-n -6 -6 468.6898 48 re B*
+n -6 -6 468.6898 60 re B*
 Q
 q
-BT 1 0 0 1 0 26 Tm 12 TL /F3 10 Tf 0 .501961 0 rg (def) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 1 rg (fact) Tj 0 0 0 rg (\() Tj (n) Tj (\):) Tj ( ) Tj /F6 10 Tf .25098 .501961 .501961 rg (# this is not tail-recursive) Tj /F4 10 Tf 0 0 0 rg  T* (    ) Tj /F3 10 Tf 0 .501961 0 rg (if) Tj /F4 10 Tf 0 0 0 rg ( ) Tj (n) Tj ( ) Tj .4 .4 .4 rg (==) Tj 0 0 0 rg ( ) Tj .4 .4 .4 rg (0) Tj 0 0 0 rg (:) Tj ( ) Tj /F3 10 Tf 0 .501961 0 rg (return) Tj /F4 10 Tf 0 0 0 rg ( ) Tj .4 .4 .4 rg (1) Tj 0 0 0 rg  T* (    ) Tj /F3 10 Tf 0 .501961 0 rg (return) Tj /F4 10 Tf 0 0 0 rg ( ) Tj (n) Tj ( ) Tj .4 .4 .4 rg (*) Tj 0 0 0 rg ( ) Tj (fact) Tj (\() Tj (n) Tj .4 .4 .4 rg (-) Tj (1) Tj 0 0 0 rg (\)) Tj T* ET
+.960784 .960784 .862745 rg
+n 0 36.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 24 36.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 48 36.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 54 36.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 60 36.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 84 36.75 168 12 re f*
+.960784 .960784 .862745 rg
+n 24 24.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 42 24.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 54 24.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 72 24.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 78 24.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 48 12.75 36 12 re f*
+.960784 .960784 .862745 rg
+n 90 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 24 .75 36 12 re f*
+.960784 .960784 .862745 rg
+n 66 .75 6 12 re f*
+.960784 .960784 .862745 rg
+n 78 .75 6 12 re f*
+.960784 .960784 .862745 rg
+n 90 .75 24 12 re f*
+.960784 .960784 .862745 rg
+n 114 .75 6 12 re f*
+.960784 .960784 .862745 rg
+n 120 .75 6 12 re f*
+.960784 .960784 .862745 rg
+n 126 .75 6 12 re f*
+.960784 .960784 .862745 rg
+n 132 .75 6 12 re f*
+.960784 .960784 .862745 rg
+n 138 .75 6 12 re f*
+BT 1 0 0 1 0 38 Tm 12 TL /F3 10 Tf 0 .501961 0 rg (def) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 1 rg (fact) Tj 0 0 0 rg (\() Tj 0 0 0 rg (n) Tj 0 0 0 rg (\):) Tj 0 0 0 rg (  ) Tj /F6 10 Tf .25098 .501961 .501961 rg (# this is not tail-recursive) Tj /F4 10 Tf 0 0 0 rg  T* (    ) Tj /F3 10 Tf 0 .501961 0 rg (if) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 0 rg (n) Tj 0 0 0 rg ( ) Tj .4 .4 .4 rg (==) Tj 0 0 0 rg ( ) Tj .4 .4 .4 rg (0) Tj 0 0 0 rg (:) Tj 0 0 0 rg  T* (        ) Tj /F3 10 Tf 0 .501961 0 rg (return) Tj /F4 10 Tf 0 0 0 rg ( ) Tj .4 .4 .4 rg (1) Tj 0 0 0 rg  T* (    ) Tj /F3 10 Tf 0 .501961 0 rg (return) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 0 rg (n) Tj 0 0 0 rg ( ) Tj .4 .4 .4 rg (*) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (fact) Tj 0 0 0 rg (\() Tj 0 0 0 rg (n) Tj .4 .4 .4 rg (-) Tj .4 .4 .4 rg (1) Tj 0 0 0 rg (\)) Tj T* ET
 Q
 Q
 Q
 Q
 Q
 q
-1 0 0 1 62.69291 627.8236 cm
+1 0 0 1 62.69291 477.4236 cm
 q
 0 0 0 rg
 BT 1 0 0 1 0 14 Tm /F1 10 Tf 12 TL .541098 Tw (\(reminder: a function is tail recursive if it either returns a value without making a recursive call, or returns) Tj T* 0 Tw (directly the result of a recursive call\).) Tj T* ET
 Q
 Q
 q
-1 0 0 1 62.69291 594.8236 cm
+1 0 0 1 62.69291 444.4236 cm
 q
 BT 1 0 0 1 0 3.5 Tm 21 TL /F2 17.5 Tf 0 0 0 rg (Caveats and limitations) Tj T* ET
 Q
 Q
 q
-1 0 0 1 62.69291 564.8236 cm
+1 0 0 1 62.69291 414.4236 cm
 q
 0 0 0 rg
 BT 1 0 0 1 0 14 Tm /F1 10 Tf 12 TL .474987 Tw (The first thing you should be aware of, it the fact that decorators have a performance penalty. The worse) Tj T* 0 Tw (case is shown by the following example:) Tj T* ET
 Q
 Q
 q
-1 0 0 1 62.69291 339.6236 cm
+1 0 0 1 62.69291 189.2236 cm
 q
 q
 1 0 0 1 0 0 cm
@@ -3492,13 +5877,13 @@ Q
 Q
 Q
 q
-1 0 0 1 62.69291 307.6236 cm
+1 0 0 1 62.69291 157.2236 cm
 q
-BT 1 0 0 1 0 14 Tm .266235 Tw 12 TL /F1 10 Tf 0 0 0 rg (On my MacBook, using the ) Tj /F4 10 Tf (do_nothing ) Tj /F1 10 Tf (decorator instead of the plain function is more than three times) Tj T* 0 Tw (slower:) Tj T* ET
+BT 1 0 0 1 0 14 Tm .266235 Tw 12 TL /F1 10 Tf 0 0 0 rg (On my MacBook, using the ) Tj /F4 10 Tf 0 0 0 rg (do_nothing ) Tj /F1 10 Tf 0 0 0 rg (decorator instead of the plain function is more than three times) Tj T* 0 Tw (slower:) Tj T* ET
 Q
 Q
 q
-1 0 0 1 62.69291 250.4236 cm
+1 0 0 1 62.69291 100.0236 cm
 q
 q
 1 0 0 1 0 0 cm
@@ -3518,21 +5903,28 @@ Q
 Q
 Q
 Q
+ 
+endstream
+endobj
+106 0 obj
+<< /Length 14576 >>
+stream
+1 0 0 1 0 0 cm  BT /F1 12 Tf 14.4 TL ET
 q
-1 0 0 1 62.69291 206.4236 cm
+1 0 0 1 62.69291 729.0236 cm
 q
-BT 1 0 0 1 0 26 Tm 1.25832 Tw 12 TL /F1 10 Tf 0 0 0 rg (It should be noted that a real life function would probably do something more useful than ) Tj /F4 10 Tf (f ) Tj /F1 10 Tf (here, and) Tj T* 0 Tw .91811 Tw (therefore in real life the performance penalty could be completely negligible. As always, the only way to) Tj T* 0 Tw (know if there is a penalty in your specific use case is to measure it.) Tj T* ET
+BT 1 0 0 1 0 26 Tm 1.25832 Tw 12 TL /F1 10 Tf 0 0 0 rg (It should be noted that a real life function would probably do something more useful than ) Tj /F4 10 Tf 0 0 0 rg (f ) Tj /F1 10 Tf 0 0 0 rg (here, and) Tj T* 0 Tw .91811 Tw (therefore in real life the performance penalty could be completely negligible. As always, the only way to) Tj T* 0 Tw (know if there is a penalty in your specific use case is to measure it.) Tj T* ET
 Q
 Q
 q
-1 0 0 1 62.69291 176.4236 cm
+1 0 0 1 62.69291 699.0236 cm
 q
 0 0 0 rg
 BT 1 0 0 1 0 14 Tm /F1 10 Tf 12 TL .867984 Tw (You should be aware that decorators will make your tracebacks longer and more difficult to understand.) Tj T* 0 Tw (Consider this example:) Tj T* ET
 Q
 Q
 q
-1 0 0 1 62.69291 119.2236 cm
+1 0 0 1 62.69291 641.8236 cm
 q
 q
 1 0 0 1 0 0 cm
@@ -3545,29 +5937,44 @@ q
 n -6 -6 468.6898 48 re B*
 Q
 q
-BT 1 0 0 1 0 26 Tm 12 TL /F4 10 Tf .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj .666667 .133333 1 rg (@trace) Tj 0 0 0 rg  T* .4 .4 .4 rg (...) Tj 0 0 0 rg ( ) Tj /F3 10 Tf 0 .501961 0 rg (def) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 1 rg (f) Tj 0 0 0 rg (\(\):) Tj  T* .4 .4 .4 rg (...) Tj 0 0 0 rg (     ) Tj .4 .4 .4 rg (1) Tj (/) Tj (0) Tj T* ET
+.960784 .960784 .862745 rg
+n 0 24.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 6 24.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 12 24.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 24 24.75 36 12 re f*
+.960784 .960784 .862745 rg
+n 0 12.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 24 12.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 48 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 54 12.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 0 .75 18 12 re f*
+.960784 .960784 .862745 rg
+n 48 .75 6 12 re f*
+.960784 .960784 .862745 rg
+n 54 .75 6 12 re f*
+.960784 .960784 .862745 rg
+n 60 .75 6 12 re f*
+BT 1 0 0 1 0 26 Tm 12 TL /F4 10 Tf .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj .666667 .133333 1 rg (@trace) Tj 0 0 0 rg  T* .4 .4 .4 rg (...) Tj 0 0 0 rg ( ) Tj /F3 10 Tf 0 .501961 0 rg (def) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 1 rg (f) Tj 0 0 0 rg (\(\):) Tj 0 0 0 rg  T* .4 .4 .4 rg (...) Tj 0 0 0 rg (     ) Tj .4 .4 .4 rg (1) Tj .4 .4 .4 rg (/) Tj .4 .4 .4 rg (0) Tj T* ET
 Q
 Q
 Q
 Q
 Q
 q
-1 0 0 1 62.69291 87.22362 cm
+1 0 0 1 62.69291 609.8236 cm
 q
-BT 1 0 0 1 0 14 Tm .583318 Tw 12 TL /F1 10 Tf 0 0 0 rg (Calling ) Tj /F4 10 Tf (f\(\) ) Tj /F1 10 Tf (will give you a ) Tj /F4 10 Tf (ZeroDivisionError) Tj /F1 10 Tf (, but since the function is decorated the traceback will) Tj T* 0 Tw (be longer:) Tj T* ET
+BT 1 0 0 1 0 14 Tm .583318 Tw 12 TL /F1 10 Tf 0 0 0 rg (Calling ) Tj /F4 10 Tf 0 0 0 rg (f\(\) ) Tj /F1 10 Tf 0 0 0 rg (will give you a ) Tj /F4 10 Tf 0 0 0 rg (ZeroDivisionError) Tj /F1 10 Tf 0 0 0 rg (, but since the function is decorated the traceback will) Tj T* 0 Tw (be longer:) Tj T* ET
 Q
 Q
- 
-endstream
-endobj
-% 'R102': class PDFStream 
-102 0 obj
-% page stream
-<< /Length 8009 >>
-stream
-1 0 0 1 0 0 cm  BT /F1 12 Tf 14.4 TL ET
 q
-1 0 0 1 62.69291 643.8236 cm
+1 0 0 1 62.69291 480.6236 cm
 q
 q
 1 0 0 1 0 0 cm
@@ -3580,38 +5987,166 @@ q
 n -6 -6 468.6898 120 re B*
 Q
 q
-BT 1 0 0 1 0 98 Tm 12 TL /F4 10 Tf .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj (f) Tj (\(\)) Tj  T* (Traceback) Tj ( ) Tj (\() Tj (most) Tj ( ) Tj (recent) Tj ( ) Tj (call) Tj ( ) Tj (last) Tj (\):) Tj  T* (  ) Tj .4 .4 .4 rg (...) Tj 0 0 0 rg  T* (     ) Tj (File) Tj ( ) Tj .729412 .129412 .129412 rg (") Tj (<) Tj (string) Tj (>) Tj (") Tj 0 0 0 rg (,) Tj ( ) Tj (line) Tj ( ) Tj .4 .4 .4 rg (2) Tj 0 0 0 rg (,) Tj ( ) Tj /F3 10 Tf .666667 .133333 1 rg (in) Tj /F4 10 Tf 0 0 0 rg ( ) Tj (f) Tj  T* (     ) Tj (File) Tj ( ) Tj .729412 .129412 .129412 rg (") Tj (<) Tj (doctest __main__[22]) Tj (>) Tj (") Tj 0 0 0 rg (,) Tj ( ) Tj (line) Tj ( ) Tj .4 .4 .4 rg (4) Tj 0 0 0 rg (,) Tj ( ) Tj /F3 10 Tf .666667 .133333 1 rg (in) Tj /F4 10 Tf 0 0 0 rg ( ) Tj (trace) Tj  T* (       ) Tj /F3 10 Tf 0 .501961 0 rg (return) Tj /F4 10 Tf 0 0 0 rg ( ) Tj (f) Tj (\() Tj .4 .4 .4 rg (*) Tj 0 0 0 rg (args) Tj (,) Tj ( ) Tj .4 .4 .4 rg (**) Tj 0 0 0 rg (kw) Tj (\)) Tj  T* (     ) Tj (File) Tj ( ) Tj .729412 .129412 .129412 rg (") Tj (<) Tj (doctest __main__[51]) Tj (>) Tj (") Tj 0 0 0 rg (,) Tj ( ) Tj (line) Tj ( ) Tj .4 .4 .4 rg (3) Tj 0 0 0 rg (,) Tj ( ) Tj /F3 10 Tf .666667 .133333 1 rg (in) Tj /F4 10 Tf 0 0 0 rg ( ) Tj (f) Tj  T* (       ) Tj .4 .4 .4 rg (1) Tj (/) Tj (0) Tj 0 0 0 rg  T* /F3 10 Tf .823529 .254902 .227451 rg (ZeroDivisionError) Tj /F4 10 Tf 0 0 0 rg (:) Tj ( ) Tj .4 .4 .4 rg (...) Tj T* ET
+.960784 .960784 .862745 rg
+n 0 96.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 6 96.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 12 96.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 24 96.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 30 96.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 0 84.75 54 12 re f*
+.960784 .960784 .862745 rg
+n 60 84.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 66 84.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 96 84.75 36 12 re f*
+.960784 .960784 .862745 rg
+n 138 84.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 168 84.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 192 84.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 12 72.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 30 60.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 60 60.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 66 60.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 72 60.75 36 12 re f*
+.960784 .960784 .862745 rg
+n 108 60.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 114 60.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 120 60.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 132 60.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 162 60.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 168 60.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 180 60.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 198 60.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 30 48.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 60 48.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 66 48.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 72 48.75 120 12 re f*
+.960784 .960784 .862745 rg
+n 192 48.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 198 48.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 204 48.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 216 48.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 246 48.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 252 48.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 264 48.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 282 48.75 30 12 re f*
+.960784 .960784 .862745 rg
+n 42 36.75 36 12 re f*
+.960784 .960784 .862745 rg
+n 84 36.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 90 36.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 96 36.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 102 36.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 126 36.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 138 36.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 150 36.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 162 36.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 30 24.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 60 24.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 66 24.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 72 24.75 120 12 re f*
+.960784 .960784 .862745 rg
+n 192 24.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 198 24.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 204 24.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 216 24.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 246 24.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 252 24.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 264 24.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 282 24.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 42 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 48 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 54 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 0 .75 102 12 re f*
+.960784 .960784 .862745 rg
+n 102 .75 6 12 re f*
+.960784 .960784 .862745 rg
+n 114 .75 18 12 re f*
+BT 1 0 0 1 0 98 Tm 12 TL /F4 10 Tf .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (f) Tj 0 0 0 rg (\(\)) Tj 0 0 0 rg  T* 0 0 0 rg (Traceback) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (\() Tj 0 0 0 rg (most) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (recent) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (call) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (last) Tj 0 0 0 rg (\):) Tj 0 0 0 rg  T* (  ) Tj .4 .4 .4 rg (...) Tj 0 0 0 rg  T* (     ) Tj 0 0 0 rg (File) Tj 0 0 0 rg ( ) Tj .729412 .129412 .129412 rg (") Tj (<) Tj (string) Tj (>) Tj (") Tj 0 0 0 rg (,) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (line) Tj 0 0 0 rg ( ) Tj .4 .4 .4 rg (2) Tj 0 0 0 rg (,) Tj 0 0 0 rg ( ) Tj /F3 10 Tf .666667 .133333 1 rg (in) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 0 rg (f) Tj 0 0 0 rg  T* (     ) Tj 0 0 0 rg (File) Tj 0 0 0 rg ( ) Tj .729412 .129412 .129412 rg (") Tj (<) Tj (doctest __main__[22]) Tj (>) Tj (") Tj 0 0 0 rg (,) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (line) Tj 0 0 0 rg ( ) Tj .4 .4 .4 rg (4) Tj 0 0 0 rg (,) Tj 0 0 0 rg ( ) Tj /F3 10 Tf .666667 .133333 1 rg (in) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 0 rg (trace) Tj 0 0 0 rg  T* (       ) Tj /F3 10 Tf 0 .501961 0 rg (return) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 0 rg (f) Tj 0 0 0 rg (\() Tj .4 .4 .4 rg (*) Tj 0 0 0 rg (args) Tj 0 0 0 rg (,) Tj 0 0 0 rg ( ) Tj .4 .4 .4 rg (**) Tj 0 0 0 rg (kw) Tj 0 0 0 rg (\)) Tj 0 0 0 rg  T* (     ) Tj 0 0 0 rg (File) Tj 0 0 0 rg ( ) Tj .729412 .129412 .129412 rg (") Tj (<) Tj (doctest __main__[51]) Tj (>) Tj (") Tj 0 0 0 rg (,) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (line) Tj 0 0 0 rg ( ) Tj .4 .4 .4 rg (3) Tj 0 0 0 rg (,) Tj 0 0 0 rg ( ) Tj /F3 10 Tf .666667 .133333 1 rg (in) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 0 rg (f) Tj 0 0 0 rg  T* (       ) Tj .4 .4 .4 rg (1) Tj .4 .4 .4 rg (/) Tj .4 .4 .4 rg (0) Tj 0 0 0 rg  T* /F3 10 Tf .823529 .254902 .227451 rg (ZeroDivisionError) Tj /F4 10 Tf 0 0 0 rg (:) Tj 0 0 0 rg ( ) Tj .4 .4 .4 rg (...) Tj T* ET
 Q
 Q
 Q
 Q
 Q
 q
-1 0 0 1 62.69291 575.8236 cm
+1 0 0 1 62.69291 412.6236 cm
 q
-BT 1 0 0 1 0 50 Tm 1.05528 Tw 12 TL /F1 10 Tf 0 0 0 rg (You see here the inner call to the decorator ) Tj /F4 10 Tf (trace) Tj /F1 10 Tf (, which calls ) Tj /F4 10 Tf (f\(*args,) Tj ( ) Tj (**kw\)) Tj /F1 10 Tf (, and a reference to) Tj T* 0 Tw .076457 Tw /F4 10 Tf (File) Tj ( ) Tj (") Tj (<) Tj (string) Tj (>) Tj (",) Tj ( ) Tj (line) Tj ( ) Tj (2,) Tj ( ) Tj (in) Tj ( ) Tj (f) Tj /F1 10 Tf (. This latter reference is due to the fact that internally the decorator) Tj T* 0 Tw 2.053318 Tw (module uses ) Tj /F4 10 Tf (exec ) Tj /F1 10 Tf (to generate the decorated function. Notice that ) Tj /F4 10 Tf (exec ) Tj /F1 10 Tf (is ) Tj /F5 10 Tf (not ) Tj /F1 10 Tf (responsibile for the) Tj T* 0 Tw 1.507485 Tw (performance penalty, since is the called ) Tj /F5 10 Tf (only once ) Tj /F1 10 Tf (at function decoration time, and not every time the) Tj T* 0 Tw (decorated function is called.) Tj T* ET
+BT 1 0 0 1 0 50 Tm 1.05528 Tw 12 TL /F1 10 Tf 0 0 0 rg (You see here the inner call to the decorator ) Tj /F4 10 Tf 0 0 0 rg (trace) Tj /F1 10 Tf 0 0 0 rg (, which calls ) Tj /F4 10 Tf 0 0 0 rg (f\(*args,) Tj ( ) Tj (**kw\)) Tj /F1 10 Tf 0 0 0 rg (, and a reference to) Tj T* 0 Tw .076457 Tw /F4 10 Tf 0 0 0 rg (File) Tj ( ) Tj (") Tj (<) Tj (string) Tj (>) Tj (",) Tj ( ) Tj (line) Tj ( ) Tj (2,) Tj ( ) Tj (in) Tj ( ) Tj (f) Tj /F1 10 Tf 0 0 0 rg (. This latter reference is due to the fact that internally the decorator) Tj T* 0 Tw 2.053318 Tw (module uses ) Tj /F4 10 Tf 0 0 0 rg (exec ) Tj /F1 10 Tf 0 0 0 rg (to generate the decorated function. Notice that ) Tj /F4 10 Tf 0 0 0 rg (exec ) Tj /F1 10 Tf 0 0 0 rg (is ) Tj /F5 10 Tf (not ) Tj /F1 10 Tf (responsibile for the) Tj T* 0 Tw 1.507485 Tw (performance penalty, since is the called ) Tj /F5 10 Tf (only once ) Tj /F1 10 Tf (at function decoration time, and not every time the) Tj T* 0 Tw (decorated function is called.) Tj T* ET
 Q
 Q
 q
-1 0 0 1 62.69291 497.8236 cm
+1 0 0 1 62.69291 334.6236 cm
 q
-BT 1 0 0 1 0 62 Tm .932209 Tw 12 TL /F1 10 Tf 0 0 0 rg (At present, there is no clean way to avoid ) Tj /F4 10 Tf (exec) Tj /F1 10 Tf (. A clean solution would require to change the CPython) Tj T* 0 Tw .777485 Tw (implementation of functions and add an hook to make it possible to change their signature directly. That) Tj T* 0 Tw .74186 Tw (could happen in future versions of Python \(see PEP ) Tj 0 0 .501961 rg (362) Tj 0 0 0 rg (\) and then the decorator module would become) Tj T* 0 Tw 2.385318 Tw (obsolete. However, at present, even in Python 3.2 it is impossible to change the function signature) Tj T* 0 Tw .931751 Tw (directly, therefore the ) Tj /F4 10 Tf (decorator ) Tj /F1 10 Tf (module is still useful. Actually, this is one of the main reasons why I) Tj T* 0 Tw (keep maintaining the module and releasing new versions.) Tj T* ET
+BT 1 0 0 1 0 62 Tm .932209 Tw 12 TL /F1 10 Tf 0 0 0 rg (At present, there is no clean way to avoid ) Tj /F4 10 Tf 0 0 0 rg (exec) Tj /F1 10 Tf 0 0 0 rg (. A clean solution would require to change the CPython) Tj T* 0 Tw .777485 Tw (implementation of functions and add an hook to make it possible to change their signature directly. That) Tj T* 0 Tw .74186 Tw (could happen in future versions of Python \(see PEP ) Tj 0 0 .501961 rg (362) Tj 0 0 0 rg (\) and then the decorator module would become) Tj T* 0 Tw 2.385318 Tw (obsolete. However, at present, even in Python 3.2 it is impossible to change the function signature) Tj T* 0 Tw .931751 Tw (directly, therefore the ) Tj /F4 10 Tf 0 0 0 rg (decorator ) Tj /F1 10 Tf 0 0 0 rg (module is still useful. Actually, this is one of the main reasons why I) Tj T* 0 Tw (keep maintaining the module and releasing new versions.) Tj T* ET
 Q
 Q
 q
-1 0 0 1 62.69291 455.8236 cm
+1 0 0 1 62.69291 292.6236 cm
 q
-BT 1 0 0 1 0 26 Tm 1.043828 Tw 12 TL /F1 10 Tf 0 0 0 rg (In the present implementation, decorators generated by ) Tj /F4 10 Tf (decorator ) Tj /F1 10 Tf (can only be used on user-defined) Tj T* 0 Tw .152485 Tw (Python functions or methods, not on generic callable objects, nor on built-in functions, due to limitations of) Tj T* 0 Tw (the ) Tj /F4 10 Tf (inspect ) Tj /F1 10 Tf (module in the standard library.) Tj T* ET
+BT 1 0 0 1 0 26 Tm 1.043828 Tw 12 TL /F1 10 Tf 0 0 0 rg (In the present implementation, decorators generated by ) Tj /F4 10 Tf 0 0 0 rg (decorator ) Tj /F1 10 Tf 0 0 0 rg (can only be used on user-defined) Tj T* 0 Tw .152485 Tw (Python functions or methods, not on generic callable objects, nor on built-in functions, due to limitations of) Tj T* 0 Tw (the ) Tj /F4 10 Tf 0 0 0 rg (inspect ) Tj /F1 10 Tf 0 0 0 rg (module in the standard library.) Tj T* ET
 Q
 Q
 q
-1 0 0 1 62.69291 425.8236 cm
+1 0 0 1 62.69291 262.6236 cm
 q
-BT 1 0 0 1 0 14 Tm .785777 Tw 12 TL /F1 10 Tf 0 0 0 rg (There is a restriction on the names of the arguments: for instance, if try to call an argument ) Tj /F4 10 Tf (_call_ ) Tj /F1 10 Tf (or) Tj T* 0 Tw /F4 10 Tf (_func_ ) Tj /F1 10 Tf (you will get a ) Tj /F4 10 Tf (NameError) Tj /F1 10 Tf (:) Tj T* ET
+BT 1 0 0 1 0 14 Tm .785777 Tw 12 TL /F1 10 Tf 0 0 0 rg (There is a restriction on the names of the arguments: for instance, if try to call an argument ) Tj /F4 10 Tf 0 0 0 rg (_call_ ) Tj /F1 10 Tf 0 0 0 rg (or) Tj T* 0 Tw /F4 10 Tf 0 0 0 rg (_func_ ) Tj /F1 10 Tf 0 0 0 rg (you will get a ) Tj /F4 10 Tf 0 0 0 rg (NameError) Tj /F1 10 Tf 0 0 0 rg (:) Tj T* ET
 Q
 Q
 q
-1 0 0 1 62.69291 308.6236 cm
+1 0 0 1 62.69291 145.4236 cm
 q
 q
 1 0 0 1 0 0 cm
@@ -3624,20 +6159,109 @@ q
 n -6 -6 468.6898 108 re B*
 Q
 q
-BT 1 0 0 1 0 86 Tm 12 TL /F4 10 Tf .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj .666667 .133333 1 rg (@trace) Tj 0 0 0 rg  T* .4 .4 .4 rg (...) Tj 0 0 0 rg ( ) Tj /F3 10 Tf 0 .501961 0 rg (def) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 1 rg (f) Tj 0 0 0 rg (\() Tj (_func_) Tj (\):) Tj ( ) Tj /F3 10 Tf 0 .501961 0 rg (print) Tj /F4 10 Tf 0 0 0 rg (\() Tj (f) Tj (\)) Tj  T* .4 .4 .4 rg (...) Tj 0 0 0 rg  T* (Traceback) Tj ( ) Tj (\() Tj (most) Tj ( ) Tj (recent) Tj ( ) Tj (call) Tj ( ) Tj (last) Tj (\):) Tj  T* (  ) Tj .4 .4 .4 rg (...) Tj 0 0 0 rg  T* /F3 10 Tf .823529 .254902 .227451 rg (NameError) Tj /F4 10 Tf 0 0 0 rg (:) Tj ( ) Tj (_func_) Tj ( ) Tj /F3 10 Tf .666667 .133333 1 rg (is) Tj /F4 10 Tf 0 0 0 rg ( ) Tj (overridden) Tj ( ) Tj /F3 10 Tf .666667 .133333 1 rg (in) Tj /F4 10 Tf 0 0 0 rg  T* /F3 10 Tf 0 .501961 0 rg (def) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 1 rg (f) Tj 0 0 0 rg (\() Tj (_func_) Tj (\):) Tj  T* (    ) Tj /F3 10 Tf 0 .501961 0 rg (return) Tj /F4 10 Tf 0 0 0 rg ( ) Tj (_call_) Tj (\() Tj (_func_) Tj (,) Tj ( ) Tj (_func_) Tj (\)) Tj T* ET
+.960784 .960784 .862745 rg
+n 0 84.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 6 84.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 12 84.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 24 84.75 36 12 re f*
+.960784 .960784 .862745 rg
+n 0 72.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 24 72.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 48 72.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 54 72.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 60 72.75 36 12 re f*
+.960784 .960784 .862745 rg
+n 96 72.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 114 72.75 30 12 re f*
+.960784 .960784 .862745 rg
+n 144 72.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 150 72.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 156 72.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 0 60.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 0 48.75 54 12 re f*
+.960784 .960784 .862745 rg
+n 60 48.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 66 48.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 96 48.75 36 12 re f*
+.960784 .960784 .862745 rg
+n 138 48.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 168 48.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 192 48.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 12 36.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 0 24.75 54 12 re f*
+.960784 .960784 .862745 rg
+n 54 24.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 66 24.75 36 12 re f*
+.960784 .960784 .862745 rg
+n 108 24.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 126 24.75 60 12 re f*
+.960784 .960784 .862745 rg
+n 192 24.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 0 12.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 24 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 30 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 36 12.75 36 12 re f*
+.960784 .960784 .862745 rg
+n 72 12.75 12 12 re f*
+.960784 .960784 .862745 rg
+n 24 .75 36 12 re f*
+.960784 .960784 .862745 rg
+n 66 .75 36 12 re f*
+.960784 .960784 .862745 rg
+n 102 .75 6 12 re f*
+.960784 .960784 .862745 rg
+n 108 .75 36 12 re f*
+.960784 .960784 .862745 rg
+n 144 .75 6 12 re f*
+.960784 .960784 .862745 rg
+n 156 .75 36 12 re f*
+.960784 .960784 .862745 rg
+n 192 .75 6 12 re f*
+BT 1 0 0 1 0 86 Tm 12 TL /F4 10 Tf .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj .666667 .133333 1 rg (@trace) Tj 0 0 0 rg  T* .4 .4 .4 rg (...) Tj 0 0 0 rg ( ) Tj /F3 10 Tf 0 .501961 0 rg (def) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 1 rg (f) Tj 0 0 0 rg (\() Tj 0 0 0 rg (_func_) Tj 0 0 0 rg (\):) Tj 0 0 0 rg ( ) Tj /F3 10 Tf 0 .501961 0 rg (print) Tj /F4 10 Tf 0 0 0 rg (\() Tj 0 0 0 rg (f) Tj 0 0 0 rg (\)) Tj 0 0 0 rg  T* .4 .4 .4 rg (...) Tj 0 0 0 rg  T* 0 0 0 rg (Traceback) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (\() Tj 0 0 0 rg (most) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (recent) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (call) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (last) Tj 0 0 0 rg (\):) Tj 0 0 0 rg  T* (  ) Tj .4 .4 .4 rg (...) Tj 0 0 0 rg  T* /F3 10 Tf .823529 .254902 .227451 rg (NameError) Tj /F4 10 Tf 0 0 0 rg (:) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (_func_) Tj 0 0 0 rg ( ) Tj /F3 10 Tf .666667 .133333 1 rg (is) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 0 rg (overridden) Tj 0 0 0 rg ( ) Tj /F3 10 Tf .666667 .133333 1 rg (in) Tj /F4 10 Tf 0 0 0 rg  T* /F3 10 Tf 0 .501961 0 rg (def) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 1 rg (f) Tj 0 0 0 rg (\() Tj 0 0 0 rg (_func_) Tj 0 0 0 rg (\):) Tj 0 0 0 rg  T* (    ) Tj /F3 10 Tf 0 .501961 0 rg (return) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 0 rg (_call_) Tj 0 0 0 rg (\() Tj 0 0 0 rg (_func_) Tj 0 0 0 rg (,) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (_func_) Tj 0 0 0 rg (\)) Tj T* ET
 Q
 Q
 Q
 Q
 Q
 q
-1 0 0 1 62.69291 276.6236 cm
+1 0 0 1 62.69291 113.4236 cm
 q
-BT 1 0 0 1 0 14 Tm 1.533318 Tw 12 TL /F1 10 Tf 0 0 0 rg (Finally, the implementation is such that the decorated function contains a ) Tj /F5 10 Tf (copy ) Tj /F1 10 Tf (of the original function) Tj T* 0 Tw (dictionary \() Tj /F4 10 Tf (vars\(decorated_f\)) Tj ( ) Tj (is) Tj ( ) Tj (not) Tj ( ) Tj (vars\(f\)) Tj /F1 10 Tf (\):) Tj T* ET
+BT 1 0 0 1 0 14 Tm 1.533318 Tw 12 TL /F1 10 Tf 0 0 0 rg (Finally, the implementation is such that the decorated function contains a ) Tj /F5 10 Tf (copy ) Tj /F1 10 Tf (of the original function) Tj T* 0 Tw (dictionary \() Tj /F4 10 Tf 0 0 0 rg (vars\(decorated_f\)) Tj ( ) Tj (is) Tj ( ) Tj (not) Tj ( ) Tj (vars\(f\)) Tj /F1 10 Tf 0 0 0 rg (\):) Tj T* ET
 Q
 Q
+ 
+endstream
+endobj
+107 0 obj
+<< /Length 11192 >>
+stream
+1 0 0 1 0 0 cm  BT /F1 12 Tf 14.4 TL ET
 q
-1 0 0 1 62.69291 123.4236 cm
+1 0 0 1 62.69291 619.8236 cm
 q
 q
 1 0 0 1 0 0 cm
@@ -3650,82 +6274,193 @@ q
 n -6 -6 468.6898 144 re B*
 Q
 q
-BT 1 0 0 1 0 122 Tm 12 TL /F4 10 Tf .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj /F3 10 Tf 0 .501961 0 rg (def) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 1 rg (f) Tj 0 0 0 rg (\(\):) Tj ( ) Tj /F3 10 Tf 0 .501961 0 rg (pass) Tj /F4 10 Tf 0 0 0 rg ( ) Tj /F6 10 Tf .25098 .501961 .501961 rg (# the original function) Tj /F4 10 Tf 0 0 0 rg  T* .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj (f) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (attr1) Tj ( ) Tj .4 .4 .4 rg (=) Tj 0 0 0 rg ( ) Tj .729412 .129412 .129412 rg ("something") Tj 0 0 0 rg ( ) Tj /F6 10 Tf .25098 .501961 .501961 rg (# setting an attribute) Tj /F4 10 Tf 0 0 0 rg  T* .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj (f) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (attr2) Tj ( ) Tj .4 .4 .4 rg (=) Tj 0 0 0 rg ( ) Tj .729412 .129412 .129412 rg ("something else") Tj 0 0 0 rg ( ) Tj /F6 10 Tf .25098 .501961 .501961 rg (# setting another attribute) Tj /F4 10 Tf 0 0 0 rg  T*  T* .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj (traced_f) Tj ( ) Tj .4 .4 .4 rg (=) Tj 0 0 0 rg ( ) Tj (trace) Tj (\() Tj (f) Tj (\)) Tj ( ) Tj /F6 10 Tf .25098 .501961 .501961 rg (# the decorated function) Tj /F4 10 Tf 0 0 0 rg  T*  T* .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj (traced_f) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (attr1) Tj  T* .729412 .129412 .129412 rg ('something') Tj 0 0 0 rg  T* .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj (traced_f) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (attr2) Tj ( ) Tj .4 .4 .4 rg (=) Tj 0 0 0 rg ( ) Tj .729412 .129412 .129412 rg ("something different") Tj 0 0 0 rg ( ) Tj /F6 10 Tf .25098 .501961 .501961 rg (# setting attr) Tj /F4 10 Tf 0 0 0 rg  T* .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj (f) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (attr2) Tj ( ) Tj /F6 10 Tf .25098 .501961 .501961 rg (# the original attribute did not change) Tj /F4 10 Tf 0 0 0 rg  T* .729412 .129412 .129412 rg ('something else') Tj T* ET
+.960784 .960784 .862745 rg
+n 0 120.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 6 120.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 12 120.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 24 120.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 48 120.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 54 120.75 18 12 re f*
+.960784 .960784 .862745 rg
+n 78 120.75 24 12 re f*
+.960784 .960784 .862745 rg
+n 108 120.75 138 12 re f*
+.960784 .960784 .862745 rg
+n 0 108.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 6 108.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 12 108.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 24 108.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 30 108.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 36 108.75 30 12 re f*
+.960784 .960784 .862745 rg
+n 72 108.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 84 108.75 66 12 re f*
+.960784 .960784 .862745 rg
+n 156 108.75 132 12 re f*
+.960784 .960784 .862745 rg
+n 0 96.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 6 96.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 12 96.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 24 96.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 30 96.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 36 96.75 30 12 re f*
+.960784 .960784 .862745 rg
+n 72 96.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 84 96.75 96 12 re f*
+.960784 .960784 .862745 rg
+n 186 96.75 162 12 re f*
+.960784 .960784 .862745 rg
+n 0 72.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 6 72.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 12 72.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 24 72.75 48 12 re f*
+.960784 .960784 .862745 rg
+n 78 72.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 90 72.75 30 12 re f*
+.960784 .960784 .862745 rg
+n 120 72.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 126 72.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 132 72.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 144 72.75 144 12 re f*
+.960784 .960784 .862745 rg
+n 0 48.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 6 48.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 12 48.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 24 48.75 48 12 re f*
+.960784 .960784 .862745 rg
+n 72 48.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 78 48.75 30 12 re f*
+.960784 .960784 .862745 rg
+n 0 36.75 66 12 re f*
+.960784 .960784 .862745 rg
+n 0 24.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 6 24.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 12 24.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 24 24.75 48 12 re f*
+.960784 .960784 .862745 rg
+n 72 24.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 78 24.75 30 12 re f*
+.960784 .960784 .862745 rg
+n 114 24.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 126 24.75 126 12 re f*
+.960784 .960784 .862745 rg
+n 258 24.75 84 12 re f*
+.960784 .960784 .862745 rg
+n 0 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 6 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 12 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 24 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 30 12.75 6 12 re f*
+.960784 .960784 .862745 rg
+n 36 12.75 30 12 re f*
+.960784 .960784 .862745 rg
+n 72 12.75 234 12 re f*
+.960784 .960784 .862745 rg
+n 0 .75 96 12 re f*
+BT 1 0 0 1 0 122 Tm 12 TL /F4 10 Tf .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj /F3 10 Tf 0 .501961 0 rg (def) Tj /F4 10 Tf 0 0 0 rg ( ) Tj 0 0 1 rg (f) Tj 0 0 0 rg (\(\):) Tj 0 0 0 rg ( ) Tj /F3 10 Tf 0 .501961 0 rg (pass) Tj /F4 10 Tf 0 0 0 rg ( ) Tj /F6 10 Tf .25098 .501961 .501961 rg (# the original function) Tj /F4 10 Tf 0 0 0 rg  T* .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (f) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (attr1) Tj 0 0 0 rg ( ) Tj .4 .4 .4 rg (=) Tj 0 0 0 rg ( ) Tj .729412 .129412 .129412 rg ("something") Tj 0 0 0 rg ( ) Tj /F6 10 Tf .25098 .501961 .501961 rg (# setting an attribute) Tj /F4 10 Tf 0 0 0 rg  T* .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (f) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (attr2) Tj 0 0 0 rg ( ) Tj .4 .4 .4 rg (=) Tj 0 0 0 rg ( ) Tj .729412 .129412 .129412 rg ("something else") Tj 0 0 0 rg ( ) Tj /F6 10 Tf .25098 .501961 .501961 rg (# setting another attribute) Tj /F4 10 Tf 0 0 0 rg  T*  T* .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (traced_f) Tj 0 0 0 rg ( ) Tj .4 .4 .4 rg (=) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (trace) Tj 0 0 0 rg (\() Tj 0 0 0 rg (f) Tj 0 0 0 rg (\)) Tj 0 0 0 rg ( ) Tj /F6 10 Tf .25098 .501961 .501961 rg (# the decorated function) Tj /F4 10 Tf 0 0 0 rg  T*  T* .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (traced_f) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (attr1) Tj 0 0 0 rg  T* .729412 .129412 .129412 rg ('something') Tj 0 0 0 rg  T* .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (traced_f) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (attr2) Tj 0 0 0 rg ( ) Tj .4 .4 .4 rg (=) Tj 0 0 0 rg ( ) Tj .729412 .129412 .129412 rg ("something different") Tj 0 0 0 rg ( ) Tj /F6 10 Tf .25098 .501961 .501961 rg (# setting attr) Tj /F4 10 Tf 0 0 0 rg  T* .4 .4 .4 rg (>) Tj (>) Tj (>) Tj 0 0 0 rg ( ) Tj 0 0 0 rg (f) Tj .4 .4 .4 rg (.) Tj 0 0 0 rg (attr2) Tj 0 0 0 rg ( ) Tj /F6 10 Tf .25098 .501961 .501961 rg (# the original attribute did not change) Tj /F4 10 Tf 0 0 0 rg  T* .729412 .129412 .129412 rg ('something else') Tj T* ET
 Q
 Q
 Q
 Q
 Q
- 
-endstream
-endobj
-% 'R103': class PDFStream 
-103 0 obj
-% page stream
-<< /Length 6552 >>
-stream
-1 0 0 1 0 0 cm  BT /F1 12 Tf 14.4 TL ET
 q
-1 0 0 1 62.69291 744.0236 cm
+1 0 0 1 62.69291 586.8236 cm
 q
 BT 1 0 0 1 0 3.5 Tm 21 TL /F2 17.5 Tf 0 0 0 rg (Compatibility notes) Tj T* ET
 Q
 Q
 q
-1 0 0 1 62.69291 678.0236 cm
+1 0 0 1 62.69291 520.8236 cm
 q
-BT 1 0 0 1 0 50 Tm 1.404985 Tw 12 TL /F1 10 Tf 0 0 0 rg (Version 3.3 is the first version of the ) Tj /F4 10 Tf (decorator ) Tj /F1 10 Tf (module to fully support Python 3, including ) Tj 0 0 .501961 rg (function) Tj T* 0 Tw .07881 Tw (annotations) Tj 0 0 0 rg (. Version 3.2 was the first version to support Python 3 via the ) Tj /F4 10 Tf (2to3 ) Tj /F1 10 Tf (conversion tool invoked in) Tj T* 0 Tw .373555 Tw (the build process by the ) Tj 0 0 .501961 rg (distribute ) Tj 0 0 0 rg (project, the Python 3-compatible replacement of easy_install. The hard) Tj T* 0 Tw .326235 Tw (work \(for me\) has been converting the documentation and the doctests. This has been possible only after) Tj T* 0 Tw (that ) Tj 0 0 .501961 rg (docutils ) Tj 0 0 0 rg (and ) Tj 0 0 .501961 rg (pygments ) Tj 0 0 0 rg (have been ported to Python 3.) Tj T* ET
+BT 1 0 0 1 0 50 Tm 1.864987 Tw 12 TL /F1 10 Tf 0 0 0 rg (Version 3.4 fixes some bugs in the support of recent versions of Python 3. Version 3.3 was the first) Tj T* 0 Tw .770697 Tw (version of the ) Tj /F4 10 Tf 0 0 0 rg (decorator ) Tj /F1 10 Tf 0 0 0 rg (module to fully support Python 3, including ) Tj 0 0 .501961 rg (function annotations) Tj 0 0 0 rg (. Version 3.2) Tj T* 0 Tw .452093 Tw (was the first version to support Python 3 via the ) Tj /F4 10 Tf 0 0 0 rg (2to3 ) Tj /F1 10 Tf 0 0 0 rg (conversion tool. The hard work \(for me\) has been) Tj T* 0 Tw 2.514983 Tw (converting the documentation and the doctests. This has been possible only after that ) Tj 0 0 .501961 rg (docutils ) Tj 0 0 0 rg (and) Tj T* 0 Tw 0 0 .501961 rg (pygments ) Tj 0 0 0 rg (have been ported to Python 3.) Tj T* ET
 Q
 Q
 q
-1 0 0 1 62.69291 600.0236 cm
+1 0 0 1 62.69291 442.8236 cm
 q
-BT 1 0 0 1 0 62 Tm .793984 Tw 12 TL /F1 10 Tf 0 0 0 rg (Version 3 of the ) Tj /F4 10 Tf (decorator ) Tj /F1 10 Tf (module do not contain any backward incompatible change, apart from the) Tj T* 0 Tw 3.63498 Tw (removal of the functions ) Tj /F4 10 Tf (get_info ) Tj /F1 10 Tf (and ) Tj /F4 10 Tf (new_wrapper) Tj /F1 10 Tf (, which have been deprecated for years.) Tj T* 0 Tw .293672 Tw /F4 10 Tf (get_info ) Tj /F1 10 Tf (has been removed since it was little used and since it had to be changed anyway to work with) Tj T* 0 Tw 2.298555 Tw (Python 3.0; ) Tj /F4 10 Tf (new_wrapper ) Tj /F1 10 Tf (has been removed since it was useless: its major use case \(converting) Tj T* 0 Tw 7.136976 Tw (signature changing decorators to signature preserving decorators\) has been subsumed by) Tj T* 0 Tw /F4 10 Tf (decorator_apply) Tj /F1 10 Tf (, whereas the other use case can be managed with the ) Tj /F4 10 Tf (FunctionMaker) Tj /F1 10 Tf (.) Tj T* ET
+BT 1 0 0 1 0 62 Tm .793984 Tw 12 TL /F1 10 Tf 0 0 0 rg (Version 3 of the ) Tj /F4 10 Tf 0 0 0 rg (decorator ) Tj /F1 10 Tf 0 0 0 rg (module do not contain any backward incompatible change, apart from the) Tj T* 0 Tw 3.63498 Tw (removal of the functions ) Tj /F4 10 Tf 0 0 0 rg (get_info ) Tj /F1 10 Tf 0 0 0 rg (and ) Tj /F4 10 Tf 0 0 0 rg (new_wrapper) Tj /F1 10 Tf 0 0 0 rg (, which have been deprecated for years.) Tj T* 0 Tw .293672 Tw /F4 10 Tf 0 0 0 rg (get_info ) Tj /F1 10 Tf 0 0 0 rg (has been removed since it was little used and since it had to be changed anyway to work with) Tj T* 0 Tw 2.298555 Tw (Python 3.0; ) Tj /F4 10 Tf 0 0 0 rg (new_wrapper ) Tj /F1 10 Tf 0 0 0 rg (has been removed since it was useless: its major use case \(converting) Tj T* 0 Tw 7.136976 Tw (signature changing decorators to signature preserving decorators\) has been subsumed by) Tj T* 0 Tw /F4 10 Tf 0 0 0 rg (decorator_apply) Tj /F1 10 Tf 0 0 0 rg (, whereas the other use case can be managed with the ) Tj /F4 10 Tf 0 0 0 rg (FunctionMaker) Tj /F1 10 Tf 0 0 0 rg (.) Tj T* ET
 Q
 Q
 q
-1 0 0 1 62.69291 558.0236 cm
+1 0 0 1 62.69291 400.8236 cm
 q
-BT 1 0 0 1 0 26 Tm 1.329213 Tw 12 TL /F1 10 Tf 0 0 0 rg (There are a few changes in the documentation: I removed the ) Tj /F4 10 Tf (decorator_factory ) Tj /F1 10 Tf (example, which) Tj T* 0 Tw 2.562927 Tw (was confusing some of my users, and I removed the part about exotic signatures in the Python 3) Tj T* 0 Tw (documentation, since Python 3 does not support them.) Tj T* ET
+BT 1 0 0 1 0 26 Tm 1.329213 Tw 12 TL /F1 10 Tf 0 0 0 rg (There are a few changes in the documentation: I removed the ) Tj /F4 10 Tf 0 0 0 rg (decorator_factory ) Tj /F1 10 Tf 0 0 0 rg (example, which) Tj T* 0 Tw 2.562927 Tw (was confusing some of my users, and I removed the part about exotic signatures in the Python 3) Tj T* 0 Tw (documentation, since Python 3 does not support them.) Tj T* ET
 Q
 Q
 q
-1 0 0 1 62.69291 492.0236 cm
+1 0 0 1 62.69291 334.8236 cm
 q
-BT 1 0 0 1 0 50 Tm .942651 Tw 12 TL /F1 10 Tf 0 0 0 rg (Finally ) Tj /F4 10 Tf (decorator ) Tj /F1 10 Tf (cannot be used as a class decorator and the ) Tj 0 0 .501961 rg (functionality introduced in version 2.3) Tj T* 0 Tw .241163 Tw 0 0 0 rg (has been removed. That means that in order to define decorator factories with classes you need to define) Tj T* 0 Tw 1.122126 Tw (the ) Tj /F4 10 Tf (__call__ ) Tj /F1 10 Tf (method explicitly \(no magic anymore\). All these changes should not cause any trouble,) Tj T* 0 Tw .601163 Tw (since they were all rarely used features. Should you have any trouble, you can always downgrade to the) Tj T* 0 Tw (2.3 version.) Tj T* ET
+BT 1 0 0 1 0 50 Tm .942651 Tw 12 TL /F1 10 Tf 0 0 0 rg (Finally ) Tj /F4 10 Tf 0 0 0 rg (decorator ) Tj /F1 10 Tf 0 0 0 rg (cannot be used as a class decorator and the ) Tj 0 0 .501961 rg (functionality introduced in version 2.3) Tj T* 0 Tw .241163 Tw 0 0 0 rg (has been removed. That means that in order to define decorator factories with classes you need to define) Tj T* 0 Tw 1.122126 Tw (the ) Tj /F4 10 Tf 0 0 0 rg (__call__ ) Tj /F1 10 Tf 0 0 0 rg (method explicitly \(no magic anymore\). All these changes should not cause any trouble,) Tj T* 0 Tw .601163 Tw (since they were all rarely used features. Should you have any trouble, you can always downgrade to the) Tj T* 0 Tw (2.3 version.) Tj T* ET
 Q
 Q
 q
-1 0 0 1 62.69291 426.0236 cm
+1 0 0 1 62.69291 268.8236 cm
 q
-BT 1 0 0 1 0 50 Tm .196098 Tw 12 TL /F1 10 Tf 0 0 0 rg (The examples shown here have been tested with Python 2.6. Python 2.4 is also supported - of course the) Tj T* 0 Tw 1.649398 Tw (examples requiring the ) Tj /F4 10 Tf (with ) Tj /F1 10 Tf (statement will not work there. Python 2.5 works fine, but if you run the) Tj T* 0 Tw 1.41784 Tw (examples in the interactive interpreter you will notice a few differences since ) Tj /F4 10 Tf (getargspec ) Tj /F1 10 Tf (returns an) Tj T* 0 Tw .909982 Tw /F4 10 Tf (ArgSpec ) Tj /F1 10 Tf (namedtuple instead of a regular tuple. That means that running the file ) Tj /F4 10 Tf (documentation.py) Tj T* 0 Tw /F1 10 Tf (under Python 2.5 will print a few errors, but they are not serious.) Tj T* ET
+BT 1 0 0 1 0 50 Tm .196098 Tw 12 TL /F1 10 Tf 0 0 0 rg (The examples shown here have been tested with Python 2.6. Python 2.4 is also supported - of course the) Tj T* 0 Tw 1.649398 Tw (examples requiring the ) Tj /F4 10 Tf 0 0 0 rg (with ) Tj /F1 10 Tf 0 0 0 rg (statement will not work there. Python 2.5 works fine, but if you run the) Tj T* 0 Tw 1.41784 Tw (examples in the interactive interpreter you will notice a few differences since ) Tj /F4 10 Tf 0 0 0 rg (getargspec ) Tj /F1 10 Tf 0 0 0 rg (returns an) Tj T* 0 Tw .909982 Tw /F4 10 Tf 0 0 0 rg (ArgSpec ) Tj /F1 10 Tf 0 0 0 rg (namedtuple instead of a regular tuple. That means that running the file ) Tj /F4 10 Tf 0 0 0 rg (documentation.py) Tj T* 0 Tw /F1 10 Tf 0 0 0 rg (under Python 2.5 will print a few errors, but they are not serious.) Tj T* ET
 Q
 Q
 q
-1 0 0 1 62.69291 393.0236 cm
+1 0 0 1 62.69291 235.8236 cm
 q
 BT 1 0 0 1 0 3.5 Tm 21 TL /F2 17.5 Tf 0 0 0 rg (LICENCE) Tj T* ET
 Q
 Q
 q
-1 0 0 1 62.69291 375.0236 cm
+1 0 0 1 62.69291 217.8236 cm
 q
 0 0 0 rg
-BT 1 0 0 1 0 2 Tm /F1 10 Tf 12 TL (Copyright \(c\) 2005-2012, Michele Simionato All rights reserved.) Tj T* ET
+BT 1 0 0 1 0 2 Tm /F1 10 Tf 12 TL (Copyright \(c\) 2005-2015, Michele Simionato All rights reserved.) Tj T* ET
 Q
 Q
 q
-1 0 0 1 62.69291 345.0236 cm
+1 0 0 1 62.69291 187.8236 cm
 q
 0 0 0 rg
 BT 1 0 0 1 0 14 Tm /F1 10 Tf 12 TL 1.328555 Tw (Redistribution and use in source and binary forms, with or without modification, are permitted provided) Tj T* 0 Tw (that the following conditions are met:) Tj T* ET
 Q
 Q
 q
-1 0 0 1 62.69291 339.0236 cm
+1 0 0 1 62.69291 181.8236 cm
 Q
 q
-1 0 0 1 62.69291 291.0236 cm
+1 0 0 1 62.69291 133.8236 cm
 0 0 0 rg
 BT /F1 10 Tf 12 TL ET
 BT 1 0 0 1 0 2 Tm  T* ET
@@ -3740,17 +6475,31 @@ q
 Q
 Q
 q
-1 0 0 1 62.69291 291.0236 cm
+1 0 0 1 62.69291 133.8236 cm
 Q
 q
-1 0 0 1 62.69291 165.0236 cm
+1 0 0 1 62.69291 79.82362 cm
+q
+0 0 0 rg
+BT 1 0 0 1 0 38 Tm /F1 10 Tf 12 TL .17998 Tw (THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND) Tj T* 0 Tw 2.911797 Tw (ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED) Tj T* 0 Tw 5.165529 Tw (WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE) Tj T* 0 Tw 1.395433 Tw (DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE) Tj T* 0 Tw ET
+Q
+Q
+ 
+endstream
+endobj
+108 0 obj
+<< /Length 1038 >>
+stream
+1 0 0 1 0 0 cm  BT /F1 12 Tf 14.4 TL ET
+q
+1 0 0 1 62.69291 693.0236 cm
 q
 0 0 0 rg
-BT 1 0 0 1 0 110 Tm /F1 10 Tf 12 TL .17998 Tw (THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND) Tj T* 0 Tw 2.911797 Tw (ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED) Tj T* 0 Tw 5.165529 Tw (WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE) Tj T* 0 Tw 1.395433 Tw (DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE) Tj T* 0 Tw 5.53122 Tw (FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL) Tj T* 0 Tw 2.705976 Tw (DAMAGES \(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR) Tj T* 0 Tw 3.868976 Tw (SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION\) HOWEVER) Tj T* 0 Tw 1.326647 Tw (CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR) Tj T* 0 Tw 1.525366 Tw (TORT \(INCLUDING NEGLIGENCE OR OTHERWISE\) ARISING IN ANY WAY OUT OF THE USE OF) Tj T* 0 Tw (THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.) Tj T* ET
+BT 1 0 0 1 0 62 Tm /F1 10 Tf 12 TL 5.53122 Tw (FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL) Tj T* 0 Tw 2.705976 Tw (DAMAGES \(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR) Tj T* 0 Tw 3.868976 Tw (SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION\) HOWEVER) Tj T* 0 Tw 1.326647 Tw (CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR) Tj T* 0 Tw 1.525366 Tw (TORT \(INCLUDING NEGLIGENCE OR OTHERWISE\) ARISING IN ANY WAY OUT OF THE USE OF) Tj T* 0 Tw (THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.) Tj T* ET
 Q
 Q
 q
-1 0 0 1 62.69291 135.0236 cm
+1 0 0 1 62.69291 663.0236 cm
 q
 0 0 0 rg
 BT 1 0 0 1 0 14 Tm /F1 10 Tf 12 TL .407132 Tw (If you use this software and you are happy with it, consider sending me a note, just to gratify my ego. On) Tj T* 0 Tw (the other hand, if you use this software and you are unhappy with it, send me a patch!) Tj T* ET
@@ -3759,260 +6508,193 @@ Q
  
 endstream
 endobj
-% 'R104': class PDFPageLabels 
-104 0 obj
-% Document Root
-<< /Nums [ 0
- 105 0 R
- 1
- 106 0 R
- 2
- 107 0 R
- 3
- 108 0 R
- 4
- 109 0 R
- 5
- 110 0 R
- 6
- 111 0 R
- 7
- 112 0 R
- 8
- 113 0 R
- 9
- 114 0 R
- 10
- 115 0 R
- 11
- 116 0 R
- 12
- 117 0 R
- 13
- 118 0 R
- 14
- 119 0 R ] >>
-endobj
-% 'R105': class PDFPageLabel 
-105 0 obj
-% None
-<< /S /D
- /St 1 >>
-endobj
-% 'R106': class PDFPageLabel 
-106 0 obj
-% None
-<< /S /D
- /St 2 >>
-endobj
-% 'R107': class PDFPageLabel 
-107 0 obj
-% None
-<< /S /D
- /St 3 >>
-endobj
-% 'R108': class PDFPageLabel 
-108 0 obj
-% None
-<< /S /D
- /St 4 >>
-endobj
-% 'R109': class PDFPageLabel 
 109 0 obj
-% None
-<< /S /D
- /St 5 >>
+<< /Nums [ 0 110 0 R 1 111 0 R 2 112 0 R 3 113 0 R 4 114 0 R 
+  5 115 0 R 6 116 0 R 7 117 0 R 8 118 0 R 9 119 0 R 
+  10 120 0 R 11 121 0 R 12 122 0 R 13 123 0 R 14 124 0 R 
+  15 125 0 R ] >>
 endobj
-% 'R110': class PDFPageLabel 
 110 0 obj
-% None
-<< /S /D
- /St 6 >>
+<< /S /D /St 1 >>
 endobj
-% 'R111': class PDFPageLabel 
 111 0 obj
-% None
-<< /S /D
- /St 7 >>
+<< /S /D /St 2 >>
 endobj
-% 'R112': class PDFPageLabel 
 112 0 obj
-% None
-<< /S /D
- /St 8 >>
+<< /S /D /St 3 >>
 endobj
-% 'R113': class PDFPageLabel 
 113 0 obj
-% None
-<< /S /D
- /St 9 >>
+<< /S /D /St 4 >>
 endobj
-% 'R114': class PDFPageLabel 
 114 0 obj
-% None
-<< /S /D
- /St 10 >>
+<< /S /D /St 5 >>
 endobj
-% 'R115': class PDFPageLabel 
 115 0 obj
-% None
-<< /S /D
- /St 11 >>
+<< /S /D /St 6 >>
 endobj
-% 'R116': class PDFPageLabel 
 116 0 obj
-% None
-<< /S /D
- /St 12 >>
+<< /S /D /St 7 >>
 endobj
-% 'R117': class PDFPageLabel 
 117 0 obj
-% None
-<< /S /D
- /St 13 >>
+<< /S /D /St 8 >>
 endobj
-% 'R118': class PDFPageLabel 
 118 0 obj
-% None
-<< /S /D
- /St 14 >>
+<< /S /D /St 9 >>
 endobj
-% 'R119': class PDFPageLabel 
 119 0 obj
-% None
-<< /S /D
- /St 15 >>
+<< /S /D /St 10 >>
+endobj
+120 0 obj
+<< /S /D /St 11 >>
+endobj
+121 0 obj
+<< /S /D /St 12 >>
+endobj
+122 0 obj
+<< /S /D /St 13 >>
+endobj
+123 0 obj
+<< /S /D /St 14 >>
+endobj
+124 0 obj
+<< /S /D /St 15 >>
+endobj
+125 0 obj
+<< /S /D /St 16 >>
 endobj
 xref
-0 120
+0 126
 0000000000 65535 f
-0000000113 00000 n
+0000000075 00000 n
+0000000161 00000 n
 0000000271 00000 n
-0000000436 00000 n
-0000000611 00000 n
-0000000794 00000 n
-0000001046 00000 n
-0000001295 00000 n
-0000001469 00000 n
-0000001710 00000 n
-0000001951 00000 n
-0000002193 00000 n
-0000002435 00000 n
-0000002677 00000 n
-0000002919 00000 n
-0000003162 00000 n
-0000003405 00000 n
-0000003648 00000 n
-0000003891 00000 n
-0000004133 00000 n
-0000004375 00000 n
-0000004618 00000 n
-0000004861 00000 n
-0000005104 00000 n
-0000005347 00000 n
-0000005590 00000 n
-0000005833 00000 n
-0000006076 00000 n
-0000006319 00000 n
-0000006562 00000 n
-0000006805 00000 n
-0000007048 00000 n
-0000007291 00000 n
-0000007534 00000 n
-0000007777 00000 n
-0000008020 00000 n
-0000008263 00000 n
-0000008506 00000 n
-0000008749 00000 n
-0000008992 00000 n
-0000009219 00000 n
-0000009815 00000 n
-0000010010 00000 n
-0000010266 00000 n
-0000010457 00000 n
-0000010717 00000 n
-0000011027 00000 n
-0000011307 00000 n
-0000011602 00000 n
-0000011845 00000 n
-0000012146 00000 n
-0000012426 00000 n
-0000012706 00000 n
-0000012986 00000 n
-0000013267 00000 n
-0000013562 00000 n
-0000013803 00000 n
-0000014119 00000 n
-0000014387 00000 n
-0000014690 00000 n
-0000014986 00000 n
-0000015231 00000 n
-0000015548 00000 n
-0000015808 00000 n
-0000016068 00000 n
-0000016326 00000 n
-0000016578 00000 n
-0000016818 00000 n
-0000017125 00000 n
-0000017473 00000 n
-0000017633 00000 n
-0000017918 00000 n
-0000018044 00000 n
-0000018217 00000 n
-0000018404 00000 n
-0000018604 00000 n
-0000018792 00000 n
-0000018985 00000 n
-0000019180 00000 n
-0000019380 00000 n
-0000019564 00000 n
-0000019745 00000 n
-0000019936 00000 n
-0000020136 00000 n
-0000020336 00000 n
-0000020548 00000 n
-0000020748 00000 n
-0000020944 00000 n
-0000021096 00000 n
-0000021331 00000 n
-0000030688 00000 n
-0000038447 00000 n
-0000046641 00000 n
-0000054544 00000 n
-0000062233 00000 n
-0000071127 00000 n
-0000077895 00000 n
-0000086065 00000 n
-0000093096 00000 n
-0000101341 00000 n
-0000108766 00000 n
-0000116365 00000 n
-0000121398 00000 n
-0000129508 00000 n
-0000136165 00000 n
-0000136462 00000 n
-0000136541 00000 n
-0000136620 00000 n
-0000136699 00000 n
-0000136778 00000 n
-0000136857 00000 n
-0000136936 00000 n
-0000137015 00000 n
-0000137094 00000 n
-0000137173 00000 n
-0000137253 00000 n
-0000137333 00000 n
-0000137413 00000 n
-0000137493 00000 n
-0000137573 00000 n
+0000000386 00000 n
+0000000499 00000 n
+0000000688 00000 n
+0000000886 00000 n
+0000000994 00000 n
+0000001165 00000 n
+0000001336 00000 n
+0000001508 00000 n
+0000001680 00000 n
+0000001852 00000 n
+0000002024 00000 n
+0000002196 00000 n
+0000002368 00000 n
+0000002540 00000 n
+0000002712 00000 n
+0000002884 00000 n
+0000003056 00000 n
+0000003228 00000 n
+0000003400 00000 n
+0000003572 00000 n
+0000003744 00000 n
+0000003916 00000 n
+0000004088 00000 n
+0000004260 00000 n
+0000004432 00000 n
+0000004604 00000 n
+0000004776 00000 n
+0000004948 00000 n
+0000005120 00000 n
+0000005292 00000 n
+0000005464 00000 n
+0000005636 00000 n
+0000005808 00000 n
+0000005980 00000 n
+0000006152 00000 n
+0000006324 00000 n
+0000006496 00000 n
+0000006668 00000 n
+0000006840 00000 n
+0000007012 00000 n
+0000007184 00000 n
+0000007356 00000 n
+0000007859 00000 n
+0000007978 00000 n
+0000008183 00000 n
+0000008300 00000 n
+0000008529 00000 n
+0000008756 00000 n
+0000008985 00000 n
+0000009195 00000 n
+0000009391 00000 n
+0000009620 00000 n
+0000009830 00000 n
+0000010040 00000 n
+0000010251 00000 n
+0000010462 00000 n
+0000010673 00000 n
+0000010864 00000 n
+0000011094 00000 n
+0000011312 00000 n
+0000011542 00000 n
+0000011753 00000 n
+0000011948 00000 n
+0000012178 00000 n
+0000012374 00000 n
+0000012562 00000 n
+0000012738 00000 n
+0000012995 00000 n
+0000013246 00000 n
+0000013457 00000 n
+0000013567 00000 n
+0000013815 00000 n
+0000013893 00000 n
+0000014010 00000 n
+0000014139 00000 n
+0000014281 00000 n
+0000014411 00000 n
+0000014546 00000 n
+0000014684 00000 n
+0000014826 00000 n
+0000014952 00000 n
+0000015075 00000 n
+0000015207 00000 n
+0000015348 00000 n
+0000015489 00000 n
+0000015642 00000 n
+0000015783 00000 n
+0000015920 00000 n
+0000016032 00000 n
+0000016206 00000 n
+0000025233 00000 n
+0000037517 00000 n
+0000053936 00000 n
+0000072471 00000 n
+0000093910 00000 n
+0000113111 00000 n
+0000127049 00000 n
+0000146974 00000 n
+0000163187 00000 n
+0000177912 00000 n
+0000192010 00000 n
+0000208189 00000 n
+0000216529 00000 n
+0000231164 00000 n
+0000242415 00000 n
+0000243511 00000 n
+0000243725 00000 n
+0000243763 00000 n
+0000243801 00000 n
+0000243839 00000 n
+0000243877 00000 n
+0000243915 00000 n
+0000243953 00000 n
+0000243991 00000 n
+0000244029 00000 n
+0000244067 00000 n
+0000244106 00000 n
+0000244145 00000 n
+0000244184 00000 n
+0000244223 00000 n
+0000244262 00000 n
+0000244301 00000 n
 trailer
 << /ID 
- % ReportLab generated PDF document -- digest (http://www.reportlab.com) 
- [(GkM\035\327P\251\240\010\276P *\252E\027) (GkM\035\327P\251\240\010\276P *\252E\027)] 
-
- /Info 70 0 R
- /Root 69 0 R
- /Size 120 >>
+ % ReportLab generated PDF document -- digest (http://www.reportlab.com)
+ [(}\272\001\2746\273\037\210\371B\317\326\372\306p\251) (}\272\001\2746\273\037\210\371B\317\326\372\306p\251)]
+ /Info 74 0 R /Root 73 0 R /Size 126 >>
 startxref
-137622
+244340
 %%EOF
diff --git a/documentation3.py b/documentation3.py
index bd86cc6..c7be177 100644
--- a/documentation3.py
+++ b/documentation3.py
@@ -24,7 +24,7 @@ believe the change is for the best, and that decorators are a great
 idea since:
 
 * decorators help reducing boilerplate code;
-* decorators help separation of concerns; 
+* decorators help separation of concerns;
 * decorators enhance readability and maintenability;
 * decorators are explicit.
 
@@ -47,8 +47,8 @@ Definitions
 ------------------------------------
 
 Technically speaking, any Python object which can be called with one argument
-can be used as  a decorator. However, this definition is somewhat too large 
-to be really useful. It is more convenient to split the generic class of 
+can be used as  a decorator. However, this definition is somewhat too large
+to be really useful. It is more convenient to split the generic class of
 decorators in two subclasses:
 
 + *signature-preserving* decorators, i.e. callable objects taking a
@@ -61,7 +61,7 @@ decorators in two subclasses:
 
 Signature-changing decorators have their use: for instance the
 builtin classes ``staticmethod`` and ``classmethod`` are in this
-group, since they take functions and return descriptor objects which 
+group, since they take functions and return descriptor objects which
 are not functions, nor callables.
 
 However, signature-preserving decorators are more common and easier to
@@ -69,8 +69,8 @@ reason about; in particular signature-preserving decorators can be
 composed together whereas other decorators in general cannot.
 
 Writing signature-preserving decorators from scratch is not that
-obvious, especially if one wants to define proper decorators that 
-can accept functions with any signature. A simple example will clarify 
+obvious, especially if one wants to define proper decorators that
+can accept functions with any signature. A simple example will clarify
 the issue.
 
 Statement of the problem
@@ -80,8 +80,8 @@ A very common use case for decorators is the memoization of functions.
 A ``memoize`` decorator works by caching
 the result of the function call in a dictionary, so that the next time
 the function is called with the same input parameters the result is retrieved
-from the cache and not recomputed. There are many implementations of 
-``memoize`` in http://www.python.org/moin/PythonDecoratorLibrary, 
+from the cache and not recomputed. There are many implementations of
+``memoize`` in http://www.python.org/moin/PythonDecoratorLibrary,
 but they do not preserve the signature.
 A simple implementation could be the following (notice
 that in general it is impossible to memoize correctly something
@@ -95,9 +95,9 @@ been added in Python 2.5 expressly to simplify the definition of decorators
 ``__name__``, ``__doc__``, ``__module__`` and ``__dict__``
 from the original function to the decorated function by hand).
 
-.. _functools.update_wrapper: http://www.python.org/doc/2.5.2/lib/module-functools.html
+.. _functools.update_wrapper: https://docs.python.org/3/library/functools.html#functools.update_wrapper
 
-The implementation above works in the sense that the decorator 
+The implementation above works in the sense that the decorator
 can accept functions with generic signatures; unfortunately this
 implementation does *not* define a signature-preserving decorator, since in
 general ``memoize_uw`` returns a function with a
@@ -118,14 +118,14 @@ keyword arguments:
 
 .. code-block:: python
 
- >>> from inspect import getargspec 
+ >>> from inspect import getargspec
  >>> print(getargspec(f1))
  ArgSpec(args=[], varargs='args', keywords='kw', defaults=None)
 
 This means that introspection tools such as pydoc will give
 wrong informations about the signature of ``f1``. This is pretty bad:
-pydoc will tell you that the function accepts a generic signature 
-``*args``, ``**kw``, but when you try to call the function with more than an 
+pydoc will tell you that the function accepts a generic signature
+``*args``, ``**kw``, but when you try to call the function with more than an
 argument, you will get an error:
 
 .. code-block:: python
@@ -185,7 +185,7 @@ The signature of ``heavy_computation`` is the one you would expect:
 
 .. code-block:: python
 
- >>> print(getargspec(heavy_computation)) 
+ >>> print(getargspec(heavy_computation))
  ArgSpec(args=[], varargs=None, keywords=None, defaults=None)
 
 A ``trace`` decorator
@@ -218,21 +218,21 @@ and it that it has the correct signature:
 
 .. code-block:: python
 
- >>> print(getargspec(f1)) 
+ >>> print(getargspec(f1))
  ArgSpec(args=['x'], varargs=None, keywords=None, defaults=None)
 
 The same decorator works with functions of any signature:
 
 .. code-block:: python
- 
+
  >>> @trace
  ... def f(x, y=1, z=2, *args, **kw):
  ...     pass
 
  >>> f(0, 3)
  calling f with args (0, 3, 2), {}
- 
- >>> print(getargspec(f)) 
+
+ >>> print(getargspec(f))
  ArgSpec(args=['x', 'y', 'z'], varargs='args', keywords='kw', defaults=(1, 2))
 
 Function annotations
@@ -241,7 +241,7 @@ Function annotations
 Python 3 introduced the concept of `function annotations`_,i.e. the ability
 to annotate the signature of a function with additional information,
 stored in a dictionary named ``__annotations__``. The decorator module,
-starting from release 3.3, is able to understand and to preserve the 
+starting from release 3.3, is able to understand and to preserve the
 annotations. Here is an example:
 
 .. code-block:: python
@@ -256,7 +256,7 @@ utility ``inspect.getfullargspec``, new in Python 3:
 
 .. code-block:: python
 
- >>> from inspect import getfullargspec 
+ >>> from inspect import getfullargspec
  >>> argspec = getfullargspec(f)
  >>> argspec.args
  ['x', 'y', 'z']
@@ -332,14 +332,14 @@ If you are using an old Python version (Python 2.4) the
 -------------------------------------------
 
 Sometimes one has to deal with blocking resources, such as ``stdin``, and
-sometimes it is best to have back a "busy" message than to block everything. 
+sometimes it is best to have back a "busy" message than to block everything.
 This behavior can be implemented with a suitable family of decorators,
 where the parameter is the busy message:
 
 $$blocking
    
 Functions decorated with ``blocking`` will return a busy message if
-the resource is unavailable, and the intended result if the resource is 
+the resource is unavailable, and the intended result if the resource is
 available. For instance:
 
 .. code-block:: python
@@ -349,18 +349,18 @@ available. For instance:
  ...     time.sleep(3) # simulate a blocking resource
  ...     return "some data"
 
- >>> print(read_data()) # data is not available yet
+ >>> print(read_data())  # data is not available yet
  Please wait ...
 
- >>> time.sleep(1)  
- >>> print(read_data()) # data is not available yet
+ >>> time.sleep(1)
+ >>> print(read_data())  # data is not available yet
  Please wait ...
 
  >>> time.sleep(1)
- >>> print(read_data()) # data is not available yet
+ >>> print(read_data())  # data is not available yet
  Please wait ...
 
- >>> time.sleep(1.1) # after 3.1 seconds, data is available
+ >>> time.sleep(1.1)  # after 3.1 seconds, data is available
  >>> print(read_data())
  some data
 
@@ -371,11 +371,11 @@ We have just seen an examples of a simple decorator factory,
 implemented as a function returning a decorator.
 For more complex situations, it is more
 convenient to implement decorator factories as classes returning
-callable objects that can be converted into decorators. 
+callable objects that can be converted into decorators.
 
 As an example, here will I show a decorator
 which is able to convert a blocking function into an asynchronous
-function. The function, when called, 
+function. The function, when called,
 is executed in a separate thread. Moreover, it is possible to set
 three callbacks ``on_success``, ``on_failure`` and ``on_closing``,
 to specify how to manage the function call (of course the code here
@@ -387,13 +387,13 @@ $$on_failure
 $$on_closing
 $$Async
 
-The decorated function returns 
-the current execution thread, which can be stored and checked later, for 
+The decorated function returns
+the current execution thread, which can be stored and checked later, for
 instance to verify that the thread ``.isAlive()``.
 
 Here is an example of usage. Suppose one wants to write some data to
 an external resource which can be accessed by a single user at once
-(for instance a printer). Then the access to the writing function must 
+(for instance a printer). Then the access to the writing function must
 be locked. Here is a minimalistic example:
 
 .. code-block:: python
@@ -410,7 +410,7 @@ be locked. Here is a minimalistic example:
  ...         datalist.append(data)
  ...     # other operations not requiring a lock here
 
-Each call to ``write`` will create a new writer thread, but there will 
+Each call to ``write`` will create a new writer thread, but there will
 be no synchronization problems since ``write`` is locked.
 
 .. code-block:: python
@@ -432,8 +432,8 @@ contextmanager
 -------------------------------------
 
 For a long time Python had in its standard library a ``contextmanager``
-decorator, able to convert generator functions into ``_GeneratorContextManager``
-factories. For instance if you write
+decorator, able to convert generator functions into
+``_GeneratorContextManager`` factories. For instance if you write
 
 .. code-block:: python
 
@@ -446,7 +446,7 @@ factories. For instance if you write
 
 
 then ``before_after`` is a factory function returning
-``_GeneratorContextManager`` objects which can be used with 
+``_GeneratorContextManager`` objects which can be used with
 the ``with`` statement:
 
 .. code-block:: python
@@ -462,7 +462,7 @@ the ``with`` statement:
 
 Basically, it is as if the content of the ``with`` block was executed
 in the place of the ``yield`` expression in the generator function.
-In Python 3.2 ``_GeneratorContextManager`` 
+In Python 3.2 ``_GeneratorContextManager``
 objects were enhanced with a ``__call__``
 method, so that they can be used as decorators as in this example:
 
@@ -477,11 +477,11 @@ method, so that they can be used as decorators as in this example:
  hello
  AFTER
 
-The ``ba`` decorator is basically inserting a ``with ba:`` 
+The ``ba`` decorator is basically inserting a ``with ba:``
 block inside the function.
-However there two issues: the first is that ``_GeneratorContextManager`` 
+However there two issues: the first is that ``_GeneratorContextManager``
 objects are callable only in Python 3.2, so the previous example will break
-in older versions of Python; the second is that 
+in older versions of Python; the second is that
 ``_GeneratorContextManager`` objects do not preserve the signature
 of the decorated functions: the decorated ``hello`` function here will have
 a generic signature ``hello(*args, **kwargs)`` but will break when
@@ -489,7 +489,7 @@ called with more than zero arguments. For such reasons the decorator
 module, starting with release 3.4, offers a ``decorator.contextmanager``
 decorator that solves both problems and works even in Python 2.5.
 The usage is the same and factories decorated with ``decorator.contextmanager``
-will returns instances of ``ContextManager``, a subclass of 
+will returns instances of ``ContextManager``, a subclass of
 ``contextlib._GeneratorContextManager`` with a ``__call__`` method
 acting as a signature-preserving decorator.
 
@@ -556,7 +556,7 @@ with attributes ``args``, ``varargs``,
 the return values of the standard library function ``inspect.getargspec``.
 For each argument in the ``args`` (which is a list of strings containing
 the names of the mandatory arguments) an attribute ``arg0``, ``arg1``,
-..., ``argN`` is also generated. Finally, there is a ``signature`` 
+..., ``argN`` is also generated. Finally, there is a ``signature``
 attribute, a string with the signature of the original function.
 
 Notice that while I do not have plans
@@ -609,7 +609,8 @@ undecorated function:
  @tail_recursive
  def factorial(n, acc=1):
      "The good old factorial"
-     if n == 0: return acc
+     if n == 0:
+         return acc
      return factorial(n-1, n*acc)
  <BLANKLINE>
 
@@ -619,8 +620,8 @@ Dealing with third party decorators
 -----------------------------------------------------------------
 
 Sometimes you find on the net some cool decorator that you would
-like to include in your code. However, more often than not the cool 
-decorator is not signature-preserving. Therefore you may want an easy way to 
+like to include in your code. However, more often than not the cool
+decorator is not signature-preserving. Therefore you may want an easy way to
 upgrade third party decorators to signature-preserving decorators without
 having to rewrite them in terms of ``decorator``. You can use a
 ``FunctionMaker`` to implement that functionality as follows:
@@ -637,10 +638,10 @@ than adding an additional level of indirection. However, practicality
 beats purity, so you can add ``decorator_apply`` to your toolbox and
 use it if you need to.
 
-In order to give an example of usage of ``decorator_apply``, I will show a 
+In order to give an example of usage of ``decorator_apply``, I will show a
 pretty slick decorator that converts a tail-recursive function in an iterative
 function. I have shamelessly stolen the basic idea from Kay Schluehr's recipe
-in the Python Cookbook, 
+in the Python Cookbook,
 http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/496691.
 
 $$TailRecursive
@@ -660,7 +661,7 @@ $$factorial
  24
 
 This decorator is pretty impressive, and should give you some food for
-your mind ;) Notice that there is no recursion limit now, and you can 
+your mind ;) Notice that there is no recursion limit now, and you can
 easily compute ``factorial(1001)`` or larger without filling the stack
 frame. Notice also that the decorator will not work on functions which
 are not tail recursive, such as the following
@@ -674,8 +675,8 @@ call).
 Caveats and limitations
 -------------------------------------------
 
-The first thing you should be aware of, it the fact that decorators 
-have a performance penalty. 
+The first thing you should be aware of, it the fact that decorators
+have a performance penalty.
 The worse case is shown by the following example::
 
  $ cat performance.sh
@@ -684,7 +685,7 @@ The worse case is shown by the following example::
 
  @decorator
  def do_nothing(func, *args, **kw):
-     return func(*args, **kw) 
+     return func(*args, **kw)
 
  @do_nothing
  def f():
@@ -703,10 +704,10 @@ plain function is more than three times slower::
  1000000 loops, best of 3: 0.669 usec per loop
  1000000 loops, best of 3: 0.181 usec per loop
 
-It should be noted that a real life function would probably do 
+It should be noted that a real life function would probably do
 something more useful than ``f`` here, and therefore in real life the
 performance penalty could be completely negligible.  As always, the
-only way to know if there is 
+only way to know if there is
 a penalty in your specific use case is to measure it.
 
 You should be aware that decorators will make your tracebacks
@@ -733,8 +734,8 @@ function is decorated the traceback will be longer:
         1/0
  ZeroDivisionError: ...
 
-You see here the inner call to the decorator ``trace``, which calls 
-``f(*args, **kw)``, and a reference to  ``File "<string>", line 2, in f``. 
+You see here the inner call to the decorator ``trace``, which calls
+``f(*args, **kw)``, and a reference to  ``File "<string>", line 2, in f``.
 This latter reference is due to the fact that internally the decorator
 module uses ``exec`` to generate the decorated function. Notice that
 ``exec`` is *not* responsibile for the performance penalty, since is the
@@ -743,8 +744,8 @@ the decorated function is called.
 
 At present, there is no clean way to avoid ``exec``. A clean solution
 would require to change the CPython implementation of functions and
-add an hook to make it possible to change their signature directly. 
-That could happen in future versions of Python (see PEP 362_) and 
+add an hook to make it possible to change their signature directly.
+That could happen in future versions of Python (see PEP 362_) and
 then the decorator module would become obsolete. However, at present,
 even in Python 3.2 it is impossible to change the function signature
 directly, therefore the ``decorator`` module is still useful.
@@ -754,7 +755,7 @@ the module and releasing new versions.
 .. _362: http://www.python.org/dev/peps/pep-0362
 
 In the present implementation, decorators generated by ``decorator``
-can only be used on user-defined Python functions or methods, not on generic 
+can only be used on user-defined Python functions or methods, not on generic
 callable objects, nor on built-in functions, due to limitations of the
 ``inspect`` module in the standard library.
 
@@ -794,14 +795,13 @@ a *copy* of the original function dictionary
 Compatibility notes
 ---------------------------------------------------------------
 
-Version 3.3 is the first version of the ``decorator`` module to fully
-support Python 3, including `function annotations`_. Version 3.2 was the
-first version to support Python 3 via the ``2to3`` conversion tool
-invoked in the build process by the distribute_ project, the Python
-3-compatible replacement of easy_install.  The hard work (for me) has
-been converting the documentation and the doctests.  This has been
-possible only after that docutils_ and pygments_ have been ported to
-Python 3.
+Version 3.4 fixes some bugs in the support of recent versions of
+Python 3.  Version 3.3 was the first version of the ``decorator``
+module to fully support Python 3, including `function
+annotations`_. Version 3.2 was the first version to support Python 3
+via the ``2to3`` conversion tool.  The hard work (for me) has been
+converting the documentation and the doctests.  This has been possible
+only after that docutils_ and pygments_ have been ported to Python 3.
 
 Version 3 of the ``decorator`` module do not contain any backward
 incompatible change, apart from the removal of the functions
@@ -813,7 +813,7 @@ case (converting signature changing decorators to signature preserving
 decorators) has been subsumed by ``decorator_apply``, whereas the other use
 case can be managed with the ``FunctionMaker``.
 
-There are a few changes in the documentation: I removed the 
+There are a few changes in the documentation: I removed the
 ``decorator_factory`` example, which was confusing some of my users,
 and I removed the part about exotic signatures in the Python 3
 documentation, since Python 3 does not support them.
@@ -834,7 +834,7 @@ you will notice a few differences since
 ``getargspec`` returns an ``ArgSpec`` namedtuple instead of a regular
 tuple. That means that running the file
 ``documentation.py`` under Python 2.5 will print a few errors, but
-they are not serious. 
+they are not serious.
 
 .. _functionality introduced in version 2.3: http://www.phyast.pitt.edu/~micheles/python/documentation.html#class-decorators-and-decorator-factories
 .. _function annotations: http://www.python.org/dev/peps/pep-3107/
@@ -845,19 +845,19 @@ they are not serious.
 LICENCE
 ---------------------------------------------
 
-Copyright (c) 2005-2012, Michele Simionato
+Copyright (c) 2005-2015, Michele Simionato
 All rights reserved.
 
 Redistribution and use in source and binary forms, with or without
 modification, are permitted provided that the following conditions are
 met:
 
-  Redistributions of source code must retain the above copyright 
+  Redistributions of source code must retain the above copyright
   notice, this list of conditions and the following disclaimer.
   Redistributions in bytecode form must reproduce the above copyright
   notice, this list of conditions and the following disclaimer in
   the documentation and/or other materials provided with the
-  distribution. 
+  distribution.
 
 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
@@ -872,12 +872,17 @@ TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
 USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
 DAMAGE.
 
-If you use this software and you are happy with it, consider sending me a 
+If you use this software and you are happy with it, consider sending me a
 note, just to gratify my ego. On the other hand, if you use this software and
 you are unhappy with it, send me a patch!
 """
 from __future__ import with_statement
-import sys, threading, time, functools, inspect, itertools  
+import sys
+import threading
+import time
+import functools
+import inspect
+import itertools  
 from decorator import *
 from functools import partial
 from setup import VERSION
@@ -886,35 +891,42 @@ today = time.strftime('%Y-%m-%d')
 
 __doc__ = __doc__.replace('$VERSION', VERSION).replace('$DATE', today)
 
+
 def decorator_apply(dec, func):
     """
-    Decorate a function by preserving the signature even if dec 
+    Decorate a function by preserving the signature even if dec
     is not a signature-preserving decorator.
     """
     return FunctionMaker.create(
         func, 'return decorated(%(signature)s)',
         dict(decorated=dec(func)), __wrapped__=func)
 
+
 def _trace(f, *args, **kw):
     kwstr = ', '.join('%r: %r' % (k, kw[k]) for k in sorted(kw))
     print("calling %s with args %s, {%s}" % (f.__name__, args, kwstr))
     return f(*args, **kw)
 
+
 def trace(f):
     return decorator(_trace, f)
 
-def on_success(result): # default implementation
+
+def on_success(result):  # default implementation
     "Called on the result of the function"
     return result
 
-def on_failure(exc_info): # default implementation
+
+def on_failure(exc_info):  # default implementation
     "Called if the function fails"
     pass
 
-def on_closing(): # default implementation
+
+def on_closing():  # default implementation
     "Called at the end, both in case of success and failure"
     pass
 
+
 class Async(object):
     """
     A decorator converting blocking functions into asynchronous
@@ -934,9 +946,10 @@ class Async(object):
     def __call__(self, func, *args, **kw):
         try:
             counter = func.counter
-        except AttributeError: # instantiate the counter at the first call
+        except AttributeError:  # instantiate the counter at the first call
             counter = func.counter = itertools.count(1)
         name = '%s-%s' % (func.__name__, next(counter))
+
         def func_wrapper():
             try:
                 result = func(*args, **kw)
@@ -950,18 +963,23 @@ class Async(object):
         thread.start()
         return thread
 
+
 def identity_dec(func):
     def wrapper(*args, **kw):
         return func(*args, **kw)
     return wrapper
 
+
 @identity_dec
-def example(): pass
+def example():
+    pass
+
 
 def memoize_uw(func):
     func.cache = {}
+
     def memoize(*args, **kw):
-        if kw: # frozenset is used to ensure hashability
+        if kw:  # frozenset is used to ensure hashability
             key = args, frozenset(kw.iteritems())
         else:
             key = args
@@ -973,51 +991,61 @@ def memoize_uw(func):
             return result
     return functools.update_wrapper(memoize, func)
 
+
 def _memoize(func, *args, **kw):
-    if kw: # frozenset is used to ensure hashability
+    if kw:  # frozenset is used to ensure hashability
         key = args, frozenset(kw.iteritems())
     else:
         key = args
-    cache = func.cache # attributed added by memoize
+    cache = func.cache  # attributed added by memoize
     if key in cache:
         return cache[key]
     else:
         cache[key] = result = func(*args, **kw)
         return result
 
+
 def memoize(f):
     f.cache = {}
     return decorator(_memoize, f)
 
+
 def blocking(not_avail):
     def blocking(f, *args, **kw):
-        if not hasattr(f, "thread"): # no thread running
-            def set_result(): f.result = f(*args, **kw)
+        if not hasattr(f, "thread"):  # no thread running
+            def set_result():
+                f.result = f(*args, **kw)
             f.thread = threading.Thread(None, set_result)
             f.thread.start()
             return not_avail
         elif f.thread.isAlive():
             return not_avail
-        else: # the thread is ended, return the stored result
+        else:  # the thread is ended, return the stored result
             del f.thread
             return f.result
     return decorator(blocking)
 
+
 class User(object):
     "Will just be able to see a page"
 
+
 class PowerUser(User):
     "Will be able to add new pages too"
 
+
 class Admin(PowerUser):
     "Will be able to delete pages too"
 
+
 def get_userclass():
     return User
 
+
 class PermissionError(Exception):
     pass
 
+
 def restricted(user_class):
     def restricted(func, *args, **kw):
         "Restrict access to a given class of users"
@@ -1030,6 +1058,7 @@ def restricted(user_class):
                 % (userclass.__name__, func.__name__))
     return decorator(restricted)
 
+
 class Action(object):
     """
     >>> a = Action()
@@ -1052,6 +1081,7 @@ class Action(object):
     def delete(self):
         pass
 
+
 class TailRecursive(object):
     """
     tail_recursive decorator based on Kay Schluehr's recipe
@@ -1062,7 +1092,7 @@ class TailRecursive(object):
     def __init__(self, func):
         self.func = func
         self.firstcall = True
-        self.CONTINUE = object() # sentinel
+        self.CONTINUE = object()  # sentinel
 
     def __call__(self, *args, **kwd):
         CONTINUE = self.CONTINUE
@@ -1072,29 +1102,35 @@ class TailRecursive(object):
             try:
                 while True:
                     result = func(*args, **kwd)
-                    if result is CONTINUE: # update arguments
+                    if result is CONTINUE:  # update arguments
                         args, kwd = self.argskwd
-                    else: # last call
+                    else:  # last call
                         return result
             finally:
                 self.firstcall = True
-        else: # return the arguments of the tail call
+        else:  # return the arguments of the tail call
             self.argskwd = args, kwd
             return CONTINUE
 
+
 def tail_recursive(func):
     return decorator_apply(TailRecursive, func)
 
+
 @tail_recursive
 def factorial(n, acc=1):
     "The good old factorial"
-    if n == 0: return acc
+    if n == 0:
+        return acc
     return factorial(n-1, n*acc)
 
-def fact(n): # this is not tail-recursive
-    if n == 0: return 1
+
+def fact(n):  # this is not tail-recursive
+    if n == 0:
+        return 1
     return n * fact(n-1)
 
+
 def a_test_for_pylons():
     """
     In version 3.1.0 decorator(caller) returned a nameless partial
@@ -1109,15 +1145,17 @@ def a_test_for_pylons():
     'The good old factorial'
     """
 
+
 def test_kwonlydefaults():
     """
     >>> @trace
     ... def f(arg, defarg=1, *args, kwonly=2): pass
     ...
-    >>> f.__kwdefaults__ 
+    >>> f.__kwdefaults__
     {'kwonly': 2}
     """
 
+
 def test_kwonlyargs():
     """
     >>> @trace
@@ -1129,6 +1167,7 @@ def test_kwonlyargs():
     ('y', 'z')
     """
 
+
 def test_kwonly_no_args():
     """# this was broken with decorator 3.3.3
     >>> @trace
@@ -1137,6 +1176,8 @@ def test_kwonly_no_args():
     >>> f()
     calling f with args (), {}
     """
+
+
 def test_kwonly_star_notation():
     """
     >>> @trace
@@ -1146,13 +1187,15 @@ def test_kwonly_star_notation():
     FullArgSpec(args=[], varargs=None, varkw='kw', defaults=None, kwonlyargs=['a'], kwonlydefaults={'a': 1}, annotations={})
     """
 
+
 @contextmanager
 def before_after(before, after):
     print(before)
     yield
     print(after)
 
-ba = before_after('BEFORE', 'AFTER') # ContextManager instance
+ba = before_after('BEFORE', 'AFTER')  # ContextManager instance
+
 
 @ba
 def hello(user):
@@ -1167,4 +1210,5 @@ def hello(user):
     print('hello %s' % user)
 
 if __name__ == '__main__':
-    import doctest; doctest.testmod()
+    import doctest
+    doctest.testmod()
diff --git a/documentation3.rst b/documentation3.rst
new file mode 100644
index 0000000..ad4a8c8
--- /dev/null
+++ b/documentation3.rst
@@ -0,0 +1,1055 @@
+
+The ``decorator`` module
+=============================================================
+
+:Author: Michele Simionato
+:E-mail: michele.simionato@gmail.com
+:Version: 3.4.1 (2015-03-16)
+:Requires: Python 2.4+
+:Download page: http://pypi.python.org/pypi/decorator/3.4.1
+:Installation: ``easy_install decorator``
+:License: BSD license
+
+.. contents::
+
+Introduction
+------------------------------------------------
+
+Python decorators are an interesting example of why syntactic sugar
+matters. In principle, their introduction in Python 2.4 changed
+nothing, since they do not provide any new functionality which was not
+already present in the language. In practice, their introduction has
+significantly changed the way we structure our programs in Python. I
+believe the change is for the best, and that decorators are a great
+idea since:
+
+* decorators help reducing boilerplate code;
+* decorators help separation of concerns;
+* decorators enhance readability and maintenability;
+* decorators are explicit.
+
+Still, as of now, writing custom decorators correctly requires
+some experience and it is not as easy as it could be. For instance,
+typical implementations of decorators involve nested functions, and
+we all know that flat is better than nested.
+
+The aim of the ``decorator`` module it to simplify the usage of
+decorators for the average programmer, and to popularize decorators by
+showing various non-trivial examples. Of course, as all techniques,
+decorators can be abused (I have seen that) and you should not try to
+solve every problem with a decorator, just because you can.
+
+You may find the source code for all the examples
+discussed here in the ``documentation.py`` file, which contains
+this documentation in the form of doctests.
+
+Definitions
+------------------------------------
+
+Technically speaking, any Python object which can be called with one argument
+can be used as  a decorator. However, this definition is somewhat too large
+to be really useful. It is more convenient to split the generic class of
+decorators in two subclasses:
+
++ *signature-preserving* decorators, i.e. callable objects taking a
+  function as input and returning a function *with the same
+  signature* as output;
+
++ *signature-changing* decorators, i.e. decorators that change
+  the signature of their input function, or decorators returning
+  non-callable objects.
+
+Signature-changing decorators have their use: for instance the
+builtin classes ``staticmethod`` and ``classmethod`` are in this
+group, since they take functions and return descriptor objects which
+are not functions, nor callables.
+
+However, signature-preserving decorators are more common and easier to
+reason about; in particular signature-preserving decorators can be
+composed together whereas other decorators in general cannot.
+
+Writing signature-preserving decorators from scratch is not that
+obvious, especially if one wants to define proper decorators that
+can accept functions with any signature. A simple example will clarify
+the issue.
+
+Statement of the problem
+------------------------------
+
+A very common use case for decorators is the memoization of functions.
+A ``memoize`` decorator works by caching
+the result of the function call in a dictionary, so that the next time
+the function is called with the same input parameters the result is retrieved
+from the cache and not recomputed. There are many implementations of
+``memoize`` in http://www.python.org/moin/PythonDecoratorLibrary,
+but they do not preserve the signature.
+A simple implementation could be the following (notice
+that in general it is impossible to memoize correctly something
+that depends on non-hashable arguments):
+
+.. code-block:: python
+
+ def memoize_uw(func):
+     func.cache = {}
+ 
+     def memoize(*args, **kw):
+         if kw:  # frozenset is used to ensure hashability
+             key = args, frozenset(kw.iteritems())
+         else:
+             key = args
+         cache = func.cache
+         if key in cache:
+             return cache[key]
+         else:
+             cache[key] = result = func(*args, **kw)
+             return result
+     return functools.update_wrapper(memoize, func)
+
+
+Here we used the functools.update_wrapper_ utility, which has
+been added in Python 2.5 expressly to simplify the definition of decorators
+(in older versions of Python you need to copy the function attributes
+``__name__``, ``__doc__``, ``__module__`` and ``__dict__``
+from the original function to the decorated function by hand).
+
+.. _functools.update_wrapper: https://docs.python.org/3/library/functools.html#functools.update_wrapper
+
+The implementation above works in the sense that the decorator
+can accept functions with generic signatures; unfortunately this
+implementation does *not* define a signature-preserving decorator, since in
+general ``memoize_uw`` returns a function with a
+*different signature* from the original function.
+
+Consider for instance the following case:
+
+.. code-block:: python
+
+ >>> @memoize_uw
+ ... def f1(x):
+ ...     time.sleep(1) # simulate some long computation
+ ...     return x
+
+Here the original function takes a single argument named ``x``,
+but the decorated function takes any number of arguments and
+keyword arguments:
+
+.. code-block:: python
+
+ >>> from inspect import getargspec
+ >>> print(getargspec(f1))
+ ArgSpec(args=[], varargs='args', keywords='kw', defaults=None)
+
+This means that introspection tools such as pydoc will give
+wrong informations about the signature of ``f1``. This is pretty bad:
+pydoc will tell you that the function accepts a generic signature
+``*args``, ``**kw``, but when you try to call the function with more than an
+argument, you will get an error:
+
+.. code-block:: python
+
+ >>> f1(0, 1) 
+ Traceback (most recent call last):
+    ...
+ TypeError: f1() takes exactly 1 positional argument (2 given)
+
+The solution
+-----------------------------------------
+
+The solution is to provide a generic factory of generators, which
+hides the complexity of making signature-preserving decorators
+from the application programmer. The ``decorator`` function in
+the ``decorator`` module is such a factory:
+
+.. code-block:: python
+
+ >>> from decorator import decorator
+
+``decorator`` takes two arguments, a caller function describing the
+functionality of the decorator and a function to be decorated; it
+returns the decorated function. The caller function must have
+signature ``(f, *args, **kw)`` and it must call the original function ``f``
+with arguments ``args`` and ``kw``, implementing the wanted capability,
+i.e. memoization in this case:
+
+.. code-block:: python
+
+ def _memoize(func, *args, **kw):
+     if kw:  # frozenset is used to ensure hashability
+         key = args, frozenset(kw.iteritems())
+     else:
+         key = args
+     cache = func.cache  # attributed added by memoize
+     if key in cache:
+         return cache[key]
+     else:
+         cache[key] = result = func(*args, **kw)
+         return result
+
+
+At this point you can define your decorator as follows:
+
+.. code-block:: python
+
+ def memoize(f):
+     f.cache = {}
+     return decorator(_memoize, f)
+
+
+The difference with respect to the ``memoize_uw`` approach, which is based
+on nested functions, is that the decorator module forces you to lift
+the inner function at the outer level (*flat is better than nested*).
+Moreover, you are forced to pass explicitly the function you want to
+decorate to the caller function.
+
+Here is a test of usage:
+
+.. code-block:: python
+
+ >>> @memoize
+ ... def heavy_computation():
+ ...     time.sleep(2)
+ ...     return "done"
+
+ >>> print(heavy_computation()) # the first time it will take 2 seconds
+ done
+
+ >>> print(heavy_computation()) # the second time it will be instantaneous
+ done
+
+The signature of ``heavy_computation`` is the one you would expect:
+
+.. code-block:: python
+
+ >>> print(getargspec(heavy_computation))
+ ArgSpec(args=[], varargs=None, keywords=None, defaults=None)
+
+A ``trace`` decorator
+------------------------------------------------------
+
+As an additional example, here is how you can define a trivial
+``trace`` decorator, which prints a message everytime the traced
+function is called:
+
+.. code-block:: python
+
+ def _trace(f, *args, **kw):
+     kwstr = ', '.join('%r: %r' % (k, kw[k]) for k in sorted(kw))
+     print("calling %s with args %s, {%s}" % (f.__name__, args, kwstr))
+     return f(*args, **kw)
+
+
+.. code-block:: python
+
+ def trace(f):
+     return decorator(_trace, f)
+
+
+Here is an example of usage:
+
+.. code-block:: python
+ 
+ >>> @trace
+ ... def f1(x):
+ ...     pass
+
+It is immediate to verify that ``f1`` works
+
+.. code-block:: python
+
+ >>> f1(0)
+ calling f1 with args (0,), {}
+
+and it that it has the correct signature:
+
+.. code-block:: python
+
+ >>> print(getargspec(f1))
+ ArgSpec(args=['x'], varargs=None, keywords=None, defaults=None)
+
+The same decorator works with functions of any signature:
+
+.. code-block:: python
+
+ >>> @trace
+ ... def f(x, y=1, z=2, *args, **kw):
+ ...     pass
+
+ >>> f(0, 3)
+ calling f with args (0, 3, 2), {}
+
+ >>> print(getargspec(f))
+ ArgSpec(args=['x', 'y', 'z'], varargs='args', keywords='kw', defaults=(1, 2))
+
+Function annotations
+---------------------------------------------
+
+Python 3 introduced the concept of `function annotations`_,i.e. the ability
+to annotate the signature of a function with additional information,
+stored in a dictionary named ``__annotations__``. The decorator module,
+starting from release 3.3, is able to understand and to preserve the
+annotations. Here is an example:
+
+.. code-block:: python
+
+ >>> @trace
+ ... def f(x: 'the first argument', y: 'default argument'=1, z=2,
+ ...       *args: 'varargs', **kw: 'kwargs'):
+ ...     pass
+ 
+In order to introspect functions with annotations, one needs the
+utility ``inspect.getfullargspec``, new in Python 3:
+
+.. code-block:: python
+
+ >>> from inspect import getfullargspec
+ >>> argspec = getfullargspec(f)
+ >>> argspec.args
+ ['x', 'y', 'z']
+ >>> argspec.varargs
+ 'args'
+ >>> argspec.varkw
+ 'kw'
+ >>> argspec.defaults
+ (1, 2)
+ >>> argspec.kwonlyargs
+ []
+ >>> argspec.kwonlydefaults
+
+You can also check that the ``__annotations__`` dictionary is preserved:
+
+.. code-block:: python
+
+  >>> f.__annotations__ == f.__wrapped__.__annotations__
+  True
+
+Depending on the version of the decorator module, the two dictionaries can
+be the same object or not: you cannot rely on object identity, but you can
+rely on the content being the same.
+
+``decorator`` is a decorator
+---------------------------------------------
+
+It may be annoying to write a caller function (like the ``_trace``
+function above) and then a trivial wrapper
+(``def trace(f): return decorator(_trace, f)``) every time. For this reason,
+the ``decorator`` module provides an easy shortcut to convert
+the caller function into a signature-preserving decorator:
+you can just call ``decorator`` with a single argument.
+In our example you can just write ``trace = decorator(_trace)``.
+The ``decorator`` function can also be used as a signature-changing
+decorator, just as ``classmethod`` and ``staticmethod``.
+However, ``classmethod`` and ``staticmethod`` return generic
+objects which are not callable, while ``decorator`` returns
+signature-preserving decorators, i.e. functions of a single argument.
+For instance, you can write directly
+
+.. code-block:: python
+
+ >>> @decorator
+ ... def trace(f, *args, **kw):
+ ...     kwstr = ', '.join('%r: %r' % (k, kw[k]) for k in sorted(kw))
+ ...     print("calling %s with args %s, {%s}" % (f.__name__, args, kwstr))
+ ...     return f(*args, **kw)
+
+and now ``trace`` will be a decorator. Actually ``trace`` is a ``partial``
+object which can be used as a decorator:
+
+.. code-block:: python
+
+ >>> trace 
+ <function trace at 0x...>
+
+Here is an example of usage:
+
+.. code-block:: python
+
+ >>> @trace
+ ... def func(): pass
+
+ >>> func()
+ calling func with args (), {}
+
+If you are using an old Python version (Python 2.4) the
+``decorator`` module provides a poor man replacement for
+``functools.partial``.
+
+``blocking``
+-------------------------------------------
+
+Sometimes one has to deal with blocking resources, such as ``stdin``, and
+sometimes it is best to have back a "busy" message than to block everything.
+This behavior can be implemented with a suitable family of decorators,
+where the parameter is the busy message:
+
+.. code-block:: python
+
+ def blocking(not_avail):
+     def blocking(f, *args, **kw):
+         if not hasattr(f, "thread"):  # no thread running
+             def set_result():
+                 f.result = f(*args, **kw)
+             f.thread = threading.Thread(None, set_result)
+             f.thread.start()
+             return not_avail
+         elif f.thread.isAlive():
+             return not_avail
+         else:  # the thread is ended, return the stored result
+             del f.thread
+             return f.result
+     return decorator(blocking)
+
+   
+Functions decorated with ``blocking`` will return a busy message if
+the resource is unavailable, and the intended result if the resource is
+available. For instance:
+
+.. code-block:: python
+
+ >>> @blocking("Please wait ...")
+ ... def read_data():
+ ...     time.sleep(3) # simulate a blocking resource
+ ...     return "some data"
+
+ >>> print(read_data())  # data is not available yet
+ Please wait ...
+
+ >>> time.sleep(1)
+ >>> print(read_data())  # data is not available yet
+ Please wait ...
+
+ >>> time.sleep(1)
+ >>> print(read_data())  # data is not available yet
+ Please wait ...
+
+ >>> time.sleep(1.1)  # after 3.1 seconds, data is available
+ >>> print(read_data())
+ some data
+
+``async``
+--------------------------------------------
+
+We have just seen an examples of a simple decorator factory,
+implemented as a function returning a decorator.
+For more complex situations, it is more
+convenient to implement decorator factories as classes returning
+callable objects that can be converted into decorators.
+
+As an example, here will I show a decorator
+which is able to convert a blocking function into an asynchronous
+function. The function, when called,
+is executed in a separate thread. Moreover, it is possible to set
+three callbacks ``on_success``, ``on_failure`` and ``on_closing``,
+to specify how to manage the function call (of course the code here
+is just an example, it is not a recommended way of doing multi-threaded
+programming). The implementation is the following:
+
+.. code-block:: python
+
+ def on_success(result):  # default implementation
+     "Called on the result of the function"
+     return result
+
+.. code-block:: python
+
+ def on_failure(exc_info):  # default implementation
+     "Called if the function fails"
+     pass
+
+.. code-block:: python
+
+ def on_closing():  # default implementation
+     "Called at the end, both in case of success and failure"
+     pass
+
+.. code-block:: python
+
+ class Async(object):
+     """
+     A decorator converting blocking functions into asynchronous
+     functions, by using threads or processes. Examples:
+ 
+     async_with_threads =  Async(threading.Thread)
+     async_with_processes =  Async(multiprocessing.Process)
+     """
+ 
+     def __init__(self, threadfactory, on_success=on_success,
+                  on_failure=on_failure, on_closing=on_closing):
+         self.threadfactory = threadfactory
+         self.on_success = on_success
+         self.on_failure = on_failure
+         self.on_closing = on_closing
+ 
+     def __call__(self, func, *args, **kw):
+         try:
+             counter = func.counter
+         except AttributeError:  # instantiate the counter at the first call
+             counter = func.counter = itertools.count(1)
+         name = '%s-%s' % (func.__name__, next(counter))
+ 
+         def func_wrapper():
+             try:
+                 result = func(*args, **kw)
+             except:
+                 self.on_failure(sys.exc_info())
+             else:
+                 return self.on_success(result)
+             finally:
+                 self.on_closing()
+         thread = self.threadfactory(None, func_wrapper, name)
+         thread.start()
+         return thread
+
+
+The decorated function returns
+the current execution thread, which can be stored and checked later, for
+instance to verify that the thread ``.isAlive()``.
+
+Here is an example of usage. Suppose one wants to write some data to
+an external resource which can be accessed by a single user at once
+(for instance a printer). Then the access to the writing function must
+be locked. Here is a minimalistic example:
+
+.. code-block:: python
+
+ >>> async = decorator(Async(threading.Thread))
+
+ >>> datalist = [] # for simplicity the written data are stored into a list.
+
+ >>> @async
+ ... def write(data):
+ ...     # append data to the datalist by locking
+ ...     with threading.Lock():
+ ...         time.sleep(1) # emulate some long running operation
+ ...         datalist.append(data)
+ ...     # other operations not requiring a lock here
+
+Each call to ``write`` will create a new writer thread, but there will
+be no synchronization problems since ``write`` is locked.
+
+.. code-block:: python
+
+ >>> write("data1") 
+ <Thread(write-1, started...)>
+ 
+ >>> time.sleep(.1) # wait a bit, so we are sure data2 is written after data1
+ 
+ >>> write("data2") 
+ <Thread(write-2, started...)>
+ 
+ >>> time.sleep(2) # wait for the writers to complete
+ 
+ >>> print(datalist)
+ ['data1', 'data2']
+
+contextmanager
+-------------------------------------
+
+For a long time Python had in its standard library a ``contextmanager``
+decorator, able to convert generator functions into
+``_GeneratorContextManager`` factories. For instance if you write
+
+.. code-block:: python
+
+ >>> from contextlib import contextmanager
+ >>> @contextmanager
+ ... def before_after(before, after):
+ ...     print(before)
+ ...     yield
+ ...     print(after)
+
+
+then ``before_after`` is a factory function returning
+``_GeneratorContextManager`` objects which can be used with
+the ``with`` statement:
+
+.. code-block:: python
+
+ >>> ba = before_after('BEFORE', 'AFTER')
+ >>> type(ba)
+ <class 'contextlib._GeneratorContextManager'>
+ >>> with ba:
+ ...     print('hello')
+ BEFORE
+ hello
+ AFTER
+
+Basically, it is as if the content of the ``with`` block was executed
+in the place of the ``yield`` expression in the generator function.
+In Python 3.2 ``_GeneratorContextManager``
+objects were enhanced with a ``__call__``
+method, so that they can be used as decorators as in this example:
+
+.. code-block:: python
+
+ >>> @ba 
+ ... def hello():
+ ...     print('hello')
+ ...
+ >>> hello() 
+ BEFORE
+ hello
+ AFTER
+
+The ``ba`` decorator is basically inserting a ``with ba:``
+block inside the function.
+However there two issues: the first is that ``_GeneratorContextManager``
+objects are callable only in Python 3.2, so the previous example will break
+in older versions of Python; the second is that
+``_GeneratorContextManager`` objects do not preserve the signature
+of the decorated functions: the decorated ``hello`` function here will have
+a generic signature ``hello(*args, **kwargs)`` but will break when
+called with more than zero arguments. For such reasons the decorator
+module, starting with release 3.4, offers a ``decorator.contextmanager``
+decorator that solves both problems and works even in Python 2.5.
+The usage is the same and factories decorated with ``decorator.contextmanager``
+will returns instances of ``ContextManager``, a subclass of
+``contextlib._GeneratorContextManager`` with a ``__call__`` method
+acting as a signature-preserving decorator.
+
+The ``FunctionMaker`` class
+---------------------------------------------------------------
+
+You may wonder about how the functionality of the ``decorator`` module
+is implemented. The basic building block is
+a ``FunctionMaker`` class which is able to generate on the fly
+functions with a given name and signature from a function template
+passed as a string. Generally speaking, you should not need to
+resort to ``FunctionMaker`` when writing ordinary decorators, but
+it is handy in some circumstances. You will see an example shortly, in
+the implementation of a cool decorator utility (``decorator_apply``).
+
+``FunctionMaker`` provides a ``.create`` classmethod which
+takes as input the name, signature, and body of the function
+we want to generate as well as the execution environment
+were the function is generated by ``exec``. Here is an example:
+
+.. code-block:: python
+
+ >>> def f(*args, **kw): # a function with a generic signature
+ ...     print(args, kw)
+
+ >>> f1 = FunctionMaker.create('f1(a, b)', 'f(a, b)', dict(f=f))
+ >>> f1(1,2)
+ (1, 2) {}
+
+It is important to notice that the function body is interpolated
+before being executed, so be careful with the ``%`` sign!
+
+``FunctionMaker.create`` also accepts keyword arguments and such
+arguments are attached to the resulting function. This is useful
+if you want to set some function attributes, for instance the
+docstring ``__doc__``.
+
+For debugging/introspection purposes it may be useful to see
+the source code of the generated function; to do that, just
+pass the flag ``addsource=True`` and a ``__source__`` attribute will
+be added to the generated function:
+
+.. code-block:: python
+
+ >>> f1 = FunctionMaker.create(
+ ...     'f1(a, b)', 'f(a, b)', dict(f=f), addsource=True)
+ >>> print(f1.__source__)
+ def f1(a, b):
+     f(a, b)
+ <BLANKLINE>
+
+``FunctionMaker.create`` can take as first argument a string,
+as in the examples before, or a function. This is the most common
+usage, since typically you want to decorate a pre-existing
+function. A framework author may want to use directly ``FunctionMaker.create``
+instead of ``decorator``, since it gives you direct access to the body
+of the generated function. For instance, suppose you want to instrument
+the ``__init__`` methods of a set of classes, by preserving their
+signature (such use case is not made up; this is done in SQAlchemy
+and in other frameworks). When the first argument of ``FunctionMaker.create``
+is a function, a ``FunctionMaker`` object is instantiated internally,
+with attributes ``args``, ``varargs``,
+``keywords`` and ``defaults`` which are the
+the return values of the standard library function ``inspect.getargspec``.
+For each argument in the ``args`` (which is a list of strings containing
+the names of the mandatory arguments) an attribute ``arg0``, ``arg1``,
+..., ``argN`` is also generated. Finally, there is a ``signature``
+attribute, a string with the signature of the original function.
+
+Notice that while I do not have plans
+to change or remove the functionality provided in the
+``FunctionMaker`` class, I do not guarantee that it will stay
+unchanged forever. For instance, right now I am using the traditional
+string interpolation syntax for function templates, but Python 2.6
+and Python 3.0 provide a newer interpolation syntax and I may use
+the new syntax in the future.
+On the other hand, the functionality provided by
+``decorator`` has been there from version 0.1 and it is guaranteed to
+stay there forever.
+
+Getting the source code
+---------------------------------------------------
+
+Internally ``FunctionMaker.create`` uses ``exec`` to generate the
+decorated function. Therefore
+``inspect.getsource`` will not work for decorated functions. That
+means that the usual '??' trick in IPython will give you the (right on
+the spot) message ``Dynamically generated function. No source code
+available``.  In the past I have considered this acceptable, since
+``inspect.getsource`` does not really work even with regular
+decorators. In that case ``inspect.getsource`` gives you the wrapper
+source code which is probably not what you want:
+
+.. code-block:: python
+
+ def identity_dec(func):
+     def wrapper(*args, **kw):
+         return func(*args, **kw)
+     return wrapper
+
+
+.. code-block:: python
+
+ @identity_dec
+ def example(): pass
+
+ >>> print(inspect.getsource(example))
+     def wrapper(*args, **kw):
+         return func(*args, **kw)
+ <BLANKLINE>
+
+(see bug report 1764286_ for an explanation of what is happening).
+Unfortunately the bug is still there, even in Python 2.7 and 3.1.
+There is however a workaround. The decorator module adds an
+attribute ``.__wrapped__`` to the decorated function, containing
+a reference to the original function. The easy way to get
+the source code is to call ``inspect.getsource`` on the
+undecorated function:
+
+.. code-block:: python
+
+ >>> print(inspect.getsource(factorial.__wrapped__))
+ @tail_recursive
+ def factorial(n, acc=1):
+     "The good old factorial"
+     if n == 0:
+         return acc
+     return factorial(n-1, n*acc)
+ <BLANKLINE>
+
+.. _1764286: http://bugs.python.org/issue1764286
+
+Dealing with third party decorators
+-----------------------------------------------------------------
+
+Sometimes you find on the net some cool decorator that you would
+like to include in your code. However, more often than not the cool
+decorator is not signature-preserving. Therefore you may want an easy way to
+upgrade third party decorators to signature-preserving decorators without
+having to rewrite them in terms of ``decorator``. You can use a
+``FunctionMaker`` to implement that functionality as follows:
+
+.. code-block:: python
+
+ def decorator_apply(dec, func):
+     """
+     Decorate a function by preserving the signature even if dec
+     is not a signature-preserving decorator.
+     """
+     return FunctionMaker.create(
+         func, 'return decorated(%(signature)s)',
+         dict(decorated=dec(func)), __wrapped__=func)
+
+
+``decorator_apply`` sets the attribute ``.__wrapped__`` of the generated
+function to the original function, so that you can get the right
+source code.
+
+Notice that I am not providing this functionality in the ``decorator``
+module directly since I think it is best to rewrite the decorator rather
+than adding an additional level of indirection. However, practicality
+beats purity, so you can add ``decorator_apply`` to your toolbox and
+use it if you need to.
+
+In order to give an example of usage of ``decorator_apply``, I will show a
+pretty slick decorator that converts a tail-recursive function in an iterative
+function. I have shamelessly stolen the basic idea from Kay Schluehr's recipe
+in the Python Cookbook,
+http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/496691.
+
+.. code-block:: python
+
+ class TailRecursive(object):
+     """
+     tail_recursive decorator based on Kay Schluehr's recipe
+     http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/496691
+     with improvements by me and George Sakkis.
+     """
+ 
+     def __init__(self, func):
+         self.func = func
+         self.firstcall = True
+         self.CONTINUE = object()  # sentinel
+ 
+     def __call__(self, *args, **kwd):
+         CONTINUE = self.CONTINUE
+         if self.firstcall:
+             func = self.func
+             self.firstcall = False
+             try:
+                 while True:
+                     result = func(*args, **kwd)
+                     if result is CONTINUE:  # update arguments
+                         args, kwd = self.argskwd
+                     else:  # last call
+                         return result
+             finally:
+                 self.firstcall = True
+         else:  # return the arguments of the tail call
+             self.argskwd = args, kwd
+             return CONTINUE
+
+
+Here the decorator is implemented as a class returning callable
+objects.
+
+.. code-block:: python
+
+ def tail_recursive(func):
+     return decorator_apply(TailRecursive, func)
+
+
+Here is how you apply the upgraded decorator to the good old factorial:
+
+.. code-block:: python
+
+ @tail_recursive
+ def factorial(n, acc=1):
+     "The good old factorial"
+     if n == 0:
+         return acc
+     return factorial(n-1, n*acc)
+
+
+.. code-block:: python
+
+ >>> print(factorial(4))
+ 24
+
+This decorator is pretty impressive, and should give you some food for
+your mind ;) Notice that there is no recursion limit now, and you can
+easily compute ``factorial(1001)`` or larger without filling the stack
+frame. Notice also that the decorator will not work on functions which
+are not tail recursive, such as the following
+
+.. code-block:: python
+
+ def fact(n):  # this is not tail-recursive
+     if n == 0:
+         return 1
+     return n * fact(n-1)
+
+
+(reminder: a function is tail recursive if it either returns a value without
+making a recursive call, or returns directly the result of a recursive
+call).
+
+Caveats and limitations
+-------------------------------------------
+
+The first thing you should be aware of, it the fact that decorators
+have a performance penalty.
+The worse case is shown by the following example::
+
+ $ cat performance.sh
+ python3 -m timeit -s "
+ from decorator import decorator
+
+ @decorator
+ def do_nothing(func, *args, **kw):
+     return func(*args, **kw)
+
+ @do_nothing
+ def f():
+     pass
+ " "f()"
+
+ python3 -m timeit -s "
+ def f():
+     pass
+ " "f()"
+
+On my MacBook, using the ``do_nothing`` decorator instead of the
+plain function is more than three times slower::
+
+ $ bash performance.sh
+ 1000000 loops, best of 3: 0.669 usec per loop
+ 1000000 loops, best of 3: 0.181 usec per loop
+
+It should be noted that a real life function would probably do
+something more useful than ``f`` here, and therefore in real life the
+performance penalty could be completely negligible.  As always, the
+only way to know if there is
+a penalty in your specific use case is to measure it.
+
+You should be aware that decorators will make your tracebacks
+longer and more difficult to understand. Consider this example:
+
+.. code-block:: python
+
+ >>> @trace
+ ... def f():
+ ...     1/0
+
+Calling ``f()`` will give you a ``ZeroDivisionError``, but since the
+function is decorated the traceback will be longer:
+
+.. code-block:: python
+
+ >>> f() 
+ Traceback (most recent call last):
+   ...
+      File "<string>", line 2, in f
+      File "<doctest __main__[22]>", line 4, in trace
+        return f(*args, **kw)
+      File "<doctest __main__[51]>", line 3, in f
+        1/0
+ ZeroDivisionError: ...
+
+You see here the inner call to the decorator ``trace``, which calls
+``f(*args, **kw)``, and a reference to  ``File "<string>", line 2, in f``.
+This latter reference is due to the fact that internally the decorator
+module uses ``exec`` to generate the decorated function. Notice that
+``exec`` is *not* responsibile for the performance penalty, since is the
+called *only once* at function decoration time, and not every time
+the decorated function is called.
+
+At present, there is no clean way to avoid ``exec``. A clean solution
+would require to change the CPython implementation of functions and
+add an hook to make it possible to change their signature directly.
+That could happen in future versions of Python (see PEP 362_) and
+then the decorator module would become obsolete. However, at present,
+even in Python 3.2 it is impossible to change the function signature
+directly, therefore the ``decorator`` module is still useful.
+Actually, this is one of the main reasons why I keep maintaining
+the module and releasing new versions.
+
+.. _362: http://www.python.org/dev/peps/pep-0362
+
+In the present implementation, decorators generated by ``decorator``
+can only be used on user-defined Python functions or methods, not on generic
+callable objects, nor on built-in functions, due to limitations of the
+``inspect`` module in the standard library.
+
+There is a restriction on the names of the arguments: for instance,
+if try to call an argument ``_call_`` or ``_func_``
+you will get a ``NameError``:
+
+.. code-block:: python
+
+ >>> @trace
+ ... def f(_func_): print(f)
+ ... 
+ Traceback (most recent call last):
+   ...
+ NameError: _func_ is overridden in
+ def f(_func_):
+     return _call_(_func_, _func_)
+
+Finally, the implementation is such that the decorated function contains
+a *copy* of the original function dictionary
+(``vars(decorated_f) is not vars(f)``):
+
+.. code-block:: python
+
+ >>> def f(): pass # the original function
+ >>> f.attr1 = "something" # setting an attribute
+ >>> f.attr2 = "something else" # setting another attribute
+
+ >>> traced_f = trace(f) # the decorated function
+
+ >>> traced_f.attr1
+ 'something'
+ >>> traced_f.attr2 = "something different" # setting attr
+ >>> f.attr2 # the original attribute did not change
+ 'something else'
+
+Compatibility notes
+---------------------------------------------------------------
+
+Version 3.4 fixes some bugs in the support of recent versions of
+Python 3.  Version 3.3 was the first version of the ``decorator``
+module to fully support Python 3, including `function
+annotations`_. Version 3.2 was the first version to support Python 3
+via the ``2to3`` conversion tool.  The hard work (for me) has been
+converting the documentation and the doctests.  This has been possible
+only after that docutils_ and pygments_ have been ported to Python 3.
+
+Version 3 of the ``decorator`` module do not contain any backward
+incompatible change, apart from the removal of the functions
+``get_info`` and ``new_wrapper``, which have been deprecated for
+years. ``get_info`` has been removed since it was little used and
+since it had to be changed anyway to work with Python 3.0;
+``new_wrapper`` has been removed since it was useless: its major use
+case (converting signature changing decorators to signature preserving
+decorators) has been subsumed by ``decorator_apply``, whereas the other use
+case can be managed with the ``FunctionMaker``.
+
+There are a few changes in the documentation: I removed the
+``decorator_factory`` example, which was confusing some of my users,
+and I removed the part about exotic signatures in the Python 3
+documentation, since Python 3 does not support them.
+
+Finally ``decorator`` cannot be used as a class decorator and the
+`functionality introduced in version 2.3`_ has been removed. That
+means that in order to define decorator factories with classes you
+need to define the ``__call__`` method explicitly (no magic anymore).
+All these changes should not cause any trouble, since they were
+all rarely used features. Should you have any trouble, you can always
+downgrade to the 2.3 version.
+
+The examples shown here have been tested with Python 2.6. Python 2.4
+is also supported - of course the examples requiring the ``with``
+statement will not work there. Python 2.5 works fine, but if you
+run the examples in the interactive interpreter
+you will notice a few differences since
+``getargspec`` returns an ``ArgSpec`` namedtuple instead of a regular
+tuple. That means that running the file
+``documentation.py`` under Python 2.5 will print a few errors, but
+they are not serious.
+
+.. _functionality introduced in version 2.3: http://www.phyast.pitt.edu/~micheles/python/documentation.html#class-decorators-and-decorator-factories
+.. _function annotations: http://www.python.org/dev/peps/pep-3107/
+.. _distribute: http://packages.python.org/distribute/
+.. _docutils: http://docutils.sourceforge.net/
+.. _pygments: http://pygments.org/
+
+LICENCE
+---------------------------------------------
+
+Copyright (c) 2005-2015, Michele Simionato
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are
+met:
+
+  Redistributions of source code must retain the above copyright
+  notice, this list of conditions and the following disclaimer.
+  Redistributions in bytecode form must reproduce the above copyright
+  notice, this list of conditions and the following disclaimer in
+  the documentation and/or other materials provided with the
+  distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
+OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
+TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
+USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
+DAMAGE.
+
+If you use this software and you are happy with it, consider sending me a
+note, just to gratify my ego. On the other hand, if you use this software and
+you are unhappy with it, send me a patch!
diff --git a/setup.py b/setup.py
index 8190acd..1521c3d 100644
--- a/setup.py
+++ b/setup.py
@@ -1,8 +1,10 @@
-try:
-    from setuptools import setup
-except ImportError:
-    from distutils.core import setup
+import sys
 import os.path
+if sys.version >= '3':
+    from setuptools import setup  # needed for the flag use_2to3
+else:
+    from distutils.core import setup
+
 
 def getversion(fname):
     """Get the __version__ reading the file: works both in Python 2.X and 3.X,
@@ -19,13 +21,13 @@ if __name__ == '__main__':
     setup(name='decorator',
           version=VERSION,
           description='Better living through Python with decorators',
-          long_description=open('README.txt').read(),
+          long_description=open('README.rst').read(),
           author='Michele Simionato',
           author_email='michele.simionato@gmail.com',
           url='http://pypi.python.org/pypi/decorator',
           license="BSD License",
-          package_dir = {'': 'src'},
-          py_modules = ['decorator'],
+          package_dir={'': 'src'},
+          py_modules=['decorator'],
           keywords="decorators generic utility",
           platforms=["All"],
           classifiers=['Development Status :: 5 - Production/Stable',
diff --git a/src/decorator.py b/src/decorator.py
index e1187bd..f180823 100644
--- a/src/decorator.py
+++ b/src/decorator.py
@@ -1,18 +1,18 @@
-##########################     LICENCE     ###############################
+# #########################     LICENCE     ############################ #
 
-# Copyright (c) 2005-2012, Michele Simionato
+# Copyright (c) 2005-2015, Michele Simionato
 # All rights reserved.
 
 # Redistribution and use in source and binary forms, with or without
 # modification, are permitted provided that the following conditions are
 # met:
 
-#   Redistributions of source code must retain the above copyright 
+#   Redistributions of source code must retain the above copyright
 #   notice, this list of conditions and the following disclaimer.
 #   Redistributions in bytecode form must reproduce the above copyright
 #   notice, this list of conditions and the following disclaimer in
 #   the documentation and/or other materials provided with the
-#   distribution. 
+#   distribution.
 
 # THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 # "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
@@ -36,9 +36,13 @@ __version__ = '3.4.1'
 
 __all__ = ["decorator", "FunctionMaker", "contextmanager"]
 
-import sys, re, inspect
+import re
+import sys
+import inspect
+
 if sys.version >= '3':
     from inspect import getfullargspec
+
     def get_init(cls):
         return cls.__init__
 else:
@@ -49,16 +53,19 @@ else:
                 inspect.getargspec(f)
             self.kwonlyargs = []
             self.kwonlydefaults = None
+
         def __iter__(self):
             yield self.args
             yield self.varargs
             yield self.varkw
             yield self.defaults
+
     def get_init(cls):
         return cls.__init__.im_func
 
 DEF = re.compile('\s*def\s*([_\w][_\w\d]*)\s*\(')
 
+
 # basic functionality
 class FunctionMaker(object):
     """
@@ -72,8 +79,8 @@ class FunctionMaker(object):
         if func:
             # func can be a class or a callable, but not an instance method
             self.name = func.__name__
-            if self.name == '<lambda>': # small hack for lambda functions
-                self.name = '_lambda_' 
+            if self.name == '<lambda>':  # small hack for lambda functions
+                self.name = '_lambda_'
             self.doc = func.__doc__
             self.module = func.__module__
             if inspect.isfunction(func):
@@ -84,18 +91,18 @@ class FunctionMaker(object):
                     setattr(self, a, getattr(argspec, a))
                 for i, arg in enumerate(self.args):
                     setattr(self, 'arg%d' % i, arg)
-                if sys.version < '3': # easy way
-                    self.shortsignature = self.signature = \
+                if sys.version < '3':  # easy way
+                    self.shortsignature = self.signature = (
                         inspect.formatargspec(
-                        formatvalue=lambda val: "", *argspec)[1:-1]
-                else: # Python 3 way
+                            formatvalue=lambda val: "", *argspec)[1:-1])
+                else:  # Python 3 way
                     allargs = list(self.args)
                     allshortargs = list(self.args)
                     if self.varargs:
                         allargs.append('*' + self.varargs)
                         allshortargs.append('*' + self.varargs)
                     elif self.kwonlyargs:
-                        allargs.append('*') # single star syntax
+                        allargs.append('*')  # single star syntax
                     for a in self.kwonlyargs:
                         allargs.append('%s=None' % a)
                         allshortargs.append('%s=%s' % (a, a))
@@ -137,19 +144,19 @@ class FunctionMaker(object):
 
     def make(self, src_templ, evaldict=None, addsource=False, **attrs):
         "Make a new function from a given template and update the signature"
-        src = src_templ % vars(self) # expand name and signature
+        src = src_templ % vars(self)  # expand name and signature
         evaldict = evaldict or {}
         mo = DEF.match(src)
         if mo is None:
             raise SyntaxError('not a valid function template\n%s' % src)
-        name = mo.group(1) # extract the function name
-        names = set([name] + [arg.strip(' *') for arg in 
-                             self.shortsignature.split(',')])
+        name = mo.group(1)  # extract the function name
+        names = set([name] + [arg.strip(' *') for arg in
+                              self.shortsignature.split(',')])
         for n in names:
             if n in ('_func_', '_call_'):
                 raise NameError('%s is overridden in\n%s' % (n, src))
-        if not src.endswith('\n'): # add a newline just for safety
-            src += '\n' # this is needed in old versions of Python
+        if not src.endswith('\n'):  # add a newline just for safety
+            src += '\n'  # this is needed in old versions of Python
         try:
             code = compile(src, '<string>', 'single')
             # print >> sys.stderr, 'Compiling %s' % src
@@ -169,42 +176,43 @@ class FunctionMaker(object):
                doc=None, module=None, addsource=True, **attrs):
         """
         Create a function from the strings name, signature and body.
-        evaldict is the evaluation dictionary. If addsource is true an attribute
-        __source__ is added to the result. The attributes attrs are added,
-        if any.
+        evaldict is the evaluation dictionary. If addsource is true an
+        attribute __source__ is added to the result. The attributes attrs
+        are added, if any.
         """
-        if isinstance(obj, str): # "name(signature)"
+        if isinstance(obj, str):  # "name(signature)"
             name, rest = obj.strip().split('(', 1)
-            signature = rest[:-1] #strip a right parens            
+            signature = rest[:-1]  # strip a right parens
             func = None
-        else: # a function
+        else:  # a function
             name = None
             signature = None
             func = obj
         self = cls(func, name, signature, defaults, doc, module)
         ibody = '\n'.join('    ' + line for line in body.splitlines())
-        return self.make('def %(name)s(%(signature)s):\n' + ibody, 
-                        evaldict, addsource, **attrs)
-  
+        return self.make('def %(name)s(%(signature)s):\n' + ibody,
+                         evaldict, addsource, **attrs)
+
+
 def decorator(caller, func=None):
     """
     decorator(caller) converts a caller function into a decorator;
     decorator(caller, func) decorates a function using a caller.
     """
-    if func is not None: # returns a decorated function
+    if func is not None:  # returns a decorated function
         evaldict = func.func_globals.copy()
         evaldict['_call_'] = caller
         evaldict['_func_'] = func
         return FunctionMaker.create(
             func, "return _call_(_func_, %(shortsignature)s)",
             evaldict, __wrapped__=func)
-    else: # returns a decorator
+    else:  # returns a decorator
         if inspect.isclass(caller):
             name = caller.__name__.lower()
             callerfunc = get_init(caller)
             doc = 'decorator(%s) converts functions/generators into ' \
                 'factories of %s objects' % (caller.__name__, caller.__name__)
-            fun = getfullargspec(callerfunc).args[1] # second arg
+            fun = getfullargspec(callerfunc).args[1]  # second arg
         elif inspect.isfunction(caller):
             if caller.__name__ == '<lambda>':
                 name = '_lambda_'
@@ -212,21 +220,22 @@ def decorator(caller, func=None):
                 name = caller.__name__
             callerfunc = caller
             doc = caller.__doc__
-            fun = getfullargspec(callerfunc).args[0] # first arg
-        else: # assume caller is an object with a __call__ method
+            fun = getfullargspec(callerfunc).args[0]  # first arg
+        else:  # assume caller is an object with a __call__ method
             name = caller.__class__.__name__.lower()
             callerfunc = caller.__call__.im_func
             doc = caller.__call__.__doc__
-            fun = getfullargspec(callerfunc).args[1] # second arg
+            fun = getfullargspec(callerfunc).args[1]  # second arg
         evaldict = callerfunc.func_globals.copy()
         evaldict['_call_'] = caller
         evaldict['decorator'] = decorator
         return FunctionMaker.create(
-            '%s(%s)' % (name, fun), 
+            '%s(%s)' % (name, fun),
             'return decorator(_call_, %s)' % fun,
             evaldict, call=caller, doc=doc, module=caller.__module__)
 
-######################### contextmanager ########################
+
+# ####################### contextmanager ####################### #
 
 def __call__(self, func):
     'Context manager decorator'
@@ -234,17 +243,18 @@ def __call__(self, func):
         func, "with _self_: return _func_(%(shortsignature)s)",
         dict(_self_=self, _func_=func), __wrapped__=func)
 
-try: # Python >= 3.2
+try:  # Python >= 3.2
+
+    from contextlib import _GeneratorContextManager
 
-    from contextlib import _GeneratorContextManager 
     class ContextManager(_GeneratorContextManager):
-        __call__=__call__
+        __call__ = __call__
 
-except ImportError: # Python >= 2.5
+except ImportError:  # Python >= 2.5
 
     try:
         from contextlib import GeneratorContextManager
-    except ImportError: # Python 2.4
+    except ImportError:  # Python 2.4
         class ContextManager(object):
             def __init__(self, g, *a, **k):
                 raise RuntimeError(
author	Michele Simionato <michele.simionato@gmail.com>	2015-03-16 13:32:00 +0100
committer	Michele Simionato <michele.simionato@gmail.com>	2015-03-16 13:32:00 +0100
commit	8bf5f43efca4654409b76200e6a59c3a539532ad (patch)
tree	42e586ddbb42b8980709d8e4ad49e01162d33448
parent	6faf8468c33457ce2e7f215bfc54c66b467ef899 (diff)
parent	d7d4bac90419a049165da9f29e2b8fef18fa7f33 (diff)
download	python-decorator-git-8bf5f43efca4654409b76200e6a59c3a539532ad.tar.gz