1 ano atrás · ccb2cde7ee
--- a/courses/flask/microblog/app/__init__.py
+++ b/courses/flask/microblog/app/__init__.py
@@ -0,0 +1,5 @@
 
				+from flask import Flask

			
 
				+

			
 
				+app = Flask(__name__)

			
 
				+

			
 
				+from app import routes

			
--- a/courses/flask/microblog/app/__pycache__/__init__.cpython-310.pyc
+++ b/courses/flask/microblog/app/__pycache__/__init__.cpython-310.pyc
--- a/courses/flask/microblog/app/__pycache__/routes.cpython-310.pyc
+++ b/courses/flask/microblog/app/__pycache__/routes.cpython-310.pyc
--- a/courses/flask/microblog/app/routes.py
+++ b/courses/flask/microblog/app/routes.py
@@ -0,0 +1,24 @@
 
				+from flask import render_template

			
 
				+from app import app

			
 
				+

			
 
				+@app.route('/')

			
 
				+@app.route('/index')

			
 
				+def index():

			
 
				+    user = {'username': 'Dm'}

			
 
				+    posts = [

			
 
				+        {

			
 
				+            'author': {'username': 'John'}, 

			
 
				+            'body': 'Beauriful day in Portland!'

			
 
				+        },

			
 
				+        {

			
 
				+            'author': {'username': 'Susan'}, 

			
 
				+            'body': 'The Avengers movie was so cool!'

			
 
				+        },

			
 
				+        {

			
 
				+            'author': {'username': 'Ипполит'}, 

			
 
				+            'body': 'Какая гадость эта ваша заливная рыба!!!'

			
 
				+        }

			
 
				+    ]

			
 
				+    return render_template('index.html', title='Home', user=user, posts=posts)

			
 
				+

			
 
				+    
			
--- a/courses/flask/microblog/app/templates/base.html
+++ b/courses/flask/microblog/app/templates/base.html
@@ -0,0 +1,14 @@
 
				+<html>

			
 
				+    <head>

			
 
				+        {% if title %}

			
 
				+        <title>{{ title }} - Microblog</title>

			
 
				+        {% else %}

			
 
				+        <title>Welcome to Microblog</title>

			
 
				+        {% endif %}

			
 
				+    </head>

			
 
				+    <body>

			
 
				+        <div>Microblog: <a href="/index">Home</a></div>

			
 
				+        <hr>

			
 
				+        {% block content %}{% endblock %}

			
 
				+    </body>

			
 
				+</html>
			
--- a/courses/flask/microblog/app/templates/index.html
+++ b/courses/flask/microblog/app/templates/index.html
@@ -0,0 +1,8 @@
 
				+{% extends "base.html" %}

			
 
				+

			
 
				+{% block content %}

			
 
				+    <h1>Hi, {{ user.username }}!</h1>

			
 
				+    {% for post in posts %}

			
 
				+    <div><p>{{ post.author.username }} says: <b>{{ post.body }}</b></p></div>

			
 
				+    {% endfor %}

			
 
				+{% endblock %}
			
--- a/courses/flask/microblog/env/Lib/site-packages/Jinja2-3.1.2.dist-info/INSTALLER
+++ b/courses/flask/microblog/env/Lib/site-packages/Jinja2-3.1.2.dist-info/INSTALLER
@@ -0,0 +1 @@
 
				+pip
			
--- a/courses/flask/microblog/env/Lib/site-packages/Jinja2-3.1.2.dist-info/LICENSE.rst
+++ b/courses/flask/microblog/env/Lib/site-packages/Jinja2-3.1.2.dist-info/LICENSE.rst
@@ -0,0 +1,28 @@
 
				+Copyright 2007 Pallets
			
 
				+
			
 
				+Redistribution and use in source and binary forms, with or without
			
 
				+modification, are permitted provided that the following conditions are
			
 
				+met:
			
 
				+
			
 
				+1.  Redistributions of source code must retain the above copyright
			
 
				+    notice, this list of conditions and the following disclaimer.
			
 
				+
			
 
				+2.  Redistributions in binary 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.
			
 
				+
			
 
				+3.  Neither the name of the copyright holder nor the names of its
			
 
				+    contributors may be used to endorse or promote products derived from
			
 
				+    this software without specific prior written permission.
			
 
				+
			
 
				+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
			
 
				+HOLDER 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.
			
--- a/courses/flask/microblog/env/Lib/site-packages/Jinja2-3.1.2.dist-info/METADATA
+++ b/courses/flask/microblog/env/Lib/site-packages/Jinja2-3.1.2.dist-info/METADATA
@@ -0,0 +1,113 @@
 
				+Metadata-Version: 2.1
			
 
				+Name: Jinja2
			
 
				+Version: 3.1.2
			
 
				+Summary: A very fast and expressive template engine.
			
 
				+Home-page: https://palletsprojects.com/p/jinja/
			
 
				+Author: Armin Ronacher
			
 
				+Author-email: armin.ronacher@active-4.com
			
 
				+Maintainer: Pallets
			
 
				+Maintainer-email: contact@palletsprojects.com
			
 
				+License: BSD-3-Clause
			
 
				+Project-URL: Donate, https://palletsprojects.com/donate
			
 
				+Project-URL: Documentation, https://jinja.palletsprojects.com/
			
 
				+Project-URL: Changes, https://jinja.palletsprojects.com/changes/
			
 
				+Project-URL: Source Code, https://github.com/pallets/jinja/
			
 
				+Project-URL: Issue Tracker, https://github.com/pallets/jinja/issues/
			
 
				+Project-URL: Twitter, https://twitter.com/PalletsTeam
			
 
				+Project-URL: Chat, https://discord.gg/pallets
			
 
				+Platform: UNKNOWN
			
 
				+Classifier: Development Status :: 5 - Production/Stable
			
 
				+Classifier: Environment :: Web Environment
			
 
				+Classifier: Intended Audience :: Developers
			
 
				+Classifier: License :: OSI Approved :: BSD License
			
 
				+Classifier: Operating System :: OS Independent
			
 
				+Classifier: Programming Language :: Python
			
 
				+Classifier: Topic :: Internet :: WWW/HTTP :: Dynamic Content
			
 
				+Classifier: Topic :: Text Processing :: Markup :: HTML
			
 
				+Requires-Python: >=3.7
			
 
				+Description-Content-Type: text/x-rst
			
 
				+License-File: LICENSE.rst
			
 
				+Requires-Dist: MarkupSafe (>=2.0)
			
 
				+Provides-Extra: i18n
			
 
				+Requires-Dist: Babel (>=2.7) ; extra == 'i18n'
			
 
				+
			
 
				+Jinja
			
 
				+=====
			
 
				+
			
 
				+Jinja is a fast, expressive, extensible templating engine. Special
			
 
				+placeholders in the template allow writing code similar to Python
			
 
				+syntax. Then the template is passed data to render the final document.
			
 
				+
			
 
				+It includes:
			
 
				+
			
 
				+-   Template inheritance and inclusion.
			
 
				+-   Define and import macros within templates.
			
 
				+-   HTML templates can use autoescaping to prevent XSS from untrusted
			
 
				+    user input.
			
 
				+-   A sandboxed environment can safely render untrusted templates.
			
 
				+-   AsyncIO support for generating templates and calling async
			
 
				+    functions.
			
 
				+-   I18N support with Babel.
			
 
				+-   Templates are compiled to optimized Python code just-in-time and
			
 
				+    cached, or can be compiled ahead-of-time.
			
 
				+-   Exceptions point to the correct line in templates to make debugging
			
 
				+    easier.
			
 
				+-   Extensible filters, tests, functions, and even syntax.
			
 
				+
			
 
				+Jinja's philosophy is that while application logic belongs in Python if
			
 
				+possible, it shouldn't make the template designer's job difficult by
			
 
				+restricting functionality too much.
			
 
				+
			
 
				+
			
 
				+Installing
			
 
				+----------
			
 
				+
			
 
				+Install and update using `pip`_:
			
 
				+
			
 
				+.. code-block:: text
			
 
				+
			
 
				+    $ pip install -U Jinja2
			
 
				+
			
 
				+.. _pip: https://pip.pypa.io/en/stable/getting-started/
			
 
				+
			
 
				+
			
 
				+In A Nutshell
			
 
				+-------------
			
 
				+
			
 
				+.. code-block:: jinja
			
 
				+
			
 
				+    {% extends "base.html" %}
			
 
				+    {% block title %}Members{% endblock %}
			
 
				+    {% block content %}
			
 
				+      <ul>
			
 
				+      {% for user in users %}
			
 
				+        <li><a href="{{ user.url }}">{{ user.username }}</a></li>
			
 
				+      {% endfor %}
			
 
				+      </ul>
			
 
				+    {% endblock %}
			
 
				+
			
 
				+
			
 
				+Donate
			
 
				+------
			
 
				+
			
 
				+The Pallets organization develops and supports Jinja and other popular
			
 
				+packages. In order to grow the community of contributors and users, and
			
 
				+allow the maintainers to devote more time to the projects, `please
			
 
				+donate today`_.
			
 
				+
			
 
				+.. _please donate today: https://palletsprojects.com/donate
			
 
				+
			
 
				+
			
 
				+Links
			
 
				+-----
			
 
				+
			
 
				+-   Documentation: https://jinja.palletsprojects.com/
			
 
				+-   Changes: https://jinja.palletsprojects.com/changes/
			
 
				+-   PyPI Releases: https://pypi.org/project/Jinja2/
			
 
				+-   Source Code: https://github.com/pallets/jinja/
			
 
				+-   Issue Tracker: https://github.com/pallets/jinja/issues/
			
 
				+-   Website: https://palletsprojects.com/p/jinja/
			
 
				+-   Twitter: https://twitter.com/PalletsTeam
			
 
				+-   Chat: https://discord.gg/pallets
			
 
				+
			
 
				+
			
--- a/courses/flask/microblog/env/Lib/site-packages/Jinja2-3.1.2.dist-info/RECORD
+++ b/courses/flask/microblog/env/Lib/site-packages/Jinja2-3.1.2.dist-info/RECORD
@@ -0,0 +1,58 @@
 
				+Jinja2-3.1.2.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4

			
 
				+Jinja2-3.1.2.dist-info/LICENSE.rst,sha256=O0nc7kEF6ze6wQ-vG-JgQI_oXSUrjp3y4JefweCUQ3s,1475

			
 
				+Jinja2-3.1.2.dist-info/METADATA,sha256=PZ6v2SIidMNixR7MRUX9f7ZWsPwtXanknqiZUmRbh4U,3539

			
 
				+Jinja2-3.1.2.dist-info/RECORD,,

			
 
				+Jinja2-3.1.2.dist-info/WHEEL,sha256=G16H4A3IeoQmnOrYV4ueZGKSjhipXx8zc8nu9FGlvMA,92

			
 
				+Jinja2-3.1.2.dist-info/entry_points.txt,sha256=zRd62fbqIyfUpsRtU7EVIFyiu1tPwfgO7EvPErnxgTE,59

			
 
				+Jinja2-3.1.2.dist-info/top_level.txt,sha256=PkeVWtLb3-CqjWi1fO29OCbj55EhX_chhKrCdrVe_zs,7

			
 
				+jinja2/__init__.py,sha256=8vGduD8ytwgD6GDSqpYc2m3aU-T7PKOAddvVXgGr_Fs,1927

			
 
				+jinja2/__pycache__/__init__.cpython-310.pyc,,

			
 
				+jinja2/__pycache__/_identifier.cpython-310.pyc,,

			
 
				+jinja2/__pycache__/async_utils.cpython-310.pyc,,

			
 
				+jinja2/__pycache__/bccache.cpython-310.pyc,,

			
 
				+jinja2/__pycache__/compiler.cpython-310.pyc,,

			
 
				+jinja2/__pycache__/constants.cpython-310.pyc,,

			
 
				+jinja2/__pycache__/debug.cpython-310.pyc,,

			
 
				+jinja2/__pycache__/defaults.cpython-310.pyc,,

			
 
				+jinja2/__pycache__/environment.cpython-310.pyc,,

			
 
				+jinja2/__pycache__/exceptions.cpython-310.pyc,,

			
 
				+jinja2/__pycache__/ext.cpython-310.pyc,,

			
 
				+jinja2/__pycache__/filters.cpython-310.pyc,,

			
 
				+jinja2/__pycache__/idtracking.cpython-310.pyc,,

			
 
				+jinja2/__pycache__/lexer.cpython-310.pyc,,

			
 
				+jinja2/__pycache__/loaders.cpython-310.pyc,,

			
 
				+jinja2/__pycache__/meta.cpython-310.pyc,,

			
 
				+jinja2/__pycache__/nativetypes.cpython-310.pyc,,

			
 
				+jinja2/__pycache__/nodes.cpython-310.pyc,,

			
 
				+jinja2/__pycache__/optimizer.cpython-310.pyc,,

			
 
				+jinja2/__pycache__/parser.cpython-310.pyc,,

			
 
				+jinja2/__pycache__/runtime.cpython-310.pyc,,

			
 
				+jinja2/__pycache__/sandbox.cpython-310.pyc,,

			
 
				+jinja2/__pycache__/tests.cpython-310.pyc,,

			
 
				+jinja2/__pycache__/utils.cpython-310.pyc,,

			
 
				+jinja2/__pycache__/visitor.cpython-310.pyc,,

			
 
				+jinja2/_identifier.py,sha256=_zYctNKzRqlk_murTNlzrju1FFJL7Va_Ijqqd7ii2lU,1958

			
 
				+jinja2/async_utils.py,sha256=dHlbTeaxFPtAOQEYOGYh_PHcDT0rsDaUJAFDl_0XtTg,2472

			
 
				+jinja2/bccache.py,sha256=mhz5xtLxCcHRAa56azOhphIAe19u1we0ojifNMClDio,14061

			
 
				+jinja2/compiler.py,sha256=Gs-N8ThJ7OWK4-reKoO8Wh1ZXz95MVphBKNVf75qBr8,72172

			
 
				+jinja2/constants.py,sha256=GMoFydBF_kdpaRKPoM5cl5MviquVRLVyZtfp5-16jg0,1433

			
 
				+jinja2/debug.py,sha256=iWJ432RadxJNnaMOPrjIDInz50UEgni3_HKuFXi2vuQ,6299

			
 
				+jinja2/defaults.py,sha256=boBcSw78h-lp20YbaXSJsqkAI2uN_mD_TtCydpeq5wU,1267

			
 
				+jinja2/environment.py,sha256=6uHIcc7ZblqOMdx_uYNKqRnnwAF0_nzbyeMP9FFtuh4,61349

			
 
				+jinja2/exceptions.py,sha256=ioHeHrWwCWNaXX1inHmHVblvc4haO7AXsjCp3GfWvx0,5071

			
 
				+jinja2/ext.py,sha256=ivr3P7LKbddiXDVez20EflcO3q2aHQwz9P_PgWGHVqE,31502

			
 
				+jinja2/filters.py,sha256=9js1V-h2RlyW90IhLiBGLM2U-k6SCy2F4BUUMgB3K9Q,53509

			
 
				+jinja2/idtracking.py,sha256=GfNmadir4oDALVxzn3DL9YInhJDr69ebXeA2ygfuCGA,10704

			
 
				+jinja2/lexer.py,sha256=DW2nX9zk-6MWp65YR2bqqj0xqCvLtD-u9NWT8AnFRxQ,29726

			
 
				+jinja2/loaders.py,sha256=BfptfvTVpClUd-leMkHczdyPNYFzp_n7PKOJ98iyHOg,23207

			
 
				+jinja2/meta.py,sha256=GNPEvifmSaU3CMxlbheBOZjeZ277HThOPUTf1RkppKQ,4396

			
 
				+jinja2/nativetypes.py,sha256=DXgORDPRmVWgy034H0xL8eF7qYoK3DrMxs-935d0Fzk,4226

			
 
				+jinja2/nodes.py,sha256=i34GPRAZexXMT6bwuf5SEyvdmS-bRCy9KMjwN5O6pjk,34550

			
 
				+jinja2/optimizer.py,sha256=tHkMwXxfZkbfA1KmLcqmBMSaz7RLIvvItrJcPoXTyD8,1650

			
 
				+jinja2/parser.py,sha256=nHd-DFHbiygvfaPtm9rcQXJChZG7DPsWfiEsqfwKerY,39595

			
 
				+jinja2/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0

			
 
				+jinja2/runtime.py,sha256=5CmD5BjbEJxSiDNTFBeKCaq8qU4aYD2v6q2EluyExms,33476

			
 
				+jinja2/sandbox.py,sha256=Y0xZeXQnH6EX5VjaV2YixESxoepnRbW_3UeQosaBU3M,14584

			
 
				+jinja2/tests.py,sha256=Am5Z6Lmfr2XaH_npIfJJ8MdXtWsbLjMULZJulTAj30E,5905

			
 
				+jinja2/utils.py,sha256=u9jXESxGn8ATZNVolwmkjUVu4SA-tLgV0W7PcSfPfdQ,23965

			
 
				+jinja2/visitor.py,sha256=MH14C6yq24G_KVtWzjwaI7Wg14PCJIYlWW1kpkxYak0,3568

			
--- a/courses/flask/microblog/env/Lib/site-packages/Jinja2-3.1.2.dist-info/WHEEL
+++ b/courses/flask/microblog/env/Lib/site-packages/Jinja2-3.1.2.dist-info/WHEEL
@@ -0,0 +1,5 @@
 
				+Wheel-Version: 1.0
			
 
				+Generator: bdist_wheel (0.37.1)
			
 
				+Root-Is-Purelib: true
			
 
				+Tag: py3-none-any
			
 
				+
			
--- a/courses/flask/microblog/env/Lib/site-packages/Jinja2-3.1.2.dist-info/entry_points.txt
+++ b/courses/flask/microblog/env/Lib/site-packages/Jinja2-3.1.2.dist-info/entry_points.txt
@@ -0,0 +1,2 @@
 
				+[babel.extractors]
			
 
				+jinja2 = jinja2.ext:babel_extract[i18n]
			
--- a/courses/flask/microblog/env/Lib/site-packages/Jinja2-3.1.2.dist-info/top_level.txt
+++ b/courses/flask/microblog/env/Lib/site-packages/Jinja2-3.1.2.dist-info/top_level.txt
@@ -0,0 +1 @@
 
				+jinja2
			
--- a/courses/flask/microblog/env/Lib/site-packages/MarkupSafe-2.1.3.dist-info/INSTALLER
+++ b/courses/flask/microblog/env/Lib/site-packages/MarkupSafe-2.1.3.dist-info/INSTALLER
@@ -0,0 +1 @@
 
				+pip
			
--- a/courses/flask/microblog/env/Lib/site-packages/MarkupSafe-2.1.3.dist-info/LICENSE.rst
+++ b/courses/flask/microblog/env/Lib/site-packages/MarkupSafe-2.1.3.dist-info/LICENSE.rst
@@ -0,0 +1,28 @@
 
				+Copyright 2010 Pallets

			
 
				+

			
 
				+Redistribution and use in source and binary forms, with or without

			
 
				+modification, are permitted provided that the following conditions are

			
 
				+met:

			
 
				+

			
 
				+1.  Redistributions of source code must retain the above copyright

			
 
				+    notice, this list of conditions and the following disclaimer.

			
 
				+

			
 
				+2.  Redistributions in binary 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.

			
 
				+

			
 
				+3.  Neither the name of the copyright holder nor the names of its

			
 
				+    contributors may be used to endorse or promote products derived from

			
 
				+    this software without specific prior written permission.

			
 
				+

			
 
				+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

			
 
				+HOLDER 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.

			
--- a/courses/flask/microblog/env/Lib/site-packages/MarkupSafe-2.1.3.dist-info/METADATA
+++ b/courses/flask/microblog/env/Lib/site-packages/MarkupSafe-2.1.3.dist-info/METADATA
@@ -0,0 +1,93 @@
 
				+Metadata-Version: 2.1

			
 
				+Name: MarkupSafe

			
 
				+Version: 2.1.3

			
 
				+Summary: Safely add untrusted strings to HTML/XML markup.

			
 
				+Home-page: https://palletsprojects.com/p/markupsafe/

			
 
				+Maintainer: Pallets

			
 
				+Maintainer-email: contact@palletsprojects.com

			
 
				+License: BSD-3-Clause

			
 
				+Project-URL: Donate, https://palletsprojects.com/donate

			
 
				+Project-URL: Documentation, https://markupsafe.palletsprojects.com/

			
 
				+Project-URL: Changes, https://markupsafe.palletsprojects.com/changes/

			
 
				+Project-URL: Source Code, https://github.com/pallets/markupsafe/

			
 
				+Project-URL: Issue Tracker, https://github.com/pallets/markupsafe/issues/

			
 
				+Project-URL: Chat, https://discord.gg/pallets

			
 
				+Classifier: Development Status :: 5 - Production/Stable

			
 
				+Classifier: Environment :: Web Environment

			
 
				+Classifier: Intended Audience :: Developers

			
 
				+Classifier: License :: OSI Approved :: BSD License

			
 
				+Classifier: Operating System :: OS Independent

			
 
				+Classifier: Programming Language :: Python

			
 
				+Classifier: Topic :: Internet :: WWW/HTTP :: Dynamic Content

			
 
				+Classifier: Topic :: Text Processing :: Markup :: HTML

			
 
				+Requires-Python: >=3.7

			
 
				+Description-Content-Type: text/x-rst

			
 
				+License-File: LICENSE.rst

			
 
				+

			
 
				+MarkupSafe

			
 
				+==========

			
 
				+

			
 
				+MarkupSafe implements a text object that escapes characters so it is

			
 
				+safe to use in HTML and XML. Characters that have special meanings are

			
 
				+replaced so that they display as the actual characters. This mitigates

			
 
				+injection attacks, meaning untrusted user input can safely be displayed

			
 
				+on a page.

			
 
				+

			
 
				+

			
 
				+Installing

			
 
				+----------

			
 
				+

			
 
				+Install and update using `pip`_:

			
 
				+

			
 
				+.. code-block:: text

			
 
				+

			
 
				+    pip install -U MarkupSafe

			
 
				+

			
 
				+.. _pip: https://pip.pypa.io/en/stable/getting-started/

			
 
				+

			
 
				+

			
 
				+Examples

			
 
				+--------

			
 
				+

			
 
				+.. code-block:: pycon

			
 
				+

			
 
				+    >>> from markupsafe import Markup, escape

			
 
				+

			
 
				+    >>> # escape replaces special characters and wraps in Markup

			
 
				+    >>> escape("<script>alert(document.cookie);</script>")

			
 
				+    Markup('&lt;script&gt;alert(document.cookie);&lt;/script&gt;')

			
 
				+

			
 
				+    >>> # wrap in Markup to mark text "safe" and prevent escaping

			
 
				+    >>> Markup("<strong>Hello</strong>")

			
 
				+    Markup('<strong>hello</strong>')

			
 
				+

			
 
				+    >>> escape(Markup("<strong>Hello</strong>"))

			
 
				+    Markup('<strong>hello</strong>')

			
 
				+

			
 
				+    >>> # Markup is a str subclass

			
 
				+    >>> # methods and operators escape their arguments

			
 
				+    >>> template = Markup("Hello <em>{name}</em>")

			
 
				+    >>> template.format(name='"World"')

			
 
				+    Markup('Hello <em>&#34;World&#34;</em>')

			
 
				+

			
 
				+

			
 
				+Donate

			
 
				+------

			
 
				+

			
 
				+The Pallets organization develops and supports MarkupSafe and other

			
 
				+popular packages. In order to grow the community of contributors and

			
 
				+users, and allow the maintainers to devote more time to the projects,

			
 
				+`please donate today`_.

			
 
				+

			
 
				+.. _please donate today: https://palletsprojects.com/donate

			
 
				+

			
 
				+

			
 
				+Links

			
 
				+-----

			
 
				+

			
 
				+-   Documentation: https://markupsafe.palletsprojects.com/

			
 
				+-   Changes: https://markupsafe.palletsprojects.com/changes/

			
 
				+-   PyPI Releases: https://pypi.org/project/MarkupSafe/

			
 
				+-   Source Code: https://github.com/pallets/markupsafe/

			
 
				+-   Issue Tracker: https://github.com/pallets/markupsafe/issues/

			
 
				+-   Chat: https://discord.gg/pallets

			
--- a/courses/flask/microblog/env/Lib/site-packages/MarkupSafe-2.1.3.dist-info/RECORD
+++ b/courses/flask/microblog/env/Lib/site-packages/MarkupSafe-2.1.3.dist-info/RECORD
@@ -0,0 +1,14 @@
 
				+MarkupSafe-2.1.3.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4

			
 
				+MarkupSafe-2.1.3.dist-info/LICENSE.rst,sha256=RjHsDbX9kKVH4zaBcmTGeYIUM4FG-KyUtKV_lu6MnsQ,1503

			
 
				+MarkupSafe-2.1.3.dist-info/METADATA,sha256=5gU_TQw6eHpTaqkI6SPeZje6KTPlJPAV82uNiL3naKE,3096

			
 
				+MarkupSafe-2.1.3.dist-info/RECORD,,

			
 
				+MarkupSafe-2.1.3.dist-info/WHEEL,sha256=jrOhEbqKwvzRFSJcbYXlJCyVkgVdHg4_7__YHrdTUfw,102

			
 
				+MarkupSafe-2.1.3.dist-info/top_level.txt,sha256=qy0Plje5IJuvsCBjejJyhDCjEAdcDLK_2agVcex8Z6U,11

			
 
				+markupsafe/__init__.py,sha256=GsRaSTjrhvg6c88PnPJNqm4MafU_mFatfXz4-h80-Qc,10642

			
 
				+markupsafe/__pycache__/__init__.cpython-310.pyc,,

			
 
				+markupsafe/__pycache__/_native.cpython-310.pyc,,

			
 
				+markupsafe/_native.py,sha256=_Q7UsXCOvgdonCgqG3l5asANI6eo50EKnDM-mlwEC5M,1776

			
 
				+markupsafe/_speedups.c,sha256=n3jzzaJwXcoN8nTFyA53f3vSqsWK2vujI-v6QYifjhQ,7403

			
 
				+markupsafe/_speedups.cp310-win_amd64.pyd,sha256=nlgDO0l-guuFD-w6o7YZey0yek5iNTBpKjJrVebhZpI,15872

			
 
				+markupsafe/_speedups.pyi,sha256=f5QtwIOP0eLrxh2v5p6SmaYmlcHIGIfmz0DovaqL0OU,238

			
 
				+markupsafe/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0

			
--- a/courses/flask/microblog/env/Lib/site-packages/MarkupSafe-2.1.3.dist-info/WHEEL
+++ b/courses/flask/microblog/env/Lib/site-packages/MarkupSafe-2.1.3.dist-info/WHEEL
@@ -0,0 +1,5 @@
 
				+Wheel-Version: 1.0
			
 
				+Generator: bdist_wheel (0.40.0)
			
 
				+Root-Is-Purelib: false
			
 
				+Tag: cp310-cp310-win_amd64
			
 
				+
			
--- a/courses/flask/microblog/env/Lib/site-packages/MarkupSafe-2.1.3.dist-info/top_level.txt
+++ b/courses/flask/microblog/env/Lib/site-packages/MarkupSafe-2.1.3.dist-info/top_level.txt
@@ -0,0 +1 @@
 
				+markupsafe
			
--- a/courses/flask/microblog/env/Lib/site-packages/_distutils_hack/__init__.py
+++ b/courses/flask/microblog/env/Lib/site-packages/_distutils_hack/__init__.py
@@ -0,0 +1,128 @@
 
				+import sys
			
 
				+import os
			
 
				+import re
			
 
				+import importlib
			
 
				+import warnings
			
 
				+
			
 
				+
			
 
				+is_pypy = '__pypy__' in sys.builtin_module_names
			
 
				+
			
 
				+
			
 
				+warnings.filterwarnings('ignore',
			
 
				+                        r'.+ distutils\b.+ deprecated',
			
 
				+                        DeprecationWarning)
			
 
				+
			
 
				+
			
 
				+def warn_distutils_present():
			
 
				+    if 'distutils' not in sys.modules:
			
 
				+        return
			
 
				+    if is_pypy and sys.version_info < (3, 7):
			
 
				+        # PyPy for 3.6 unconditionally imports distutils, so bypass the warning
			
 
				+        # https://foss.heptapod.net/pypy/pypy/-/blob/be829135bc0d758997b3566062999ee8b23872b4/lib-python/3/site.py#L250
			
 
				+        return
			
 
				+    warnings.warn(
			
 
				+        "Distutils was imported before Setuptools, but importing Setuptools "
			
 
				+        "also replaces the `distutils` module in `sys.modules`. This may lead "
			
 
				+        "to undesirable behaviors or errors. To avoid these issues, avoid "
			
 
				+        "using distutils directly, ensure that setuptools is installed in the "
			
 
				+        "traditional way (e.g. not an editable install), and/or make sure "
			
 
				+        "that setuptools is always imported before distutils.")
			
 
				+
			
 
				+
			
 
				+def clear_distutils():
			
 
				+    if 'distutils' not in sys.modules:
			
 
				+        return
			
 
				+    warnings.warn("Setuptools is replacing distutils.")
			
 
				+    mods = [name for name in sys.modules if re.match(r'distutils\b', name)]
			
 
				+    for name in mods:
			
 
				+        del sys.modules[name]
			
 
				+
			
 
				+
			
 
				+def enabled():
			
 
				+    """
			
 
				+    Allow selection of distutils by environment variable.
			
 
				+    """
			
 
				+    which = os.environ.get('SETUPTOOLS_USE_DISTUTILS', 'stdlib')
			
 
				+    return which == 'local'
			
 
				+
			
 
				+
			
 
				+def ensure_local_distutils():
			
 
				+    clear_distutils()
			
 
				+    distutils = importlib.import_module('setuptools._distutils')
			
 
				+    distutils.__name__ = 'distutils'
			
 
				+    sys.modules['distutils'] = distutils
			
 
				+
			
 
				+    # sanity check that submodules load as expected
			
 
				+    core = importlib.import_module('distutils.core')
			
 
				+    assert '_distutils' in core.__file__, core.__file__
			
 
				+
			
 
				+
			
 
				+def do_override():
			
 
				+    """
			
 
				+    Ensure that the local copy of distutils is preferred over stdlib.
			
 
				+
			
 
				+    See https://github.com/pypa/setuptools/issues/417#issuecomment-392298401
			
 
				+    for more motivation.
			
 
				+    """
			
 
				+    if enabled():
			
 
				+        warn_distutils_present()
			
 
				+        ensure_local_distutils()
			
 
				+
			
 
				+
			
 
				+class DistutilsMetaFinder:
			
 
				+    def find_spec(self, fullname, path, target=None):
			
 
				+        if path is not None:
			
 
				+            return
			
 
				+
			
 
				+        method_name = 'spec_for_{fullname}'.format(**locals())
			
 
				+        method = getattr(self, method_name, lambda: None)
			
 
				+        return method()
			
 
				+
			
 
				+    def spec_for_distutils(self):
			
 
				+        import importlib.abc
			
 
				+        import importlib.util
			
 
				+
			
 
				+        class DistutilsLoader(importlib.abc.Loader):
			
 
				+
			
 
				+            def create_module(self, spec):
			
 
				+                return importlib.import_module('setuptools._distutils')
			
 
				+
			
 
				+            def exec_module(self, module):
			
 
				+                pass
			
 
				+
			
 
				+        return importlib.util.spec_from_loader('distutils', DistutilsLoader())
			
 
				+
			
 
				+    def spec_for_pip(self):
			
 
				+        """
			
 
				+        Ensure stdlib distutils when running under pip.
			
 
				+        See pypa/pip#8761 for rationale.
			
 
				+        """
			
 
				+        if self.pip_imported_during_build():
			
 
				+            return
			
 
				+        clear_distutils()
			
 
				+        self.spec_for_distutils = lambda: None
			
 
				+
			
 
				+    @staticmethod
			
 
				+    def pip_imported_during_build():
			
 
				+        """
			
 
				+        Detect if pip is being imported in a build script. Ref #2355.
			
 
				+        """
			
 
				+        import traceback
			
 
				+        return any(
			
 
				+            frame.f_globals['__file__'].endswith('setup.py')
			
 
				+            for frame, line in traceback.walk_stack(None)
			
 
				+        )
			
 
				+
			
 
				+
			
 
				+DISTUTILS_FINDER = DistutilsMetaFinder()
			
 
				+
			
 
				+
			
 
				+def add_shim():
			
 
				+    sys.meta_path.insert(0, DISTUTILS_FINDER)
			
 
				+
			
 
				+
			
 
				+def remove_shim():
			
 
				+    try:
			
 
				+        sys.meta_path.remove(DISTUTILS_FINDER)
			
 
				+    except ValueError:
			
 
				+        pass
			
--- a/courses/flask/microblog/env/Lib/site-packages/_distutils_hack/__pycache__/__init__.cpython-310.pyc
+++ b/courses/flask/microblog/env/Lib/site-packages/_distutils_hack/__pycache__/__init__.cpython-310.pyc
--- a/courses/flask/microblog/env/Lib/site-packages/_distutils_hack/__pycache__/override.cpython-310.pyc
+++ b/courses/flask/microblog/env/Lib/site-packages/_distutils_hack/__pycache__/override.cpython-310.pyc
--- a/courses/flask/microblog/env/Lib/site-packages/_distutils_hack/override.py
+++ b/courses/flask/microblog/env/Lib/site-packages/_distutils_hack/override.py
@@ -0,0 +1 @@
 
				+__import__('_distutils_hack').do_override()
			
--- a/courses/flask/microblog/env/Lib/site-packages/blinker-1.6.3.dist-info/INSTALLER
+++ b/courses/flask/microblog/env/Lib/site-packages/blinker-1.6.3.dist-info/INSTALLER
@@ -0,0 +1 @@
 
				+pip
			
--- a/courses/flask/microblog/env/Lib/site-packages/blinker-1.6.3.dist-info/LICENSE.rst
+++ b/courses/flask/microblog/env/Lib/site-packages/blinker-1.6.3.dist-info/LICENSE.rst
@@ -0,0 +1,20 @@
 
				+Copyright 2010 Jason Kirtland
			
 
				+
			
 
				+Permission is hereby granted, free of charge, to any person obtaining a
			
 
				+copy of this software and associated documentation files (the
			
 
				+"Software"), to deal in the Software without restriction, including
			
 
				+without limitation the rights to use, copy, modify, merge, publish,
			
 
				+distribute, sublicense, and/or sell copies of the Software, and to
			
 
				+permit persons to whom the Software is furnished to do so, subject to
			
 
				+the following conditions:
			
 
				+
			
 
				+The above copyright notice and this permission notice shall be included
			
 
				+in all copies or substantial portions of the Software.
			
 
				+
			
 
				+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
			
 
				+OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
			
 
				+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
			
 
				+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
			
 
				+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
			
 
				+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
			
 
				+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
			
--- a/courses/flask/microblog/env/Lib/site-packages/blinker-1.6.3.dist-info/METADATA
+++ b/courses/flask/microblog/env/Lib/site-packages/blinker-1.6.3.dist-info/METADATA
@@ -0,0 +1,62 @@
 
				+Metadata-Version: 2.1
			
 
				+Name: blinker
			
 
				+Version: 1.6.3
			
 
				+Summary: Fast, simple object-to-object and broadcast signaling
			
 
				+Keywords: signal,emit,events,broadcast
			
 
				+Author-email: Jason Kirtland <jek@discorporate.us>
			
 
				+Maintainer-email: Pallets Ecosystem <contact@palletsprojects.com>
			
 
				+Requires-Python: >=3.7
			
 
				+Description-Content-Type: text/x-rst
			
 
				+Classifier: Development Status :: 5 - Production/Stable
			
 
				+Classifier: Intended Audience :: Developers
			
 
				+Classifier: License :: OSI Approved :: MIT License
			
 
				+Classifier: Operating System :: OS Independent
			
 
				+Classifier: Programming Language :: Python
			
 
				+Classifier: Topic :: Software Development :: Libraries
			
 
				+Project-URL: Chat, https://discord.gg/pallets
			
 
				+Project-URL: Documentation, https://blinker.readthedocs.io
			
 
				+Project-URL: Homepage, https://blinker.readthedocs.io
			
 
				+Project-URL: Issue Tracker, https://github.com/pallets-eco/blinker/issues/
			
 
				+Project-URL: Source Code, https://github.com/pallets-eco/blinker/
			
 
				+
			
 
				+Blinker
			
 
				+=======
			
 
				+
			
 
				+Blinker provides a fast dispatching system that allows any number of
			
 
				+interested parties to subscribe to events, or "signals".
			
 
				+
			
 
				+Signal receivers can subscribe to specific senders or receive signals
			
 
				+sent by any sender.
			
 
				+
			
 
				+.. code-block:: pycon
			
 
				+
			
 
				+    >>> from blinker import signal
			
 
				+    >>> started = signal('round-started')
			
 
				+    >>> def each(round):
			
 
				+    ...     print(f"Round {round}")
			
 
				+    ...
			
 
				+    >>> started.connect(each)
			
 
				+
			
 
				+    >>> def round_two(round):
			
 
				+    ...     print("This is round two.")
			
 
				+    ...
			
 
				+    >>> started.connect(round_two, sender=2)
			
 
				+
			
 
				+    >>> for round in range(1, 4):
			
 
				+    ...     started.send(round)
			
 
				+    ...
			
 
				+    Round 1!
			
 
				+    Round 2!
			
 
				+    This is round two.
			
 
				+    Round 3!
			
 
				+
			
 
				+
			
 
				+Links
			
 
				+-----
			
 
				+
			
 
				+-   Documentation: https://blinker.readthedocs.io/
			
 
				+-   Changes: https://blinker.readthedocs.io/#changes
			
 
				+-   PyPI Releases: https://pypi.org/project/blinker/
			
 
				+-   Source Code: https://github.com/pallets-eco/blinker/
			
 
				+-   Issue Tracker: https://github.com/pallets-eco/blinker/issues/
			
 
				+
			
--- a/courses/flask/microblog/env/Lib/site-packages/blinker-1.6.3.dist-info/RECORD
+++ b/courses/flask/microblog/env/Lib/site-packages/blinker-1.6.3.dist-info/RECORD
@@ -0,0 +1,14 @@
 
				+blinker-1.6.3.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4

			
 
				+blinker-1.6.3.dist-info/LICENSE.rst,sha256=nrc6HzhZekqhcCXSrhvjg5Ykx5XphdTw6Xac4p-spGc,1054

			
 
				+blinker-1.6.3.dist-info/METADATA,sha256=yDLuXpi6nLMwYYWJlGDIBvbZxFZH23JHbdxPGzIU4vg,1918

			
 
				+blinker-1.6.3.dist-info/RECORD,,

			
 
				+blinker-1.6.3.dist-info/WHEEL,sha256=EZbGkh7Ie4PoZfRQ8I0ZuP9VklN_TvcZ6DSE5Uar4z4,81

			
 
				+blinker/__init__.py,sha256=E7dbyl7JyaK4RbWHlGrWY3mQ8d3BEnxRCeKQnqMa0bw,408

			
 
				+blinker/__pycache__/__init__.cpython-310.pyc,,

			
 
				+blinker/__pycache__/_saferef.cpython-310.pyc,,

			
 
				+blinker/__pycache__/_utilities.cpython-310.pyc,,

			
 
				+blinker/__pycache__/base.cpython-310.pyc,,

			
 
				+blinker/_saferef.py,sha256=kWOTIWnCY3kOb8lZP74Rbx7bR_BLVg4TjwzNCRLhKHs,9096

			
 
				+blinker/_utilities.py,sha256=GPXtJzykzVotoxHC79mgFQMPJtICwpVDCCpus4_JtsA,4110

			
 
				+blinker/base.py,sha256=ZfN6L36P0BzPaQAcAF0tSNAicxiG4f7xLPug6iLsjjE,20293

			
 
				+blinker/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0

			
--- a/courses/flask/microblog/env/Lib/site-packages/blinker-1.6.3.dist-info/WHEEL
+++ b/courses/flask/microblog/env/Lib/site-packages/blinker-1.6.3.dist-info/WHEEL
@@ -0,0 +1,4 @@
 
				+Wheel-Version: 1.0
			
 
				+Generator: flit 3.9.0
			
 
				+Root-Is-Purelib: true
			
 
				+Tag: py3-none-any
			
--- a/courses/flask/microblog/env/Lib/site-packages/blinker/__init__.py
+++ b/courses/flask/microblog/env/Lib/site-packages/blinker/__init__.py
@@ -0,0 +1,19 @@
 
				+from blinker.base import ANY
			
 
				+from blinker.base import NamedSignal
			
 
				+from blinker.base import Namespace
			
 
				+from blinker.base import receiver_connected
			
 
				+from blinker.base import Signal
			
 
				+from blinker.base import signal
			
 
				+from blinker.base import WeakNamespace
			
 
				+
			
 
				+__all__ = [
			
 
				+    "ANY",
			
 
				+    "NamedSignal",
			
 
				+    "Namespace",
			
 
				+    "Signal",
			
 
				+    "WeakNamespace",
			
 
				+    "receiver_connected",
			
 
				+    "signal",
			
 
				+]
			
 
				+
			
 
				+__version__ = "1.6.3"
			
--- a/courses/flask/microblog/env/Lib/site-packages/blinker/__pycache__/__init__.cpython-310.pyc
+++ b/courses/flask/microblog/env/Lib/site-packages/blinker/__pycache__/__init__.cpython-310.pyc
--- a/courses/flask/microblog/env/Lib/site-packages/blinker/__pycache__/_saferef.cpython-310.pyc
+++ b/courses/flask/microblog/env/Lib/site-packages/blinker/__pycache__/_saferef.cpython-310.pyc
--- a/courses/flask/microblog/env/Lib/site-packages/blinker/__pycache__/_utilities.cpython-310.pyc
+++ b/courses/flask/microblog/env/Lib/site-packages/blinker/__pycache__/_utilities.cpython-310.pyc
--- a/courses/flask/microblog/env/Lib/site-packages/blinker/__pycache__/base.cpython-310.pyc
+++ b/courses/flask/microblog/env/Lib/site-packages/blinker/__pycache__/base.cpython-310.pyc
--- a/courses/flask/microblog/env/Lib/site-packages/blinker/_saferef.py
+++ b/courses/flask/microblog/env/Lib/site-packages/blinker/_saferef.py
@@ -0,0 +1,230 @@
 
				+# extracted from Louie, http://pylouie.org/
			
 
				+# updated for Python 3
			
 
				+#
			
 
				+# Copyright (c) 2006 Patrick K. O'Brien, Mike C. Fletcher,
			
 
				+#                    Matthew R. Scott
			
 
				+#
			
 
				+# 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 binary 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.
			
 
				+#
			
 
				+#     * Neither the name of the <ORGANIZATION> nor the names of its
			
 
				+#       contributors may be used to endorse or promote products derived
			
 
				+#       from this software without specific prior written permission.
			
 
				+#
			
 
				+# 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
			
 
				+# OWNER 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.
			
 
				+#
			
 
				+"""Refactored 'safe reference from dispatcher.py"""
			
 
				+import operator
			
 
				+import sys
			
 
				+import traceback
			
 
				+import weakref
			
 
				+
			
 
				+
			
 
				+get_self = operator.attrgetter("__self__")
			
 
				+get_func = operator.attrgetter("__func__")
			
 
				+
			
 
				+
			
 
				+def safe_ref(target, on_delete=None):
			
 
				+    """Return a *safe* weak reference to a callable target.
			
 
				+
			
 
				+    - ``target``: The object to be weakly referenced, if it's a bound
			
 
				+      method reference, will create a BoundMethodWeakref, otherwise
			
 
				+      creates a simple weakref.
			
 
				+
			
 
				+    - ``on_delete``: If provided, will have a hard reference stored to
			
 
				+      the callable to be called after the safe reference goes out of
			
 
				+      scope with the reference object, (either a weakref or a
			
 
				+      BoundMethodWeakref) as argument.
			
 
				+    """
			
 
				+    try:
			
 
				+        im_self = get_self(target)
			
 
				+    except AttributeError:
			
 
				+        if callable(on_delete):
			
 
				+            return weakref.ref(target, on_delete)
			
 
				+        else:
			
 
				+            return weakref.ref(target)
			
 
				+    else:
			
 
				+        if im_self is not None:
			
 
				+            # Turn a bound method into a BoundMethodWeakref instance.
			
 
				+            # Keep track of these instances for lookup by disconnect().
			
 
				+            assert hasattr(target, "im_func") or hasattr(target, "__func__"), (
			
 
				+                f"safe_ref target {target!r} has im_self, but no im_func, "
			
 
				+                "don't know how to create reference"
			
 
				+            )
			
 
				+            reference = BoundMethodWeakref(target=target, on_delete=on_delete)
			
 
				+            return reference
			
 
				+
			
 
				+
			
 
				+class BoundMethodWeakref:
			
 
				+    """'Safe' and reusable weak references to instance methods.
			
 
				+
			
 
				+    BoundMethodWeakref objects provide a mechanism for referencing a
			
 
				+    bound method without requiring that the method object itself
			
 
				+    (which is normally a transient object) is kept alive.  Instead,
			
 
				+    the BoundMethodWeakref object keeps weak references to both the
			
 
				+    object and the function which together define the instance method.
			
 
				+
			
 
				+    Attributes:
			
 
				+
			
 
				+    - ``key``: The identity key for the reference, calculated by the
			
 
				+      class's calculate_key method applied to the target instance method.
			
 
				+
			
 
				+    - ``deletion_methods``: Sequence of callable objects taking single
			
 
				+      argument, a reference to this object which will be called when
			
 
				+      *either* the target object or target function is garbage
			
 
				+      collected (i.e. when this object becomes invalid).  These are
			
 
				+      specified as the on_delete parameters of safe_ref calls.
			
 
				+
			
 
				+    - ``weak_self``: Weak reference to the target object.
			
 
				+
			
 
				+    - ``weak_func``: Weak reference to the target function.
			
 
				+
			
 
				+    Class Attributes:
			
 
				+
			
 
				+    - ``_all_instances``: Class attribute pointing to all live
			
 
				+      BoundMethodWeakref objects indexed by the class's
			
 
				+      calculate_key(target) method applied to the target objects.
			
 
				+      This weak value dictionary is used to short-circuit creation so
			
 
				+      that multiple references to the same (object, function) pair
			
 
				+      produce the same BoundMethodWeakref instance.
			
 
				+    """
			
 
				+
			
 
				+    _all_instances = weakref.WeakValueDictionary()  # type: ignore[var-annotated]
			
 
				+
			
 
				+    def __new__(cls, target, on_delete=None, *arguments, **named):
			
 
				+        """Create new instance or return current instance.
			
 
				+
			
 
				+        Basically this method of construction allows us to
			
 
				+        short-circuit creation of references to already-referenced
			
 
				+        instance methods.  The key corresponding to the target is
			
 
				+        calculated, and if there is already an existing reference,
			
 
				+        that is returned, with its deletion_methods attribute updated.
			
 
				+        Otherwise the new instance is created and registered in the
			
 
				+        table of already-referenced methods.
			
 
				+        """
			
 
				+        key = cls.calculate_key(target)
			
 
				+        current = cls._all_instances.get(key)
			
 
				+        if current is not None:
			
 
				+            current.deletion_methods.append(on_delete)
			
 
				+            return current
			
 
				+        else:
			
 
				+            base = super().__new__(cls)
			
 
				+            cls._all_instances[key] = base
			
 
				+            base.__init__(target, on_delete, *arguments, **named)
			
 
				+            return base
			
 
				+
			
 
				+    def __init__(self, target, on_delete=None):
			
 
				+        """Return a weak-reference-like instance for a bound method.
			
 
				+
			
 
				+        - ``target``: The instance-method target for the weak reference,
			
 
				+          must have im_self and im_func attributes and be
			
 
				+          reconstructable via the following, which is true of built-in
			
 
				+          instance methods::
			
 
				+
			
 
				+            target.im_func.__get__( target.im_self )
			
 
				+
			
 
				+        - ``on_delete``: Optional callback which will be called when
			
 
				+          this weak reference ceases to be valid (i.e. either the
			
 
				+          object or the function is garbage collected).  Should take a
			
 
				+          single argument, which will be passed a pointer to this
			
 
				+          object.
			
 
				+        """
			
 
				+
			
 
				+        def remove(weak, self=self):
			
 
				+            """Set self.isDead to True when method or instance is destroyed."""
			
 
				+            methods = self.deletion_methods[:]
			
 
				+            del self.deletion_methods[:]
			
 
				+            try:
			
 
				+                del self.__class__._all_instances[self.key]
			
 
				+            except KeyError:
			
 
				+                pass
			
 
				+            for function in methods:
			
 
				+                try:
			
 
				+                    if callable(function):
			
 
				+                        function(self)
			
 
				+                except Exception:
			
 
				+                    try:
			
 
				+                        traceback.print_exc()
			
 
				+                    except AttributeError:
			
 
				+                        e = sys.exc_info()[1]
			
 
				+                        print(
			
 
				+                            f"Exception during saferef {self} "
			
 
				+                            f"cleanup function {function}: {e}"
			
 
				+                        )
			
 
				+
			
 
				+        self.deletion_methods = [on_delete]
			
 
				+        self.key = self.calculate_key(target)
			
 
				+        im_self = get_self(target)
			
 
				+        im_func = get_func(target)
			
 
				+        self.weak_self = weakref.ref(im_self, remove)
			
 
				+        self.weak_func = weakref.ref(im_func, remove)
			
 
				+        self.self_name = str(im_self)
			
 
				+        self.func_name = str(im_func.__name__)
			
 
				+
			
 
				+    @classmethod
			
 
				+    def calculate_key(cls, target):
			
 
				+        """Calculate the reference key for this reference.
			
 
				+
			
 
				+        Currently this is a two-tuple of the id()'s of the target
			
 
				+        object and the target function respectively.
			
 
				+        """
			
 
				+        return (id(get_self(target)), id(get_func(target)))
			
 
				+
			
 
				+    def __str__(self):
			
 
				+        """Give a friendly representation of the object."""
			
 
				+        return "{}({}.{})".format(
			
 
				+            self.__class__.__name__,
			
 
				+            self.self_name,
			
 
				+            self.func_name,
			
 
				+        )
			
 
				+
			
 
				+    __repr__ = __str__
			
 
				+
			
 
				+    def __hash__(self):
			
 
				+        return hash((self.self_name, self.key))
			
 
				+
			
 
				+    def __nonzero__(self):
			
 
				+        """Whether we are still a valid reference."""
			
 
				+        return self() is not None
			
 
				+
			
 
				+    def __eq__(self, other):
			
 
				+        """Compare with another reference."""
			
 
				+        if not isinstance(other, self.__class__):
			
 
				+            return operator.eq(self.__class__, type(other))
			
 
				+        return operator.eq(self.key, other.key)
			
 
				+
			
 
				+    def __call__(self):
			
 
				+        """Return a strong reference to the bound method.
			
 
				+
			
 
				+        If the target cannot be retrieved, then will return None,
			
 
				+        otherwise returns a bound instance method for our object and
			
 
				+        function.
			
 
				+
			
 
				+        Note: You may call this method any number of times, as it does
			
 
				+        not invalidate the reference.
			
 
				+        """
			
 
				+        target = self.weak_self()
			
 
				+        if target is not None:
			
 
				+            function = self.weak_func()
			
 
				+            if function is not None:
			
 
				+                return function.__get__(target)
			
 
				+        return None
			
--- a/courses/flask/microblog/env/Lib/site-packages/blinker/_utilities.py
+++ b/courses/flask/microblog/env/Lib/site-packages/blinker/_utilities.py
@@ -0,0 +1,142 @@
 
				+from __future__ import annotations
			
 
				+
			
 
				+import asyncio
			
 
				+import inspect
			
 
				+import sys
			
 
				+import typing as t
			
 
				+from functools import partial
			
 
				+from weakref import ref
			
 
				+
			
 
				+from blinker._saferef import BoundMethodWeakref
			
 
				+
			
 
				+IdentityType = t.Union[t.Tuple[int, int], str, int]
			
 
				+
			
 
				+
			
 
				+class _symbol:
			
 
				+    def __init__(self, name):
			
 
				+        """Construct a new named symbol."""
			
 
				+        self.__name__ = self.name = name
			
 
				+
			
 
				+    def __reduce__(self):
			
 
				+        return symbol, (self.name,)
			
 
				+
			
 
				+    def __repr__(self):
			
 
				+        return self.name
			
 
				+
			
 
				+
			
 
				+_symbol.__name__ = "symbol"
			
 
				+
			
 
				+
			
 
				+class symbol:
			
 
				+    """A constant symbol.
			
 
				+
			
 
				+    >>> symbol('foo') is symbol('foo')
			
 
				+    True
			
 
				+    >>> symbol('foo')
			
 
				+    foo
			
 
				+
			
 
				+    A slight refinement of the MAGICCOOKIE=object() pattern.  The primary
			
 
				+    advantage of symbol() is its repr().  They are also singletons.
			
 
				+
			
 
				+    Repeated calls of symbol('name') will all return the same instance.
			
 
				+
			
 
				+    """
			
 
				+
			
 
				+    symbols = {}  # type: ignore[var-annotated]
			
 
				+
			
 
				+    def __new__(cls, name):
			
 
				+        try:
			
 
				+            return cls.symbols[name]
			
 
				+        except KeyError:
			
 
				+            return cls.symbols.setdefault(name, _symbol(name))
			
 
				+
			
 
				+
			
 
				+def hashable_identity(obj: object) -> IdentityType:
			
 
				+    if hasattr(obj, "__func__"):
			
 
				+        return (id(obj.__func__), id(obj.__self__))  # type: ignore[attr-defined]
			
 
				+    elif hasattr(obj, "im_func"):
			
 
				+        return (id(obj.im_func), id(obj.im_self))  # type: ignore[attr-defined]
			
 
				+    elif isinstance(obj, (int, str)):
			
 
				+        return obj
			
 
				+    else:
			
 
				+        return id(obj)
			
 
				+
			
 
				+
			
 
				+WeakTypes = (ref, BoundMethodWeakref)
			
 
				+
			
 
				+
			
 
				+class annotatable_weakref(ref):
			
 
				+    """A weakref.ref that supports custom instance attributes."""
			
 
				+
			
 
				+    receiver_id: t.Optional[IdentityType]
			
 
				+    sender_id: t.Optional[IdentityType]
			
 
				+
			
 
				+
			
 
				+def reference(  # type: ignore[no-untyped-def]
			
 
				+    object, callback=None, **annotations
			
 
				+) -> annotatable_weakref:
			
 
				+    """Return an annotated weak ref."""
			
 
				+    if callable(object):
			
 
				+        weak = callable_reference(object, callback)
			
 
				+    else:
			
 
				+        weak = annotatable_weakref(object, callback)
			
 
				+    for key, value in annotations.items():
			
 
				+        setattr(weak, key, value)
			
 
				+    return weak  # type: ignore[no-any-return]
			
 
				+
			
 
				+
			
 
				+def callable_reference(object, callback=None):
			
 
				+    """Return an annotated weak ref, supporting bound instance methods."""
			
 
				+    if hasattr(object, "im_self") and object.im_self is not None:
			
 
				+        return BoundMethodWeakref(target=object, on_delete=callback)
			
 
				+    elif hasattr(object, "__self__") and object.__self__ is not None:
			
 
				+        return BoundMethodWeakref(target=object, on_delete=callback)
			
 
				+    return annotatable_weakref(object, callback)
			
 
				+
			
 
				+
			
 
				+class lazy_property:
			
 
				+    """A @property that is only evaluated once."""
			
 
				+
			
 
				+    def __init__(self, deferred):
			
 
				+        self._deferred = deferred
			
 
				+        self.__doc__ = deferred.__doc__
			
 
				+
			
 
				+    def __get__(self, obj, cls):
			
 
				+        if obj is None:
			
 
				+            return self
			
 
				+        value = self._deferred(obj)
			
 
				+        setattr(obj, self._deferred.__name__, value)
			
 
				+        return value
			
 
				+
			
 
				+
			
 
				+def is_coroutine_function(func: t.Any) -> bool:
			
 
				+    # Python < 3.8 does not correctly determine partially wrapped
			
 
				+    # coroutine functions are coroutine functions, hence the need for
			
 
				+    # this to exist. Code taken from CPython.
			
 
				+    if sys.version_info >= (3, 8):
			
 
				+        return asyncio.iscoroutinefunction(func)
			
 
				+    else:
			
 
				+        # Note that there is something special about the AsyncMock
			
 
				+        # such that it isn't determined as a coroutine function
			
 
				+        # without an explicit check.
			
 
				+        try:
			
 
				+            from unittest.mock import AsyncMock  # type: ignore[attr-defined]
			
 
				+
			
 
				+            if isinstance(func, AsyncMock):
			
 
				+                return True
			
 
				+        except ImportError:
			
 
				+            # Not testing, no asynctest to import
			
 
				+            pass
			
 
				+
			
 
				+        while inspect.ismethod(func):
			
 
				+            func = func.__func__
			
 
				+        while isinstance(func, partial):
			
 
				+            func = func.func
			
 
				+        if not inspect.isfunction(func):
			
 
				+            return False
			
 
				+
			
 
				+        if func.__code__.co_flags & inspect.CO_COROUTINE:
			
 
				+            return True
			
 
				+
			
 
				+        acic = asyncio.coroutines._is_coroutine  # type: ignore[attr-defined]
			
 
				+        return getattr(func, "_is_coroutine", None) is acic
			
--- a/courses/flask/microblog/env/Lib/site-packages/blinker/base.py
+++ b/courses/flask/microblog/env/Lib/site-packages/blinker/base.py
@@ -0,0 +1,548 @@
 
				+"""Signals and events.
			
 
				+
			
 
				+A small implementation of signals, inspired by a snippet of Django signal
			
 
				+API client code seen in a blog post.  Signals are first-class objects and
			
 
				+each manages its own receivers and message emission.
			
 
				+
			
 
				+The :func:`signal` function provides singleton behavior for named signals.
			
 
				+
			
 
				+"""
			
 
				+from __future__ import annotations
			
 
				+
			
 
				+import typing as t
			
 
				+from collections import defaultdict
			
 
				+from contextlib import contextmanager
			
 
				+from warnings import warn
			
 
				+from weakref import WeakValueDictionary
			
 
				+
			
 
				+from blinker._utilities import annotatable_weakref
			
 
				+from blinker._utilities import hashable_identity
			
 
				+from blinker._utilities import IdentityType
			
 
				+from blinker._utilities import is_coroutine_function
			
 
				+from blinker._utilities import lazy_property
			
 
				+from blinker._utilities import reference
			
 
				+from blinker._utilities import symbol
			
 
				+from blinker._utilities import WeakTypes
			
 
				+
			
 
				+if t.TYPE_CHECKING:
			
 
				+    import typing_extensions as te
			
 
				+
			
 
				+    T_callable = t.TypeVar("T_callable", bound=t.Callable[..., t.Any])
			
 
				+
			
 
				+    T = t.TypeVar("T")
			
 
				+    P = te.ParamSpec("P")
			
 
				+
			
 
				+    AsyncWrapperType = t.Callable[[t.Callable[P, t.Awaitable[T]]], t.Callable[P, T]]
			
 
				+    SyncWrapperType = t.Callable[[t.Callable[P, T]], t.Callable[P, t.Awaitable[T]]]
			
 
				+
			
 
				+ANY = symbol("ANY")
			
 
				+ANY.__doc__ = 'Token for "any sender".'
			
 
				+ANY_ID = 0
			
 
				+
			
 
				+
			
 
				+class Signal:
			
 
				+    """A notification emitter."""
			
 
				+
			
 
				+    #: An :obj:`ANY` convenience synonym, allows ``Signal.ANY``
			
 
				+    #: without an additional import.
			
 
				+    ANY = ANY
			
 
				+
			
 
				+    @lazy_property
			
 
				+    def receiver_connected(self) -> Signal:
			
 
				+        """Emitted after each :meth:`connect`.
			
 
				+
			
 
				+        The signal sender is the signal instance, and the :meth:`connect`
			
 
				+        arguments are passed through: *receiver*, *sender*, and *weak*.
			
 
				+
			
 
				+        .. versionadded:: 1.2
			
 
				+
			
 
				+        """
			
 
				+        return Signal(doc="Emitted after a receiver connects.")
			
 
				+
			
 
				+    @lazy_property
			
 
				+    def receiver_disconnected(self) -> Signal:
			
 
				+        """Emitted after :meth:`disconnect`.
			
 
				+
			
 
				+        The sender is the signal instance, and the :meth:`disconnect` arguments
			
 
				+        are passed through: *receiver* and *sender*.
			
 
				+
			
 
				+        Note, this signal is emitted **only** when :meth:`disconnect` is
			
 
				+        called explicitly.
			
 
				+
			
 
				+        The disconnect signal can not be emitted by an automatic disconnect
			
 
				+        (due to a weakly referenced receiver or sender going out of scope),
			
 
				+        as the receiver and/or sender instances are no longer available for
			
 
				+        use at the time this signal would be emitted.
			
 
				+
			
 
				+        An alternative approach is available by subscribing to
			
 
				+        :attr:`receiver_connected` and setting up a custom weakref cleanup
			
 
				+        callback on weak receivers and senders.
			
 
				+
			
 
				+        .. versionadded:: 1.2
			
 
				+
			
 
				+        """
			
 
				+        return Signal(doc="Emitted after a receiver disconnects.")
			
 
				+
			
 
				+    def __init__(self, doc: str | None = None) -> None:
			
 
				+        """
			
 
				+        :param doc: optional.  If provided, will be assigned to the signal's
			
 
				+          __doc__ attribute.
			
 
				+
			
 
				+        """
			
 
				+        if doc:
			
 
				+            self.__doc__ = doc
			
 
				+        #: A mapping of connected receivers.
			
 
				+        #:
			
 
				+        #: The values of this mapping are not meaningful outside of the
			
 
				+        #: internal :class:`Signal` implementation, however the boolean value
			
 
				+        #: of the mapping is useful as an extremely efficient check to see if
			
 
				+        #: any receivers are connected to the signal.
			
 
				+        self.receivers: dict[IdentityType, t.Callable | annotatable_weakref] = {}
			
 
				+        self.is_muted = False
			
 
				+        self._by_receiver: dict[IdentityType, set[IdentityType]] = defaultdict(set)
			
 
				+        self._by_sender: dict[IdentityType, set[IdentityType]] = defaultdict(set)
			
 
				+        self._weak_senders: dict[IdentityType, annotatable_weakref] = {}
			
 
				+
			
 
				+    def connect(
			
 
				+        self, receiver: T_callable, sender: t.Any = ANY, weak: bool = True
			
 
				+    ) -> T_callable:
			
 
				+        """Connect *receiver* to signal events sent by *sender*.
			
 
				+
			
 
				+        :param receiver: A callable.  Will be invoked by :meth:`send` with
			
 
				+          `sender=` as a single positional argument and any ``kwargs`` that
			
 
				+          were provided to a call to :meth:`send`.
			
 
				+
			
 
				+        :param sender: Any object or :obj:`ANY`, defaults to ``ANY``.
			
 
				+          Restricts notifications delivered to *receiver* to only those
			
 
				+          :meth:`send` emissions sent by *sender*.  If ``ANY``, the receiver
			
 
				+          will always be notified.  A *receiver* may be connected to
			
 
				+          multiple *sender* values on the same Signal through multiple calls
			
 
				+          to :meth:`connect`.
			
 
				+
			
 
				+        :param weak: If true, the Signal will hold a weakref to *receiver*
			
 
				+          and automatically disconnect when *receiver* goes out of scope or
			
 
				+          is garbage collected.  Defaults to True.
			
 
				+
			
 
				+        """
			
 
				+        receiver_id = hashable_identity(receiver)
			
 
				+        receiver_ref: T_callable | annotatable_weakref
			
 
				+
			
 
				+        if weak:
			
 
				+            receiver_ref = reference(receiver, self._cleanup_receiver)
			
 
				+            receiver_ref.receiver_id = receiver_id
			
 
				+        else:
			
 
				+            receiver_ref = receiver
			
 
				+        sender_id: IdentityType
			
 
				+        if sender is ANY:
			
 
				+            sender_id = ANY_ID
			
 
				+        else:
			
 
				+            sender_id = hashable_identity(sender)
			
 
				+
			
 
				+        self.receivers.setdefault(receiver_id, receiver_ref)
			
 
				+        self._by_sender[sender_id].add(receiver_id)
			
 
				+        self._by_receiver[receiver_id].add(sender_id)
			
 
				+        del receiver_ref
			
 
				+
			
 
				+        if sender is not ANY and sender_id not in self._weak_senders:
			
 
				+            # wire together a cleanup for weakref-able senders
			
 
				+            try:
			
 
				+                sender_ref = reference(sender, self._cleanup_sender)
			
 
				+                sender_ref.sender_id = sender_id
			
 
				+            except TypeError:
			
 
				+                pass
			
 
				+            else:
			
 
				+                self._weak_senders.setdefault(sender_id, sender_ref)
			
 
				+                del sender_ref
			
 
				+
			
 
				+        # broadcast this connection.  if receivers raise, disconnect.
			
 
				+        if "receiver_connected" in self.__dict__ and self.receiver_connected.receivers:
			
 
				+            try:
			
 
				+                self.receiver_connected.send(
			
 
				+                    self, receiver=receiver, sender=sender, weak=weak
			
 
				+                )
			
 
				+            except TypeError as e:
			
 
				+                self.disconnect(receiver, sender)
			
 
				+                raise e
			
 
				+        if receiver_connected.receivers and self is not receiver_connected:
			
 
				+            try:
			
 
				+                receiver_connected.send(
			
 
				+                    self, receiver_arg=receiver, sender_arg=sender, weak_arg=weak
			
 
				+                )
			
 
				+            except TypeError as e:
			
 
				+                self.disconnect(receiver, sender)
			
 
				+                raise e
			
 
				+        return receiver
			
 
				+
			
 
				+    def connect_via(
			
 
				+        self, sender: t.Any, weak: bool = False
			
 
				+    ) -> t.Callable[[T_callable], T_callable]:
			
 
				+        """Connect the decorated function as a receiver for *sender*.
			
 
				+
			
 
				+        :param sender: Any object or :obj:`ANY`.  The decorated function
			
 
				+          will only receive :meth:`send` emissions sent by *sender*.  If
			
 
				+          ``ANY``, the receiver will always be notified.  A function may be
			
 
				+          decorated multiple times with differing *sender* values.
			
 
				+
			
 
				+        :param weak: If true, the Signal will hold a weakref to the
			
 
				+          decorated function and automatically disconnect when *receiver*
			
 
				+          goes out of scope or is garbage collected.  Unlike
			
 
				+          :meth:`connect`, this defaults to False.
			
 
				+
			
 
				+        The decorated function will be invoked by :meth:`send` with
			
 
				+          `sender=` as a single positional argument and any ``kwargs`` that
			
 
				+          were provided to the call to :meth:`send`.
			
 
				+
			
 
				+
			
 
				+        .. versionadded:: 1.1
			
 
				+
			
 
				+        """
			
 
				+
			
 
				+        def decorator(fn: T_callable) -> T_callable:
			
 
				+            self.connect(fn, sender, weak)
			
 
				+            return fn
			
 
				+
			
 
				+        return decorator
			
 
				+
			
 
				+    @contextmanager
			
 
				+    def connected_to(
			
 
				+        self, receiver: t.Callable, sender: t.Any = ANY
			
 
				+    ) -> t.Generator[None, None, None]:
			
 
				+        """Execute a block with the signal temporarily connected to *receiver*.
			
 
				+
			
 
				+        :param receiver: a receiver callable
			
 
				+        :param sender: optional, a sender to filter on
			
 
				+
			
 
				+        This is a context manager for use in the ``with`` statement.  It can
			
 
				+        be useful in unit tests.  *receiver* is connected to the signal for
			
 
				+        the duration of the ``with`` block, and will be disconnected
			
 
				+        automatically when exiting the block:
			
 
				+
			
 
				+        .. code-block:: python
			
 
				+
			
 
				+          with on_ready.connected_to(receiver):
			
 
				+             # do stuff
			
 
				+             on_ready.send(123)
			
 
				+
			
 
				+        .. versionadded:: 1.1
			
 
				+
			
 
				+        """
			
 
				+        self.connect(receiver, sender=sender, weak=False)
			
 
				+        try:
			
 
				+            yield None
			
 
				+        finally:
			
 
				+            self.disconnect(receiver)
			
 
				+
			
 
				+    @contextmanager
			
 
				+    def muted(self) -> t.Generator[None, None, None]:
			
 
				+        """Context manager for temporarily disabling signal.
			
 
				+        Useful for test purposes.
			
 
				+        """
			
 
				+        self.is_muted = True
			
 
				+        try:
			
 
				+            yield None
			
 
				+        except Exception as e:
			
 
				+            raise e
			
 
				+        finally:
			
 
				+            self.is_muted = False
			
 
				+
			
 
				+    def temporarily_connected_to(
			
 
				+        self, receiver: t.Callable, sender: t.Any = ANY
			
 
				+    ) -> t.ContextManager[None]:
			
 
				+        """An alias for :meth:`connected_to`.
			
 
				+
			
 
				+        :param receiver: a receiver callable
			
 
				+        :param sender: optional, a sender to filter on
			
 
				+
			
 
				+        .. versionadded:: 0.9
			
 
				+
			
 
				+        .. versionchanged:: 1.1
			
 
				+          Renamed to :meth:`connected_to`.  ``temporarily_connected_to`` was
			
 
				+          deprecated in 1.2 and will be removed in a subsequent version.
			
 
				+
			
 
				+        """
			
 
				+        warn(
			
 
				+            "temporarily_connected_to is deprecated; use connected_to instead.",
			
 
				+            DeprecationWarning,
			
 
				+        )
			
 
				+        return self.connected_to(receiver, sender)
			
 
				+
			
 
				+    def send(
			
 
				+        self,
			
 
				+        *sender: t.Any,
			
 
				+        _async_wrapper: AsyncWrapperType | None = None,
			
 
				+        **kwargs: t.Any,
			
 
				+    ) -> list[tuple[t.Callable, t.Any]]:
			
 
				+        """Emit this signal on behalf of *sender*, passing on ``kwargs``.
			
 
				+
			
 
				+        Returns a list of 2-tuples, pairing receivers with their return
			
 
				+        value. The ordering of receiver notification is undefined.
			
 
				+
			
 
				+        :param sender: Any object or ``None``.  If omitted, synonymous
			
 
				+          with ``None``.  Only accepts one positional argument.
			
 
				+        :param _async_wrapper: A callable that should wrap a coroutine
			
 
				+          receiver and run it when called synchronously.
			
 
				+
			
 
				+        :param kwargs: Data to be sent to receivers.
			
 
				+        """
			
 
				+        if self.is_muted:
			
 
				+            return []
			
 
				+
			
 
				+        sender = self._extract_sender(sender)
			
 
				+        results = []
			
 
				+        for receiver in self.receivers_for(sender):
			
 
				+            if is_coroutine_function(receiver):
			
 
				+                if _async_wrapper is None:
			
 
				+                    raise RuntimeError("Cannot send to a coroutine function")
			
 
				+                receiver = _async_wrapper(receiver)
			
 
				+            result = receiver(sender, **kwargs)
			
 
				+            results.append((receiver, result))
			
 
				+        return results
			
 
				+
			
 
				+    async def send_async(
			
 
				+        self,
			
 
				+        *sender: t.Any,
			
 
				+        _sync_wrapper: SyncWrapperType | None = None,
			
 
				+        **kwargs: t.Any,
			
 
				+    ) -> list[tuple[t.Callable, t.Any]]:
			
 
				+        """Emit this signal on behalf of *sender*, passing on ``kwargs``.
			
 
				+
			
 
				+        Returns a list of 2-tuples, pairing receivers with their return
			
 
				+        value. The ordering of receiver notification is undefined.
			
 
				+
			
 
				+        :param sender: Any object or ``None``.  If omitted, synonymous
			
 
				+          with ``None``. Only accepts one positional argument.
			
 
				+        :param _sync_wrapper: A callable that should wrap a synchronous
			
 
				+          receiver and run it when awaited.
			
 
				+
			
 
				+        :param kwargs: Data to be sent to receivers.
			
 
				+        """
			
 
				+        if self.is_muted:
			
 
				+            return []
			
 
				+
			
 
				+        sender = self._extract_sender(sender)
			
 
				+        results = []
			
 
				+        for receiver in self.receivers_for(sender):
			
 
				+            if not is_coroutine_function(receiver):
			
 
				+                if _sync_wrapper is None:
			
 
				+                    raise RuntimeError("Cannot send to a non-coroutine function")
			
 
				+                receiver = _sync_wrapper(receiver)
			
 
				+            result = await receiver(sender, **kwargs)
			
 
				+            results.append((receiver, result))
			
 
				+        return results
			
 
				+
			
 
				+    def _extract_sender(self, sender: t.Any) -> t.Any:
			
 
				+        if not self.receivers:
			
 
				+            # Ensure correct signature even on no-op sends, disable with -O
			
 
				+            # for lowest possible cost.
			
 
				+            if __debug__ and sender and len(sender) > 1:
			
 
				+                raise TypeError(
			
 
				+                    f"send() accepts only one positional argument, {len(sender)} given"
			
 
				+                )
			
 
				+            return []
			
 
				+
			
 
				+        # Using '*sender' rather than 'sender=None' allows 'sender' to be
			
 
				+        # used as a keyword argument- i.e. it's an invisible name in the
			
 
				+        # function signature.
			
 
				+        if len(sender) == 0:
			
 
				+            sender = None
			
 
				+        elif len(sender) > 1:
			
 
				+            raise TypeError(
			
 
				+                f"send() accepts only one positional argument, {len(sender)} given"
			
 
				+            )
			
 
				+        else:
			
 
				+            sender = sender[0]
			
 
				+        return sender
			
 
				+
			
 
				+    def has_receivers_for(self, sender: t.Any) -> bool:
			
 
				+        """True if there is probably a receiver for *sender*.
			
 
				+
			
 
				+        Performs an optimistic check only.  Does not guarantee that all
			
 
				+        weakly referenced receivers are still alive.  See
			
 
				+        :meth:`receivers_for` for a stronger search.
			
 
				+
			
 
				+        """
			
 
				+        if not self.receivers:
			
 
				+            return False
			
 
				+        if self._by_sender[ANY_ID]:
			
 
				+            return True
			
 
				+        if sender is ANY:
			
 
				+            return False
			
 
				+        return hashable_identity(sender) in self._by_sender
			
 
				+
			
 
				+    def receivers_for(
			
 
				+        self, sender: t.Any
			
 
				+    ) -> t.Generator[t.Callable[[t.Any], t.Any], None, None]:
			
 
				+        """Iterate all live receivers listening for *sender*."""
			
 
				+        # TODO: test receivers_for(ANY)
			
 
				+        if self.receivers:
			
 
				+            sender_id = hashable_identity(sender)
			
 
				+            if sender_id in self._by_sender:
			
 
				+                ids = self._by_sender[ANY_ID] | self._by_sender[sender_id]
			
 
				+            else:
			
 
				+                ids = self._by_sender[ANY_ID].copy()
			
 
				+            for receiver_id in ids:
			
 
				+                receiver = self.receivers.get(receiver_id)
			
 
				+                if receiver is None:
			
 
				+                    continue
			
 
				+                if isinstance(receiver, WeakTypes):
			
 
				+                    strong = receiver()
			
 
				+                    if strong is None:
			
 
				+                        self._disconnect(receiver_id, ANY_ID)
			
 
				+                        continue
			
 
				+                    receiver = strong
			
 
				+                yield receiver  # type: ignore[misc]
			
 
				+
			
 
				+    def disconnect(self, receiver: t.Callable, sender: t.Any = ANY) -> None:
			
 
				+        """Disconnect *receiver* from this signal's events.
			
 
				+
			
 
				+        :param receiver: a previously :meth:`connected<connect>` callable
			
 
				+
			
 
				+        :param sender: a specific sender to disconnect from, or :obj:`ANY`
			
 
				+          to disconnect from all senders.  Defaults to ``ANY``.
			
 
				+
			
 
				+        """
			
 
				+        sender_id: IdentityType
			
 
				+        if sender is ANY:
			
 
				+            sender_id = ANY_ID
			
 
				+        else:
			
 
				+            sender_id = hashable_identity(sender)
			
 
				+        receiver_id = hashable_identity(receiver)
			
 
				+        self._disconnect(receiver_id, sender_id)
			
 
				+
			
 
				+        if (
			
 
				+            "receiver_disconnected" in self.__dict__
			
 
				+            and self.receiver_disconnected.receivers
			
 
				+        ):
			
 
				+            self.receiver_disconnected.send(self, receiver=receiver, sender=sender)
			
 
				+
			
 
				+    def _disconnect(self, receiver_id: IdentityType, sender_id: IdentityType) -> None:
			
 
				+        if sender_id == ANY_ID:
			
 
				+            if self._by_receiver.pop(receiver_id, False):
			
 
				+                for bucket in self._by_sender.values():
			
 
				+                    bucket.discard(receiver_id)
			
 
				+            self.receivers.pop(receiver_id, None)
			
 
				+        else:
			
 
				+            self._by_sender[sender_id].discard(receiver_id)
			
 
				+            self._by_receiver[receiver_id].discard(sender_id)
			
 
				+
			
 
				+    def _cleanup_receiver(self, receiver_ref: annotatable_weakref) -> None:
			
 
				+        """Disconnect a receiver from all senders."""
			
 
				+        self._disconnect(t.cast(IdentityType, receiver_ref.receiver_id), ANY_ID)
			
 
				+
			
 
				+    def _cleanup_sender(self, sender_ref: annotatable_weakref) -> None:
			
 
				+        """Disconnect all receivers from a sender."""
			
 
				+        sender_id = t.cast(IdentityType, sender_ref.sender_id)
			
 
				+        assert sender_id != ANY_ID
			
 
				+        self._weak_senders.pop(sender_id, None)
			
 
				+        for receiver_id in self._by_sender.pop(sender_id, ()):
			
 
				+            self._by_receiver[receiver_id].discard(sender_id)
			
 
				+
			
 
				+    def _cleanup_bookkeeping(self) -> None:
			
 
				+        """Prune unused sender/receiver bookkeeping. Not threadsafe.
			
 
				+
			
 
				+        Connecting & disconnecting leave behind a small amount of bookkeeping
			
 
				+        for the receiver and sender values. Typical workloads using Blinker,
			
 
				+        for example in most web apps, Flask, CLI scripts, etc., are not
			
 
				+        adversely affected by this bookkeeping.
			
 
				+
			
 
				+        With a long-running Python process performing dynamic signal routing
			
 
				+        with high volume- e.g. connecting to function closures, "senders" are
			
 
				+        all unique object instances, and doing all of this over and over- you
			
 
				+        may see memory usage will grow due to extraneous bookkeeping. (An empty
			
 
				+        set() for each stale sender/receiver pair.)
			
 
				+
			
 
				+        This method will prune that bookkeeping away, with the caveat that such
			
 
				+        pruning is not threadsafe. The risk is that cleanup of a fully
			
 
				+        disconnected receiver/sender pair occurs while another thread is
			
 
				+        connecting that same pair. If you are in the highly dynamic, unique
			
 
				+        receiver/sender situation that has lead you to this method, that
			
 
				+        failure mode is perhaps not a big deal for you.
			
 
				+        """
			
 
				+        for mapping in (self._by_sender, self._by_receiver):
			
 
				+            for _id, bucket in list(mapping.items()):
			
 
				+                if not bucket:
			
 
				+                    mapping.pop(_id, None)
			
 
				+
			
 
				+    def _clear_state(self) -> None:
			
 
				+        """Throw away all signal state.  Useful for unit tests."""
			
 
				+        self._weak_senders.clear()
			
 
				+        self.receivers.clear()
			
 
				+        self._by_sender.clear()
			
 
				+        self._by_receiver.clear()
			
 
				+
			
 
				+
			
 
				+receiver_connected = Signal(
			
 
				+    """\
			
 
				+Sent by a :class:`Signal` after a receiver connects.
			
 
				+
			
 
				+:argument: the Signal that was connected to
			
 
				+:keyword receiver_arg: the connected receiver
			
 
				+:keyword sender_arg: the sender to connect to
			
 
				+:keyword weak_arg: true if the connection to receiver_arg is a weak reference
			
 
				+
			
 
				+.. deprecated:: 1.2
			
 
				+
			
 
				+As of 1.2, individual signals have their own private
			
 
				+:attr:`~Signal.receiver_connected` and
			
 
				+:attr:`~Signal.receiver_disconnected` signals with a slightly simplified
			
 
				+call signature.  This global signal is planned to be removed in 1.6.
			
 
				+
			
 
				+"""
			
 
				+)
			
 
				+
			
 
				+
			
 
				+class NamedSignal(Signal):
			
 
				+    """A named generic notification emitter."""
			
 
				+
			
 
				+    def __init__(self, name: str, doc: str | None = None) -> None:
			
 
				+        Signal.__init__(self, doc)
			
 
				+
			
 
				+        #: The name of this signal.
			
 
				+        self.name = name
			
 
				+
			
 
				+    def __repr__(self) -> str:
			
 
				+        base = Signal.__repr__(self)
			
 
				+        return f"{base[:-1]}; {self.name!r}>"
			
 
				+
			
 
				+
			
 
				+class Namespace(dict):
			
 
				+    """A mapping of signal names to signals."""
			
 
				+
			
 
				+    def signal(self, name: str, doc: str | None = None) -> NamedSignal:
			
 
				+        """Return the :class:`NamedSignal` *name*, creating it if required.
			
 
				+
			
 
				+        Repeated calls to this function will return the same signal object.
			
 
				+
			
 
				+        """
			
 
				+        try:
			
 
				+            return self[name]  # type: ignore[no-any-return]
			
 
				+        except KeyError:
			
 
				+            result = self.setdefault(name, NamedSignal(name, doc))
			
 
				+            return result  # type: ignore[no-any-return]
			
 
				+
			
 
				+
			
 
				+class WeakNamespace(WeakValueDictionary):
			
 
				+    """A weak mapping of signal names to signals.
			
 
				+
			
 
				+    Automatically cleans up unused Signals when the last reference goes out
			
 
				+    of scope.  This namespace implementation exists for a measure of legacy
			
 
				+    compatibility with Blinker <= 1.2, and may be dropped in the future.
			
 
				+
			
 
				+    .. versionadded:: 1.3
			
 
				+
			
 
				+    """
			
 
				+
			
 
				+    def signal(self, name: str, doc: str | None = None) -> NamedSignal:
			
 
				+        """Return the :class:`NamedSignal` *name*, creating it if required.
			
 
				+
			
 
				+        Repeated calls to this function will return the same signal object.
			
 
				+
			
 
				+        """
			
 
				+        try:
			
 
				+            return self[name]  # type: ignore[no-any-return]
			
 
				+        except KeyError:
			
 
				+            result = self.setdefault(name, NamedSignal(name, doc))
			
 
				+            return result  # type: ignore[no-any-return]
			
 
				+
			
 
				+
			
 
				+signal = Namespace().signal
			
--- a/courses/flask/microblog/env/Lib/site-packages/blinker/py.typed
+++ b/courses/flask/microblog/env/Lib/site-packages/blinker/py.typed
--- a/courses/flask/microblog/env/Lib/site-packages/click-8.1.7.dist-info/INSTALLER
+++ b/courses/flask/microblog/env/Lib/site-packages/click-8.1.7.dist-info/INSTALLER
@@ -0,0 +1 @@
 
				+pip
			
--- a/courses/flask/microblog/env/Lib/site-packages/click-8.1.7.dist-info/LICENSE.rst
+++ b/courses/flask/microblog/env/Lib/site-packages/click-8.1.7.dist-info/LICENSE.rst
@@ -0,0 +1,28 @@
 
				+Copyright 2014 Pallets
			
 
				+
			
 
				+Redistribution and use in source and binary forms, with or without
			
 
				+modification, are permitted provided that the following conditions are
			
 
				+met:
			
 
				+
			
 
				+1.  Redistributions of source code must retain the above copyright
			
 
				+    notice, this list of conditions and the following disclaimer.
			
 
				+
			
 
				+2.  Redistributions in binary 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.
			
 
				+
			
 
				+3.  Neither the name of the copyright holder nor the names of its
			
 
				+    contributors may be used to endorse or promote products derived from
			
 
				+    this software without specific prior written permission.
			
 
				+
			
 
				+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
			
 
				+HOLDER 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.
			
--- a/courses/flask/microblog/env/Lib/site-packages/click-8.1.7.dist-info/METADATA
+++ b/courses/flask/microblog/env/Lib/site-packages/click-8.1.7.dist-info/METADATA
@@ -0,0 +1,103 @@
 
				+Metadata-Version: 2.1
			
 
				+Name: click
			
 
				+Version: 8.1.7
			
 
				+Summary: Composable command line interface toolkit
			
 
				+Home-page: https://palletsprojects.com/p/click/
			
 
				+Maintainer: Pallets
			
 
				+Maintainer-email: contact@palletsprojects.com
			
 
				+License: BSD-3-Clause
			
 
				+Project-URL: Donate, https://palletsprojects.com/donate
			
 
				+Project-URL: Documentation, https://click.palletsprojects.com/
			
 
				+Project-URL: Changes, https://click.palletsprojects.com/changes/
			
 
				+Project-URL: Source Code, https://github.com/pallets/click/
			
 
				+Project-URL: Issue Tracker, https://github.com/pallets/click/issues/
			
 
				+Project-URL: Chat, https://discord.gg/pallets
			
 
				+Classifier: Development Status :: 5 - Production/Stable
			
 
				+Classifier: Intended Audience :: Developers
			
 
				+Classifier: License :: OSI Approved :: BSD License
			
 
				+Classifier: Operating System :: OS Independent
			
 
				+Classifier: Programming Language :: Python
			
 
				+Requires-Python: >=3.7
			
 
				+Description-Content-Type: text/x-rst
			
 
				+License-File: LICENSE.rst
			
 
				+Requires-Dist: colorama ; platform_system == "Windows"
			
 
				+Requires-Dist: importlib-metadata ; python_version < "3.8"
			
 
				+
			
 
				+\$ click\_
			
 
				+==========
			
 
				+
			
 
				+Click is a Python package for creating beautiful command line interfaces
			
 
				+in a composable way with as little code as necessary. It's the "Command
			
 
				+Line Interface Creation Kit". It's highly configurable but comes with
			
 
				+sensible defaults out of the box.
			
 
				+
			
 
				+It aims to make the process of writing command line tools quick and fun
			
 
				+while also preventing any frustration caused by the inability to
			
 
				+implement an intended CLI API.
			
 
				+
			
 
				+Click in three points:
			
 
				+
			
 
				+-   Arbitrary nesting of commands
			
 
				+-   Automatic help page generation
			
 
				+-   Supports lazy loading of subcommands at runtime
			
 
				+
			
 
				+
			
 
				+Installing
			
 
				+----------
			
 
				+
			
 
				+Install and update using `pip`_:
			
 
				+
			
 
				+.. code-block:: text
			
 
				+
			
 
				+    $ pip install -U click
			
 
				+
			
 
				+.. _pip: https://pip.pypa.io/en/stable/getting-started/
			
 
				+
			
 
				+
			
 
				+A Simple Example
			
 
				+----------------
			
 
				+
			
 
				+.. code-block:: python
			
 
				+
			
 
				+    import click
			
 
				+
			
 
				+    @click.command()
			
 
				+    @click.option("--count", default=1, help="Number of greetings.")
			
 
				+    @click.option("--name", prompt="Your name", help="The person to greet.")
			
 
				+    def hello(count, name):
			
 
				+        """Simple program that greets NAME for a total of COUNT times."""
			
 
				+        for _ in range(count):
			
 
				+            click.echo(f"Hello, {name}!")
			
 
				+
			
 
				+    if __name__ == '__main__':
			
 
				+        hello()
			
 
				+
			
 
				+.. code-block:: text
			
 
				+
			
 
				+    $ python hello.py --count=3
			
 
				+    Your name: Click
			
 
				+    Hello, Click!
			
 
				+    Hello, Click!
			
 
				+    Hello, Click!
			
 
				+
			
 
				+
			
 
				+Donate
			
 
				+------
			
 
				+
			
 
				+The Pallets organization develops and supports Click and other popular
			
 
				+packages. In order to grow the community of contributors and users, and
			
 
				+allow the maintainers to devote more time to the projects, `please
			
 
				+donate today`_.
			
 
				+
			
 
				+.. _please donate today: https://palletsprojects.com/donate
			
 
				+
			
 
				+
			
 
				+Links
			
 
				+-----
			
 
				+
			
 
				+-   Documentation: https://click.palletsprojects.com/
			
 
				+-   Changes: https://click.palletsprojects.com/changes/
			
 
				+-   PyPI Releases: https://pypi.org/project/click/
			
 
				+-   Source Code: https://github.com/pallets/click
			
 
				+-   Issue Tracker: https://github.com/pallets/click/issues
			
 
				+-   Chat: https://discord.gg/pallets
			
--- a/courses/flask/microblog/env/Lib/site-packages/click-8.1.7.dist-info/RECORD
+++ b/courses/flask/microblog/env/Lib/site-packages/click-8.1.7.dist-info/RECORD
@@ -0,0 +1,39 @@
 
				+click-8.1.7.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4

			
 
				+click-8.1.7.dist-info/LICENSE.rst,sha256=morRBqOU6FO_4h9C9OctWSgZoigF2ZG18ydQKSkrZY0,1475

			
 
				+click-8.1.7.dist-info/METADATA,sha256=qIMevCxGA9yEmJOM_4WHuUJCwWpsIEVbCPOhs45YPN4,3014

			
 
				+click-8.1.7.dist-info/RECORD,,

			
 
				+click-8.1.7.dist-info/WHEEL,sha256=5sUXSg9e4bi7lTLOHcm6QEYwO5TIF1TNbTSVFVjcJcc,92

			
 
				+click-8.1.7.dist-info/top_level.txt,sha256=J1ZQogalYS4pphY_lPECoNMfw0HzTSrZglC4Yfwo4xA,6

			
 
				+click/__init__.py,sha256=YDDbjm406dTOA0V8bTtdGnhN7zj5j-_dFRewZF_pLvw,3138

			
 
				+click/__pycache__/__init__.cpython-310.pyc,,

			
 
				+click/__pycache__/_compat.cpython-310.pyc,,

			
 
				+click/__pycache__/_termui_impl.cpython-310.pyc,,

			
 
				+click/__pycache__/_textwrap.cpython-310.pyc,,

			
 
				+click/__pycache__/_winconsole.cpython-310.pyc,,

			
 
				+click/__pycache__/core.cpython-310.pyc,,

			
 
				+click/__pycache__/decorators.cpython-310.pyc,,

			
 
				+click/__pycache__/exceptions.cpython-310.pyc,,

			
 
				+click/__pycache__/formatting.cpython-310.pyc,,

			
 
				+click/__pycache__/globals.cpython-310.pyc,,

			
 
				+click/__pycache__/parser.cpython-310.pyc,,

			
 
				+click/__pycache__/shell_completion.cpython-310.pyc,,

			
 
				+click/__pycache__/termui.cpython-310.pyc,,

			
 
				+click/__pycache__/testing.cpython-310.pyc,,

			
 
				+click/__pycache__/types.cpython-310.pyc,,

			
 
				+click/__pycache__/utils.cpython-310.pyc,,

			
 
				+click/_compat.py,sha256=5318agQpbt4kroKsbqDOYpTSWzL_YCZVUQiTT04yXmc,18744

			
 
				+click/_termui_impl.py,sha256=3dFYv4445Nw-rFvZOTBMBPYwB1bxnmNk9Du6Dm_oBSU,24069

			
 
				+click/_textwrap.py,sha256=10fQ64OcBUMuK7mFvh8363_uoOxPlRItZBmKzRJDgoY,1353

			
 
				+click/_winconsole.py,sha256=5ju3jQkcZD0W27WEMGqmEP4y_crUVzPCqsX_FYb7BO0,7860

			
 
				+click/core.py,sha256=j6oEWtGgGna8JarD6WxhXmNnxLnfRjwXglbBc-8jr7U,114086

			
 
				+click/decorators.py,sha256=-ZlbGYgV-oI8jr_oH4RpuL1PFS-5QmeuEAsLDAYgxtw,18719

			
 
				+click/exceptions.py,sha256=fyROO-47HWFDjt2qupo7A3J32VlpM-ovJnfowu92K3s,9273

			
 
				+click/formatting.py,sha256=Frf0-5W33-loyY_i9qrwXR8-STnW3m5gvyxLVUdyxyk,9706

			
 
				+click/globals.py,sha256=TP-qM88STzc7f127h35TD_v920FgfOD2EwzqA0oE8XU,1961

			
 
				+click/parser.py,sha256=LKyYQE9ZLj5KgIDXkrcTHQRXIggfoivX14_UVIn56YA,19067

			
 
				+click/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0

			
 
				+click/shell_completion.py,sha256=Ty3VM_ts0sQhj6u7eFTiLwHPoTgcXTGEAUg2OpLqYKw,18460

			
 
				+click/termui.py,sha256=H7Q8FpmPelhJ2ovOhfCRhjMtCpNyjFXryAMLZODqsdc,28324

			
 
				+click/testing.py,sha256=1Qd4kS5bucn1hsNIRryd0WtTMuCpkA93grkWxT8POsU,16084

			
 
				+click/types.py,sha256=TZvz3hKvBztf-Hpa2enOmP4eznSPLzijjig5b_0XMxE,36391

			
 
				+click/utils.py,sha256=1476UduUNY6UePGU4m18uzVHLt1sKM2PP3yWsQhbItM,20298

			
--- a/courses/flask/microblog/env/Lib/site-packages/click-8.1.7.dist-info/WHEEL
+++ b/courses/flask/microblog/env/Lib/site-packages/click-8.1.7.dist-info/WHEEL
@@ -0,0 +1,5 @@
 
				+Wheel-Version: 1.0
			
 
				+Generator: bdist_wheel (0.41.1)
			
 
				+Root-Is-Purelib: true
			
 
				+Tag: py3-none-any
			
 
				+
			
--- a/courses/flask/microblog/env/Lib/site-packages/click-8.1.7.dist-info/top_level.txt
+++ b/courses/flask/microblog/env/Lib/site-packages/click-8.1.7.dist-info/top_level.txt
@@ -0,0 +1 @@
 
				+click
			
--- a/courses/flask/microblog/env/Lib/site-packages/click/__init__.py
+++ b/courses/flask/microblog/env/Lib/site-packages/click/__init__.py
@@ -0,0 +1,73 @@
 
				+"""
			
 
				+Click is a simple Python module inspired by the stdlib optparse to make
			
 
				+writing command line scripts fun. Unlike other modules, it's based
			
 
				+around a simple API that does not come with too much magic and is
			
 
				+composable.
			
 
				+"""
			
 
				+from .core import Argument as Argument
			
 
				+from .core import BaseCommand as BaseCommand
			
 
				+from .core import Command as Command
			
 
				+from .core import CommandCollection as CommandCollection
			
 
				+from .core import Context as Context
			
 
				+from .core import Group as Group
			
 
				+from .core import MultiCommand as MultiCommand
			
 
				+from .core import Option as Option
			
 
				+from .core import Parameter as Parameter
			
 
				+from .decorators import argument as argument
			
 
				+from .decorators import command as command
			
 
				+from .decorators import confirmation_option as confirmation_option
			
 
				+from .decorators import group as group
			
 
				+from .decorators import help_option as help_option
			
 
				+from .decorators import make_pass_decorator as make_pass_decorator
			
 
				+from .decorators import option as option
			
 
				+from .decorators import pass_context as pass_context
			
 
				+from .decorators import pass_obj as pass_obj
			
 
				+from .decorators import password_option as password_option
			
 
				+from .decorators import version_option as version_option
			
 
				+from .exceptions import Abort as Abort
			
 
				+from .exceptions import BadArgumentUsage as BadArgumentUsage
			
 
				+from .exceptions import BadOptionUsage as BadOptionUsage
			
 
				+from .exceptions import BadParameter as BadParameter
			
 
				+from .exceptions import ClickException as ClickException
			
 
				+from .exceptions import FileError as FileError
			
 
				+from .exceptions import MissingParameter as MissingParameter
			
 
				+from .exceptions import NoSuchOption as NoSuchOption
			
 
				+from .exceptions import UsageError as UsageError
			
 
				+from .formatting import HelpFormatter as HelpFormatter
			
 
				+from .formatting import wrap_text as wrap_text
			
 
				+from .globals import get_current_context as get_current_context
			
 
				+from .parser import OptionParser as OptionParser
			
 
				+from .termui import clear as clear
			
 
				+from .termui import confirm as confirm
			
 
				+from .termui import echo_via_pager as echo_via_pager
			
 
				+from .termui import edit as edit
			
 
				+from .termui import getchar as getchar
			
 
				+from .termui import launch as launch
			
 
				+from .termui import pause as pause
			
 
				+from .termui import progressbar as progressbar
			
 
				+from .termui import prompt as prompt
			
 
				+from .termui import secho as secho
			
 
				+from .termui import style as style
			
 
				+from .termui import unstyle as unstyle
			
 
				+from .types import BOOL as BOOL
			
 
				+from .types import Choice as Choice
			
 
				+from .types import DateTime as DateTime
			
 
				+from .types import File as File
			
 
				+from .types import FLOAT as FLOAT
			
 
				+from .types import FloatRange as FloatRange
			
 
				+from .types import INT as INT
			
 
				+from .types import IntRange as IntRange
			
 
				+from .types import ParamType as ParamType
			
 
				+from .types import Path as Path
			
 
				+from .types import STRING as STRING
			
 
				+from .types import Tuple as Tuple
			
 
				+from .types import UNPROCESSED as UNPROCESSED
			
 
				+from .types import UUID as UUID
			
 
				+from .utils import echo as echo
			
 
				+from .utils import format_filename as format_filename
			
 
				+from .utils import get_app_dir as get_app_dir
			
 
				+from .utils import get_binary_stream as get_binary_stream
			
 
				+from .utils import get_text_stream as get_text_stream
			
 
				+from .utils import open_file as open_file
			
 
				+
			
 
				+__version__ = "8.1.7"
			
--- a/courses/flask/microblog/env/Lib/site-packages/click/__pycache__/__init__.cpython-310.pyc
+++ b/courses/flask/microblog/env/Lib/site-packages/click/__pycache__/__init__.cpython-310.pyc
--- a/courses/flask/microblog/env/Lib/site-packages/click/__pycache__/_compat.cpython-310.pyc
+++ b/courses/flask/microblog/env/Lib/site-packages/click/__pycache__/_compat.cpython-310.pyc
--- a/courses/flask/microblog/env/Lib/site-packages/click/__pycache__/_termui_impl.cpython-310.pyc
+++ b/courses/flask/microblog/env/Lib/site-packages/click/__pycache__/_termui_impl.cpython-310.pyc
--- a/courses/flask/microblog/env/Lib/site-packages/click/__pycache__/_textwrap.cpython-310.pyc
+++ b/courses/flask/microblog/env/Lib/site-packages/click/__pycache__/_textwrap.cpython-310.pyc
--- a/courses/flask/microblog/env/Lib/site-packages/click/__pycache__/_winconsole.cpython-310.pyc
+++ b/courses/flask/microblog/env/Lib/site-packages/click/__pycache__/_winconsole.cpython-310.pyc
--- a/courses/flask/microblog/env/Lib/site-packages/click/__pycache__/core.cpython-310.pyc
+++ b/courses/flask/microblog/env/Lib/site-packages/click/__pycache__/core.cpython-310.pyc
--- a/courses/flask/microblog/env/Lib/site-packages/click/__pycache__/decorators.cpython-310.pyc
+++ b/courses/flask/microblog/env/Lib/site-packages/click/__pycache__/decorators.cpython-310.pyc
--- a/courses/flask/microblog/env/Lib/site-packages/click/__pycache__/exceptions.cpython-310.pyc
+++ b/courses/flask/microblog/env/Lib/site-packages/click/__pycache__/exceptions.cpython-310.pyc
--- a/courses/flask/microblog/env/Lib/site-packages/click/__pycache__/formatting.cpython-310.pyc
+++ b/courses/flask/microblog/env/Lib/site-packages/click/__pycache__/formatting.cpython-310.pyc
--- a/courses/flask/microblog/env/Lib/site-packages/click/__pycache__/globals.cpython-310.pyc
+++ b/courses/flask/microblog/env/Lib/site-packages/click/__pycache__/globals.cpython-310.pyc
--- a/courses/flask/microblog/env/Lib/site-packages/click/__pycache__/parser.cpython-310.pyc
+++ b/courses/flask/microblog/env/Lib/site-packages/click/__pycache__/parser.cpython-310.pyc
--- a/courses/flask/microblog/env/Lib/site-packages/click/__pycache__/shell_completion.cpython-310.pyc
+++ b/courses/flask/microblog/env/Lib/site-packages/click/__pycache__/shell_completion.cpython-310.pyc
--- a/courses/flask/microblog/env/Lib/site-packages/click/__pycache__/termui.cpython-310.pyc
+++ b/courses/flask/microblog/env/Lib/site-packages/click/__pycache__/termui.cpython-310.pyc
--- a/courses/flask/microblog/env/Lib/site-packages/click/__pycache__/testing.cpython-310.pyc
+++ b/courses/flask/microblog/env/Lib/site-packages/click/__pycache__/testing.cpython-310.pyc
--- a/courses/flask/microblog/env/Lib/site-packages/click/__pycache__/types.cpython-310.pyc
+++ b/courses/flask/microblog/env/Lib/site-packages/click/__pycache__/types.cpython-310.pyc
--- a/courses/flask/microblog/env/Lib/site-packages/click/__pycache__/utils.cpython-310.pyc
+++ b/courses/flask/microblog/env/Lib/site-packages/click/__pycache__/utils.cpython-310.pyc
--- a/courses/flask/microblog/env/Lib/site-packages/click/_compat.py
+++ b/courses/flask/microblog/env/Lib/site-packages/click/_compat.py
@@ -0,0 +1,623 @@
 
				+import codecs
			
 
				+import io
			
 
				+import os
			
 
				+import re
			
 
				+import sys
			
 
				+import typing as t
			
 
				+from weakref import WeakKeyDictionary
			
 
				+
			
 
				+CYGWIN = sys.platform.startswith("cygwin")
			
 
				+WIN = sys.platform.startswith("win")
			
 
				+auto_wrap_for_ansi: t.Optional[t.Callable[[t.TextIO], t.TextIO]] = None
			
 
				+_ansi_re = re.compile(r"\033\[[;?0-9]*[a-zA-Z]")
			
 
				+
			
 
				+
			
 
				+def _make_text_stream(
			
 
				+    stream: t.BinaryIO,
			
 
				+    encoding: t.Optional[str],
			
 
				+    errors: t.Optional[str],
			
 
				+    force_readable: bool = False,
			
 
				+    force_writable: bool = False,
			
 
				+) -> t.TextIO:
			
 
				+    if encoding is None:
			
 
				+        encoding = get_best_encoding(stream)
			
 
				+    if errors is None:
			
 
				+        errors = "replace"
			
 
				+    return _NonClosingTextIOWrapper(
			
 
				+        stream,
			
 
				+        encoding,
			
 
				+        errors,
			
 
				+        line_buffering=True,
			
 
				+        force_readable=force_readable,
			
 
				+        force_writable=force_writable,
			
 
				+    )
			
 
				+
			
 
				+
			
 
				+def is_ascii_encoding(encoding: str) -> bool:
			
 
				+    """Checks if a given encoding is ascii."""
			
 
				+    try:
			
 
				+        return codecs.lookup(encoding).name == "ascii"
			
 
				+    except LookupError:
			
 
				+        return False
			
 
				+
			
 
				+
			
 
				+def get_best_encoding(stream: t.IO[t.Any]) -> str:
			
 
				+    """Returns the default stream encoding if not found."""
			
 
				+    rv = getattr(stream, "encoding", None) or sys.getdefaultencoding()
			
 
				+    if is_ascii_encoding(rv):
			
 
				+        return "utf-8"
			
 
				+    return rv
			
 
				+
			
 
				+
			
 
				+class _NonClosingTextIOWrapper(io.TextIOWrapper):
			
 
				+    def __init__(
			
 
				+        self,
			
 
				+        stream: t.BinaryIO,
			
 
				+        encoding: t.Optional[str],
			
 
				+        errors: t.Optional[str],
			
 
				+        force_readable: bool = False,
			
 
				+        force_writable: bool = False,
			
 
				+        **extra: t.Any,
			
 
				+    ) -> None:
			
 
				+        self._stream = stream = t.cast(
			
 
				+            t.BinaryIO, _FixupStream(stream, force_readable, force_writable)
			
 
				+        )
			
 
				+        super().__init__(stream, encoding, errors, **extra)
			
 
				+
			
 
				+    def __del__(self) -> None:
			
 
				+        try:
			
 
				+            self.detach()
			
 
				+        except Exception:
			
 
				+            pass
			
 
				+
			
 
				+    def isatty(self) -> bool:
			
 
				+        # https://bitbucket.org/pypy/pypy/issue/1803
			
 
				+        return self._stream.isatty()
			
 
				+
			
 
				+
			
 
				+class _FixupStream:
			
 
				+    """The new io interface needs more from streams than streams
			
 
				+    traditionally implement.  As such, this fix-up code is necessary in
			
 
				+    some circumstances.
			
 
				+
			
 
				+    The forcing of readable and writable flags are there because some tools
			
 
				+    put badly patched objects on sys (one such offender are certain version
			
 
				+    of jupyter notebook).
			
 
				+    """
			
 
				+
			
 
				+    def __init__(
			
 
				+        self,
			
 
				+        stream: t.BinaryIO,
			
 
				+        force_readable: bool = False,
			
 
				+        force_writable: bool = False,
			
 
				+    ):
			
 
				+        self._stream = stream
			
 
				+        self._force_readable = force_readable
			
 
				+        self._force_writable = force_writable
			
 
				+
			
 
				+    def __getattr__(self, name: str) -> t.Any:
			
 
				+        return getattr(self._stream, name)
			
 
				+
			
 
				+    def read1(self, size: int) -> bytes:
			
 
				+        f = getattr(self._stream, "read1", None)
			
 
				+
			
 
				+        if f is not None:
			
 
				+            return t.cast(bytes, f(size))
			
 
				+
			
 
				+        return self._stream.read(size)
			
 
				+
			
 
				+    def readable(self) -> bool:
			
 
				+        if self._force_readable:
			
 
				+            return True
			
 
				+        x = getattr(self._stream, "readable", None)
			
 
				+        if x is not None:
			
 
				+            return t.cast(bool, x())
			
 
				+        try:
			
 
				+            self._stream.read(0)
			
 
				+        except Exception:
			
 
				+            return False
			
 
				+        return True
			
 
				+
			
 
				+    def writable(self) -> bool:
			
 
				+        if self._force_writable:
			
 
				+            return True
			
 
				+        x = getattr(self._stream, "writable", None)
			
 
				+        if x is not None:
			
 
				+            return t.cast(bool, x())
			
 
				+        try:
			
 
				+            self._stream.write("")  # type: ignore
			
 
				+        except Exception:
			
 
				+            try:
			
 
				+                self._stream.write(b"")
			
 
				+            except Exception:
			
 
				+                return False
			
 
				+        return True
			
 
				+
			
 
				+    def seekable(self) -> bool:
			
 
				+        x = getattr(self._stream, "seekable", None)
			
 
				+        if x is not None:
			
 
				+            return t.cast(bool, x())
			
 
				+        try:
			
 
				+            self._stream.seek(self._stream.tell())
			
 
				+        except Exception:
			
 
				+            return False
			
 
				+        return True
			
 
				+
			
 
				+
			
 
				+def _is_binary_reader(stream: t.IO[t.Any], default: bool = False) -> bool:
			
 
				+    try:
			
 
				+        return isinstance(stream.read(0), bytes)
			
 
				+    except Exception:
			
 
				+        return default
			
 
				+        # This happens in some cases where the stream was already
			
 
				+        # closed.  In this case, we assume the default.
			
 
				+
			
 
				+
			
 
				+def _is_binary_writer(stream: t.IO[t.Any], default: bool = False) -> bool:
			
 
				+    try:
			
 
				+        stream.write(b"")
			
 
				+    except Exception:
			
 
				+        try:
			
 
				+            stream.write("")
			
 
				+            return False
			
 
				+        except Exception:
			
 
				+            pass
			
 
				+        return default
			
 
				+    return True
			
 
				+
			
 
				+
			
 
				+def _find_binary_reader(stream: t.IO[t.Any]) -> t.Optional[t.BinaryIO]:
			
 
				+    # We need to figure out if the given stream is already binary.
			
 
				+    # This can happen because the official docs recommend detaching
			
 
				+    # the streams to get binary streams.  Some code might do this, so
			
 
				+    # we need to deal with this case explicitly.
			
 
				+    if _is_binary_reader(stream, False):
			
 
				+        return t.cast(t.BinaryIO, stream)
			
 
				+
			
 
				+    buf = getattr(stream, "buffer", None)
			
 
				+
			
 
				+    # Same situation here; this time we assume that the buffer is
			
 
				+    # actually binary in case it's closed.
			
 
				+    if buf is not None and _is_binary_reader(buf, True):
			
 
				+        return t.cast(t.BinaryIO, buf)
			
 
				+
			
 
				+    return None
			
 
				+
			
 
				+
			
 
				+def _find_binary_writer(stream: t.IO[t.Any]) -> t.Optional[t.BinaryIO]:
			
 
				+    # We need to figure out if the given stream is already binary.
			
 
				+    # This can happen because the official docs recommend detaching
			
 
				+    # the streams to get binary streams.  Some code might do this, so
			
 
				+    # we need to deal with this case explicitly.
			
 
				+    if _is_binary_writer(stream, False):
			
 
				+        return t.cast(t.BinaryIO, stream)
			
 
				+
			
 
				+    buf = getattr(stream, "buffer", None)
			
 
				+
			
 
				+    # Same situation here; this time we assume that the buffer is
			
 
				+    # actually binary in case it's closed.
			
 
				+    if buf is not None and _is_binary_writer(buf, True):
			
 
				+        return t.cast(t.BinaryIO, buf)
			
 
				+
			
 
				+    return None
			
 
				+
			
 
				+
			
 
				+def _stream_is_misconfigured(stream: t.TextIO) -> bool:
			
 
				+    """A stream is misconfigured if its encoding is ASCII."""
			
 
				+    # If the stream does not have an encoding set, we assume it's set
			
 
				+    # to ASCII.  This appears to happen in certain unittest
			
 
				+    # environments.  It's not quite clear what the correct behavior is
			
 
				+    # but this at least will force Click to recover somehow.
			
 
				+    return is_ascii_encoding(getattr(stream, "encoding", None) or "ascii")
			
 
				+
			
 
				+
			
 
				+def _is_compat_stream_attr(stream: t.TextIO, attr: str, value: t.Optional[str]) -> bool:
			
 
				+    """A stream attribute is compatible if it is equal to the
			
 
				+    desired value or the desired value is unset and the attribute
			
 
				+    has a value.
			
 
				+    """
			
 
				+    stream_value = getattr(stream, attr, None)
			
 
				+    return stream_value == value or (value is None and stream_value is not None)
			
 
				+
			
 
				+
			
 
				+def _is_compatible_text_stream(
			
 
				+    stream: t.TextIO, encoding: t.Optional[str], errors: t.Optional[str]
			
 
				+) -> bool:
			
 
				+    """Check if a stream's encoding and errors attributes are
			
 
				+    compatible with the desired values.
			
 
				+    """
			
 
				+    return _is_compat_stream_attr(
			
 
				+        stream, "encoding", encoding
			
 
				+    ) and _is_compat_stream_attr(stream, "errors", errors)
			
 
				+
			
 
				+
			
 
				+def _force_correct_text_stream(
			
 
				+    text_stream: t.IO[t.Any],
			
 
				+    encoding: t.Optional[str],
			
 
				+    errors: t.Optional[str],
			
 
				+    is_binary: t.Callable[[t.IO[t.Any], bool], bool],
			
 
				+    find_binary: t.Callable[[t.IO[t.Any]], t.Optional[t.BinaryIO]],
			
 
				+    force_readable: bool = False,
			
 
				+    force_writable: bool = False,
			
 
				+) -> t.TextIO:
			
 
				+    if is_binary(text_stream, False):
			
 
				+        binary_reader = t.cast(t.BinaryIO, text_stream)
			
 
				+    else:
			
 
				+        text_stream = t.cast(t.TextIO, text_stream)
			
 
				+        # If the stream looks compatible, and won't default to a
			
 
				+        # misconfigured ascii encoding, return it as-is.
			
 
				+        if _is_compatible_text_stream(text_stream, encoding, errors) and not (
			
 
				+            encoding is None and _stream_is_misconfigured(text_stream)
			
 
				+        ):
			
 
				+            return text_stream
			
 
				+
			
 
				+        # Otherwise, get the underlying binary reader.
			
 
				+        possible_binary_reader = find_binary(text_stream)
			
 
				+
			
 
				+        # If that's not possible, silently use the original reader
			
 
				+        # and get mojibake instead of exceptions.
			
 
				+        if possible_binary_reader is None:
			
 
				+            return text_stream
			
 
				+
			
 
				+        binary_reader = possible_binary_reader
			
 
				+
			
 
				+    # Default errors to replace instead of strict in order to get
			
 
				+    # something that works.
			
 
				+    if errors is None:
			
 
				+        errors = "replace"
			
 
				+
			
 
				+    # Wrap the binary stream in a text stream with the correct
			
 
				+    # encoding parameters.
			
 
				+    return _make_text_stream(
			
 
				+        binary_reader,
			
 
				+        encoding,
			
 
				+        errors,
			
 
				+        force_readable=force_readable,
			
 
				+        force_writable=force_writable,
			
 
				+    )
			
 
				+
			
 
				+
			
 
				+def _force_correct_text_reader(
			
 
				+    text_reader: t.IO[t.Any],
			
 
				+    encoding: t.Optional[str],
			
 
				+    errors: t.Optional[str],
			
 
				+    force_readable: bool = False,
			
 
				+) -> t.TextIO:
			
 
				+    return _force_correct_text_stream(
			
 
				+        text_reader,
			
 
				+        encoding,
			
 
				+        errors,
			
 
				+        _is_binary_reader,
			
 
				+        _find_binary_reader,
			
 
				+        force_readable=force_readable,
			
 
				+    )
			
 
				+
			
 
				+
			
 
				+def _force_correct_text_writer(
			
 
				+    text_writer: t.IO[t.Any],
			
 
				+    encoding: t.Optional[str],
			
 
				+    errors: t.Optional[str],
			
 
				+    force_writable: bool = False,
			
 
				+) -> t.TextIO:
			
 
				+    return _force_correct_text_stream(
			
 
				+        text_writer,
			
 
				+        encoding,
			
 
				+        errors,
			
 
				+        _is_binary_writer,
			
 
				+        _find_binary_writer,
			
 
				+        force_writable=force_writable,
			
 
				+    )
			
 
				+
			
 
				+
			
 
				+def get_binary_stdin() -> t.BinaryIO:
			
 
				+    reader = _find_binary_reader(sys.stdin)
			
 
				+    if reader is None:
			
 
				+        raise RuntimeError("Was not able to determine binary stream for sys.stdin.")
			
 
				+    return reader
			
 
				+
			
 
				+
			
 
				+def get_binary_stdout() -> t.BinaryIO:
			
 
				+    writer = _find_binary_writer(sys.stdout)
			
 
				+    if writer is None:
			
 
				+        raise RuntimeError("Was not able to determine binary stream for sys.stdout.")
			
 
				+    return writer
			
 
				+
			
 
				+
			
 
				+def get_binary_stderr() -> t.BinaryIO:
			
 
				+    writer = _find_binary_writer(sys.stderr)
			
 
				+    if writer is None:
			
 
				+        raise RuntimeError("Was not able to determine binary stream for sys.stderr.")
			
 
				+    return writer
			
 
				+
			
 
				+
			
 
				+def get_text_stdin(
			
 
				+    encoding: t.Optional[str] = None, errors: t.Optional[str] = None
			
 
				+) -> t.TextIO:
			
 
				+    rv = _get_windows_console_stream(sys.stdin, encoding, errors)
			
 
				+    if rv is not None:
			
 
				+        return rv
			
 
				+    return _force_correct_text_reader(sys.stdin, encoding, errors, force_readable=True)
			
 
				+
			
 
				+
			
 
				+def get_text_stdout(
			
 
				+    encoding: t.Optional[str] = None, errors: t.Optional[str] = None
			
 
				+) -> t.TextIO:
			
 
				+    rv = _get_windows_console_stream(sys.stdout, encoding, errors)
			
 
				+    if rv is not None:
			
 
				+        return rv
			
 
				+    return _force_correct_text_writer(sys.stdout, encoding, errors, force_writable=True)
			
 
				+
			
 
				+
			
 
				+def get_text_stderr(
			
 
				+    encoding: t.Optional[str] = None, errors: t.Optional[str] = None
			
 
				+) -> t.TextIO:
			
 
				+    rv = _get_windows_console_stream(sys.stderr, encoding, errors)
			
 
				+    if rv is not None:
			
 
				+        return rv
			
 
				+    return _force_correct_text_writer(sys.stderr, encoding, errors, force_writable=True)
			
 
				+
			
 
				+
			
 
				+def _wrap_io_open(
			
 
				+    file: t.Union[str, "os.PathLike[str]", int],
			
 
				+    mode: str,
			
 
				+    encoding: t.Optional[str],
			
 
				+    errors: t.Optional[str],
			
 
				+) -> t.IO[t.Any]:
			
 
				+    """Handles not passing ``encoding`` and ``errors`` in binary mode."""
			
 
				+    if "b" in mode:
			
 
				+        return open(file, mode)
			
 
				+
			
 
				+    return open(file, mode, encoding=encoding, errors=errors)
			
 
				+
			
 
				+
			
 
				+def open_stream(
			
 
				+    filename: "t.Union[str, os.PathLike[str]]",
			
 
				+    mode: str = "r",
			
 
				+    encoding: t.Optional[str] = None,
			
 
				+    errors: t.Optional[str] = "strict",
			
 
				+    atomic: bool = False,
			
 
				+) -> t.Tuple[t.IO[t.Any], bool]:
			
 
				+    binary = "b" in mode
			
 
				+    filename = os.fspath(filename)
			
 
				+
			
 
				+    # Standard streams first. These are simple because they ignore the
			
 
				+    # atomic flag. Use fsdecode to handle Path("-").
			
 
				+    if os.fsdecode(filename) == "-":
			
 
				+        if any(m in mode for m in ["w", "a", "x"]):
			
 
				+            if binary:
			
 
				+                return get_binary_stdout(), False
			
 
				+            return get_text_stdout(encoding=encoding, errors=errors), False
			
 
				+        if binary:
			
 
				+            return get_binary_stdin(), False
			
 
				+        return get_text_stdin(encoding=encoding, errors=errors), False
			
 
				+
			
 
				+    # Non-atomic writes directly go out through the regular open functions.
			
 
				+    if not atomic:
			
 
				+        return _wrap_io_open(filename, mode, encoding, errors), True
			
 
				+
			
 
				+    # Some usability stuff for atomic writes
			
 
				+    if "a" in mode:
			
 
				+        raise ValueError(
			
 
				+            "Appending to an existing file is not supported, because that"
			
 
				+            " would involve an expensive `copy`-operation to a temporary"
			
 
				+            " file. Open the file in normal `w`-mode and copy explicitly"
			
 
				+            " if that's what you're after."
			
 
				+        )
			
 
				+    if "x" in mode:
			
 
				+        raise ValueError("Use the `overwrite`-parameter instead.")
			
 
				+    if "w" not in mode:
			
 
				+        raise ValueError("Atomic writes only make sense with `w`-mode.")
			
 
				+
			
 
				+    # Atomic writes are more complicated.  They work by opening a file
			
 
				+    # as a proxy in the same folder and then using the fdopen
			
 
				+    # functionality to wrap it in a Python file.  Then we wrap it in an
			
 
				+    # atomic file that moves the file over on close.
			
 
				+    import errno
			
 
				+    import random
			
 
				+
			
 
				+    try:
			
 
				+        perm: t.Optional[int] = os.stat(filename).st_mode
			
 
				+    except OSError:
			
 
				+        perm = None
			
 
				+
			
 
				+    flags = os.O_RDWR | os.O_CREAT | os.O_EXCL
			
 
				+
			
 
				+    if binary:
			
 
				+        flags |= getattr(os, "O_BINARY", 0)
			
 
				+
			
 
				+    while True:
			
 
				+        tmp_filename = os.path.join(
			
 
				+            os.path.dirname(filename),
			
 
				+            f".__atomic-write{random.randrange(1 << 32):08x}",
			
 
				+        )
			
 
				+        try:
			
 
				+            fd = os.open(tmp_filename, flags, 0o666 if perm is None else perm)
			
 
				+            break
			
 
				+        except OSError as e:
			
 
				+            if e.errno == errno.EEXIST or (
			
 
				+                os.name == "nt"
			
 
				+                and e.errno == errno.EACCES
			
 
				+                and os.path.isdir(e.filename)
			
 
				+                and os.access(e.filename, os.W_OK)
			
 
				+            ):
			
 
				+                continue
			
 
				+            raise
			
 
				+
			
 
				+    if perm is not None:
			
 
				+        os.chmod(tmp_filename, perm)  # in case perm includes bits in umask
			
 
				+
			
 
				+    f = _wrap_io_open(fd, mode, encoding, errors)
			
 
				+    af = _AtomicFile(f, tmp_filename, os.path.realpath(filename))
			
 
				+    return t.cast(t.IO[t.Any], af), True
			
 
				+
			
 
				+
			
 
				+class _AtomicFile:
			
 
				+    def __init__(self, f: t.IO[t.Any], tmp_filename: str, real_filename: str) -> None:
			
 
				+        self._f = f
			
 
				+        self._tmp_filename = tmp_filename
			
 
				+        self._real_filename = real_filename
			
 
				+        self.closed = False
			
 
				+
			
 
				+    @property
			
 
				+    def name(self) -> str:
			
 
				+        return self._real_filename
			
 
				+
			
 
				+    def close(self, delete: bool = False) -> None:
			
 
				+        if self.closed:
			
 
				+            return
			
 
				+        self._f.close()
			
 
				+        os.replace(self._tmp_filename, self._real_filename)
			
 
				+        self.closed = True
			
 
				+
			
 
				+    def __getattr__(self, name: str) -> t.Any:
			
 
				+        return getattr(self._f, name)
			
 
				+
			
 
				+    def __enter__(self) -> "_AtomicFile":
			
 
				+        return self
			
 
				+
			
 
				+    def __exit__(self, exc_type: t.Optional[t.Type[BaseException]], *_: t.Any) -> None:
			
 
				+        self.close(delete=exc_type is not None)
			
 
				+
			
 
				+    def __repr__(self) -> str:
			
 
				+        return repr(self._f)
			
 
				+
			
 
				+
			
 
				+def strip_ansi(value: str) -> str:
			
 
				+    return _ansi_re.sub("", value)
			
 
				+
			
 
				+
			
 
				+def _is_jupyter_kernel_output(stream: t.IO[t.Any]) -> bool:
			
 
				+    while isinstance(stream, (_FixupStream, _NonClosingTextIOWrapper)):
			
 
				+        stream = stream._stream
			
 
				+
			
 
				+    return stream.__class__.__module__.startswith("ipykernel.")
			
 
				+
			
 
				+
			
 
				+def should_strip_ansi(
			
 
				+    stream: t.Optional[t.IO[t.Any]] = None, color: t.Optional[bool] = None
			
 
				+) -> bool:
			
 
				+    if color is None:
			
 
				+        if stream is None:
			
 
				+            stream = sys.stdin
			
 
				+        return not isatty(stream) and not _is_jupyter_kernel_output(stream)
			
 
				+    return not color
			
 
				+
			
 
				+
			
 
				+# On Windows, wrap the output streams with colorama to support ANSI
			
 
				+# color codes.
			
 
				+# NOTE: double check is needed so mypy does not analyze this on Linux
			
 
				+if sys.platform.startswith("win") and WIN:
			
 
				+    from ._winconsole import _get_windows_console_stream
			
 
				+
			
 
				+    def _get_argv_encoding() -> str:
			
 
				+        import locale
			
 
				+
			
 
				+        return locale.getpreferredencoding()
			
 
				+
			
 
				+    _ansi_stream_wrappers: t.MutableMapping[t.TextIO, t.TextIO] = WeakKeyDictionary()
			
 
				+
			
 
				+    def auto_wrap_for_ansi(  # noqa: F811
			
 
				+        stream: t.TextIO, color: t.Optional[bool] = None
			
 
				+    ) -> t.TextIO:
			
 
				+        """Support ANSI color and style codes on Windows by wrapping a
			
 
				+        stream with colorama.
			
 
				+        """
			
 
				+        try:
			
 
				+            cached = _ansi_stream_wrappers.get(stream)
			
 
				+        except Exception:
			
 
				+            cached = None
			
 
				+
			
 
				+        if cached is not None:
			
 
				+            return cached
			
 
				+
			
 
				+        import colorama
			
 
				+
			
 
				+        strip = should_strip_ansi(stream, color)
			
 
				+        ansi_wrapper = colorama.AnsiToWin32(stream, strip=strip)
			
 
				+        rv = t.cast(t.TextIO, ansi_wrapper.stream)
			
 
				+        _write = rv.write
			
 
				+
			
 
				+        def _safe_write(s):
			
 
				+            try:
			
 
				+                return _write(s)
			
 
				+            except BaseException:
			
 
				+                ansi_wrapper.reset_all()
			
 
				+                raise
			
 
				+
			
 
				+        rv.write = _safe_write
			
 
				+
			
 
				+        try:
			
 
				+            _ansi_stream_wrappers[stream] = rv
			
 
				+        except Exception:
			
 
				+            pass
			
 
				+
			
 
				+        return rv
			
 
				+
			
 
				+else:
			
 
				+
			
 
				+    def _get_argv_encoding() -> str:
			
 
				+        return getattr(sys.stdin, "encoding", None) or sys.getfilesystemencoding()
			
 
				+
			
 
				+    def _get_windows_console_stream(
			
 
				+        f: t.TextIO, encoding: t.Optional[str], errors: t.Optional[str]
			
 
				+    ) -> t.Optional[t.TextIO]:
			
 
				+        return None
			
 
				+
			
 
				+
			
 
				+def term_len(x: str) -> int:
			
 
				+    return len(strip_ansi(x))
			
 
				+
			
 
				+
			
 
				+def isatty(stream: t.IO[t.Any]) -> bool:
			
 
				+    try:
			
 
				+        return stream.isatty()
			
 
				+    except Exception:
			
 
				+        return False
			
 
				+
			
 
				+
			
 
				+def _make_cached_stream_func(
			
 
				+    src_func: t.Callable[[], t.Optional[t.TextIO]],
			
 
				+    wrapper_func: t.Callable[[], t.TextIO],
			
 
				+) -> t.Callable[[], t.Optional[t.TextIO]]:
			
 
				+    cache: t.MutableMapping[t.TextIO, t.TextIO] = WeakKeyDictionary()
			
 
				+
			
 
				+    def func() -> t.Optional[t.TextIO]:
			
 
				+        stream = src_func()
			
 
				+
			
 
				+        if stream is None:
			
 
				+            return None
			
 
				+
			
 
				+        try:
			
 
				+            rv = cache.get(stream)
			
 
				+        except Exception:
			
 
				+            rv = None
			
 
				+        if rv is not None:
			
 
				+            return rv
			
 
				+        rv = wrapper_func()
			
 
				+        try:
			
 
				+            cache[stream] = rv
			
 
				+        except Exception:
			
 
				+            pass
			
 
				+        return rv
			
 
				+
			
 
				+    return func
			
 
				+
			
 
				+
			
 
				+_default_text_stdin = _make_cached_stream_func(lambda: sys.stdin, get_text_stdin)
			
 
				+_default_text_stdout = _make_cached_stream_func(lambda: sys.stdout, get_text_stdout)
			
 
				+_default_text_stderr = _make_cached_stream_func(lambda: sys.stderr, get_text_stderr)
			
 
				+
			
 
				+
			
 
				+binary_streams: t.Mapping[str, t.Callable[[], t.BinaryIO]] = {
			
 
				+    "stdin": get_binary_stdin,
			
 
				+    "stdout": get_binary_stdout,
			
 
				+    "stderr": get_binary_stderr,
			
 
				+}
			
 
				+
			
 
				+text_streams: t.Mapping[
			
 
				+    str, t.Callable[[t.Optional[str], t.Optional[str]], t.TextIO]
			
 
				+] = {
			
 
				+    "stdin": get_text_stdin,
			
 
				+    "stdout": get_text_stdout,
			
 
				+    "stderr": get_text_stderr,
			
 
				+}
			
--- a/courses/flask/microblog/env/Lib/site-packages/click/_termui_impl.py
+++ b/courses/flask/microblog/env/Lib/site-packages/click/_termui_impl.py
@@ -0,0 +1,739 @@
 
				+"""
			
 
				+This module contains implementations for the termui module. To keep the
			
 
				+import time of Click down, some infrequently used functionality is
			
 
				+placed in this module and only imported as needed.
			
 
				+"""
			
 
				+import contextlib
			
 
				+import math
			
 
				+import os
			
 
				+import sys
			
 
				+import time
			
 
				+import typing as t
			
 
				+from gettext import gettext as _
			
 
				+from io import StringIO
			
 
				+from types import TracebackType
			
 
				+
			
 
				+from ._compat import _default_text_stdout
			
 
				+from ._compat import CYGWIN
			
 
				+from ._compat import get_best_encoding
			
 
				+from ._compat import isatty
			
 
				+from ._compat import open_stream
			
 
				+from ._compat import strip_ansi
			
 
				+from ._compat import term_len
			
 
				+from ._compat import WIN
			
 
				+from .exceptions import ClickException
			
 
				+from .utils import echo
			
 
				+
			
 
				+V = t.TypeVar("V")
			
 
				+
			
 
				+if os.name == "nt":
			
 
				+    BEFORE_BAR = "\r"
			
 
				+    AFTER_BAR = "\n"
			
 
				+else:
			
 
				+    BEFORE_BAR = "\r\033[?25l"
			
 
				+    AFTER_BAR = "\033[?25h\n"
			
 
				+
			
 
				+
			
 
				+class ProgressBar(t.Generic[V]):
			
 
				+    def __init__(
			
 
				+        self,
			
 
				+        iterable: t.Optional[t.Iterable[V]],
			
 
				+        length: t.Optional[int] = None,
			
 
				+        fill_char: str = "#",
			
 
				+        empty_char: str = " ",
			
 
				+        bar_template: str = "%(bar)s",
			
 
				+        info_sep: str = "  ",
			
 
				+        show_eta: bool = True,
			
 
				+        show_percent: t.Optional[bool] = None,
			
 
				+        show_pos: bool = False,
			
 
				+        item_show_func: t.Optional[t.Callable[[t.Optional[V]], t.Optional[str]]] = None,
			
 
				+        label: t.Optional[str] = None,
			
 
				+        file: t.Optional[t.TextIO] = None,
			
 
				+        color: t.Optional[bool] = None,
			
 
				+        update_min_steps: int = 1,
			
 
				+        width: int = 30,
			
 
				+    ) -> None:
			
 
				+        self.fill_char = fill_char
			
 
				+        self.empty_char = empty_char
			
 
				+        self.bar_template = bar_template
			
 
				+        self.info_sep = info_sep
			
 
				+        self.show_eta = show_eta
			
 
				+        self.show_percent = show_percent
			
 
				+        self.show_pos = show_pos
			
 
				+        self.item_show_func = item_show_func
			
 
				+        self.label: str = label or ""
			
 
				+
			
 
				+        if file is None:
			
 
				+            file = _default_text_stdout()
			
 
				+
			
 
				+            # There are no standard streams attached to write to. For example,
			
 
				+            # pythonw on Windows.
			
 
				+            if file is None:
			
 
				+                file = StringIO()
			
 
				+
			
 
				+        self.file = file
			
 
				+        self.color = color
			
 
				+        self.update_min_steps = update_min_steps
			
 
				+        self._completed_intervals = 0
			
 
				+        self.width: int = width
			
 
				+        self.autowidth: bool = width == 0
			
 
				+
			
 
				+        if length is None:
			
 
				+            from operator import length_hint
			
 
				+
			
 
				+            length = length_hint(iterable, -1)
			
 
				+
			
 
				+            if length == -1:
			
 
				+                length = None
			
 
				+        if iterable is None:
			
 
				+            if length is None:
			
 
				+                raise TypeError("iterable or length is required")
			
 
				+            iterable = t.cast(t.Iterable[V], range(length))
			
 
				+        self.iter: t.Iterable[V] = iter(iterable)
			
 
				+        self.length = length
			
 
				+        self.pos = 0
			
 
				+        self.avg: t.List[float] = []
			
 
				+        self.last_eta: float
			
 
				+        self.start: float
			
 
				+        self.start = self.last_eta = time.time()
			
 
				+        self.eta_known: bool = False
			
 
				+        self.finished: bool = False
			
 
				+        self.max_width: t.Optional[int] = None
			
 
				+        self.entered: bool = False
			
 
				+        self.current_item: t.Optional[V] = None
			
 
				+        self.is_hidden: bool = not isatty(self.file)
			
 
				+        self._last_line: t.Optional[str] = None
			
 
				+
			
 
				+    def __enter__(self) -> "ProgressBar[V]":
			
 
				+        self.entered = True
			
 
				+        self.render_progress()
			
 
				+        return self
			
 
				+
			
 
				+    def __exit__(
			
 
				+        self,
			
 
				+        exc_type: t.Optional[t.Type[BaseException]],
			
 
				+        exc_value: t.Optional[BaseException],
			
 
				+        tb: t.Optional[TracebackType],
			
 
				+    ) -> None:
			
 
				+        self.render_finish()
			
 
				+
			
 
				+    def __iter__(self) -> t.Iterator[V]:
			
 
				+        if not self.entered:
			
 
				+            raise RuntimeError("You need to use progress bars in a with block.")
			
 
				+        self.render_progress()
			
 
				+        return self.generator()
			
 
				+
			
 
				+    def __next__(self) -> V:
			
 
				+        # Iteration is defined in terms of a generator function,
			
 
				+        # returned by iter(self); use that to define next(). This works
			
 
				+        # because `self.iter` is an iterable consumed by that generator,
			
 
				+        # so it is re-entry safe. Calling `next(self.generator())`
			
 
				+        # twice works and does "what you want".
			
 
				+        return next(iter(self))
			
 
				+
			
 
				+    def render_finish(self) -> None:
			
 
				+        if self.is_hidden:
			
 
				+            return
			
 
				+        self.file.write(AFTER_BAR)
			
 
				+        self.file.flush()
			
 
				+
			
 
				+    @property
			
 
				+    def pct(self) -> float:
			
 
				+        if self.finished:
			
 
				+            return 1.0
			
 
				+        return min(self.pos / (float(self.length or 1) or 1), 1.0)
			
 
				+
			
 
				+    @property
			
 
				+    def time_per_iteration(self) -> float:
			
 
				+        if not self.avg:
			
 
				+            return 0.0
			
 
				+        return sum(self.avg) / float(len(self.avg))
			
 
				+
			
 
				+    @property
			
 
				+    def eta(self) -> float:
			
 
				+        if self.length is not None and not self.finished:
			
 
				+            return self.time_per_iteration * (self.length - self.pos)
			
 
				+        return 0.0
			
 
				+
			
 
				+    def format_eta(self) -> str:
			
 
				+        if self.eta_known:
			
 
				+            t = int(self.eta)
			
 
				+            seconds = t % 60
			
 
				+            t //= 60
			
 
				+            minutes = t % 60
			
 
				+            t //= 60
			
 
				+            hours = t % 24
			
 
				+            t //= 24
			
 
				+            if t > 0:
			
 
				+                return f"{t}d {hours:02}:{minutes:02}:{seconds:02}"
			
 
				+            else:
			
 
				+                return f"{hours:02}:{minutes:02}:{seconds:02}"
			
 
				+        return ""
			
 
				+
			
 
				+    def format_pos(self) -> str:
			
 
				+        pos = str(self.pos)
			
 
				+        if self.length is not None:
			
 
				+            pos += f"/{self.length}"
			
 
				+        return pos
			
 
				+
			
 
				+    def format_pct(self) -> str:
			
 
				+        return f"{int(self.pct * 100): 4}%"[1:]
			
 
				+
			
 
				+    def format_bar(self) -> str:
			
 
				+        if self.length is not None:
			
 
				+            bar_length = int(self.pct * self.width)
			
 
				+            bar = self.fill_char * bar_length
			
 
				+            bar += self.empty_char * (self.width - bar_length)
			
 
				+        elif self.finished:
			
 
				+            bar = self.fill_char * self.width
			
 
				+        else:
			
 
				+            chars = list(self.empty_char * (self.width or 1))
			
 
				+            if self.time_per_iteration != 0:
			
 
				+                chars[
			
 
				+                    int(
			
 
				+                        (math.cos(self.pos * self.time_per_iteration) / 2.0 + 0.5)
			
 
				+                        * self.width
			
 
				+                    )
			
 
				+                ] = self.fill_char
			
 
				+            bar = "".join(chars)
			
 
				+        return bar
			
 
				+
			
 
				+    def format_progress_line(self) -> str:
			
 
				+        show_percent = self.show_percent
			
 
				+
			
 
				+        info_bits = []
			
 
				+        if self.length is not None and show_percent is None:
			
 
				+            show_percent = not self.show_pos
			
 
				+
			
 
				+        if self.show_pos:
			
 
				+            info_bits.append(self.format_pos())
			
 
				+        if show_percent:
			
 
				+            info_bits.append(self.format_pct())
			
 
				+        if self.show_eta and self.eta_known and not self.finished:
			
 
				+            info_bits.append(self.format_eta())
			
 
				+        if self.item_show_func is not None:
			
 
				+            item_info = self.item_show_func(self.current_item)
			
 
				+            if item_info is not None:
			
 
				+                info_bits.append(item_info)
			
 
				+
			
 
				+        return (
			
 
				+            self.bar_template
			
 
				+            % {
			
 
				+                "label": self.label,
			
 
				+                "bar": self.format_bar(),
			
 
				+                "info": self.info_sep.join(info_bits),
			
 
				+            }
			
 
				+        ).rstrip()
			
 
				+
			
 
				+    def render_progress(self) -> None:
			
 
				+        import shutil
			
 
				+
			
 
				+        if self.is_hidden:
			
 
				+            # Only output the label as it changes if the output is not a
			
 
				+            # TTY. Use file=stderr if you expect to be piping stdout.
			
 
				+            if self._last_line != self.label:
			
 
				+                self._last_line = self.label
			
 
				+                echo(self.label, file=self.file, color=self.color)
			
 
				+
			
 
				+            return
			
 
				+
			
 
				+        buf = []
			
 
				+        # Update width in case the terminal has been resized
			
 
				+        if self.autowidth:
			
 
				+            old_width = self.width
			
 
				+            self.width = 0
			
 
				+            clutter_length = term_len(self.format_progress_line())
			
 
				+            new_width = max(0, shutil.get_terminal_size().columns - clutter_length)
			
 
				+            if new_width < old_width:
			
 
				+                buf.append(BEFORE_BAR)
			
 
				+                buf.append(" " * self.max_width)  # type: ignore
			
 
				+                self.max_width = new_width
			
 
				+            self.width = new_width
			
 
				+
			
 
				+        clear_width = self.width
			
 
				+        if self.max_width is not None:
			
 
				+            clear_width = self.max_width
			
 
				+
			
 
				+        buf.append(BEFORE_BAR)
			
 
				+        line = self.format_progress_line()
			
 
				+        line_len = term_len(line)
			
 
				+        if self.max_width is None or self.max_width < line_len:
			
 
				+            self.max_width = line_len
			
 
				+
			
 
				+        buf.append(line)
			
 
				+        buf.append(" " * (clear_width - line_len))
			
 
				+        line = "".join(buf)
			
 
				+        # Render the line only if it changed.
			
 
				+
			
 
				+        if line != self._last_line:
			
 
				+            self._last_line = line
			
 
				+            echo(line, file=self.file, color=self.color, nl=False)
			
 
				+            self.file.flush()
			
 
				+
			
 
				+    def make_step(self, n_steps: int) -> None:
			
 
				+        self.pos += n_steps
			
 
				+        if self.length is not None and self.pos >= self.length:
			
 
				+            self.finished = True
			
 
				+
			
 
				+        if (time.time() - self.last_eta) < 1.0:
			
 
				+            return
			
 
				+
			
 
				+        self.last_eta = time.time()
			
 
				+
			
 
				+        # self.avg is a rolling list of length <= 7 of steps where steps are
			
 
				+        # defined as time elapsed divided by the total progress through
			
 
				+        # self.length.
			
 
				+        if self.pos:
			
 
				+            step = (time.time() - self.start) / self.pos
			
 
				+        else:
			
 
				+            step = time.time() - self.start
			
 
				+
			
 
				+        self.avg = self.avg[-6:] + [step]
			
 
				+
			
 
				+        self.eta_known = self.length is not None
			
 
				+
			
 
				+    def update(self, n_steps: int, current_item: t.Optional[V] = None) -> None:
			
 
				+        """Update the progress bar by advancing a specified number of
			
 
				+        steps, and optionally set the ``current_item`` for this new
			
 
				+        position.
			
 
				+
			
 
				+        :param n_steps: Number of steps to advance.
			
 
				+        :param current_item: Optional item to set as ``current_item``
			
 
				+            for the updated position.
			
 
				+
			
 
				+        .. versionchanged:: 8.0
			
 
				+            Added the ``current_item`` optional parameter.
			
 
				+
			
 
				+        .. versionchanged:: 8.0
			
 
				+            Only render when the number of steps meets the
			
 
				+            ``update_min_steps`` threshold.
			
 
				+        """
			
 
				+        if current_item is not None:
			
 
				+            self.current_item = current_item
			
 
				+
			
 
				+        self._completed_intervals += n_steps
			
 
				+
			
 
				+        if self._completed_intervals >= self.update_min_steps:
			
 
				+            self.make_step(self._completed_intervals)
			
 
				+            self.render_progress()
			
 
				+            self._completed_intervals = 0
			
 
				+
			
 
				+    def finish(self) -> None:
			
 
				+        self.eta_known = False
			
 
				+        self.current_item = None
			
 
				+        self.finished = True
			
 
				+
			
 
				+    def generator(self) -> t.Iterator[V]:
			
 
				+        """Return a generator which yields the items added to the bar
			
 
				+        during construction, and updates the progress bar *after* the
			
 
				+        yielded block returns.
			
 
				+        """
			
 
				+        # WARNING: the iterator interface for `ProgressBar` relies on
			
 
				+        # this and only works because this is a simple generator which
			
 
				+        # doesn't create or manage additional state. If this function
			
 
				+        # changes, the impact should be evaluated both against
			
 
				+        # `iter(bar)` and `next(bar)`. `next()` in particular may call
			
 
				+        # `self.generator()` repeatedly, and this must remain safe in
			
 
				+        # order for that interface to work.
			
 
				+        if not self.entered:
			
 
				+            raise RuntimeError("You need to use progress bars in a with block.")
			
 
				+
			
 
				+        if self.is_hidden:
			
 
				+            yield from self.iter
			
 
				+        else:
			
 
				+            for rv in self.iter:
			
 
				+                self.current_item = rv
			
 
				+
			
 
				+                # This allows show_item_func to be updated before the
			
 
				+                # item is processed. Only trigger at the beginning of
			
 
				+                # the update interval.
			
 
				+                if self._completed_intervals == 0:
			
 
				+                    self.render_progress()
			
 
				+
			
 
				+                yield rv
			
 
				+                self.update(1)
			
 
				+
			
 
				+            self.finish()
			
 
				+            self.render_progress()
			
 
				+
			
 
				+
			
 
				+def pager(generator: t.Iterable[str], color: t.Optional[bool] = None) -> None:
			
 
				+    """Decide what method to use for paging through text."""
			
 
				+    stdout = _default_text_stdout()
			
 
				+
			
 
				+    # There are no standard streams attached to write to. For example,
			
 
				+    # pythonw on Windows.
			
 
				+    if stdout is None:
			
 
				+        stdout = StringIO()
			
 
				+
			
 
				+    if not isatty(sys.stdin) or not isatty(stdout):
			
 
				+        return _nullpager(stdout, generator, color)
			
 
				+    pager_cmd = (os.environ.get("PAGER", None) or "").strip()
			
 
				+    if pager_cmd:
			
 
				+        if WIN:
			
 
				+            return _tempfilepager(generator, pager_cmd, color)
			
 
				+        return _pipepager(generator, pager_cmd, color)
			
 
				+    if os.environ.get("TERM") in ("dumb", "emacs"):
			
 
				+        return _nullpager(stdout, generator, color)
			
 
				+    if WIN or sys.platform.startswith("os2"):
			
 
				+        return _tempfilepager(generator, "more <", color)
			
 
				+    if hasattr(os, "system") and os.system("(less) 2>/dev/null") == 0:
			
 
				+        return _pipepager(generator, "less", color)
			
 
				+
			
 
				+    import tempfile
			
 
				+
			
 
				+    fd, filename = tempfile.mkstemp()
			
 
				+    os.close(fd)
			
 
				+    try:
			
 
				+        if hasattr(os, "system") and os.system(f'more "{filename}"') == 0:
			
 
				+            return _pipepager(generator, "more", color)
			
 
				+        return _nullpager(stdout, generator, color)
			
 
				+    finally:
			
 
				+        os.unlink(filename)
			
 
				+
			
 
				+
			
 
				+def _pipepager(generator: t.Iterable[str], cmd: str, color: t.Optional[bool]) -> None:
			
 
				+    """Page through text by feeding it to another program.  Invoking a
			
 
				+    pager through this might support colors.
			
 
				+    """
			
 
				+    import subprocess
			
 
				+
			
 
				+    env = dict(os.environ)
			
 
				+
			
 
				+    # If we're piping to less we might support colors under the
			
 
				+    # condition that
			
 
				+    cmd_detail = cmd.rsplit("/", 1)[-1].split()
			
 
				+    if color is None and cmd_detail[0] == "less":
			
 
				+        less_flags = f"{os.environ.get('LESS', '')}{' '.join(cmd_detail[1:])}"
			
 
				+        if not less_flags:
			
 
				+            env["LESS"] = "-R"
			
 
				+            color = True
			
 
				+        elif "r" in less_flags or "R" in less_flags:
			
 
				+            color = True
			
 
				+
			
 
				+    c = subprocess.Popen(cmd, shell=True, stdin=subprocess.PIPE, env=env)
			
 
				+    stdin = t.cast(t.BinaryIO, c.stdin)
			
 
				+    encoding = get_best_encoding(stdin)
			
 
				+    try:
			
 
				+        for text in generator:
			
 
				+            if not color:
			
 
				+                text = strip_ansi(text)
			
 
				+
			
 
				+            stdin.write(text.encode(encoding, "replace"))
			
 
				+    except (OSError, KeyboardInterrupt):
			
 
				+        pass
			
 
				+    else:
			
 
				+        stdin.close()
			
 
				+
			
 
				+    # Less doesn't respect ^C, but catches it for its own UI purposes (aborting
			
 
				+    # search or other commands inside less).
			
 
				+    #
			
 
				+    # That means when the user hits ^C, the parent process (click) terminates,
			
 
				+    # but less is still alive, paging the output and messing up the terminal.
			
 
				+    #
			
 
				+    # If the user wants to make the pager exit on ^C, they should set
			
 
				+    # `LESS='-K'`. It's not our decision to make.
			
 
				+    while True:
			
 
				+        try:
			
 
				+            c.wait()
			
 
				+        except KeyboardInterrupt:
			
 
				+            pass
			
 
				+        else:
			
 
				+            break
			
 
				+
			
 
				+
			
 
				+def _tempfilepager(
			
 
				+    generator: t.Iterable[str], cmd: str, color: t.Optional[bool]
			
 
				+) -> None:
			
 
				+    """Page through text by invoking a program on a temporary file."""
			
 
				+    import tempfile
			
 
				+
			
 
				+    fd, filename = tempfile.mkstemp()
			
 
				+    # TODO: This never terminates if the passed generator never terminates.
			
 
				+    text = "".join(generator)
			
 
				+    if not color:
			
 
				+        text = strip_ansi(text)
			
 
				+    encoding = get_best_encoding(sys.stdout)
			
 
				+    with open_stream(filename, "wb")[0] as f:
			
 
				+        f.write(text.encode(encoding))
			
 
				+    try:
			
 
				+        os.system(f'{cmd} "{filename}"')
			
 
				+    finally:
			
 
				+        os.close(fd)
			
 
				+        os.unlink(filename)
			
 
				+
			
 
				+
			
 
				+def _nullpager(
			
 
				+    stream: t.TextIO, generator: t.Iterable[str], color: t.Optional[bool]
			
 
				+) -> None:
			
 
				+    """Simply print unformatted text.  This is the ultimate fallback."""
			
 
				+    for text in generator:
			
 
				+        if not color:
			
 
				+            text = strip_ansi(text)
			
 
				+        stream.write(text)
			
 
				+
			
 
				+
			
 
				+class Editor:
			
 
				+    def __init__(
			
 
				+        self,
			
 
				+        editor: t.Optional[str] = None,
			
 
				+        env: t.Optional[t.Mapping[str, str]] = None,
			
 
				+        require_save: bool = True,
			
 
				+        extension: str = ".txt",
			
 
				+    ) -> None:
			
 
				+        self.editor = editor
			
 
				+        self.env = env
			
 
				+        self.require_save = require_save
			
 
				+        self.extension = extension
			
 
				+
			
 
				+    def get_editor(self) -> str:
			
 
				+        if self.editor is not None:
			
 
				+            return self.editor
			
 
				+        for key in "VISUAL", "EDITOR":
			
 
				+            rv = os.environ.get(key)
			
 
				+            if rv:
			
 
				+                return rv
			
 
				+        if WIN:
			
 
				+            return "notepad"
			
 
				+        for editor in "sensible-editor", "vim", "nano":
			
 
				+            if os.system(f"which {editor} >/dev/null 2>&1") == 0:
			
 
				+                return editor
			
 
				+        return "vi"
			
 
				+
			
 
				+    def edit_file(self, filename: str) -> None:
			
 
				+        import subprocess
			
 
				+
			
 
				+        editor = self.get_editor()
			
 
				+        environ: t.Optional[t.Dict[str, str]] = None
			
 
				+
			
 
				+        if self.env:
			
 
				+            environ = os.environ.copy()
			
 
				+            environ.update(self.env)
			
 
				+
			
 
				+        try:
			
 
				+            c = subprocess.Popen(f'{editor} "{filename}"', env=environ, shell=True)
			
 
				+            exit_code = c.wait()
			
 
				+            if exit_code != 0:
			
 
				+                raise ClickException(
			
 
				+                    _("{editor}: Editing failed").format(editor=editor)
			
 
				+                )
			
 
				+        except OSError as e:
			
 
				+            raise ClickException(
			
 
				+                _("{editor}: Editing failed: {e}").format(editor=editor, e=e)
			
 
				+            ) from e
			
 
				+
			
 
				+    def edit(self, text: t.Optional[t.AnyStr]) -> t.Optional[t.AnyStr]:
			
 
				+        import tempfile
			
 
				+
			
 
				+        if not text:
			
 
				+            data = b""
			
 
				+        elif isinstance(text, (bytes, bytearray)):
			
 
				+            data = text
			
 
				+        else:
			
 
				+            if text and not text.endswith("\n"):
			
 
				+                text += "\n"
			
 
				+
			
 
				+            if WIN:
			
 
				+                data = text.replace("\n", "\r\n").encode("utf-8-sig")
			
 
				+            else:
			
 
				+                data = text.encode("utf-8")
			
 
				+
			
 
				+        fd, name = tempfile.mkstemp(prefix="editor-", suffix=self.extension)
			
 
				+        f: t.BinaryIO
			
 
				+
			
 
				+        try:
			
 
				+            with os.fdopen(fd, "wb") as f:
			
 
				+                f.write(data)
			
 
				+
			
 
				+            # If the filesystem resolution is 1 second, like Mac OS
			
 
				+            # 10.12 Extended, or 2 seconds, like FAT32, and the editor
			
 
				+            # closes very fast, require_save can fail. Set the modified
			
 
				+            # time to be 2 seconds in the past to work around this.
			
 
				+            os.utime(name, (os.path.getatime(name), os.path.getmtime(name) - 2))
			
 
				+            # Depending on the resolution, the exact value might not be
			
 
				+            # recorded, so get the new recorded value.
			
 
				+            timestamp = os.path.getmtime(name)
			
 
				+
			
 
				+            self.edit_file(name)
			
 
				+
			
 
				+            if self.require_save and os.path.getmtime(name) == timestamp:
			
 
				+                return None
			
 
				+
			
 
				+            with open(name, "rb") as f:
			
 
				+                rv = f.read()
			
 
				+
			
 
				+            if isinstance(text, (bytes, bytearray)):
			
 
				+                return rv
			
 
				+
			
 
				+            return rv.decode("utf-8-sig").replace("\r\n", "\n")  # type: ignore
			
 
				+        finally:
			
 
				+            os.unlink(name)
			
 
				+
			
 
				+
			
 
				+def open_url(url: str, wait: bool = False, locate: bool = False) -> int:
			
 
				+    import subprocess
			
 
				+
			
 
				+    def _unquote_file(url: str) -> str:
			
 
				+        from urllib.parse import unquote
			
 
				+
			
 
				+        if url.startswith("file://"):
			
 
				+            url = unquote(url[7:])
			
 
				+
			
 
				+        return url
			
 
				+
			
 
				+    if sys.platform == "darwin":
			
 
				+        args = ["open"]
			
 
				+        if wait:
			
 
				+            args.append("-W")
			
 
				+        if locate:
			
 
				+            args.append("-R")
			
 
				+        args.append(_unquote_file(url))
			
 
				+        null = open("/dev/null", "w")
			
 
				+        try:
			
 
				+            return subprocess.Popen(args, stderr=null).wait()
			
 
				+        finally:
			
 
				+            null.close()
			
 
				+    elif WIN:
			
 
				+        if locate:
			
 
				+            url = _unquote_file(url.replace('"', ""))
			
 
				+            args = f'explorer /select,"{url}"'
			
 
				+        else:
			
 
				+            url = url.replace('"', "")
			
 
				+            wait_str = "/WAIT" if wait else ""
			
 
				+            args = f'start {wait_str} "" "{url}"'
			
 
				+        return os.system(args)
			
 
				+    elif CYGWIN:
			
 
				+        if locate:
			
 
				+            url = os.path.dirname(_unquote_file(url).replace('"', ""))
			
 
				+            args = f'cygstart "{url}"'
			
 
				+        else:
			
 
				+            url = url.replace('"', "")
			
 
				+            wait_str = "-w" if wait else ""
			
 
				+            args = f'cygstart {wait_str} "{url}"'
			
 
				+        return os.system(args)
			
 
				+
			
 
				+    try:
			
 
				+        if locate:
			
 
				+            url = os.path.dirname(_unquote_file(url)) or "."
			
 
				+        else:
			
 
				+            url = _unquote_file(url)
			
 
				+        c = subprocess.Popen(["xdg-open", url])
			
 
				+        if wait:
			
 
				+            return c.wait()
			
 
				+        return 0
			
 
				+    except OSError:
			
 
				+        if url.startswith(("http://", "https://")) and not locate and not wait:
			
 
				+            import webbrowser
			
 
				+
			
 
				+            webbrowser.open(url)
			
 
				+            return 0
			
 
				+        return 1
			
 
				+
			
 
				+
			
 
				+def _translate_ch_to_exc(ch: str) -> t.Optional[BaseException]:
			
 
				+    if ch == "\x03":
			
 
				+        raise KeyboardInterrupt()
			
 
				+
			
 
				+    if ch == "\x04" and not WIN:  # Unix-like, Ctrl+D
			
 
				+        raise EOFError()
			
 
				+
			
 
				+    if ch == "\x1a" and WIN:  # Windows, Ctrl+Z
			
 
				+        raise EOFError()
			
 
				+
			
 
				+    return None
			
 
				+
			
 
				+
			
 
				+if WIN:
			
 
				+    import msvcrt
			
 
				+
			
 
				+    @contextlib.contextmanager
			
 
				+    def raw_terminal() -> t.Iterator[int]:
			
 
				+        yield -1
			
 
				+
			
 
				+    def getchar(echo: bool) -> str:
			
 
				+        # The function `getch` will return a bytes object corresponding to
			
 
				+        # the pressed character. Since Windows 10 build 1803, it will also
			
 
				+        # return \x00 when called a second time after pressing a regular key.
			
 
				+        #
			
 
				+        # `getwch` does not share this probably-bugged behavior. Moreover, it
			
 
				+        # returns a Unicode object by default, which is what we want.
			
 
				+        #
			
 
				+        # Either of these functions will return \x00 or \xe0 to indicate
			
 
				+        # a special key, and you need to call the same function again to get
			
 
				+        # the "rest" of the code. The fun part is that \u00e0 is
			
 
				+        # "latin small letter a with grave", so if you type that on a French
			
 
				+        # keyboard, you _also_ get a \xe0.
			
 
				+        # E.g., consider the Up arrow. This returns \xe0 and then \x48. The
			
 
				+        # resulting Unicode string reads as "a with grave" + "capital H".
			
 
				+        # This is indistinguishable from when the user actually types
			
 
				+        # "a with grave" and then "capital H".
			
 
				+        #
			
 
				+        # When \xe0 is returned, we assume it's part of a special-key sequence
			
 
				+        # and call `getwch` again, but that means that when the user types
			
 
				+        # the \u00e0 character, `getchar` doesn't return until a second
			
 
				+        # character is typed.
			
 
				+        # The alternative is returning immediately, but that would mess up
			
 
				+        # cross-platform handling of arrow keys and others that start with
			
 
				+        # \xe0. Another option is using `getch`, but then we can't reliably
			
 
				+        # read non-ASCII characters, because return values of `getch` are
			
 
				+        # limited to the current 8-bit codepage.
			
 
				+        #
			
 
				+        # Anyway, Click doesn't claim to do this Right(tm), and using `getwch`
			
 
				+        # is doing the right thing in more situations than with `getch`.
			
 
				+        func: t.Callable[[], str]
			
 
				+
			
 
				+        if echo:
			
 
				+            func = msvcrt.getwche  # type: ignore
			
 
				+        else:
			
 
				+            func = msvcrt.getwch  # type: ignore
			
 
				+
			
 
				+        rv = func()
			
 
				+
			
 
				+        if rv in ("\x00", "\xe0"):
			
 
				+            # \x00 and \xe0 are control characters that indicate special key,
			
 
				+            # see above.
			
 
				+            rv += func()
			
 
				+
			
 
				+        _translate_ch_to_exc(rv)
			
 
				+        return rv
			
 
				+
			
 
				+else:
			
 
				+    import tty
			
 
				+    import termios
			
 
				+
			
 
				+    @contextlib.contextmanager
			
 
				+    def raw_terminal() -> t.Iterator[int]:
			
 
				+        f: t.Optional[t.TextIO]
			
 
				+        fd: int
			
 
				+
			
 
				+        if not isatty(sys.stdin):
			
 
				+            f = open("/dev/tty")
			
 
				+            fd = f.fileno()
			
 
				+        else:
			
 
				+            fd = sys.stdin.fileno()
			
 
				+            f = None
			
 
				+
			
 
				+        try:
			
 
				+            old_settings = termios.tcgetattr(fd)
			
 
				+
			
 
				+            try:
			
 
				+                tty.setraw(fd)
			
 
				+                yield fd
			
 
				+            finally:
			
 
				+                termios.tcsetattr(fd, termios.TCSADRAIN, old_settings)
			
 
				+                sys.stdout.flush()
			
 
				+
			
 
				+                if f is not None:
			
 
				+                    f.close()
			
 
				+        except termios.error:
			
 
				+            pass
			
 
				+
			
 
				+    def getchar(echo: bool) -> str:
			
 
				+        with raw_terminal() as fd:
			
 
				+            ch = os.read(fd, 32).decode(get_best_encoding(sys.stdin), "replace")
			
 
				+
			
 
				+            if echo and isatty(sys.stdout):
			
 
				+                sys.stdout.write(ch)
			
 
				+
			
 
				+            _translate_ch_to_exc(ch)
			
 
				+            return ch
			
--- a/courses/flask/microblog/env/Lib/site-packages/click/_textwrap.py
+++ b/courses/flask/microblog/env/Lib/site-packages/click/_textwrap.py
@@ -0,0 +1,49 @@
 
				+import textwrap
			
 
				+import typing as t
			
 
				+from contextlib import contextmanager
			
 
				+
			
 
				+
			
 
				+class TextWrapper(textwrap.TextWrapper):
			
 
				+    def _handle_long_word(
			
 
				+        self,
			
 
				+        reversed_chunks: t.List[str],
			
 
				+        cur_line: t.List[str],
			
 
				+        cur_len: int,
			
 
				+        width: int,
			
 
				+    ) -> None:
			
 
				+        space_left = max(width - cur_len, 1)
			
 
				+
			
 
				+        if self.break_long_words:
			
 
				+            last = reversed_chunks[-1]
			
 
				+            cut = last[:space_left]
			
 
				+            res = last[space_left:]
			
 
				+            cur_line.append(cut)
			
 
				+            reversed_chunks[-1] = res
			
 
				+        elif not cur_line:
			
 
				+            cur_line.append(reversed_chunks.pop())
			
 
				+
			
 
				+    @contextmanager
			
 
				+    def extra_indent(self, indent: str) -> t.Iterator[None]:
			
 
				+        old_initial_indent = self.initial_indent
			
 
				+        old_subsequent_indent = self.subsequent_indent
			
 
				+        self.initial_indent += indent
			
 
				+        self.subsequent_indent += indent
			
 
				+
			
 
				+        try:
			
 
				+            yield
			
 
				+        finally:
			
 
				+            self.initial_indent = old_initial_indent
			
 
				+            self.subsequent_indent = old_subsequent_indent
			
 
				+
			
 
				+    def indent_only(self, text: str) -> str:
			
 
				+        rv = []
			
 
				+
			
 
				+        for idx, line in enumerate(text.splitlines()):
			
 
				+            indent = self.initial_indent
			
 
				+
			
 
				+            if idx > 0:
			
 
				+                indent = self.subsequent_indent
			
 
				+
			
 
				+            rv.append(f"{indent}{line}")
			
 
				+
			
 
				+        return "\n".join(rv)
			
--- a/courses/flask/microblog/env/Lib/site-packages/click/_winconsole.py
+++ b/courses/flask/microblog/env/Lib/site-packages/click/_winconsole.py
@@ -0,0 +1,279 @@
 
				+# This module is based on the excellent work by Adam Bartoš who
			
 
				+# provided a lot of what went into the implementation here in
			
 
				+# the discussion to issue1602 in the Python bug tracker.
			
 
				+#
			
 
				+# There are some general differences in regards to how this works
			
 
				+# compared to the original patches as we do not need to patch
			
 
				+# the entire interpreter but just work in our little world of
			
 
				+# echo and prompt.
			
 
				+import io
			
 
				+import sys
			
 
				+import time
			
 
				+import typing as t
			
 
				+from ctypes import byref
			
 
				+from ctypes import c_char
			
 
				+from ctypes import c_char_p
			
 
				+from ctypes import c_int
			
 
				+from ctypes import c_ssize_t
			
 
				+from ctypes import c_ulong
			
 
				+from ctypes import c_void_p
			
 
				+from ctypes import POINTER
			
 
				+from ctypes import py_object
			
 
				+from ctypes import Structure
			
 
				+from ctypes.wintypes import DWORD
			
 
				+from ctypes.wintypes import HANDLE
			
 
				+from ctypes.wintypes import LPCWSTR
			
 
				+from ctypes.wintypes import LPWSTR
			
 
				+
			
 
				+from ._compat import _NonClosingTextIOWrapper
			
 
				+
			
 
				+assert sys.platform == "win32"
			
 
				+import msvcrt  # noqa: E402
			
 
				+from ctypes import windll  # noqa: E402
			
 
				+from ctypes import WINFUNCTYPE  # noqa: E402
			
 
				+
			
 
				+c_ssize_p = POINTER(c_ssize_t)
			
 
				+
			
 
				+kernel32 = windll.kernel32
			
 
				+GetStdHandle = kernel32.GetStdHandle
			
 
				+ReadConsoleW = kernel32.ReadConsoleW
			
 
				+WriteConsoleW = kernel32.WriteConsoleW
			
 
				+GetConsoleMode = kernel32.GetConsoleMode
			
 
				+GetLastError = kernel32.GetLastError
			
 
				+GetCommandLineW = WINFUNCTYPE(LPWSTR)(("GetCommandLineW", windll.kernel32))
			
 
				+CommandLineToArgvW = WINFUNCTYPE(POINTER(LPWSTR), LPCWSTR, POINTER(c_int))(
			
 
				+    ("CommandLineToArgvW", windll.shell32)
			
 
				+)
			
 
				+LocalFree = WINFUNCTYPE(c_void_p, c_void_p)(("LocalFree", windll.kernel32))
			
 
				+
			
 
				+STDIN_HANDLE = GetStdHandle(-10)
			
 
				+STDOUT_HANDLE = GetStdHandle(-11)
			
 
				+STDERR_HANDLE = GetStdHandle(-12)
			
 
				+
			
 
				+PyBUF_SIMPLE = 0
			
 
				+PyBUF_WRITABLE = 1
			
 
				+
			
 
				+ERROR_SUCCESS = 0
			
 
				+ERROR_NOT_ENOUGH_MEMORY = 8
			
 
				+ERROR_OPERATION_ABORTED = 995
			
 
				+
			
 
				+STDIN_FILENO = 0
			
 
				+STDOUT_FILENO = 1
			
 
				+STDERR_FILENO = 2
			
 
				+
			
 
				+EOF = b"\x1a"
			
 
				+MAX_BYTES_WRITTEN = 32767
			
 
				+
			
 
				+try:
			
 
				+    from ctypes import pythonapi
			
 
				+except ImportError:
			
 
				+    # On PyPy we cannot get buffers so our ability to operate here is
			
 
				+    # severely limited.
			
 
				+    get_buffer = None
			
 
				+else:
			
 
				+
			
 
				+    class Py_buffer(Structure):
			
 
				+        _fields_ = [
			
 
				+            ("buf", c_void_p),
			
 
				+            ("obj", py_object),
			
 
				+            ("len", c_ssize_t),
			
 
				+            ("itemsize", c_ssize_t),
			
 
				+            ("readonly", c_int),
			
 
				+            ("ndim", c_int),
			
 
				+            ("format", c_char_p),
			
 
				+            ("shape", c_ssize_p),
			
 
				+            ("strides", c_ssize_p),
			
 
				+            ("suboffsets", c_ssize_p),
			
 
				+            ("internal", c_void_p),
			
 
				+        ]
			
 
				+
			
 
				+    PyObject_GetBuffer = pythonapi.PyObject_GetBuffer
			
 
				+    PyBuffer_Release = pythonapi.PyBuffer_Release
			
 
				+
			
 
				+    def get_buffer(obj, writable=False):
			
 
				+        buf = Py_buffer()
			
 
				+        flags = PyBUF_WRITABLE if writable else PyBUF_SIMPLE
			
 
				+        PyObject_GetBuffer(py_object(obj), byref(buf), flags)
			
 
				+
			
 
				+        try:
			
 
				+            buffer_type = c_char * buf.len
			
 
				+            return buffer_type.from_address(buf.buf)
			
 
				+        finally:
			
 
				+            PyBuffer_Release(byref(buf))
			
 
				+
			
 
				+
			
 
				+class _WindowsConsoleRawIOBase(io.RawIOBase):
			
 
				+    def __init__(self, handle):
			
 
				+        self.handle = handle
			
 
				+
			
 
				+    def isatty(self):
			
 
				+        super().isatty()
			
 
				+        return True
			
 
				+
			
 
				+
			
 
				+class _WindowsConsoleReader(_WindowsConsoleRawIOBase):
			
 
				+    def readable(self):
			
 
				+        return True
			
 
				+
			
 
				+    def readinto(self, b):
			
 
				+        bytes_to_be_read = len(b)
			
 
				+        if not bytes_to_be_read:
			
 
				+            return 0
			
 
				+        elif bytes_to_be_read % 2:
			
 
				+            raise ValueError(
			
 
				+                "cannot read odd number of bytes from UTF-16-LE encoded console"
			
 
				+            )
			
 
				+
			
 
				+        buffer = get_buffer(b, writable=True)
			
 
				+        code_units_to_be_read = bytes_to_be_read // 2
			
 
				+        code_units_read = c_ulong()
			
 
				+
			
 
				+        rv = ReadConsoleW(
			
 
				+            HANDLE(self.handle),
			
 
				+            buffer,
			
 
				+            code_units_to_be_read,
			
 
				+            byref(code_units_read),
			
 
				+            None,
			
 
				+        )
			
 
				+        if GetLastError() == ERROR_OPERATION_ABORTED:
			
 
				+            # wait for KeyboardInterrupt
			
 
				+            time.sleep(0.1)
			
 
				+        if not rv:
			
 
				+            raise OSError(f"Windows error: {GetLastError()}")
			
 
				+
			
 
				+        if buffer[0] == EOF:
			
 
				+            return 0
			
 
				+        return 2 * code_units_read.value
			
 
				+
			
 
				+
			
 
				+class _WindowsConsoleWriter(_WindowsConsoleRawIOBase):
			
 
				+    def writable(self):
			
 
				+        return True
			
 
				+
			
 
				+    @staticmethod
			
 
				+    def _get_error_message(errno):
			
 
				+        if errno == ERROR_SUCCESS:
			
 
				+            return "ERROR_SUCCESS"
			
 
				+        elif errno == ERROR_NOT_ENOUGH_MEMORY:
			
 
				+            return "ERROR_NOT_ENOUGH_MEMORY"
			
 
				+        return f"Windows error {errno}"
			
 
				+
			
 
				+    def write(self, b):
			
 
				+        bytes_to_be_written = len(b)
			
 
				+        buf = get_buffer(b)
			
 
				+        code_units_to_be_written = min(bytes_to_be_written, MAX_BYTES_WRITTEN) // 2
			
 
				+        code_units_written = c_ulong()
			
 
				+
			
 
				+        WriteConsoleW(
			
 
				+            HANDLE(self.handle),
			
 
				+            buf,
			
 
				+            code_units_to_be_written,
			
 
				+            byref(code_units_written),
			
 
				+            None,
			
 
				+        )
			
 
				+        bytes_written = 2 * code_units_written.value
			
 
				+
			
 
				+        if bytes_written == 0 and bytes_to_be_written > 0:
			
 
				+            raise OSError(self._get_error_message(GetLastError()))
			
 
				+        return bytes_written
			
 
				+
			
 
				+
			
 
				+class ConsoleStream:
			
 
				+    def __init__(self, text_stream: t.TextIO, byte_stream: t.BinaryIO) -> None:
			
 
				+        self._text_stream = text_stream
			
 
				+        self.buffer = byte_stream
			
 
				+
			
 
				+    @property
			
 
				+    def name(self) -> str:
			
 
				+        return self.buffer.name
			
 
				+
			
 
				+    def write(self, x: t.AnyStr) -> int:
			
 
				+        if isinstance(x, str):
			
 
				+            return self._text_stream.write(x)
			
 
				+        try:
			
 
				+            self.flush()
			
 
				+        except Exception:
			
 
				+            pass
			
 
				+        return self.buffer.write(x)
			
 
				+
			
 
				+    def writelines(self, lines: t.Iterable[t.AnyStr]) -> None:
			
 
				+        for line in lines:
			
 
				+            self.write(line)
			
 
				+
			
 
				+    def __getattr__(self, name: str) -> t.Any:
			
 
				+        return getattr(self._text_stream, name)
			
 
				+
			
 
				+    def isatty(self) -> bool:
			
 
				+        return self.buffer.isatty()
			
 
				+
			
 
				+    def __repr__(self):
			
 
				+        return f"<ConsoleStream name={self.name!r} encoding={self.encoding!r}>"
			
 
				+
			
 
				+
			
 
				+def _get_text_stdin(buffer_stream: t.BinaryIO) -> t.TextIO:
			
 
				+    text_stream = _NonClosingTextIOWrapper(
			
 
				+        io.BufferedReader(_WindowsConsoleReader(STDIN_HANDLE)),
			
 
				+        "utf-16-le",
			
 
				+        "strict",
			
 
				+        line_buffering=True,
			
 
				+    )
			
 
				+    return t.cast(t.TextIO, ConsoleStream(text_stream, buffer_stream))
			
 
				+
			
 
				+
			
 
				+def _get_text_stdout(buffer_stream: t.BinaryIO) -> t.TextIO:
			
 
				+    text_stream = _NonClosingTextIOWrapper(
			
 
				+        io.BufferedWriter(_WindowsConsoleWriter(STDOUT_HANDLE)),
			
 
				+        "utf-16-le",
			
 
				+        "strict",
			
 
				+        line_buffering=True,
			
 
				+    )
			
 
				+    return t.cast(t.TextIO, ConsoleStream(text_stream, buffer_stream))
			
 
				+
			
 
				+
			
 
				+def _get_text_stderr(buffer_stream: t.BinaryIO) -> t.TextIO:
			
 
				+    text_stream = _NonClosingTextIOWrapper(
			
 
				+        io.BufferedWriter(_WindowsConsoleWriter(STDERR_HANDLE)),
			
 
				+        "utf-16-le",
			
 
				+        "strict",
			
 
				+        line_buffering=True,
			
 
				+    )
			
 
				+    return t.cast(t.TextIO, ConsoleStream(text_stream, buffer_stream))
			
 
				+
			
 
				+
			
 
				+_stream_factories: t.Mapping[int, t.Callable[[t.BinaryIO], t.TextIO]] = {
			
 
				+    0: _get_text_stdin,
			
 
				+    1: _get_text_stdout,
			
 
				+    2: _get_text_stderr,
			
 
				+}
			
 
				+
			
 
				+
			
 
				+def _is_console(f: t.TextIO) -> bool:
			
 
				+    if not hasattr(f, "fileno"):
			
 
				+        return False
			
 
				+
			
 
				+    try:
			
 
				+        fileno = f.fileno()
			
 
				+    except (OSError, io.UnsupportedOperation):
			
 
				+        return False
			
 
				+
			
 
				+    handle = msvcrt.get_osfhandle(fileno)
			
 
				+    return bool(GetConsoleMode(handle, byref(DWORD())))
			
 
				+
			
 
				+
			
 
				+def _get_windows_console_stream(
			
 
				+    f: t.TextIO, encoding: t.Optional[str], errors: t.Optional[str]
			
 
				+) -> t.Optional[t.TextIO]:
			
 
				+    if (
			
 
				+        get_buffer is not None
			
 
				+        and encoding in {"utf-16-le", None}
			
 
				+        and errors in {"strict", None}
			
 
				+        and _is_console(f)
			
 
				+    ):
			
 
				+        func = _stream_factories.get(f.fileno())
			
 
				+        if func is not None:
			
 
				+            b = getattr(f, "buffer", None)
			
 
				+
			
 
				+            if b is None:
			
 
				+                return None
			
 
				+
			
 
				+            return func(b)
			
--- a/courses/flask/microblog/env/Lib/site-packages/click/core.py
+++ b/courses/flask/microblog/env/Lib/site-packages/click/core.py
@@ -0,0 +1,3042 @@
 
				+import enum
			
 
				+import errno
			
 
				+import inspect
			
 
				+import os
			
 
				+import sys
			
 
				+import typing as t
			
 
				+from collections import abc
			
 
				+from contextlib import contextmanager
			
 
				+from contextlib import ExitStack
			
 
				+from functools import update_wrapper
			
 
				+from gettext import gettext as _
			
 
				+from gettext import ngettext
			
 
				+from itertools import repeat
			
 
				+from types import TracebackType
			
 
				+
			
 
				+from . import types
			
 
				+from .exceptions import Abort
			
 
				+from .exceptions import BadParameter
			
 
				+from .exceptions import ClickException
			
 
				+from .exceptions import Exit
			
 
				+from .exceptions import MissingParameter
			
 
				+from .exceptions import UsageError
			
 
				+from .formatting import HelpFormatter
			
 
				+from .formatting import join_options
			
 
				+from .globals import pop_context
			
 
				+from .globals import push_context
			
 
				+from .parser import _flag_needs_value
			
 
				+from .parser import OptionParser
			
 
				+from .parser import split_opt
			
 
				+from .termui import confirm
			
 
				+from .termui import prompt
			
 
				+from .termui import style
			
 
				+from .utils import _detect_program_name
			
 
				+from .utils import _expand_args
			
 
				+from .utils import echo
			
 
				+from .utils import make_default_short_help
			
 
				+from .utils import make_str
			
 
				+from .utils import PacifyFlushWrapper
			
 
				+
			
 
				+if t.TYPE_CHECKING:
			
 
				+    import typing_extensions as te
			
 
				+    from .shell_completion import CompletionItem
			
 
				+
			
 
				+F = t.TypeVar("F", bound=t.Callable[..., t.Any])
			
 
				+V = t.TypeVar("V")
			
 
				+
			
 
				+
			
 
				+def _complete_visible_commands(
			
 
				+    ctx: "Context", incomplete: str
			
 
				+) -> t.Iterator[t.Tuple[str, "Command"]]:
			
 
				+    """List all the subcommands of a group that start with the
			
 
				+    incomplete value and aren't hidden.
			
 
				+
			
 
				+    :param ctx: Invocation context for the group.
			
 
				+    :param incomplete: Value being completed. May be empty.
			
 
				+    """
			
 
				+    multi = t.cast(MultiCommand, ctx.command)
			
 
				+
			
 
				+    for name in multi.list_commands(ctx):
			
 
				+        if name.startswith(incomplete):
			
 
				+            command = multi.get_command(ctx, name)
			
 
				+
			
 
				+            if command is not None and not command.hidden:
			
 
				+                yield name, command
			
 
				+
			
 
				+
			
 
				+def _check_multicommand(
			
 
				+    base_command: "MultiCommand", cmd_name: str, cmd: "Command", register: bool = False
			
 
				+) -> None:
			
 
				+    if not base_command.chain or not isinstance(cmd, MultiCommand):
			
 
				+        return
			
 
				+    if register:
			
 
				+        hint = (
			
 
				+            "It is not possible to add multi commands as children to"
			
 
				+            " another multi command that is in chain mode."
			
 
				+        )
			
 
				+    else:
			
 
				+        hint = (
			
 
				+            "Found a multi command as subcommand to a multi command"
			
 
				+            " that is in chain mode. This is not supported."
			
 
				+        )
			
 
				+    raise RuntimeError(
			
 
				+        f"{hint}. Command {base_command.name!r} is set to chain and"
			
 
				+        f" {cmd_name!r} was added as a subcommand but it in itself is a"
			
 
				+        f" multi command. ({cmd_name!r} is a {type(cmd).__name__}"
			
 
				+        f" within a chained {type(base_command).__name__} named"
			
 
				+        f" {base_command.name!r})."
			
 
				+    )
			
 
				+
			
 
				+
			
 
				+def batch(iterable: t.Iterable[V], batch_size: int) -> t.List[t.Tuple[V, ...]]:
			
 
				+    return list(zip(*repeat(iter(iterable), batch_size)))
			
 
				+
			
 
				+
			
 
				+@contextmanager
			
 
				+def augment_usage_errors(
			
 
				+    ctx: "Context", param: t.Optional["Parameter"] = None
			
 
				+) -> t.Iterator[None]:
			
 
				+    """Context manager that attaches extra information to exceptions."""
			
 
				+    try:
			
 
				+        yield
			
 
				+    except BadParameter as e:
			
 
				+        if e.ctx is None:
			
 
				+            e.ctx = ctx
			
 
				+        if param is not None and e.param is None:
			
 
				+            e.param = param
			
 
				+        raise
			
 
				+    except UsageError as e:
			
 
				+        if e.ctx is None:
			
 
				+            e.ctx = ctx
			
 
				+        raise
			
 
				+
			
 
				+
			
 
				+def iter_params_for_processing(
			
 
				+    invocation_order: t.Sequence["Parameter"],
			
 
				+    declaration_order: t.Sequence["Parameter"],
			
 
				+) -> t.List["Parameter"]:
			
 
				+    """Given a sequence of parameters in the order as should be considered
			
 
				+    for processing and an iterable of parameters that exist, this returns
			
 
				+    a list in the correct order as they should be processed.
			
 
				+    """
			
 
				+
			
 
				+    def sort_key(item: "Parameter") -> t.Tuple[bool, float]:
			
 
				+        try:
			
 
				+            idx: float = invocation_order.index(item)
			
 
				+        except ValueError:
			
 
				+            idx = float("inf")
			
 
				+
			
 
				+        return not item.is_eager, idx
			
 
				+
			
 
				+    return sorted(declaration_order, key=sort_key)
			
 
				+
			
 
				+
			
 
				+class ParameterSource(enum.Enum):
			
 
				+    """This is an :class:`~enum.Enum` that indicates the source of a
			
 
				+    parameter's value.
			
 
				+
			
 
				+    Use :meth:`click.Context.get_parameter_source` to get the
			
 
				+    source for a parameter by name.
			
 
				+
			
 
				+    .. versionchanged:: 8.0
			
 
				+        Use :class:`~enum.Enum` and drop the ``validate`` method.
			
 
				+
			
 
				+    .. versionchanged:: 8.0
			
 
				+        Added the ``PROMPT`` value.
			
 
				+    """
			
 
				+
			
 
				+    COMMANDLINE = enum.auto()
			
 
				+    """The value was provided by the command line args."""
			
 
				+    ENVIRONMENT = enum.auto()
			
 
				+    """The value was provided with an environment variable."""
			
 
				+    DEFAULT = enum.auto()
			
 
				+    """Used the default specified by the parameter."""
			
 
				+    DEFAULT_MAP = enum.auto()
			
 
				+    """Used a default provided by :attr:`Context.default_map`."""
			
 
				+    PROMPT = enum.auto()
			
 
				+    """Used a prompt to confirm a default or provide a value."""
			
 
				+
			
 
				+
			
 
				+class Context:
			
 
				+    """The context is a special internal object that holds state relevant
			
 
				+    for the script execution at every single level.  It's normally invisible
			
 
				+    to commands unless they opt-in to getting access to it.
			
 
				+
			
 
				+    The context is useful as it can pass internal objects around and can
			
 
				+    control special execution features such as reading data from
			
 
				+    environment variables.
			
 
				+
			
 
				+    A context can be used as context manager in which case it will call
			
 
				+    :meth:`close` on teardown.
			
 
				+
			
 
				+    :param command: the command class for this context.
			
 
				+    :param parent: the parent context.
			
 
				+    :param info_name: the info name for this invocation.  Generally this
			
 
				+                      is the most descriptive name for the script or
			
 
				+                      command.  For the toplevel script it is usually
			
 
				+                      the name of the script, for commands below it it's
			
 
				+                      the name of the script.
			
 
				+    :param obj: an arbitrary object of user data.
			
 
				+    :param auto_envvar_prefix: the prefix to use for automatic environment
			
 
				+                               variables.  If this is `None` then reading
			
 
				+                               from environment variables is disabled.  This
			
 
				+                               does not affect manually set environment
			
 
				+                               variables which are always read.
			
 
				+    :param default_map: a dictionary (like object) with default values
			
 
				+                        for parameters.
			
 
				+    :param terminal_width: the width of the terminal.  The default is
			
 
				+                           inherit from parent context.  If no context
			
 
				+                           defines the terminal width then auto
			
 
				+                           detection will be applied.
			
 
				+    :param max_content_width: the maximum width for content rendered by
			
 
				+                              Click (this currently only affects help
			
 
				+                              pages).  This defaults to 80 characters if
			
 
				+                              not overridden.  In other words: even if the
			
 
				+                              terminal is larger than that, Click will not
			
 
				+                              format things wider than 80 characters by
			
 
				+                              default.  In addition to that, formatters might
			
 
				+                              add some safety mapping on the right.
			
 
				+    :param resilient_parsing: if this flag is enabled then Click will
			
 
				+                              parse without any interactivity or callback
			
 
				+                              invocation.  Default values will also be
			
 
				+                              ignored.  This is useful for implementing
			
 
				+                              things such as completion support.
			
 
				+    :param allow_extra_args: if this is set to `True` then extra arguments
			
 
				+                             at the end will not raise an error and will be
			
 
				+                             kept on the context.  The default is to inherit
			
 
				+                             from the command.
			
 
				+    :param allow_interspersed_args: if this is set to `False` then options
			
 
				+                                    and arguments cannot be mixed.  The
			
 
				+                                    default is to inherit from the command.
			
 
				+    :param ignore_unknown_options: instructs click to ignore options it does
			
 
				+                                   not know and keeps them for later
			
 
				+                                   processing.
			
 
				+    :param help_option_names: optionally a list of strings that define how
			
 
				+                              the default help parameter is named.  The
			
 
				+                              default is ``['--help']``.
			
 
				+    :param token_normalize_func: an optional function that is used to
			
 
				+                                 normalize tokens (options, choices,
			
 
				+                                 etc.).  This for instance can be used to
			
 
				+                                 implement case insensitive behavior.
			
 
				+    :param color: controls if the terminal supports ANSI colors or not.  The
			
 
				+                  default is autodetection.  This is only needed if ANSI
			
 
				+                  codes are used in texts that Click prints which is by
			
 
				+                  default not the case.  This for instance would affect
			
 
				+                  help output.
			
 
				+    :param show_default: Show the default value for commands. If this
			
 
				+        value is not set, it defaults to the value from the parent
			
 
				+        context. ``Command.show_default`` overrides this default for the
			
 
				+        specific command.
			
 
				+
			
 
				+    .. versionchanged:: 8.1
			
 
				+        The ``show_default`` parameter is overridden by
			
 
				+        ``Command.show_default``, instead of the other way around.
			
 
				+
			
 
				+    .. versionchanged:: 8.0
			
 
				+        The ``show_default`` parameter defaults to the value from the
			
 
				+        parent context.
			
 
				+
			
 
				+    .. versionchanged:: 7.1
			
 
				+       Added the ``show_default`` parameter.
			
 
				+
			
 
				+    .. versionchanged:: 4.0
			
 
				+        Added the ``color``, ``ignore_unknown_options``, and
			
 
				+        ``max_content_width`` parameters.
			
 
				+
			
 
				+    .. versionchanged:: 3.0
			
 
				+        Added the ``allow_extra_args`` and ``allow_interspersed_args``
			
 
				+        parameters.
			
 
				+
			
 
				+    .. versionchanged:: 2.0
			
 
				+        Added the ``resilient_parsing``, ``help_option_names``, and
			
 
				+        ``token_normalize_func`` parameters.
			
 
				+    """
			
 
				+
			
 
				+    #: The formatter class to create with :meth:`make_formatter`.
			
 
				+    #:
			
 
				+    #: .. versionadded:: 8.0
			
 
				+    formatter_class: t.Type["HelpFormatter"] = HelpFormatter
			
 
				+
			
 
				+    def __init__(
			
 
				+        self,
			
 
				+        command: "Command",
			
 
				+        parent: t.Optional["Context"] = None,
			
 
				+        info_name: t.Optional[str] = None,
			
 
				+        obj: t.Optional[t.Any] = None,
			
 
				+        auto_envvar_prefix: t.Optional[str] = None,
			
 
				+        default_map: t.Optional[t.MutableMapping[str, t.Any]] = None,
			
 
				+        terminal_width: t.Optional[int] = None,
			
 
				+        max_content_width: t.Optional[int] = None,
			
 
				+        resilient_parsing: bool = False,
			
 
				+        allow_extra_args: t.Optional[bool] = None,
			
 
				+        allow_interspersed_args: t.Optional[bool] = None,
			
 
				+        ignore_unknown_options: t.Optional[bool] = None,
			
 
				+        help_option_names: t.Optional[t.List[str]] = None,
			
 
				+        token_normalize_func: t.Optional[t.Callable[[str], str]] = None,
			
 
				+        color: t.Optional[bool] = None,
			
 
				+        show_default: t.Optional[bool] = None,
			
 
				+    ) -> None:
			
 
				+        #: the parent context or `None` if none exists.
			
 
				+        self.parent = parent
			
 
				+        #: the :class:`Command` for this context.
			
 
				+        self.command = command
			
 
				+        #: the descriptive information name
			
 
				+        self.info_name = info_name
			
 
				+        #: Map of parameter names to their parsed values. Parameters
			
 
				+        #: with ``expose_value=False`` are not stored.
			
 
				+        self.params: t.Dict[str, t.Any] = {}
			
 
				+        #: the leftover arguments.
			
 
				+        self.args: t.List[str] = []
			
 
				+        #: protected arguments.  These are arguments that are prepended
			
 
				+        #: to `args` when certain parsing scenarios are encountered but
			
 
				+        #: must be never propagated to another arguments.  This is used
			
 
				+        #: to implement nested parsing.
			
 
				+        self.protected_args: t.List[str] = []
			
 
				+        #: the collected prefixes of the command's options.
			
 
				+        self._opt_prefixes: t.Set[str] = set(parent._opt_prefixes) if parent else set()
			
 
				+
			
 
				+        if obj is None and parent is not None:
			
 
				+            obj = parent.obj
			
 
				+
			
 
				+        #: the user object stored.
			
 
				+        self.obj: t.Any = obj
			
 
				+        self._meta: t.Dict[str, t.Any] = getattr(parent, "meta", {})
			
 
				+
			
 
				+        #: A dictionary (-like object) with defaults for parameters.
			
 
				+        if (
			
 
				+            default_map is None
			
 
				+            and info_name is not None
			
 
				+            and parent is not None
			
 
				+            and parent.default_map is not None
			
 
				+        ):
			
 
				+            default_map = parent.default_map.get(info_name)
			
 
				+
			
 
				+        self.default_map: t.Optional[t.MutableMapping[str, t.Any]] = default_map
			
 
				+
			
 
				+        #: This flag indicates if a subcommand is going to be executed. A
			
 
				+        #: group callback can use this information to figure out if it's
			
 
				+        #: being executed directly or because the execution flow passes
			
 
				+        #: onwards to a subcommand. By default it's None, but it can be
			
 
				+        #: the name of the subcommand to execute.
			
 
				+        #:
			
 
				+        #: If chaining is enabled this will be set to ``'*'`` in case
			
 
				+        #: any commands are executed.  It is however not possible to
			
 
				+        #: figure out which ones.  If you require this knowledge you
			
 
				+        #: should use a :func:`result_callback`.
			
 
				+        self.invoked_subcommand: t.Optional[str] = None
			
 
				+
			
 
				+        if terminal_width is None and parent is not None:
			
 
				+            terminal_width = parent.terminal_width
			
 
				+
			
 
				+        #: The width of the terminal (None is autodetection).
			
 
				+        self.terminal_width: t.Optional[int] = terminal_width
			
 
				+
			
 
				+        if max_content_width is None and parent is not None:
			
 
				+            max_content_width = parent.max_content_width
			
 
				+
			
 
				+        #: The maximum width of formatted content (None implies a sensible
			
 
				+        #: default which is 80 for most things).
			
 
				+        self.max_content_width: t.Optional[int] = max_content_width
			
 
				+
			
 
				+        if allow_extra_args is None:
			
 
				+            allow_extra_args = command.allow_extra_args
			
 
				+
			
 
				+        #: Indicates if the context allows extra args or if it should
			
 
				+        #: fail on parsing.
			
 
				+        #:
			
 
				+        #: .. versionadded:: 3.0
			
 
				+        self.allow_extra_args = allow_extra_args
			
 
				+
			
 
				+        if allow_interspersed_args is None:
			
 
				+            allow_interspersed_args = command.allow_interspersed_args
			
 
				+
			
 
				+        #: Indicates if the context allows mixing of arguments and
			
 
				+        #: options or not.
			
 
				+        #:
			
 
				+        #: .. versionadded:: 3.0
			
 
				+        self.allow_interspersed_args: bool = allow_interspersed_args
			
 
				+
			
 
				+        if ignore_unknown_options is None:
			
 
				+            ignore_unknown_options = command.ignore_unknown_options
			
 
				+
			
 
				+        #: Instructs click to ignore options that a command does not
			
 
				+        #: understand and will store it on the context for later
			
 
				+        #: processing.  This is primarily useful for situations where you
			
 
				+        #: want to call into external programs.  Generally this pattern is
			
 
				+        #: strongly discouraged because it's not possibly to losslessly
			
 
				+        #: forward all arguments.
			
 
				+        #:
			
 
				+        #: .. versionadded:: 4.0
			
 
				+        self.ignore_unknown_options: bool = ignore_unknown_options
			
 
				+
			
 
				+        if help_option_names is None:
			
 
				+            if parent is not None:
			
 
				+                help_option_names = parent.help_option_names
			
 
				+            else:
			
 
				+                help_option_names = ["--help"]
			
 
				+
			
 
				+        #: The names for the help options.
			
 
				+        self.help_option_names: t.List[str] = help_option_names
			
 
				+
			
 
				+        if token_normalize_func is None and parent is not None:
			
 
				+            token_normalize_func = parent.token_normalize_func
			
 
				+
			
 
				+        #: An optional normalization function for tokens.  This is
			
 
				+        #: options, choices, commands etc.
			
 
				+        self.token_normalize_func: t.Optional[
			
 
				+            t.Callable[[str], str]
			
 
				+        ] = token_normalize_func
			
 
				+
			
 
				+        #: Indicates if resilient parsing is enabled.  In that case Click
			
 
				+        #: will do its best to not cause any failures and default values
			
 
				+        #: will be ignored. Useful for completion.
			
 
				+        self.resilient_parsing: bool = resilient_parsing
			
 
				+
			
 
				+        # If there is no envvar prefix yet, but the parent has one and
			
 
				+        # the command on this level has a name, we can expand the envvar
			
 
				+        # prefix automatically.
			
 
				+        if auto_envvar_prefix is None:
			
 
				+            if (
			
 
				+                parent is not None
			
 
				+                and parent.auto_envvar_prefix is not None
			
 
				+                and self.info_name is not None
			
 
				+            ):
			
 
				+                auto_envvar_prefix = (
			
 
				+                    f"{parent.auto_envvar_prefix}_{self.info_name.upper()}"
			
 
				+                )
			
 
				+        else:
			
 
				+            auto_envvar_prefix = auto_envvar_prefix.upper()
			
 
				+
			
 
				+        if auto_envvar_prefix is not None:
			
 
				+            auto_envvar_prefix = auto_envvar_prefix.replace("-", "_")
			
 
				+
			
 
				+        self.auto_envvar_prefix: t.Optional[str] = auto_envvar_prefix
			
 
				+
			
 
				+        if color is None and parent is not None:
			
 
				+            color = parent.color
			
 
				+
			
 
				+        #: Controls if styling output is wanted or not.
			
 
				+        self.color: t.Optional[bool] = color
			
 
				+
			
 
				+        if show_default is None and parent is not None:
			
 
				+            show_default = parent.show_default
			
 
				+
			
 
				+        #: Show option default values when formatting help text.
			
 
				+        self.show_default: t.Optional[bool] = show_default
			
 
				+
			
 
				+        self._close_callbacks: t.List[t.Callable[[], t.Any]] = []
			
 
				+        self._depth = 0
			
 
				+        self._parameter_source: t.Dict[str, ParameterSource] = {}
			
 
				+        self._exit_stack = ExitStack()
			
 
				+
			
 
				+    def to_info_dict(self) -> t.Dict[str, t.Any]:
			
 
				+        """Gather information that could be useful for a tool generating
			
 
				+        user-facing documentation. This traverses the entire CLI
			
 
				+        structure.
			
 
				+
			
 
				+        .. code-block:: python
			
 
				+
			
 
				+            with Context(cli) as ctx:
			
 
				+                info = ctx.to_info_dict()
			
 
				+
			
 
				+        .. versionadded:: 8.0
			
 
				+        """
			
 
				+        return {
			
 
				+            "command": self.command.to_info_dict(self),
			
 
				+            "info_name": self.info_name,
			
 
				+            "allow_extra_args": self.allow_extra_args,
			
 
				+            "allow_interspersed_args": self.allow_interspersed_args,
			
 
				+            "ignore_unknown_options": self.ignore_unknown_options,
			
 
				+            "auto_envvar_prefix": self.auto_envvar_prefix,
			
 
				+        }
			
 
				+
			
 
				+    def __enter__(self) -> "Context":
			
 
				+        self._depth += 1
			
 
				+        push_context(self)
			
 
				+        return self
			
 
				+
			
 
				+    def __exit__(
			
 
				+        self,
			
 
				+        exc_type: t.Optional[t.Type[BaseException]],
			
 
				+        exc_value: t.Optional[BaseException],
			
 
				+        tb: t.Optional[TracebackType],
			
 
				+    ) -> None:
			
 
				+        self._depth -= 1
			
 
				+        if self._depth == 0:
			
 
				+            self.close()
			
 
				+        pop_context()
			
 
				+
			
 
				+    @contextmanager
			
 
				+    def scope(self, cleanup: bool = True) -> t.Iterator["Context"]:
			
 
				+        """This helper method can be used with the context object to promote
			
 
				+        it to the current thread local (see :func:`get_current_context`).
			
 
				+        The default behavior of this is to invoke the cleanup functions which
			
 
				+        can be disabled by setting `cleanup` to `False`.  The cleanup
			
 
				+        functions are typically used for things such as closing file handles.
			
 
				+
			
 
				+        If the cleanup is intended the context object can also be directly
			
 
				+        used as a context manager.
			
 
				+
			
 
				+        Example usage::
			
 
				+
			
 
				+            with ctx.scope():
			
 
				+                assert get_current_context() is ctx
			
 
				+
			
 
				+        This is equivalent::
			
 
				+
			
 
				+            with ctx:
			
 
				+                assert get_current_context() is ctx
			
 
				+
			
 
				+        .. versionadded:: 5.0
			
 
				+
			
 
				+        :param cleanup: controls if the cleanup functions should be run or
			
 
				+                        not.  The default is to run these functions.  In
			
 
				+                        some situations the context only wants to be
			
 
				+                        temporarily pushed in which case this can be disabled.
			
 
				+                        Nested pushes automatically defer the cleanup.
			
 
				+        """
			
 
				+        if not cleanup:
			
 
				+            self._depth += 1
			
 
				+        try:
			
 
				+            with self as rv:
			
 
				+                yield rv
			
 
				+        finally:
			
 
				+            if not cleanup:
			
 
				+                self._depth -= 1
			
 
				+
			
 
				+    @property
			
 
				+    def meta(self) -> t.Dict[str, t.Any]:
			
 
				+        """This is a dictionary which is shared with all the contexts
			
 
				+        that are nested.  It exists so that click utilities can store some
			
 
				+        state here if they need to.  It is however the responsibility of
			
 
				+        that code to manage this dictionary well.
			
 
				+
			
 
				+        The keys are supposed to be unique dotted strings.  For instance
			
 
				+        module paths are a good choice for it.  What is stored in there is
			
 
				+        irrelevant for the operation of click.  However what is important is
			
 
				+        that code that places data here adheres to the general semantics of
			
 
				+        the system.
			
 
				+
			
 
				+        Example usage::
			
 
				+
			
 
				+            LANG_KEY = f'{__name__}.lang'
			
 
				+
			
 
				+            def set_language(value):
			
 
				+                ctx = get_current_context()
			
 
				+                ctx.meta[LANG_KEY] = value
			
 
				+
			
 
				+            def get_language():
			
 
				+                return get_current_context().meta.get(LANG_KEY, 'en_US')
			
 
				+
			
 
				+        .. versionadded:: 5.0
			
 
				+        """
			
 
				+        return self._meta
			
 
				+
			
 
				+    def make_formatter(self) -> HelpFormatter:
			
 
				+        """Creates the :class:`~click.HelpFormatter` for the help and
			
 
				+        usage output.
			
 
				+
			
 
				+        To quickly customize the formatter class used without overriding
			
 
				+        this method, set the :attr:`formatter_class` attribute.
			
 
				+
			
 
				+        .. versionchanged:: 8.0
			
 
				+            Added the :attr:`formatter_class` attribute.
			
 
				+        """
			
 
				+        return self.formatter_class(
			
 
				+            width=self.terminal_width, max_width=self.max_content_width
			
 
				+        )
			
 
				+
			
 
				+    def with_resource(self, context_manager: t.ContextManager[V]) -> V:
			
 
				+        """Register a resource as if it were used in a ``with``
			
 
				+        statement. The resource will be cleaned up when the context is
			
 
				+        popped.
			
 
				+
			
 
				+        Uses :meth:`contextlib.ExitStack.enter_context`. It calls the
			
 
				+        resource's ``__enter__()`` method and returns the result. When
			
 
				+        the context is popped, it closes the stack, which calls the
			
 
				+        resource's ``__exit__()`` method.
			
 
				+
			
 
				+        To register a cleanup function for something that isn't a
			
 
				+        context manager, use :meth:`call_on_close`. Or use something
			
 
				+        from :mod:`contextlib` to turn it into a context manager first.
			
 
				+
			
 
				+        .. code-block:: python
			
 
				+
			
 
				+            @click.group()
			
 
				+            @click.option("--name")
			
 
				+            @click.pass_context
			
 
				+            def cli(ctx):
			
 
				+                ctx.obj = ctx.with_resource(connect_db(name))
			
 
				+
			
 
				+        :param context_manager: The context manager to enter.
			
 
				+        :return: Whatever ``context_manager.__enter__()`` returns.
			
 
				+
			
 
				+        .. versionadded:: 8.0
			
 
				+        """
			
 
				+        return self._exit_stack.enter_context(context_manager)
			
 
				+
			
 
				+    def call_on_close(self, f: t.Callable[..., t.Any]) -> t.Callable[..., t.Any]:
			
 
				+        """Register a function to be called when the context tears down.
			
 
				+
			
 
				+        This can be used to close resources opened during the script
			
 
				+        execution. Resources that support Python's context manager
			
 
				+        protocol which would be used in a ``with`` statement should be
			
 
				+        registered with :meth:`with_resource` instead.
			
 
				+
			
 
				+        :param f: The function to execute on teardown.
			
 
				+        """
			
 
				+        return self._exit_stack.callback(f)
			
 
				+
			
 
				+    def close(self) -> None:
			
 
				+        """Invoke all close callbacks registered with
			
 
				+        :meth:`call_on_close`, and exit all context managers entered
			
 
				+        with :meth:`with_resource`.
			
 
				+        """
			
 
				+        self._exit_stack.close()
			
 
				+        # In case the context is reused, create a new exit stack.
			
 
				+        self._exit_stack = ExitStack()
			
 
				+
			
 
				+    @property
			
 
				+    def command_path(self) -> str:
			
 
				+        """The computed command path.  This is used for the ``usage``
			
 
				+        information on the help page.  It's automatically created by
			
 
				+        combining the info names of the chain of contexts to the root.
			
 
				+        """
			
 
				+        rv = ""
			
 
				+        if self.info_name is not None:
			
 
				+            rv = self.info_name
			
 
				+        if self.parent is not None:
			
 
				+            parent_command_path = [self.parent.command_path]
			
 
				+
			
 
				+            if isinstance(self.parent.command, Command):
			
 
				+                for param in self.parent.command.get_params(self):
			
 
				+                    parent_command_path.extend(param.get_usage_pieces(self))
			
 
				+
			
 
				+            rv = f"{' '.join(parent_command_path)} {rv}"
			
 
				+        return rv.lstrip()
			
 
				+
			
 
				+    def find_root(self) -> "Context":
			
 
				+        """Finds the outermost context."""
			
 
				+        node = self
			
 
				+        while node.parent is not None:
			
 
				+            node = node.parent
			
 
				+        return node
			
 
				+
			
 
				+    def find_object(self, object_type: t.Type[V]) -> t.Optional[V]:
			
 
				+        """Finds the closest object of a given type."""
			
 
				+        node: t.Optional["Context"] = self
			
 
				+
			
 
				+        while node is not None:
			
 
				+            if isinstance(node.obj, object_type):
			
 
				+                return node.obj
			
 
				+
			
 
				+            node = node.parent
			
 
				+
			
 
				+        return None
			
 
				+
			
 
				+    def ensure_object(self, object_type: t.Type[V]) -> V:
			
 
				+        """Like :meth:`find_object` but sets the innermost object to a
			
 
				+        new instance of `object_type` if it does not exist.
			
 
				+        """
			
 
				+        rv = self.find_object(object_type)
			
 
				+        if rv is None:
			
 
				+            self.obj = rv = object_type()
			
 
				+        return rv
			
 
				+
			
 
				+    @t.overload
			
 
				+    def lookup_default(
			
 
				+        self, name: str, call: "te.Literal[True]" = True
			
 
				+    ) -> t.Optional[t.Any]:
			
 
				+        ...
			
 
				+
			
 
				+    @t.overload
			
 
				+    def lookup_default(
			
 
				+        self, name: str, call: "te.Literal[False]" = ...
			
 
				+    ) -> t.Optional[t.Union[t.Any, t.Callable[[], t.Any]]]:
			
 
				+        ...
			
 
				+
			
 
				+    def lookup_default(self, name: str, call: bool = True) -> t.Optional[t.Any]:
			
 
				+        """Get the default for a parameter from :attr:`default_map`.
			
 
				+
			
 
				+        :param name: Name of the parameter.
			
 
				+        :param call: If the default is a callable, call it. Disable to
			
 
				+            return the callable instead.
			
 
				+
			
 
				+        .. versionchanged:: 8.0
			
 
				+            Added the ``call`` parameter.
			
 
				+        """
			
 
				+        if self.default_map is not None:
			
 
				+            value = self.default_map.get(name)
			
 
				+
			
 
				+            if call and callable(value):
			
 
				+                return value()
			
 
				+
			
 
				+            return value
			
 
				+
			
 
				+        return None
			
 
				+
			
 
				+    def fail(self, message: str) -> "te.NoReturn":
			
 
				+        """Aborts the execution of the program with a specific error
			
 
				+        message.
			
 
				+
			
 
				+        :param message: the error message to fail with.
			
 
				+        """
			
 
				+        raise UsageError(message, self)
			
 
				+
			
 
				+    def abort(self) -> "te.NoReturn":
			
 
				+        """Aborts the script."""
			
 
				+        raise Abort()
			
 
				+
			
 
				+    def exit(self, code: int = 0) -> "te.NoReturn":
			
 
				+        """Exits the application with a given exit code."""
			
 
				+        raise Exit(code)
			
 
				+
			
 
				+    def get_usage(self) -> str:
			
 
				+        """Helper method to get formatted usage string for the current
			
 
				+        context and command.
			
 
				+        """
			
 
				+        return self.command.get_usage(self)
			
 
				+
			
 
				+    def get_help(self) -> str:
			
 
				+        """Helper method to get formatted help page for the current
			
 
				+        context and command.
			
 
				+        """
			
 
				+        return self.command.get_help(self)
			
 
				+
			
 
				+    def _make_sub_context(self, command: "Command") -> "Context":
			
 
				+        """Create a new context of the same type as this context, but
			
 
				+        for a new command.
			
 
				+
			
 
				+        :meta private:
			
 
				+        """
			
 
				+        return type(self)(command, info_name=command.name, parent=self)
			
 
				+
			
 
				+    @t.overload
			
 
				+    def invoke(
			
 
				+        __self,  # noqa: B902
			
 
				+        __callback: "t.Callable[..., V]",
			
 
				+        *args: t.Any,
			
 
				+        **kwargs: t.Any,
			
 
				+    ) -> V:
			
 
				+        ...
			
 
				+
			
 
				+    @t.overload
			
 
				+    def invoke(
			
 
				+        __self,  # noqa: B902
			
 
				+        __callback: "Command",
			
 
				+        *args: t.Any,
			
 
				+        **kwargs: t.Any,
			
 
				+    ) -> t.Any:
			
 
				+        ...
			
 
				+
			
 
				+    def invoke(
			
 
				+        __self,  # noqa: B902
			
 
				+        __callback: t.Union["Command", "t.Callable[..., V]"],
			
 
				+        *args: t.Any,
			
 
				+        **kwargs: t.Any,
			
 
				+    ) -> t.Union[t.Any, V]:
			
 
				+        """Invokes a command callback in exactly the way it expects.  There
			
 
				+        are two ways to invoke this method:
			
 
				+
			
 
				+        1.  the first argument can be a callback and all other arguments and
			
 
				+            keyword arguments are forwarded directly to the function.
			
 
				+        2.  the first argument is a click command object.  In that case all
			
 
				+            arguments are forwarded as well but proper click parameters
			
 
				+            (options and click arguments) must be keyword arguments and Click
			
 
				+            will fill in defaults.
			
 
				+
			
 
				+        Note that before Click 3.2 keyword arguments were not properly filled
			
 
				+        in against the intention of this code and no context was created.  For
			
 
				+        more information about this change and why it was done in a bugfix
			
 
				+        release see :ref:`upgrade-to-3.2`.
			
 
				+
			
 
				+        .. versionchanged:: 8.0
			
 
				+            All ``kwargs`` are tracked in :attr:`params` so they will be
			
 
				+            passed if :meth:`forward` is called at multiple levels.
			
 
				+        """
			
 
				+        if isinstance(__callback, Command):
			
 
				+            other_cmd = __callback
			
 
				+
			
 
				+            if other_cmd.callback is None:
			
 
				+                raise TypeError(
			
 
				+                    "The given command does not have a callback that can be invoked."
			
 
				+                )
			
 
				+            else:
			
 
				+                __callback = t.cast("t.Callable[..., V]", other_cmd.callback)
			
 
				+
			
 
				+            ctx = __self._make_sub_context(other_cmd)
			
 
				+
			
 
				+            for param in other_cmd.params:
			
 
				+                if param.name not in kwargs and param.expose_value:
			
 
				+                    kwargs[param.name] = param.type_cast_value(  # type: ignore
			
 
				+                        ctx, param.get_default(ctx)
			
 
				+                    )
			
 
				+
			
 
				+            # Track all kwargs as params, so that forward() will pass
			
 
				+            # them on in subsequent calls.
			
 
				+            ctx.params.update(kwargs)
			
 
				+        else:
			
 
				+            ctx = __self
			
 
				+
			
 
				+        with augment_usage_errors(__self):
			
 
				+            with ctx:
			
 
				+                return __callback(*args, **kwargs)
			
 
				+
			
 
				+    def forward(
			
 
				+        __self, __cmd: "Command", *args: t.Any, **kwargs: t.Any  # noqa: B902
			
 
				+    ) -> t.Any:
			
 
				+        """Similar to :meth:`invoke` but fills in default keyword
			
 
				+        arguments from the current context if the other command expects
			
 
				+        it.  This cannot invoke callbacks directly, only other commands.
			
 
				+
			
 
				+        .. versionchanged:: 8.0
			
 
				+            All ``kwargs`` are tracked in :attr:`params` so they will be
			
 
				+            passed if ``forward`` is called at multiple levels.
			
 
				+        """
			
 
				+        # Can only forward to other commands, not direct callbacks.
			
 
				+        if not isinstance(__cmd, Command):
			
 
				+            raise TypeError("Callback is not a command.")
			
 
				+
			
 
				+        for param in __self.params:
			
 
				+            if param not in kwargs:
			
 
				+                kwargs[param] = __self.params[param]
			
 
				+
			
 
				+        return __self.invoke(__cmd, *args, **kwargs)
			
 
				+
			
 
				+    def set_parameter_source(self, name: str, source: ParameterSource) -> None:
			
 
				+        """Set the source of a parameter. This indicates the location
			
 
				+        from which the value of the parameter was obtained.
			
 
				+
			
 
				+        :param name: The name of the parameter.
			
 
				+        :param source: A member of :class:`~click.core.ParameterSource`.
			
 
				+        """
			
 
				+        self._parameter_source[name] = source
			
 
				+
			
 
				+    def get_parameter_source(self, name: str) -> t.Optional[ParameterSource]:
			
 
				+        """Get the source of a parameter. This indicates the location
			
 
				+        from which the value of the parameter was obtained.
			
 
				+
			
 
				+        This can be useful for determining when a user specified a value
			
 
				+        on the command line that is the same as the default value. It
			
 
				+        will be :attr:`~click.core.ParameterSource.DEFAULT` only if the
			
 
				+        value was actually taken from the default.
			
 
				+
			
 
				+        :param name: The name of the parameter.
			
 
				+        :rtype: ParameterSource
			
 
				+
			
 
				+        .. versionchanged:: 8.0
			
 
				+            Returns ``None`` if the parameter was not provided from any
			
 
				+            source.
			
 
				+        """
			
 
				+        return self._parameter_source.get(name)
			
 
				+
			
 
				+
			
 
				+class BaseCommand:
			
 
				+    """The base command implements the minimal API contract of commands.
			
 
				+    Most code will never use this as it does not implement a lot of useful
			
 
				+    functionality but it can act as the direct subclass of alternative
			
 
				+    parsing methods that do not depend on the Click parser.
			
 
				+
			
 
				+    For instance, this can be used to bridge Click and other systems like
			
 
				+    argparse or docopt.
			
 
				+
			
 
				+    Because base commands do not implement a lot of the API that other
			
 
				+    parts of Click take for granted, they are not supported for all
			
 
				+    operations.  For instance, they cannot be used with the decorators
			
 
				+    usually and they have no built-in callback system.
			
 
				+
			
 
				+    .. versionchanged:: 2.0
			
 
				+       Added the `context_settings` parameter.
			
 
				+
			
 
				+    :param name: the name of the command to use unless a group overrides it.
			
 
				+    :param context_settings: an optional dictionary with defaults that are
			
 
				+                             passed to the context object.
			
 
				+    """
			
 
				+
			
 
				+    #: The context class to create with :meth:`make_context`.
			
 
				+    #:
			
 
				+    #: .. versionadded:: 8.0
			
 
				+    context_class: t.Type[Context] = Context
			
 
				+    #: the default for the :attr:`Context.allow_extra_args` flag.
			
 
				+    allow_extra_args = False
			
 
				+    #: the default for the :attr:`Context.allow_interspersed_args` flag.
			
 
				+    allow_interspersed_args = True
			
 
				+    #: the default for the :attr:`Context.ignore_unknown_options` flag.
			
 
				+    ignore_unknown_options = False
			
 
				+
			
 
				+    def __init__(
			
 
				+        self,
			
 
				+        name: t.Optional[str],
			
 
				+        context_settings: t.Optional[t.MutableMapping[str, t.Any]] = None,
			
 
				+    ) -> None:
			
 
				+        #: the name the command thinks it has.  Upon registering a command
			
 
				+        #: on a :class:`Group` the group will default the command name
			
 
				+        #: with this information.  You should instead use the
			
 
				+        #: :class:`Context`\'s :attr:`~Context.info_name` attribute.
			
 
				+        self.name = name
			
 
				+
			
 
				+        if context_settings is None:
			
 
				+            context_settings = {}
			
 
				+
			
 
				+        #: an optional dictionary with defaults passed to the context.
			
 
				+        self.context_settings: t.MutableMapping[str, t.Any] = context_settings
			
 
				+
			
 
				+    def to_info_dict(self, ctx: Context) -> t.Dict[str, t.Any]:
			
 
				+        """Gather information that could be useful for a tool generating
			
 
				+        user-facing documentation. This traverses the entire structure
			
 
				+        below this command.
			
 
				+
			
 
				+        Use :meth:`click.Context.to_info_dict` to traverse the entire
			
 
				+        CLI structure.
			
 
				+
			
 
				+        :param ctx: A :class:`Context` representing this command.
			
 
				+
			
 
				+        .. versionadded:: 8.0
			
 
				+        """
			
 
				+        return {"name": self.name}
			
 
				+
			
 
				+    def __repr__(self) -> str:
			
 
				+        return f"<{self.__class__.__name__} {self.name}>"
			
 
				+
			
 
				+    def get_usage(self, ctx: Context) -> str:
			
 
				+        raise NotImplementedError("Base commands cannot get usage")
			
 
				+
			
 
				+    def get_help(self, ctx: Context) -> str:
			
 
				+        raise NotImplementedError("Base commands cannot get help")
			
 
				+
			
 
				+    def make_context(
			
 
				+        self,
			
 
				+        info_name: t.Optional[str],
			
 
				+        args: t.List[str],
			
 
				+        parent: t.Optional[Context] = None,
			
 
				+        **extra: t.Any,
			
 
				+    ) -> Context:
			
 
				+        """This function when given an info name and arguments will kick
			
 
				+        off the parsing and create a new :class:`Context`.  It does not
			
 
				+        invoke the actual command callback though.
			
 
				+
			
 
				+        To quickly customize the context class used without overriding
			
 
				+        this method, set the :attr:`context_class` attribute.
			
 
				+
			
 
				+        :param info_name: the info name for this invocation.  Generally this
			
 
				+                          is the most descriptive name for the script or
			
 
				+                          command.  For the toplevel script it's usually
			
 
				+                          the name of the script, for commands below it's
			
 
				+                          the name of the command.
			
 
				+        :param args: the arguments to parse as list of strings.
			
 
				+        :param parent: the parent context if available.
			
 
				+        :param extra: extra keyword arguments forwarded to the context
			
 
				+                      constructor.
			
 
				+
			
 
				+        .. versionchanged:: 8.0
			
 
				+            Added the :attr:`context_class` attribute.
			
 
				+        """
			
 
				+        for key, value in self.context_settings.items():
			
 
				+            if key not in extra:
			
 
				+                extra[key] = value
			
 
				+
			
 
				+        ctx = self.context_class(
			
 
				+            self, info_name=info_name, parent=parent, **extra  # type: ignore
			
 
				+        )
			
 
				+
			
 
				+        with ctx.scope(cleanup=False):
			
 
				+            self.parse_args(ctx, args)
			
 
				+        return ctx
			
 
				+
			
 
				+    def parse_args(self, ctx: Context, args: t.List[str]) -> t.List[str]:
			
 
				+        """Given a context and a list of arguments this creates the parser
			
 
				+        and parses the arguments, then modifies the context as necessary.
			
 
				+        This is automatically invoked by :meth:`make_context`.
			
 
				+        """
			
 
				+        raise NotImplementedError("Base commands do not know how to parse arguments.")
			
 
				+
			
 
				+    def invoke(self, ctx: Context) -> t.Any:
			
 
				+        """Given a context, this invokes the command.  The default
			
 
				+        implementation is raising a not implemented error.
			
 
				+        """
			
 
				+        raise NotImplementedError("Base commands are not invocable by default")
			
 
				+
			
 
				+    def shell_complete(self, ctx: Context, incomplete: str) -> t.List["CompletionItem"]:
			
 
				+        """Return a list of completions for the incomplete value. Looks
			
 
				+        at the names of chained multi-commands.
			
 
				+
			
 
				+        Any command could be part of a chained multi-command, so sibling
			
 
				+        commands are valid at any point during command completion. Other
			
 
				+        command classes will return more completions.
			
 
				+
			
 
				+        :param ctx: Invocation context for this command.
			
 
				+        :param incomplete: Value being completed. May be empty.
			
 
				+
			
 
				+        .. versionadded:: 8.0
			
 
				+        """
			
 
				+        from click.shell_completion import CompletionItem
			
 
				+
			
 
				+        results: t.List["CompletionItem"] = []
			
 
				+
			
 
				+        while ctx.parent is not None:
			
 
				+            ctx = ctx.parent
			
 
				+
			
 
				+            if isinstance(ctx.command, MultiCommand) and ctx.command.chain:
			
 
				+                results.extend(
			
 
				+                    CompletionItem(name, help=command.get_short_help_str())
			
 
				+                    for name, command in _complete_visible_commands(ctx, incomplete)
			
 
				+                    if name not in ctx.protected_args
			
 
				+                )
			
 
				+
			
 
				+        return results
			
 
				+
			
 
				+    @t.overload
			
 
				+    def main(
			
 
				+        self,
			
 
				+        args: t.Optional[t.Sequence[str]] = None,
			
 
				+        prog_name: t.Optional[str] = None,
			
 
				+        complete_var: t.Optional[str] = None,
			
 
				+        standalone_mode: "te.Literal[True]" = True,
			
 
				+        **extra: t.Any,
			
 
				+    ) -> "te.NoReturn":
			
 
				+        ...
			
 
				+
			
 
				+    @t.overload
			
 
				+    def main(
			
 
				+        self,
			
 
				+        args: t.Optional[t.Sequence[str]] = None,
			
 
				+        prog_name: t.Optional[str] = None,
			
 
				+        complete_var: t.Optional[str] = None,
			
 
				+        standalone_mode: bool = ...,
			
 
				+        **extra: t.Any,
			
 
				+    ) -> t.Any:
			
 
				+        ...
			
 
				+
			
 
				+    def main(
			
 
				+        self,
			
 
				+        args: t.Optional[t.Sequence[str]] = None,
			
 
				+        prog_name: t.Optional[str] = None,
			
 
				+        complete_var: t.Optional[str] = None,
			
 
				+        standalone_mode: bool = True,
			
 
				+        windows_expand_args: bool = True,
			
 
				+        **extra: t.Any,
			
 
				+    ) -> t.Any:
			
 
				+        """This is the way to invoke a script with all the bells and
			
 
				+        whistles as a command line application.  This will always terminate
			
 
				+        the application after a call.  If this is not wanted, ``SystemExit``
			
 
				+        needs to be caught.
			
 
				+
			
 
				+        This method is also available by directly calling the instance of
			
 
				+        a :class:`Command`.
			
 
				+
			
 
				+        :param args: the arguments that should be used for parsing.  If not
			
 
				+                     provided, ``sys.argv[1:]`` is used.
			
 
				+        :param prog_name: the program name that should be used.  By default
			
 
				+                          the program name is constructed by taking the file
			
 
				+                          name from ``sys.argv[0]``.
			
 
				+        :param complete_var: the environment variable that controls the
			
 
				+                             bash completion support.  The default is
			
 
				+                             ``"_<prog_name>_COMPLETE"`` with prog_name in
			
 
				+                             uppercase.
			
 
				+        :param standalone_mode: the default behavior is to invoke the script
			
 
				+                                in standalone mode.  Click will then
			
 
				+                                handle exceptions and convert them into
			
 
				+                                error messages and the function will never
			
 
				+                                return but shut down the interpreter.  If
			
 
				+                                this is set to `False` they will be
			
 
				+                                propagated to the caller and the return
			
 
				+                                value of this function is the return value
			
 
				+                                of :meth:`invoke`.
			
 
				+        :param windows_expand_args: Expand glob patterns, user dir, and
			
 
				+            env vars in command line args on Windows.
			
 
				+        :param extra: extra keyword arguments are forwarded to the context
			
 
				+                      constructor.  See :class:`Context` for more information.
			
 
				+
			
 
				+        .. versionchanged:: 8.0.1
			
 
				+            Added the ``windows_expand_args`` parameter to allow
			
 
				+            disabling command line arg expansion on Windows.
			
 
				+
			
 
				+        .. versionchanged:: 8.0
			
 
				+            When taking arguments from ``sys.argv`` on Windows, glob
			
 
				+            patterns, user dir, and env vars are expanded.
			
 
				+
			
 
				+        .. versionchanged:: 3.0
			
 
				+           Added the ``standalone_mode`` parameter.
			
 
				+        """
			
 
				+        if args is None:
			
 
				+            args = sys.argv[1:]
			
 
				+
			
 
				+            if os.name == "nt" and windows_expand_args:
			
 
				+                args = _expand_args(args)
			
 
				+        else:
			
 
				+            args = list(args)
			
 
				+
			
 
				+        if prog_name is None:
			
 
				+            prog_name = _detect_program_name()
			
 
				+
			
 
				+        # Process shell completion requests and exit early.
			
 
				+        self._main_shell_completion(extra, prog_name, complete_var)
			
 
				+
			
 
				+        try:
			
 
				+            try:
			
 
				+                with self.make_context(prog_name, args, **extra) as ctx:
			
 
				+                    rv = self.invoke(ctx)
			
 
				+                    if not standalone_mode:
			
 
				+                        return rv
			
 
				+                    # it's not safe to `ctx.exit(rv)` here!
			
 
				+                    # note that `rv` may actually contain data like "1" which
			
 
				+                    # has obvious effects
			
 
				+                    # more subtle case: `rv=[None, None]` can come out of
			
 
				+                    # chained commands which all returned `None` -- so it's not
			
 
				+                    # even always obvious that `rv` indicates success/failure
			
 
				+                    # by its truthiness/falsiness
			
 
				+                    ctx.exit()
			
 
				+            except (EOFError, KeyboardInterrupt) as e:
			
 
				+                echo(file=sys.stderr)
			
 
				+                raise Abort() from e
			
 
				+            except ClickException as e:
			
 
				+                if not standalone_mode:
			
 
				+                    raise
			
 
				+                e.show()
			
 
				+                sys.exit(e.exit_code)
			
 
				+            except OSError as e:
			
 
				+                if e.errno == errno.EPIPE:
			
 
				+                    sys.stdout = t.cast(t.TextIO, PacifyFlushWrapper(sys.stdout))
			
 
				+                    sys.stderr = t.cast(t.TextIO, PacifyFlushWrapper(sys.stderr))
			
 
				+                    sys.exit(1)
			
 
				+                else:
			
 
				+                    raise
			
 
				+        except Exit as e:
			
 
				+            if standalone_mode:
			
 
				+                sys.exit(e.exit_code)
			
 
				+            else:
			
 
				+                # in non-standalone mode, return the exit code
			
 
				+                # note that this is only reached if `self.invoke` above raises
			
 
				+                # an Exit explicitly -- thus bypassing the check there which
			
 
				+                # would return its result
			
 
				+                # the results of non-standalone execution may therefore be
			
 
				+                # somewhat ambiguous: if there are codepaths which lead to
			
 
				+                # `ctx.exit(1)` and to `return 1`, the caller won't be able to
			
 
				+                # tell the difference between the two
			
 
				+                return e.exit_code
			
 
				+        except Abort:
			
 
				+            if not standalone_mode:
			
 
				+                raise
			
 
				+            echo(_("Aborted!"), file=sys.stderr)
			
 
				+            sys.exit(1)
			
 
				+
			
 
				+    def _main_shell_completion(
			
 
				+        self,
			
 
				+        ctx_args: t.MutableMapping[str, t.Any],
			
 
				+        prog_name: str,
			
 
				+        complete_var: t.Optional[str] = None,
			
 
				+    ) -> None:
			
 
				+        """Check if the shell is asking for tab completion, process
			
 
				+        that, then exit early. Called from :meth:`main` before the
			
 
				+        program is invoked.
			
 
				+
			
 
				+        :param prog_name: Name of the executable in the shell.
			
 
				+        :param complete_var: Name of the environment variable that holds
			
 
				+            the completion instruction. Defaults to
			
 
				+            ``_{PROG_NAME}_COMPLETE``.
			
 
				+
			
 
				+        .. versionchanged:: 8.2.0
			
 
				+            Dots (``.``) in ``prog_name`` are replaced with underscores (``_``).
			
 
				+        """
			
 
				+        if complete_var is None:
			
 
				+            complete_name = prog_name.replace("-", "_").replace(".", "_")
			
 
				+            complete_var = f"_{complete_name}_COMPLETE".upper()
			
 
				+
			
 
				+        instruction = os.environ.get(complete_var)
			
 
				+
			
 
				+        if not instruction:
			
 
				+            return
			
 
				+
			
 
				+        from .shell_completion import shell_complete
			
 
				+
			
 
				+        rv = shell_complete(self, ctx_args, prog_name, complete_var, instruction)
			
 
				+        sys.exit(rv)
			
 
				+
			
 
				+    def __call__(self, *args: t.Any, **kwargs: t.Any) -> t.Any:
			
 
				+        """Alias for :meth:`main`."""
			
 
				+        return self.main(*args, **kwargs)
			
 
				+
			
 
				+
			
 
				+class Command(BaseCommand):
			
 
				+    """Commands are the basic building block of command line interfaces in
			
 
				+    Click.  A basic command handles command line parsing and might dispatch
			
 
				+    more parsing to commands nested below it.
			
 
				+
			
 
				+    :param name: the name of the command to use unless a group overrides it.
			
 
				+    :param context_settings: an optional dictionary with defaults that are
			
 
				+                             passed to the context object.
			
 
				+    :param callback: the callback to invoke.  This is optional.
			
 
				+    :param params: the parameters to register with this command.  This can
			
 
				+                   be either :class:`Option` or :class:`Argument` objects.
			
 
				+    :param help: the help string to use for this command.
			
 
				+    :param epilog: like the help string but it's printed at the end of the
			
 
				+                   help page after everything else.
			
 
				+    :param short_help: the short help to use for this command.  This is
			
 
				+                       shown on the command listing of the parent command.
			
 
				+    :param add_help_option: by default each command registers a ``--help``
			
 
				+                            option.  This can be disabled by this parameter.
			
 
				+    :param no_args_is_help: this controls what happens if no arguments are
			
 
				+                            provided.  This option is disabled by default.
			
 
				+                            If enabled this will add ``--help`` as argument
			
 
				+                            if no arguments are passed
			
 
				+    :param hidden: hide this command from help outputs.
			
 
				+
			
 
				+    :param deprecated: issues a message indicating that
			
 
				+                             the command is deprecated.
			
 
				+
			
 
				+    .. versionchanged:: 8.1
			
 
				+        ``help``, ``epilog``, and ``short_help`` are stored unprocessed,
			
 
				+        all formatting is done when outputting help text, not at init,
			
 
				+        and is done even if not using the ``@command`` decorator.
			
 
				+
			
 
				+    .. versionchanged:: 8.0
			
 
				+        Added a ``repr`` showing the command name.
			
 
				+
			
 
				+    .. versionchanged:: 7.1
			
 
				+        Added the ``no_args_is_help`` parameter.
			
 
				+
			
 
				+    .. versionchanged:: 2.0
			
 
				+        Added the ``context_settings`` parameter.
			
 
				+    """
			
 
				+
			
 
				+    def __init__(
			
 
				+        self,
			
 
				+        name: t.Optional[str],
			
 
				+        context_settings: t.Optional[t.MutableMapping[str, t.Any]] = None,
			
 
				+        callback: t.Optional[t.Callable[..., t.Any]] = None,
			
 
				+        params: t.Optional[t.List["Parameter"]] = None,
			
 
				+        help: t.Optional[str] = None,
			
 
				+        epilog: t.Optional[str] = None,
			
 
				+        short_help: t.Optional[str] = None,
			
 
				+        options_metavar: t.Optional[str] = "[OPTIONS]",
			
 
				+        add_help_option: bool = True,
			
 
				+        no_args_is_help: bool = False,
			
 
				+        hidden: bool = False,
			
 
				+        deprecated: bool = False,
			
 
				+    ) -> None:
			
 
				+        super().__init__(name, context_settings)
			
 
				+        #: the callback to execute when the command fires.  This might be
			
 
				+        #: `None` in which case nothing happens.
			
 
				+        self.callback = callback
			
 
				+        #: the list of parameters for this command in the order they
			
 
				+        #: should show up in the help page and execute.  Eager parameters
			
 
				+        #: will automatically be handled before non eager ones.
			
 
				+        self.params: t.List["Parameter"] = params or []
			
 
				+        self.help = help
			
 
				+        self.epilog = epilog
			
 
				+        self.options_metavar = options_metavar
			
 
				+        self.short_help = short_help
			
 
				+        self.add_help_option = add_help_option
			
 
				+        self.no_args_is_help = no_args_is_help
			
 
				+        self.hidden = hidden
			
 
				+        self.deprecated = deprecated
			
 
				+
			
 
				+    def to_info_dict(self, ctx: Context) -> t.Dict[str, t.Any]:
			
 
				+        info_dict = super().to_info_dict(ctx)
			
 
				+        info_dict.update(
			
 
				+            params=[param.to_info_dict() for param in self.get_params(ctx)],
			
 
				+            help=self.help,
			
 
				+            epilog=self.epilog,
			
 
				+            short_help=self.short_help,
			
 
				+            hidden=self.hidden,
			
 
				+            deprecated=self.deprecated,
			
 
				+        )
			
 
				+        return info_dict
			
 
				+
			
 
				+    def get_usage(self, ctx: Context) -> str:
			
 
				+        """Formats the usage line into a string and returns it.
			
 
				+
			
 
				+        Calls :meth:`format_usage` internally.
			
 
				+        """
			
 
				+        formatter = ctx.make_formatter()
			
 
				+        self.format_usage(ctx, formatter)
			
 
				+        return formatter.getvalue().rstrip("\n")
			
 
				+
			
 
				+    def get_params(self, ctx: Context) -> t.List["Parameter"]:
			
 
				+        rv = self.params
			
 
				+        help_option = self.get_help_option(ctx)
			
 
				+
			
 
				+        if help_option is not None:
			
 
				+            rv = [*rv, help_option]
			
 
				+
			
 
				+        return rv
			
 
				+
			
 
				+    def format_usage(self, ctx: Context, formatter: HelpFormatter) -> None:
			
 
				+        """Writes the usage line into the formatter.
			
 
				+
			
 
				+        This is a low-level method called by :meth:`get_usage`.
			
 
				+        """
			
 
				+        pieces = self.collect_usage_pieces(ctx)
			
 
				+        formatter.write_usage(ctx.command_path, " ".join(pieces))
			
 
				+
			
 
				+    def collect_usage_pieces(self, ctx: Context) -> t.List[str]:
			
 
				+        """Returns all the pieces that go into the usage line and returns
			
 
				+        it as a list of strings.
			
 
				+        """
			
 
				+        rv = [self.options_metavar] if self.options_metavar else []
			
 
				+
			
 
				+        for param in self.get_params(ctx):
			
 
				+            rv.extend(param.get_usage_pieces(ctx))
			
 
				+
			
 
				+        return rv
			
 
				+
			
 
				+    def get_help_option_names(self, ctx: Context) -> t.List[str]:
			
 
				+        """Returns the names for the help option."""
			
 
				+        all_names = set(ctx.help_option_names)
			
 
				+        for param in self.params:
			
 
				+            all_names.difference_update(param.opts)
			
 
				+            all_names.difference_update(param.secondary_opts)
			
 
				+        return list(all_names)
			
 
				+
			
 
				+    def get_help_option(self, ctx: Context) -> t.Optional["Option"]:
			
 
				+        """Returns the help option object."""
			
 
				+        help_options = self.get_help_option_names(ctx)
			
 
				+
			
 
				+        if not help_options or not self.add_help_option:
			
 
				+            return None
			
 
				+
			
 
				+        def show_help(ctx: Context, param: "Parameter", value: str) -> None:
			
 
				+            if value and not ctx.resilient_parsing:
			
 
				+                echo(ctx.get_help(), color=ctx.color)
			
 
				+                ctx.exit()
			
 
				+
			
 
				+        return Option(
			
 
				+            help_options,
			
 
				+            is_flag=True,
			
 
				+            is_eager=True,
			
 
				+            expose_value=False,
			
 
				+            callback=show_help,
			
 
				+            help=_("Show this message and exit."),
			
 
				+        )
			
 
				+
			
 
				+    def make_parser(self, ctx: Context) -> OptionParser:
			
 
				+        """Creates the underlying option parser for this command."""
			
 
				+        parser = OptionParser(ctx)
			
 
				+        for param in self.get_params(ctx):
			
 
				+            param.add_to_parser(parser, ctx)
			
 
				+        return parser
			
 
				+
			
 
				+    def get_help(self, ctx: Context) -> str:
			
 
				+        """Formats the help into a string and returns it.
			
 
				+
			
 
				+        Calls :meth:`format_help` internally.
			
 
				+        """
			
 
				+        formatter = ctx.make_formatter()
			
 
				+        self.format_help(ctx, formatter)
			
 
				+        return formatter.getvalue().rstrip("\n")
			
 
				+
			
 
				+    def get_short_help_str(self, limit: int = 45) -> str:
			
 
				+        """Gets short help for the command or makes it by shortening the
			
 
				+        long help string.
			
 
				+        """
			
 
				+        if self.short_help:
			
 
				+            text = inspect.cleandoc(self.short_help)
			
 
				+        elif self.help:
			
 
				+            text = make_default_short_help(self.help, limit)
			
 
				+        else:
			
 
				+            text = ""
			
 
				+
			
 
				+        if self.deprecated:
			
 
				+            text = _("(Deprecated) {text}").format(text=text)
			
 
				+
			
 
				+        return text.strip()
			
 
				+
			
 
				+    def format_help(self, ctx: Context, formatter: HelpFormatter) -> None:
			
 
				+        """Writes the help into the formatter if it exists.
			
 
				+
			
 
				+        This is a low-level method called by :meth:`get_help`.
			
 
				+
			
 
				+        This calls the following methods:
			
 
				+
			
 
				+        -   :meth:`format_usage`
			
 
				+        -   :meth:`format_help_text`
			
 
				+        -   :meth:`format_options`
			
 
				+        -   :meth:`format_epilog`
			
 
				+        """
			
 
				+        self.format_usage(ctx, formatter)
			
 
				+        self.format_help_text(ctx, formatter)
			
 
				+        self.format_options(ctx, formatter)
			
 
				+        self.format_epilog(ctx, formatter)
			
 
				+
			
 
				+    def format_help_text(self, ctx: Context, formatter: HelpFormatter) -> None:
			
 
				+        """Writes the help text to the formatter if it exists."""
			
 
				+        if self.help is not None:
			
 
				+            # truncate the help text to the first form feed
			
 
				+            text = inspect.cleandoc(self.help).partition("\f")[0]
			
 
				+        else:
			
 
				+            text = ""
			
 
				+
			
 
				+        if self.deprecated:
			
 
				+            text = _("(Deprecated) {text}").format(text=text)
			
 
				+
			
 
				+        if text:
			
 
				+            formatter.write_paragraph()
			
 
				+
			
 
				+            with formatter.indentation():
			
 
				+                formatter.write_text(text)
			
 
				+
			
 
				+    def format_options(self, ctx: Context, formatter: HelpFormatter) -> None:
			
 
				+        """Writes all the options into the formatter if they exist."""
			
 
				+        opts = []
			
 
				+        for param in self.get_params(ctx):
			
 
				+            rv = param.get_help_record(ctx)
			
 
				+            if rv is not None:
			
 
				+                opts.append(rv)
			
 
				+
			
 
				+        if opts:
			
 
				+            with formatter.section(_("Options")):
			
 
				+                formatter.write_dl(opts)
			
 
				+
			
 
				+    def format_epilog(self, ctx: Context, formatter: HelpFormatter) -> None:
			
 
				+        """Writes the epilog into the formatter if it exists."""
			
 
				+        if self.epilog:
			
 
				+            epilog = inspect.cleandoc(self.epilog)
			
 
				+            formatter.write_paragraph()
			
 
				+
			
 
				+            with formatter.indentation():
			
 
				+                formatter.write_text(epilog)
			
 
				+
			
 
				+    def parse_args(self, ctx: Context, args: t.List[str]) -> t.List[str]:
			
 
				+        if not args and self.no_args_is_help and not ctx.resilient_parsing:
			
 
				+            echo(ctx.get_help(), color=ctx.color)
			
 
				+            ctx.exit()
			
 
				+
			
 
				+        parser = self.make_parser(ctx)
			
 
				+        opts, args, param_order = parser.parse_args(args=args)
			
 
				+
			
 
				+        for param in iter_params_for_processing(param_order, self.get_params(ctx)):
			
 
				+            value, args = param.handle_parse_result(ctx, opts, args)
			
 
				+
			
 
				+        if args and not ctx.allow_extra_args and not ctx.resilient_parsing:
			
 
				+            ctx.fail(
			
 
				+                ngettext(
			
 
				+                    "Got unexpected extra argument ({args})",
			
 
				+                    "Got unexpected extra arguments ({args})",
			
 
				+                    len(args),
			
 
				+                ).format(args=" ".join(map(str, args)))
			
 
				+            )
			
 
				+
			
 
				+        ctx.args = args
			
 
				+        ctx._opt_prefixes.update(parser._opt_prefixes)
			
 
				+        return args
			
 
				+
			
 
				+    def invoke(self, ctx: Context) -> t.Any:
			
 
				+        """Given a context, this invokes the attached callback (if it exists)
			
 
				+        in the right way.
			
 
				+        """
			
 
				+        if self.deprecated:
			
 
				+            message = _(
			
 
				+                "DeprecationWarning: The command {name!r} is deprecated."
			
 
				+            ).format(name=self.name)
			
 
				+            echo(style(message, fg="red"), err=True)
			
 
				+
			
 
				+        if self.callback is not None:
			
 
				+            return ctx.invoke(self.callback, **ctx.params)
			
 
				+
			
 
				+    def shell_complete(self, ctx: Context, incomplete: str) -> t.List["CompletionItem"]:
			
 
				+        """Return a list of completions for the incomplete value. Looks
			
 
				+        at the names of options and chained multi-commands.
			
 
				+
			
 
				+        :param ctx: Invocation context for this command.
			
 
				+        :param incomplete: Value being completed. May be empty.
			
 
				+
			
 
				+        .. versionadded:: 8.0
			
 
				+        """
			
 
				+        from click.shell_completion import CompletionItem
			
 
				+
			
 
				+        results: t.List["CompletionItem"] = []
			
 
				+
			
 
				+        if incomplete and not incomplete[0].isalnum():
			
 
				+            for param in self.get_params(ctx):
			
 
				+                if (
			
 
				+                    not isinstance(param, Option)
			
 
				+                    or param.hidden
			
 
				+                    or (
			
 
				+                        not param.multiple
			
 
				+                        and ctx.get_parameter_source(param.name)  # type: ignore
			
 
				+                        is ParameterSource.COMMANDLINE
			
 
				+                    )
			
 
				+                ):
			
 
				+                    continue
			
 
				+
			
 
				+                results.extend(
			
 
				+                    CompletionItem(name, help=param.help)
			
 
				+                    for name in [*param.opts, *param.secondary_opts]
			
 
				+                    if name.startswith(incomplete)
			
 
				+                )
			
 
				+
			
 
				+        results.extend(super().shell_complete(ctx, incomplete))
			
 
				+        return results
			
 
				+
			
 
				+
			
 
				+class MultiCommand(Command):
			
 
				+    """A multi command is the basic implementation of a command that
			
 
				+    dispatches to subcommands.  The most common version is the
			
 
				+    :class:`Group`.
			
 
				+
			
 
				+    :param invoke_without_command: this controls how the multi command itself
			
 
				+                                   is invoked.  By default it's only invoked
			
 
				+                                   if a subcommand is provided.
			
 
				+    :param no_args_is_help: this controls what happens if no arguments are
			
 
				+                            provided.  This option is enabled by default if
			
 
				+                            `invoke_without_command` is disabled or disabled
			
 
				+                            if it's enabled.  If enabled this will add
			
 
				+                            ``--help`` as argument if no arguments are
			
 
				+                            passed.
			
 
				+    :param subcommand_metavar: the string that is used in the documentation
			
 
				+                               to indicate the subcommand place.
			
 
				+    :param chain: if this is set to `True` chaining of multiple subcommands
			
 
				+                  is enabled.  This restricts the form of commands in that
			
 
				+                  they cannot have optional arguments but it allows
			
 
				+                  multiple commands to be chained together.
			
 
				+    :param result_callback: The result callback to attach to this multi
			
 
				+        command. This can be set or changed later with the
			
 
				+        :meth:`result_callback` decorator.
			
 
				+    :param attrs: Other command arguments described in :class:`Command`.
			
 
				+    """
			
 
				+
			
 
				+    allow_extra_args = True
			
 
				+    allow_interspersed_args = False
			
 
				+
			
 
				+    def __init__(
			
 
				+        self,
			
 
				+        name: t.Optional[str] = None,
			
 
				+        invoke_without_command: bool = False,
			
 
				+        no_args_is_help: t.Optional[bool] = None,
			
 
				+        subcommand_metavar: t.Optional[str] = None,
			
 
				+        chain: bool = False,
			
 
				+        result_callback: t.Optional[t.Callable[..., t.Any]] = None,
			
 
				+        **attrs: t.Any,
			
 
				+    ) -> None:
			
 
				+        super().__init__(name, **attrs)
			
 
				+
			
 
				+        if no_args_is_help is None:
			
 
				+            no_args_is_help = not invoke_without_command
			
 
				+
			
 
				+        self.no_args_is_help = no_args_is_help
			
 
				+        self.invoke_without_command = invoke_without_command
			
 
				+
			
 
				+        if subcommand_metavar is None:
			
 
				+            if chain:
			
 
				+                subcommand_metavar = "COMMAND1 [ARGS]... [COMMAND2 [ARGS]...]..."
			
 
				+            else:
			
 
				+                subcommand_metavar = "COMMAND [ARGS]..."
			
 
				+
			
 
				+        self.subcommand_metavar = subcommand_metavar
			
 
				+        self.chain = chain
			
 
				+        # The result callback that is stored. This can be set or
			
 
				+        # overridden with the :func:`result_callback` decorator.
			
 
				+        self._result_callback = result_callback
			
 
				+
			
 
				+        if self.chain:
			
 
				+            for param in self.params:
			
 
				+                if isinstance(param, Argument) and not param.required:
			
 
				+                    raise RuntimeError(
			
 
				+                        "Multi commands in chain mode cannot have"
			
 
				+                        " optional arguments."
			
 
				+                    )
			
 
				+
			
 
				+    def to_info_dict(self, ctx: Context) -> t.Dict[str, t.Any]:
			
 
				+        info_dict = super().to_info_dict(ctx)
			
 
				+        commands = {}
			
 
				+
			
 
				+        for name in self.list_commands(ctx):
			
 
				+            command = self.get_command(ctx, name)
			
 
				+
			
 
				+            if command is None:
			
 
				+                continue
			
 
				+
			
 
				+            sub_ctx = ctx._make_sub_context(command)
			
 
				+
			
 
				+            with sub_ctx.scope(cleanup=False):
			
 
				+                commands[name] = command.to_info_dict(sub_ctx)
			
 
				+
			
 
				+        info_dict.update(commands=commands, chain=self.chain)
			
 
				+        return info_dict
			
 
				+
			
 
				+    def collect_usage_pieces(self, ctx: Context) -> t.List[str]:
			
 
				+        rv = super().collect_usage_pieces(ctx)
			
 
				+        rv.append(self.subcommand_metavar)
			
 
				+        return rv
			
 
				+
			
 
				+    def format_options(self, ctx: Context, formatter: HelpFormatter) -> None:
			
 
				+        super().format_options(ctx, formatter)
			
 
				+        self.format_commands(ctx, formatter)
			
 
				+
			
 
				+    def result_callback(self, replace: bool = False) -> t.Callable[[F], F]:
			
 
				+        """Adds a result callback to the command.  By default if a
			
 
				+        result callback is already registered this will chain them but
			
 
				+        this can be disabled with the `replace` parameter.  The result
			
 
				+        callback is invoked with the return value of the subcommand
			
 
				+        (or the list of return values from all subcommands if chaining
			
 
				+        is enabled) as well as the parameters as they would be passed
			
 
				+        to the main callback.
			
 
				+
			
 
				+        Example::
			
 
				+
			
 
				+            @click.group()
			
 
				+            @click.option('-i', '--input', default=23)
			
 
				+            def cli(input):
			
 
				+                return 42
			
 
				+
			
 
				+            @cli.result_callback()
			
 
				+            def process_result(result, input):
			
 
				+                return result + input
			
 
				+
			
 
				+        :param replace: if set to `True` an already existing result
			
 
				+                        callback will be removed.
			
 
				+
			
 
				+        .. versionchanged:: 8.0
			
 
				+            Renamed from ``resultcallback``.
			
 
				+
			
 
				+        .. versionadded:: 3.0
			
 
				+        """
			
 
				+
			
 
				+        def decorator(f: F) -> F:
			
 
				+            old_callback = self._result_callback
			
 
				+
			
 
				+            if old_callback is None or replace:
			
 
				+                self._result_callback = f
			
 
				+                return f
			
 
				+
			
 
				+            def function(__value, *args, **kwargs):  # type: ignore
			
 
				+                inner = old_callback(__value, *args, **kwargs)
			
 
				+                return f(inner, *args, **kwargs)
			
 
				+
			
 
				+            self._result_callback = rv = update_wrapper(t.cast(F, function), f)
			
 
				+            return rv
			
 
				+
			
 
				+        return decorator
			
 
				+
			
 
				+    def format_commands(self, ctx: Context, formatter: HelpFormatter) -> None:
			
 
				+        """Extra format methods for multi methods that adds all the commands
			
 
				+        after the options.
			
 
				+        """
			
 
				+        commands = []
			
 
				+        for subcommand in self.list_commands(ctx):
			
 
				+            cmd = self.get_command(ctx, subcommand)
			
 
				+            # What is this, the tool lied about a command.  Ignore it
			
 
				+            if cmd is None:
			
 
				+                continue
			
 
				+            if cmd.hidden:
			
 
				+                continue
			
 
				+
			
 
				+            commands.append((subcommand, cmd))
			
 
				+
			
 
				+        # allow for 3 times the default spacing
			
 
				+        if len(commands):
			
 
				+            limit = formatter.width - 6 - max(len(cmd[0]) for cmd in commands)
			
 
				+
			
 
				+            rows = []
			
 
				+            for subcommand, cmd in commands:
			
 
				+                help = cmd.get_short_help_str(limit)
			
 
				+                rows.append((subcommand, help))
			
 
				+
			
 
				+            if rows:
			
 
				+                with formatter.section(_("Commands")):
			
 
				+                    formatter.write_dl(rows)
			
 
				+
			
 
				+    def parse_args(self, ctx: Context, args: t.List[str]) -> t.List[str]:
			
 
				+        if not args and self.no_args_is_help and not ctx.resilient_parsing:
			
 
				+            echo(ctx.get_help(), color=ctx.color)
			
 
				+            ctx.exit()
			
 
				+
			
 
				+        rest = super().parse_args(ctx, args)
			
 
				+
			
 
				+        if self.chain:
			
 
				+            ctx.protected_args = rest
			
 
				+            ctx.args = []
			
 
				+        elif rest:
			
 
				+            ctx.protected_args, ctx.args = rest[:1], rest[1:]
			
 
				+
			
 
				+        return ctx.args
			
 
				+
			
 
				+    def invoke(self, ctx: Context) -> t.Any:
			
 
				+        def _process_result(value: t.Any) -> t.Any:
			
 
				+            if self._result_callback is not None:
			
 
				+                value = ctx.invoke(self._result_callback, value, **ctx.params)
			
 
				+            return value
			
 
				+
			
 
				+        if not ctx.protected_args:
			
 
				+            if self.invoke_without_command:
			
 
				+                # No subcommand was invoked, so the result callback is
			
 
				+                # invoked with the group return value for regular
			
 
				+                # groups, or an empty list for chained groups.
			
 
				+                with ctx:
			
 
				+                    rv = super().invoke(ctx)
			
 
				+                    return _process_result([] if self.chain else rv)
			
 
				+            ctx.fail(_("Missing command."))
			
 
				+
			
 
				+        # Fetch args back out
			
 
				+        args = [*ctx.protected_args, *ctx.args]
			
 
				+        ctx.args = []
			
 
				+        ctx.protected_args = []
			
 
				+
			
 
				+        # If we're not in chain mode, we only allow the invocation of a
			
 
				+        # single command but we also inform the current context about the
			
 
				+        # name of the command to invoke.
			
 
				+        if not self.chain:
			
 
				+            # Make sure the context is entered so we do not clean up
			
 
				+            # resources until the result processor has worked.
			
 
				+            with ctx:
			
 
				+                cmd_name, cmd, args = self.resolve_command(ctx, args)
			
 
				+                assert cmd is not None
			
 
				+                ctx.invoked_subcommand = cmd_name
			
 
				+                super().invoke(ctx)
			
 
				+                sub_ctx = cmd.make_context(cmd_name, args, parent=ctx)
			
 
				+                with sub_ctx:
			
 
				+                    return _process_result(sub_ctx.command.invoke(sub_ctx))
			
 
				+
			
 
				+        # In chain mode we create the contexts step by step, but after the
			
 
				+        # base command has been invoked.  Because at that point we do not
			
 
				+        # know the subcommands yet, the invoked subcommand attribute is
			
 
				+        # set to ``*`` to inform the command that subcommands are executed
			
 
				+        # but nothing else.
			
 
				+        with ctx:
			
 
				+            ctx.invoked_subcommand = "*" if args else None
			
 
				+            super().invoke(ctx)
			
 
				+
			
 
				+            # Otherwise we make every single context and invoke them in a
			
 
				+            # chain.  In that case the return value to the result processor
			
 
				+            # is the list of all invoked subcommand's results.
			
 
				+            contexts = []
			
 
				+            while args:
			
 
				+                cmd_name, cmd, args = self.resolve_command(ctx, args)
			
 
				+                assert cmd is not None
			
 
				+                sub_ctx = cmd.make_context(
			
 
				+                    cmd_name,
			
 
				+                    args,
			
 
				+                    parent=ctx,
			
 
				+                    allow_extra_args=True,
			
 
				+                    allow_interspersed_args=False,
			
 
				+                )
			
 
				+                contexts.append(sub_ctx)
			
 
				+                args, sub_ctx.args = sub_ctx.args, []
			
 
				+
			
 
				+            rv = []
			
 
				+            for sub_ctx in contexts:
			
 
				+                with sub_ctx:
			
 
				+                    rv.append(sub_ctx.command.invoke(sub_ctx))
			
 
				+            return _process_result(rv)
			
 
				+
			
 
				+    def resolve_command(
			
 
				+        self, ctx: Context, args: t.List[str]
			
 
				+    ) -> t.Tuple[t.Optional[str], t.Optional[Command], t.List[str]]:
			
 
				+        cmd_name = make_str(args[0])
			
 
				+        original_cmd_name = cmd_name
			
 
				+
			
 
				+        # Get the command
			
 
				+        cmd = self.get_command(ctx, cmd_name)
			
 
				+
			
 
				+        # If we can't find the command but there is a normalization
			
 
				+        # function available, we try with that one.
			
 
				+        if cmd is None and ctx.token_normalize_func is not None:
			
 
				+            cmd_name = ctx.token_normalize_func(cmd_name)
			
 
				+            cmd = self.get_command(ctx, cmd_name)
			
 
				+
			
 
				+        # If we don't find the command we want to show an error message
			
 
				+        # to the user that it was not provided.  However, there is
			
 
				+        # something else we should do: if the first argument looks like
			
 
				+        # an option we want to kick off parsing again for arguments to
			
 
				+        # resolve things like --help which now should go to the main
			
 
				+        # place.
			
 
				+        if cmd is None and not ctx.resilient_parsing:
			
 
				+            if split_opt(cmd_name)[0]:
			
 
				+                self.parse_args(ctx, ctx.args)
			
 
				+            ctx.fail(_("No such command {name!r}.").format(name=original_cmd_name))
			
 
				+        return cmd_name if cmd else None, cmd, args[1:]
			
 
				+
			
 
				+    def get_command(self, ctx: Context, cmd_name: str) -> t.Optional[Command]:
			
 
				+        """Given a context and a command name, this returns a
			
 
				+        :class:`Command` object if it exists or returns `None`.
			
 
				+        """
			
 
				+        raise NotImplementedError
			
 
				+
			
 
				+    def list_commands(self, ctx: Context) -> t.List[str]:
			
 
				+        """Returns a list of subcommand names in the order they should
			
 
				+        appear.
			
 
				+        """
			
 
				+        return []
			
 
				+
			
 
				+    def shell_complete(self, ctx: Context, incomplete: str) -> t.List["CompletionItem"]:
			
 
				+        """Return a list of completions for the incomplete value. Looks
			
 
				+        at the names of options, subcommands, and chained
			
 
				+        multi-commands.
			
 
				+
			
 
				+        :param ctx: Invocation context for this command.
			
 
				+        :param incomplete: Value being completed. May be empty.
			
 
				+
			
 
				+        .. versionadded:: 8.0
			
 
				+        """
			
 
				+        from click.shell_completion import CompletionItem
			
 
				+
			
 
				+        results = [
			
 
				+            CompletionItem(name, help=command.get_short_help_str())
			
 
				+            for name, command in _complete_visible_commands(ctx, incomplete)
			
 
				+        ]
			
 
				+        results.extend(super().shell_complete(ctx, incomplete))
			
 
				+        return results
			
 
				+
			
 
				+
			
 
				+class Group(MultiCommand):
			
 
				+    """A group allows a command to have subcommands attached. This is
			
 
				+    the most common way to implement nesting in Click.
			
 
				+
			
 
				+    :param name: The name of the group command.
			
 
				+    :param commands: A dict mapping names to :class:`Command` objects.
			
 
				+        Can also be a list of :class:`Command`, which will use
			
 
				+        :attr:`Command.name` to create the dict.
			
 
				+    :param attrs: Other command arguments described in
			
 
				+        :class:`MultiCommand`, :class:`Command`, and
			
 
				+        :class:`BaseCommand`.
			
 
				+
			
 
				+    .. versionchanged:: 8.0
			
 
				+        The ``commands`` argument can be a list of command objects.
			
 
				+    """
			
 
				+
			
 
				+    #: If set, this is used by the group's :meth:`command` decorator
			
 
				+    #: as the default :class:`Command` class. This is useful to make all
			
 
				+    #: subcommands use a custom command class.
			
 
				+    #:
			
 
				+    #: .. versionadded:: 8.0
			
 
				+    command_class: t.Optional[t.Type[Command]] = None
			
 
				+
			
 
				+    #: If set, this is used by the group's :meth:`group` decorator
			
 
				+    #: as the default :class:`Group` class. This is useful to make all
			
 
				+    #: subgroups use a custom group class.
			
 
				+    #:
			
 
				+    #: If set to the special value :class:`type` (literally
			
 
				+    #: ``group_class = type``), this group's class will be used as the
			
 
				+    #: default class. This makes a custom group class continue to make
			
 
				+    #: custom groups.
			
 
				+    #:
			
 
				+    #: .. versionadded:: 8.0
			
 
				+    group_class: t.Optional[t.Union[t.Type["Group"], t.Type[type]]] = None
			
 
				+    # Literal[type] isn't valid, so use Type[type]
			
 
				+
			
 
				+    def __init__(
			
 
				+        self,
			
 
				+        name: t.Optional[str] = None,
			
 
				+        commands: t.Optional[
			
 
				+            t.Union[t.MutableMapping[str, Command], t.Sequence[Command]]
			
 
				+        ] = None,
			
 
				+        **attrs: t.Any,
			
 
				+    ) -> None:
			
 
				+        super().__init__(name, **attrs)
			
 
				+
			
 
				+        if commands is None:
			
 
				+            commands = {}
			
 
				+        elif isinstance(commands, abc.Sequence):
			
 
				+            commands = {c.name: c for c in commands if c.name is not None}
			
 
				+
			
 
				+        #: The registered subcommands by their exported names.
			
 
				+        self.commands: t.MutableMapping[str, Command] = commands
			
 
				+
			
 
				+    def add_command(self, cmd: Command, name: t.Optional[str] = None) -> None:
			
 
				+        """Registers another :class:`Command` with this group.  If the name
			
 
				+        is not provided, the name of the command is used.
			
 
				+        """
			
 
				+        name = name or cmd.name
			
 
				+        if name is None:
			
 
				+            raise TypeError("Command has no name.")
			
 
				+        _check_multicommand(self, name, cmd, register=True)
			
 
				+        self.commands[name] = cmd
			
 
				+
			
 
				+    @t.overload
			
 
				+    def command(self, __func: t.Callable[..., t.Any]) -> Command:
			
 
				+        ...
			
 
				+
			
 
				+    @t.overload
			
 
				+    def command(
			
 
				+        self, *args: t.Any, **kwargs: t.Any
			
 
				+    ) -> t.Callable[[t.Callable[..., t.Any]], Command]:
			
 
				+        ...
			
 
				+
			
 
				+    def command(
			
 
				+        self, *args: t.Any, **kwargs: t.Any
			
 
				+    ) -> t.Union[t.Callable[[t.Callable[..., t.Any]], Command], Command]:
			
 
				+        """A shortcut decorator for declaring and attaching a command to
			
 
				+        the group. This takes the same arguments as :func:`command` and
			
 
				+        immediately registers the created command with this group by
			
 
				+        calling :meth:`add_command`.
			
 
				+
			
 
				+        To customize the command class used, set the
			
 
				+        :attr:`command_class` attribute.
			
 
				+
			
 
				+        .. versionchanged:: 8.1
			
 
				+            This decorator can be applied without parentheses.
			
 
				+
			
 
				+        .. versionchanged:: 8.0
			
 
				+            Added the :attr:`command_class` attribute.
			
 
				+        """
			
 
				+        from .decorators import command
			
 
				+
			
 
				+        func: t.Optional[t.Callable[..., t.Any]] = None
			
 
				+
			
 
				+        if args and callable(args[0]):
			
 
				+            assert (
			
 
				+                len(args) == 1 and not kwargs
			
 
				+            ), "Use 'command(**kwargs)(callable)' to provide arguments."
			
 
				+            (func,) = args
			
 
				+            args = ()
			
 
				+
			
 
				+        if self.command_class and kwargs.get("cls") is None:
			
 
				+            kwargs["cls"] = self.command_class
			
 
				+
			
 
				+        def decorator(f: t.Callable[..., t.Any]) -> Command:
			
 
				+            cmd: Command = command(*args, **kwargs)(f)
			
 
				+            self.add_command(cmd)
			
 
				+            return cmd
			
 
				+
			
 
				+        if func is not None:
			
 
				+            return decorator(func)
			
 
				+
			
 
				+        return decorator
			
 
				+
			
 
				+    @t.overload
			
 
				+    def group(self, __func: t.Callable[..., t.Any]) -> "Group":
			
 
				+        ...
			
 
				+
			
 
				+    @t.overload
			
 
				+    def group(
			
 
				+        self, *args: t.Any, **kwargs: t.Any
			
 
				+    ) -> t.Callable[[t.Callable[..., t.Any]], "Group"]:
			
 
				+        ...
			
 
				+
			
 
				+    def group(
			
 
				+        self, *args: t.Any, **kwargs: t.Any
			
 
				+    ) -> t.Union[t.Callable[[t.Callable[..., t.Any]], "Group"], "Group"]:
			
 
				+        """A shortcut decorator for declaring and attaching a group to
			
 
				+        the group. This takes the same arguments as :func:`group` and
			
 
				+        immediately registers the created group with this group by
			
 
				+        calling :meth:`add_command`.
			
 
				+
			
 
				+        To customize the group class used, set the :attr:`group_class`
			
 
				+        attribute.
			
 
				+
			
 
				+        .. versionchanged:: 8.1
			
 
				+            This decorator can be applied without parentheses.
			
 
				+
			
 
				+        .. versionchanged:: 8.0
			
 
				+            Added the :attr:`group_class` attribute.
			
 
				+        """
			
 
				+        from .decorators import group
			
 
				+
			
 
				+        func: t.Optional[t.Callable[..., t.Any]] = None
			
 
				+
			
 
				+        if args and callable(args[0]):
			
 
				+            assert (
			
 
				+                len(args) == 1 and not kwargs
			
 
				+            ), "Use 'group(**kwargs)(callable)' to provide arguments."
			
 
				+            (func,) = args
			
 
				+            args = ()
			
 
				+
			
 
				+        if self.group_class is not None and kwargs.get("cls") is None:
			
 
				+            if self.group_class is type:
			
 
				+                kwargs["cls"] = type(self)
			
 
				+            else:
			
 
				+                kwargs["cls"] = self.group_class
			
 
				+
			
 
				+        def decorator(f: t.Callable[..., t.Any]) -> "Group":
			
 
				+            cmd: Group = group(*args, **kwargs)(f)
			
 
				+            self.add_command(cmd)
			
 
				+            return cmd
			
 
				+
			
 
				+        if func is not None:
			
 
				+            return decorator(func)
			
 
				+
			
 
				+        return decorator
			
 
				+
			
 
				+    def get_command(self, ctx: Context, cmd_name: str) -> t.Optional[Command]:
			
 
				+        return self.commands.get(cmd_name)
			
 
				+
			
 
				+    def list_commands(self, ctx: Context) -> t.List[str]:
			
 
				+        return sorted(self.commands)
			
 
				+
			
 
				+
			
 
				+class CommandCollection(MultiCommand):
			
 
				+    """A command collection is a multi command that merges multiple multi
			
 
				+    commands together into one.  This is a straightforward implementation
			
 
				+    that accepts a list of different multi commands as sources and
			
 
				+    provides all the commands for each of them.
			
 
				+
			
 
				+    See :class:`MultiCommand` and :class:`Command` for the description of
			
 
				+    ``name`` and ``attrs``.
			
 
				+    """
			
 
				+
			
 
				+    def __init__(
			
 
				+        self,
			
 
				+        name: t.Optional[str] = None,
			
 
				+        sources: t.Optional[t.List[MultiCommand]] = None,
			
 
				+        **attrs: t.Any,
			
 
				+    ) -> None:
			
 
				+        super().__init__(name, **attrs)
			
 
				+        #: The list of registered multi commands.
			
 
				+        self.sources: t.List[MultiCommand] = sources or []
			
 
				+
			
 
				+    def add_source(self, multi_cmd: MultiCommand) -> None:
			
 
				+        """Adds a new multi command to the chain dispatcher."""
			
 
				+        self.sources.append(multi_cmd)
			
 
				+
			
 
				+    def get_command(self, ctx: Context, cmd_name: str) -> t.Optional[Command]:
			
 
				+        for source in self.sources:
			
 
				+            rv = source.get_command(ctx, cmd_name)
			
 
				+
			
 
				+            if rv is not None:
			
 
				+                if self.chain:
			
 
				+                    _check_multicommand(self, cmd_name, rv)
			
 
				+
			
 
				+                return rv
			
 
				+
			
 
				+        return None
			
 
				+
			
 
				+    def list_commands(self, ctx: Context) -> t.List[str]:
			
 
				+        rv: t.Set[str] = set()
			
 
				+
			
 
				+        for source in self.sources:
			
 
				+            rv.update(source.list_commands(ctx))
			
 
				+
			
 
				+        return sorted(rv)
			
 
				+
			
 
				+
			
 
				+def _check_iter(value: t.Any) -> t.Iterator[t.Any]:
			
 
				+    """Check if the value is iterable but not a string. Raises a type
			
 
				+    error, or return an iterator over the value.
			
 
				+    """
			
 
				+    if isinstance(value, str):
			
 
				+        raise TypeError
			
 
				+
			
 
				+    return iter(value)
			
 
				+
			
 
				+
			
 
				+class Parameter:
			
 
				+    r"""A parameter to a command comes in two versions: they are either
			
 
				+    :class:`Option`\s or :class:`Argument`\s.  Other subclasses are currently
			
 
				+    not supported by design as some of the internals for parsing are
			
 
				+    intentionally not finalized.
			
 
				+
			
 
				+    Some settings are supported by both options and arguments.
			
 
				+
			
 
				+    :param param_decls: the parameter declarations for this option or
			
 
				+                        argument.  This is a list of flags or argument
			
 
				+                        names.
			
 
				+    :param type: the type that should be used.  Either a :class:`ParamType`
			
 
				+                 or a Python type.  The latter is converted into the former
			
 
				+                 automatically if supported.
			
 
				+    :param required: controls if this is optional or not.
			
 
				+    :param default: the default value if omitted.  This can also be a callable,
			
 
				+                    in which case it's invoked when the default is needed
			
 
				+                    without any arguments.
			
 
				+    :param callback: A function to further process or validate the value
			
 
				+        after type conversion. It is called as ``f(ctx, param, value)``
			
 
				+        and must return the value. It is called for all sources,
			
 
				+        including prompts.
			
 
				+    :param nargs: the number of arguments to match.  If not ``1`` the return
			
 
				+                  value is a tuple instead of single value.  The default for
			
 
				+                  nargs is ``1`` (except if the type is a tuple, then it's
			
 
				+                  the arity of the tuple). If ``nargs=-1``, all remaining
			
 
				+                  parameters are collected.
			
 
				+    :param metavar: how the value is represented in the help page.
			
 
				+    :param expose_value: if this is `True` then the value is passed onwards
			
 
				+                         to the command callback and stored on the context,
			
 
				+                         otherwise it's skipped.
			
 
				+    :param is_eager: eager values are processed before non eager ones.  This
			
 
				+                     should not be set for arguments or it will inverse the
			
 
				+                     order of processing.
			
 
				+    :param envvar: a string or list of strings that are environment variables
			
 
				+                   that should be checked.
			
 
				+    :param shell_complete: A function that returns custom shell
			
 
				+        completions. Used instead of the param's type completion if
			
 
				+        given. Takes ``ctx, param, incomplete`` and must return a list
			
 
				+        of :class:`~click.shell_completion.CompletionItem` or a list of
			
 
				+        strings.
			
 
				+
			
 
				+    .. versionchanged:: 8.0
			
 
				+        ``process_value`` validates required parameters and bounded
			
 
				+        ``nargs``, and invokes the parameter callback before returning
			
 
				+        the value. This allows the callback to validate prompts.
			
 
				+        ``full_process_value`` is removed.
			
 
				+
			
 
				+    .. versionchanged:: 8.0
			
 
				+        ``autocompletion`` is renamed to ``shell_complete`` and has new
			
 
				+        semantics described above. The old name is deprecated and will
			
 
				+        be removed in 8.1, until then it will be wrapped to match the
			
 
				+        new requirements.
			
 
				+
			
 
				+    .. versionchanged:: 8.0
			
 
				+        For ``multiple=True, nargs>1``, the default must be a list of
			
 
				+        tuples.
			
 
				+
			
 
				+    .. versionchanged:: 8.0
			
 
				+        Setting a default is no longer required for ``nargs>1``, it will
			
 
				+        default to ``None``. ``multiple=True`` or ``nargs=-1`` will
			
 
				+        default to ``()``.
			
 
				+
			
 
				+    .. versionchanged:: 7.1
			
 
				+        Empty environment variables are ignored rather than taking the
			
 
				+        empty string value. This makes it possible for scripts to clear
			
 
				+        variables if they can't unset them.
			
 
				+
			
 
				+    .. versionchanged:: 2.0
			
 
				+        Changed signature for parameter callback to also be passed the
			
 
				+        parameter. The old callback format will still work, but it will
			
 
				+        raise a warning to give you a chance to migrate the code easier.
			
 
				+    """
			
 
				+
			
 
				+    param_type_name = "parameter"
			
 
				+
			
 
				+    def __init__(
			
 
				+        self,
			
 
				+        param_decls: t.Optional[t.Sequence[str]] = None,
			
 
				+        type: t.Optional[t.Union[types.ParamType, t.Any]] = None,
			
 
				+        required: bool = False,
			
 
				+        default: t.Optional[t.Union[t.Any, t.Callable[[], t.Any]]] = None,
			
 
				+        callback: t.Optional[t.Callable[[Context, "Parameter", t.Any], t.Any]] = None,
			
 
				+        nargs: t.Optional[int] = None,
			
 
				+        multiple: bool = False,
			
 
				+        metavar: t.Optional[str] = None,
			
 
				+        expose_value: bool = True,
			
 
				+        is_eager: bool = False,
			
 
				+        envvar: t.Optional[t.Union[str, t.Sequence[str]]] = None,
			
 
				+        shell_complete: t.Optional[
			
 
				+            t.Callable[
			
 
				+                [Context, "Parameter", str],
			
 
				+                t.Union[t.List["CompletionItem"], t.List[str]],
			
 
				+            ]
			
 
				+        ] = None,
			
 
				+    ) -> None:
			
 
				+        self.name: t.Optional[str]
			
 
				+        self.opts: t.List[str]
			
 
				+        self.secondary_opts: t.List[str]
			
 
				+        self.name, self.opts, self.secondary_opts = self._parse_decls(
			
 
				+            param_decls or (), expose_value
			
 
				+        )
			
 
				+        self.type: types.ParamType = types.convert_type(type, default)
			
 
				+
			
 
				+        # Default nargs to what the type tells us if we have that
			
 
				+        # information available.
			
 
				+        if nargs is None:
			
 
				+            if self.type.is_composite:
			
 
				+                nargs = self.type.arity
			
 
				+            else:
			
 
				+                nargs = 1
			
 
				+
			
 
				+        self.required = required
			
 
				+        self.callback = callback
			
 
				+        self.nargs = nargs
			
 
				+        self.multiple = multiple
			
 
				+        self.expose_value = expose_value
			
 
				+        self.default = default
			
 
				+        self.is_eager = is_eager
			
 
				+        self.metavar = metavar
			
 
				+        self.envvar = envvar
			
 
				+        self._custom_shell_complete = shell_complete
			
 
				+
			
 
				+        if __debug__:
			
 
				+            if self.type.is_composite and nargs != self.type.arity:
			
 
				+                raise ValueError(
			
 
				+                    f"'nargs' must be {self.type.arity} (or None) for"
			
 
				+                    f" type {self.type!r}, but it was {nargs}."
			
 
				+                )
			
 
				+
			
 
				+            # Skip no default or callable default.
			
 
				+            check_default = default if not callable(default) else None
			
 
				+
			
 
				+            if check_default is not None:
			
 
				+                if multiple:
			
 
				+                    try:
			
 
				+                        # Only check the first value against nargs.
			
 
				+                        check_default = next(_check_iter(check_default), None)
			
 
				+                    except TypeError:
			
 
				+                        raise ValueError(
			
 
				+                            "'default' must be a list when 'multiple' is true."
			
 
				+                        ) from None
			
 
				+
			
 
				+                # Can be None for multiple with empty default.
			
 
				+                if nargs != 1 and check_default is not None:
			
 
				+                    try:
			
 
				+                        _check_iter(check_default)
			
 
				+                    except TypeError:
			
 
				+                        if multiple:
			
 
				+                            message = (
			
 
				+                                "'default' must be a list of lists when 'multiple' is"
			
 
				+                                " true and 'nargs' != 1."
			
 
				+                            )
			
 
				+                        else:
			
 
				+                            message = "'default' must be a list when 'nargs' != 1."
			
 
				+
			
 
				+                        raise ValueError(message) from None
			
 
				+
			
 
				+                    if nargs > 1 and len(check_default) != nargs:
			
 
				+                        subject = "item length" if multiple else "length"
			
 
				+                        raise ValueError(
			
 
				+                            f"'default' {subject} must match nargs={nargs}."
			
 
				+                        )
			
 
				+
			
 
				+    def to_info_dict(self) -> t.Dict[str, t.Any]:
			
 
				+        """Gather information that could be useful for a tool generating
			
 
				+        user-facing documentation.
			
 
				+
			
 
				+        Use :meth:`click.Context.to_info_dict` to traverse the entire
			
 
				+        CLI structure.
			
 
				+
			
 
				+        .. versionadded:: 8.0
			
 
				+        """
			
 
				+        return {
			
 
				+            "name": self.name,
			
 
				+            "param_type_name": self.param_type_name,
			
 
				+            "opts": self.opts,
			
 
				+            "secondary_opts": self.secondary_opts,
			
 
				+            "type": self.type.to_info_dict(),
			
 
				+            "required": self.required,
			
 
				+            "nargs": self.nargs,
			
 
				+            "multiple": self.multiple,
			
 
				+            "default": self.default,
			
 
				+            "envvar": self.envvar,
			
 
				+        }
			
 
				+
			
 
				+    def __repr__(self) -> str:
			
 
				+        return f"<{self.__class__.__name__} {self.name}>"
			
 
				+
			
 
				+    def _parse_decls(
			
 
				+        self, decls: t.Sequence[str], expose_value: bool
			
 
				+    ) -> t.Tuple[t.Optional[str], t.List[str], t.List[str]]:
			
 
				+        raise NotImplementedError()
			
 
				+
			
 
				+    @property
			
 
				+    def human_readable_name(self) -> str:
			
 
				+        """Returns the human readable name of this parameter.  This is the
			
 
				+        same as the name for options, but the metavar for arguments.
			
 
				+        """
			
 
				+        return self.name  # type: ignore
			
 
				+
			
 
				+    def make_metavar(self) -> str:
			
 
				+        if self.metavar is not None:
			
 
				+            return self.metavar
			
 
				+
			
 
				+        metavar = self.type.get_metavar(self)
			
 
				+
			
 
				+        if metavar is None:
			
 
				+            metavar = self.type.name.upper()
			
 
				+
			
 
				+        if self.nargs != 1:
			
 
				+            metavar += "..."
			
 
				+
			
 
				+        return metavar
			
 
				+
			
 
				+    @t.overload
			
 
				+    def get_default(
			
 
				+        self, ctx: Context, call: "te.Literal[True]" = True
			
 
				+    ) -> t.Optional[t.Any]:
			
 
				+        ...
			
 
				+
			
 
				+    @t.overload
			
 
				+    def get_default(
			
 
				+        self, ctx: Context, call: bool = ...
			
 
				+    ) -> t.Optional[t.Union[t.Any, t.Callable[[], t.Any]]]:
			
 
				+        ...
			
 
				+
			
 
				+    def get_default(
			
 
				+        self, ctx: Context, call: bool = True
			
 
				+    ) -> t.Optional[t.Union[t.Any, t.Callable[[], t.Any]]]:
			
 
				+        """Get the default for the parameter. Tries
			
 
				+        :meth:`Context.lookup_default` first, then the local default.
			
 
				+
			
 
				+        :param ctx: Current context.
			
 
				+        :param call: If the default is a callable, call it. Disable to
			
 
				+            return the callable instead.
			
 
				+
			
 
				+        .. versionchanged:: 8.0.2
			
 
				+            Type casting is no longer performed when getting a default.
			
 
				+
			
 
				+        .. versionchanged:: 8.0.1
			
 
				+            Type casting can fail in resilient parsing mode. Invalid
			
 
				+            defaults will not prevent showing help text.
			
 
				+
			
 
				+        .. versionchanged:: 8.0
			
 
				+            Looks at ``ctx.default_map`` first.
			
 
				+
			
 
				+        .. versionchanged:: 8.0
			
 
				+            Added the ``call`` parameter.
			
 
				+        """
			
 
				+        value = ctx.lookup_default(self.name, call=False)  # type: ignore
			
 
				+
			
 
				+        if value is None:
			
 
				+            value = self.default
			
 
				+
			
 
				+        if call and callable(value):
			
 
				+            value = value()
			
 
				+
			
 
				+        return value
			
 
				+
			
 
				+    def add_to_parser(self, parser: OptionParser, ctx: Context) -> None:
			
 
				+        raise NotImplementedError()
			
 
				+
			
 
				+    def consume_value(
			
 
				+        self, ctx: Context, opts: t.Mapping[str, t.Any]
			
 
				+    ) -> t.Tuple[t.Any, ParameterSource]:
			
 
				+        value = opts.get(self.name)  # type: ignore
			
 
				+        source = ParameterSource.COMMANDLINE
			
 
				+
			
 
				+        if value is None:
			
 
				+            value = self.value_from_envvar(ctx)
			
 
				+            source = ParameterSource.ENVIRONMENT
			
 
				+
			
 
				+        if value is None:
			
 
				+            value = ctx.lookup_default(self.name)  # type: ignore
			
 
				+            source = ParameterSource.DEFAULT_MAP
			
 
				+
			
 
				+        if value is None:
			
 
				+            value = self.get_default(ctx)
			
 
				+            source = ParameterSource.DEFAULT
			
 
				+
			
 
				+        return value, source
			
 
				+
			
 
				+    def type_cast_value(self, ctx: Context, value: t.Any) -> t.Any:
			
 
				+        """Convert and validate a value against the option's
			
 
				+        :attr:`type`, :attr:`multiple`, and :attr:`nargs`.
			
 
				+        """
			
 
				+        if value is None:
			
 
				+            return () if self.multiple or self.nargs == -1 else None
			
 
				+
			
 
				+        def check_iter(value: t.Any) -> t.Iterator[t.Any]:
			
 
				+            try:
			
 
				+                return _check_iter(value)
			
 
				+            except TypeError:
			
 
				+                # This should only happen when passing in args manually,
			
 
				+                # the parser should construct an iterable when parsing
			
 
				+                # the command line.
			
 
				+                raise BadParameter(
			
 
				+                    _("Value must be an iterable."), ctx=ctx, param=self
			
 
				+                ) from None
			
 
				+
			
 
				+        if self.nargs == 1 or self.type.is_composite:
			
 
				+
			
 
				+            def convert(value: t.Any) -> t.Any:
			
 
				+                return self.type(value, param=self, ctx=ctx)
			
 
				+
			
 
				+        elif self.nargs == -1:
			
 
				+
			
 
				+            def convert(value: t.Any) -> t.Any:  # t.Tuple[t.Any, ...]
			
 
				+                return tuple(self.type(x, self, ctx) for x in check_iter(value))
			
 
				+
			
 
				+        else:  # nargs > 1
			
 
				+
			
 
				+            def convert(value: t.Any) -> t.Any:  # t.Tuple[t.Any, ...]
			
 
				+                value = tuple(check_iter(value))
			
 
				+
			
 
				+                if len(value) != self.nargs:
			
 
				+                    raise BadParameter(
			
 
				+                        ngettext(
			
 
				+                            "Takes {nargs} values but 1 was given.",
			
 
				+                            "Takes {nargs} values but {len} were given.",
			
 
				+                            len(value),
			
 
				+                        ).format(nargs=self.nargs, len=len(value)),
			
 
				+                        ctx=ctx,
			
 
				+                        param=self,
			
 
				+                    )
			
 
				+
			
 
				+                return tuple(self.type(x, self, ctx) for x in value)
			
 
				+
			
 
				+        if self.multiple:
			
 
				+            return tuple(convert(x) for x in check_iter(value))
			
 
				+
			
 
				+        return convert(value)
			
 
				+
			
 
				+    def value_is_missing(self, value: t.Any) -> bool:
			
 
				+        if value is None:
			
 
				+            return True
			
 
				+
			
 
				+        if (self.nargs != 1 or self.multiple) and value == ():
			
 
				+            return True
			
 
				+
			
 
				+        return False
			
 
				+
			
 
				+    def process_value(self, ctx: Context, value: t.Any) -> t.Any:
			
 
				+        value = self.type_cast_value(ctx, value)
			
 
				+
			
 
				+        if self.required and self.value_is_missing(value):
			
 
				+            raise MissingParameter(ctx=ctx, param=self)
			
 
				+
			
 
				+        if self.callback is not None:
			
 
				+            value = self.callback(ctx, self, value)
			
 
				+
			
 
				+        return value
			
 
				+
			
 
				+    def resolve_envvar_value(self, ctx: Context) -> t.Optional[str]:
			
 
				+        if self.envvar is None:
			
 
				+            return None
			
 
				+
			
 
				+        if isinstance(self.envvar, str):
			
 
				+            rv = os.environ.get(self.envvar)
			
 
				+
			
 
				+            if rv:
			
 
				+                return rv
			
 
				+        else:
			
 
				+            for envvar in self.envvar:
			
 
				+                rv = os.environ.get(envvar)
			
 
				+
			
 
				+                if rv:
			
 
				+                    return rv
			
 
				+
			
 
				+        return None
			
 
				+
			
 
				+    def value_from_envvar(self, ctx: Context) -> t.Optional[t.Any]:
			
 
				+        rv: t.Optional[t.Any] = self.resolve_envvar_value(ctx)
			
 
				+
			
 
				+        if rv is not None and self.nargs != 1:
			
 
				+            rv = self.type.split_envvar_value(rv)
			
 
				+
			
 
				+        return rv
			
 
				+
			
 
				+    def handle_parse_result(
			
 
				+        self, ctx: Context, opts: t.Mapping[str, t.Any], args: t.List[str]
			
 
				+    ) -> t.Tuple[t.Any, t.List[str]]:
			
 
				+        with augment_usage_errors(ctx, param=self):
			
 
				+            value, source = self.consume_value(ctx, opts)
			
 
				+            ctx.set_parameter_source(self.name, source)  # type: ignore
			
 
				+
			
 
				+            try:
			
 
				+                value = self.process_value(ctx, value)
			
 
				+            except Exception:
			
 
				+                if not ctx.resilient_parsing:
			
 
				+                    raise
			
 
				+
			
 
				+                value = None
			
 
				+
			
 
				+        if self.expose_value:
			
 
				+            ctx.params[self.name] = value  # type: ignore
			
 
				+
			
 
				+        return value, args
			
 
				+
			
 
				+    def get_help_record(self, ctx: Context) -> t.Optional[t.Tuple[str, str]]:
			
 
				+        pass
			
 
				+
			
 
				+    def get_usage_pieces(self, ctx: Context) -> t.List[str]:
			
 
				+        return []
			
 
				+
			
 
				+    def get_error_hint(self, ctx: Context) -> str:
			
 
				+        """Get a stringified version of the param for use in error messages to
			
 
				+        indicate which param caused the error.
			
 
				+        """
			
 
				+        hint_list = self.opts or [self.human_readable_name]
			
 
				+        return " / ".join(f"'{x}'" for x in hint_list)
			
 
				+
			
 
				+    def shell_complete(self, ctx: Context, incomplete: str) -> t.List["CompletionItem"]:
			
 
				+        """Return a list of completions for the incomplete value. If a
			
 
				+        ``shell_complete`` function was given during init, it is used.
			
 
				+        Otherwise, the :attr:`type`
			
 
				+        :meth:`~click.types.ParamType.shell_complete` function is used.
			
 
				+
			
 
				+        :param ctx: Invocation context for this command.
			
 
				+        :param incomplete: Value being completed. May be empty.
			
 
				+
			
 
				+        .. versionadded:: 8.0
			
 
				+        """
			
 
				+        if self._custom_shell_complete is not None:
			
 
				+            results = self._custom_shell_complete(ctx, self, incomplete)
			
 
				+
			
 
				+            if results and isinstance(results[0], str):
			
 
				+                from click.shell_completion import CompletionItem
			
 
				+
			
 
				+                results = [CompletionItem(c) for c in results]
			
 
				+
			
 
				+            return t.cast(t.List["CompletionItem"], results)
			
 
				+
			
 
				+        return self.type.shell_complete(ctx, self, incomplete)
			
 
				+
			
 
				+
			
 
				+class Option(Parameter):
			
 
				+    """Options are usually optional values on the command line and
			
 
				+    have some extra features that arguments don't have.
			
 
				+
			
 
				+    All other parameters are passed onwards to the parameter constructor.
			
 
				+
			
 
				+    :param show_default: Show the default value for this option in its
			
 
				+        help text. Values are not shown by default, unless
			
 
				+        :attr:`Context.show_default` is ``True``. If this value is a
			
 
				+        string, it shows that string in parentheses instead of the
			
 
				+        actual value. This is particularly useful for dynamic options.
			
 
				+        For single option boolean flags, the default remains hidden if
			
 
				+        its value is ``False``.
			
 
				+    :param show_envvar: Controls if an environment variable should be
			
 
				+        shown on the help page. Normally, environment variables are not
			
 
				+        shown.
			
 
				+    :param prompt: If set to ``True`` or a non empty string then the
			
 
				+        user will be prompted for input. If set to ``True`` the prompt
			
 
				+        will be the option name capitalized.
			
 
				+    :param confirmation_prompt: Prompt a second time to confirm the
			
 
				+        value if it was prompted for. Can be set to a string instead of
			
 
				+        ``True`` to customize the message.
			
 
				+    :param prompt_required: If set to ``False``, the user will be
			
 
				+        prompted for input only when the option was specified as a flag
			
 
				+        without a value.
			
 
				+    :param hide_input: If this is ``True`` then the input on the prompt
			
 
				+        will be hidden from the user. This is useful for password input.
			
 
				+    :param is_flag: forces this option to act as a flag.  The default is
			
 
				+                    auto detection.
			
 
				+    :param flag_value: which value should be used for this flag if it's
			
 
				+                       enabled.  This is set to a boolean automatically if
			
 
				+                       the option string contains a slash to mark two options.
			
 
				+    :param multiple: if this is set to `True` then the argument is accepted
			
 
				+                     multiple times and recorded.  This is similar to ``nargs``
			
 
				+                     in how it works but supports arbitrary number of
			
 
				+                     arguments.
			
 
				+    :param count: this flag makes an option increment an integer.
			
 
				+    :param allow_from_autoenv: if this is enabled then the value of this
			
 
				+                               parameter will be pulled from an environment
			
 
				+                               variable in case a prefix is defined on the
			
 
				+                               context.
			
 
				+    :param help: the help string.
			
 
				+    :param hidden: hide this option from help outputs.
			
 
				+    :param attrs: Other command arguments described in :class:`Parameter`.
			
 
				+
			
 
				+    .. versionchanged:: 8.1.0
			
 
				+        Help text indentation is cleaned here instead of only in the
			
 
				+        ``@option`` decorator.
			
 
				+
			
 
				+    .. versionchanged:: 8.1.0
			
 
				+        The ``show_default`` parameter overrides
			
 
				+        ``Context.show_default``.
			
 
				+
			
 
				+    .. versionchanged:: 8.1.0
			
 
				+        The default of a single option boolean flag is not shown if the
			
 
				+        default value is ``False``.
			
 
				+
			
 
				+    .. versionchanged:: 8.0.1
			
 
				+        ``type`` is detected from ``flag_value`` if given.
			
 
				+    """
			
 
				+
			
 
				+    param_type_name = "option"
			
 
				+
			
 
				+    def __init__(
			
 
				+        self,
			
 
				+        param_decls: t.Optional[t.Sequence[str]] = None,
			
 
				+        show_default: t.Union[bool, str, None] = None,
			
 
				+        prompt: t.Union[bool, str] = False,
			
 
				+        confirmation_prompt: t.Union[bool, str] = False,
			
 
				+        prompt_required: bool = True,
			
 
				+        hide_input: bool = False,
			
 
				+        is_flag: t.Optional[bool] = None,
			
 
				+        flag_value: t.Optional[t.Any] = None,
			
 
				+        multiple: bool = False,
			
 
				+        count: bool = False,
			
 
				+        allow_from_autoenv: bool = True,
			
 
				+        type: t.Optional[t.Union[types.ParamType, t.Any]] = None,
			
 
				+        help: t.Optional[str] = None,
			
 
				+        hidden: bool = False,
			
 
				+        show_choices: bool = True,
			
 
				+        show_envvar: bool = False,
			
 
				+        **attrs: t.Any,
			
 
				+    ) -> None:
			
 
				+        if help:
			
 
				+            help = inspect.cleandoc(help)
			
 
				+
			
 
				+        default_is_missing = "default" not in attrs
			
 
				+        super().__init__(param_decls, type=type, multiple=multiple, **attrs)
			
 
				+
			
 
				+        if prompt is True:
			
 
				+            if self.name is None:
			
 
				+                raise TypeError("'name' is required with 'prompt=True'.")
			
 
				+
			
 
				+            prompt_text: t.Optional[str] = self.name.replace("_", " ").capitalize()
			
 
				+        elif prompt is False:
			
 
				+            prompt_text = None
			
 
				+        else:
			
 
				+            prompt_text = prompt
			
 
				+
			
 
				+        self.prompt = prompt_text
			
 
				+        self.confirmation_prompt = confirmation_prompt
			
 
				+        self.prompt_required = prompt_required
			
 
				+        self.hide_input = hide_input
			
 
				+        self.hidden = hidden
			
 
				+
			
 
				+        # If prompt is enabled but not required, then the option can be
			
 
				+        # used as a flag to indicate using prompt or flag_value.
			
 
				+        self._flag_needs_value = self.prompt is not None and not self.prompt_required
			
 
				+
			
 
				+        if is_flag is None:
			
 
				+            if flag_value is not None:
			
 
				+                # Implicitly a flag because flag_value was set.
			
 
				+                is_flag = True
			
 
				+            elif self._flag_needs_value:
			
 
				+                # Not a flag, but when used as a flag it shows a prompt.
			
 
				+                is_flag = False
			
 
				+            else:
			
 
				+                # Implicitly a flag because flag options were given.
			
 
				+                is_flag = bool(self.secondary_opts)
			
 
				+        elif is_flag is False and not self._flag_needs_value:
			
 
				+            # Not a flag, and prompt is not enabled, can be used as a
			
 
				+            # flag if flag_value is set.
			
 
				+            self._flag_needs_value = flag_value is not None
			
 
				+
			
 
				+        self.default: t.Union[t.Any, t.Callable[[], t.Any]]
			
 
				+
			
 
				+        if is_flag and default_is_missing and not self.required:
			
 
				+            if multiple:
			
 
				+                self.default = ()
			
 
				+            else:
			
 
				+                self.default = False
			
 
				+
			
 
				+        if flag_value is None:
			
 
				+            flag_value = not self.default
			
 
				+
			
 
				+        self.type: types.ParamType
			
 
				+        if is_flag and type is None:
			
 
				+            # Re-guess the type from the flag value instead of the
			
 
				+            # default.
			
 
				+            self.type = types.convert_type(None, flag_value)
			
 
				+
			
 
				+        self.is_flag: bool = is_flag
			
 
				+        self.is_bool_flag: bool = is_flag and isinstance(self.type, types.BoolParamType)
			
 
				+        self.flag_value: t.Any = flag_value
			
 
				+
			
 
				+        # Counting
			
 
				+        self.count = count
			
 
				+        if count:
			
 
				+            if type is None:
			
 
				+                self.type = types.IntRange(min=0)
			
 
				+            if default_is_missing:
			
 
				+                self.default = 0
			
 
				+
			
 
				+        self.allow_from_autoenv = allow_from_autoenv
			
 
				+        self.help = help
			
 
				+        self.show_default = show_default
			
 
				+        self.show_choices = show_choices
			
 
				+        self.show_envvar = show_envvar
			
 
				+
			
 
				+        if __debug__:
			
 
				+            if self.nargs == -1:
			
 
				+                raise TypeError("nargs=-1 is not supported for options.")
			
 
				+
			
 
				+            if self.prompt and self.is_flag and not self.is_bool_flag:
			
 
				+                raise TypeError("'prompt' is not valid for non-boolean flag.")
			
 
				+
			
 
				+            if not self.is_bool_flag and self.secondary_opts:
			
 
				+                raise TypeError("Secondary flag is not valid for non-boolean flag.")
			
 
				+
			
 
				+            if self.is_bool_flag and self.hide_input and self.prompt is not None:
			
 
				+                raise TypeError(
			
 
				+                    "'prompt' with 'hide_input' is not valid for boolean flag."
			
 
				+                )
			
 
				+
			
 
				+            if self.count:
			
 
				+                if self.multiple:
			
 
				+                    raise TypeError("'count' is not valid with 'multiple'.")
			
 
				+
			
 
				+                if self.is_flag:
			
 
				+                    raise TypeError("'count' is not valid with 'is_flag'.")
			
 
				+
			
 
				+    def to_info_dict(self) -> t.Dict[str, t.Any]:
			
 
				+        info_dict = super().to_info_dict()
			
 
				+        info_dict.update(
			
 
				+            help=self.help,
			
 
				+            prompt=self.prompt,
			
 
				+            is_flag=self.is_flag,
			
 
				+            flag_value=self.flag_value,
			
 
				+            count=self.count,
			
 
				+            hidden=self.hidden,
			
 
				+        )
			
 
				+        return info_dict
			
 
				+
			
 
				+    def _parse_decls(
			
 
				+        self, decls: t.Sequence[str], expose_value: bool
			
 
				+    ) -> t.Tuple[t.Optional[str], t.List[str], t.List[str]]:
			
 
				+        opts = []
			
 
				+        secondary_opts = []
			
 
				+        name = None
			
 
				+        possible_names = []
			
 
				+
			
 
				+        for decl in decls:
			
 
				+            if decl.isidentifier():
			
 
				+                if name is not None:
			
 
				+                    raise TypeError(f"Name '{name}' defined twice")
			
 
				+                name = decl
			
 
				+            else:
			
 
				+                split_char = ";" if decl[:1] == "/" else "/"
			
 
				+                if split_char in decl:
			
 
				+                    first, second = decl.split(split_char, 1)
			
 
				+                    first = first.rstrip()
			
 
				+                    if first:
			
 
				+                        possible_names.append(split_opt(first))
			
 
				+                        opts.append(first)
			
 
				+                    second = second.lstrip()
			
 
				+                    if second:
			
 
				+                        secondary_opts.append(second.lstrip())
			
 
				+                    if first == second:
			
 
				+                        raise ValueError(
			
 
				+                            f"Boolean option {decl!r} cannot use the"
			
 
				+                            " same flag for true/false."
			
 
				+                        )
			
 
				+                else:
			
 
				+                    possible_names.append(split_opt(decl))
			
 
				+                    opts.append(decl)
			
 
				+
			
 
				+        if name is None and possible_names:
			
 
				+            possible_names.sort(key=lambda x: -len(x[0]))  # group long options first
			
 
				+            name = possible_names[0][1].replace("-", "_").lower()
			
 
				+            if not name.isidentifier():
			
 
				+                name = None
			
 
				+
			
 
				+        if name is None:
			
 
				+            if not expose_value:
			
 
				+                return None, opts, secondary_opts
			
 
				+            raise TypeError("Could not determine name for option")
			
 
				+
			
 
				+        if not opts and not secondary_opts:
			
 
				+            raise TypeError(
			
 
				+                f"No options defined but a name was passed ({name})."
			
 
				+                " Did you mean to declare an argument instead? Did"
			
 
				+                f" you mean to pass '--{name}'?"
			
 
				+            )
			
 
				+
			
 
				+        return name, opts, secondary_opts
			
 
				+
			
 
				+    def add_to_parser(self, parser: OptionParser, ctx: Context) -> None:
			
 
				+        if self.multiple:
			
 
				+            action = "append"
			
 
				+        elif self.count:
			
 
				+            action = "count"
			
 
				+        else:
			
 
				+            action = "store"
			
 
				+
			
 
				+        if self.is_flag:
			
 
				+            action = f"{action}_const"
			
 
				+
			
 
				+            if self.is_bool_flag and self.secondary_opts:
			
 
				+                parser.add_option(
			
 
				+                    obj=self, opts=self.opts, dest=self.name, action=action, const=True
			
 
				+                )
			
 
				+                parser.add_option(
			
 
				+                    obj=self,
			
 
				+                    opts=self.secondary_opts,
			
 
				+                    dest=self.name,
			
 
				+                    action=action,
			
 
				+                    const=False,
			
 
				+                )
			
 
				+            else:
			
 
				+                parser.add_option(
			
 
				+                    obj=self,
			
 
				+                    opts=self.opts,
			
 
				+                    dest=self.name,
			
 
				+                    action=action,
			
 
				+                    const=self.flag_value,
			
 
				+                )
			
 
				+        else:
			
 
				+            parser.add_option(
			
 
				+                obj=self,
			
 
				+                opts=self.opts,
			
 
				+                dest=self.name,
			
 
				+                action=action,
			
 
				+                nargs=self.nargs,
			
 
				+            )
			
 
				+
			
 
				+    def get_help_record(self, ctx: Context) -> t.Optional[t.Tuple[str, str]]:
			
 
				+        if self.hidden:
			
 
				+            return None
			
 
				+
			
 
				+        any_prefix_is_slash = False
			
 
				+
			
 
				+        def _write_opts(opts: t.Sequence[str]) -> str:
			
 
				+            nonlocal any_prefix_is_slash
			
 
				+
			
 
				+            rv, any_slashes = join_options(opts)
			
 
				+
			
 
				+            if any_slashes:
			
 
				+                any_prefix_is_slash = True
			
 
				+
			
 
				+            if not self.is_flag and not self.count:
			
 
				+                rv += f" {self.make_metavar()}"
			
 
				+
			
 
				+            return rv
			
 
				+
			
 
				+        rv = [_write_opts(self.opts)]
			
 
				+
			
 
				+        if self.secondary_opts:
			
 
				+            rv.append(_write_opts(self.secondary_opts))
			
 
				+
			
 
				+        help = self.help or ""
			
 
				+        extra = []
			
 
				+
			
 
				+        if self.show_envvar:
			
 
				+            envvar = self.envvar
			
 
				+
			
 
				+            if envvar is None:
			
 
				+                if (
			
 
				+                    self.allow_from_autoenv
			
 
				+                    and ctx.auto_envvar_prefix is not None
			
 
				+                    and self.name is not None
			
 
				+                ):
			
 
				+                    envvar = f"{ctx.auto_envvar_prefix}_{self.name.upper()}"
			
 
				+
			
 
				+            if envvar is not None:
			
 
				+                var_str = (
			
 
				+                    envvar
			
 
				+                    if isinstance(envvar, str)
			
 
				+                    else ", ".join(str(d) for d in envvar)
			
 
				+                )
			
 
				+                extra.append(_("env var: {var}").format(var=var_str))
			
 
				+
			
 
				+        # Temporarily enable resilient parsing to avoid type casting
			
 
				+        # failing for the default. Might be possible to extend this to
			
 
				+        # help formatting in general.
			
 
				+        resilient = ctx.resilient_parsing
			
 
				+        ctx.resilient_parsing = True
			
 
				+
			
 
				+        try:
			
 
				+            default_value = self.get_default(ctx, call=False)
			
 
				+        finally:
			
 
				+            ctx.resilient_parsing = resilient
			
 
				+
			
 
				+        show_default = False
			
 
				+        show_default_is_str = False
			
 
				+
			
 
				+        if self.show_default is not None:
			
 
				+            if isinstance(self.show_default, str):
			
 
				+                show_default_is_str = show_default = True
			
 
				+            else:
			
 
				+                show_default = self.show_default
			
 
				+        elif ctx.show_default is not None:
			
 
				+            show_default = ctx.show_default
			
 
				+
			
 
				+        if show_default_is_str or (show_default and (default_value is not None)):
			
 
				+            if show_default_is_str:
			
 
				+                default_string = f"({self.show_default})"
			
 
				+            elif isinstance(default_value, (list, tuple)):
			
 
				+                default_string = ", ".join(str(d) for d in default_value)
			
 
				+            elif inspect.isfunction(default_value):
			
 
				+                default_string = _("(dynamic)")
			
 
				+            elif self.is_bool_flag and self.secondary_opts:
			
 
				+                # For boolean flags that have distinct True/False opts,
			
 
				+                # use the opt without prefix instead of the value.
			
 
				+                default_string = split_opt(
			
 
				+                    (self.opts if self.default else self.secondary_opts)[0]
			
 
				+                )[1]
			
 
				+            elif self.is_bool_flag and not self.secondary_opts and not default_value:
			
 
				+                default_string = ""
			
 
				+            else:
			
 
				+                default_string = str(default_value)
			
 
				+
			
 
				+            if default_string:
			
 
				+                extra.append(_("default: {default}").format(default=default_string))
			
 
				+
			
 
				+        if (
			
 
				+            isinstance(self.type, types._NumberRangeBase)
			
 
				+            # skip count with default range type
			
 
				+            and not (self.count and self.type.min == 0 and self.type.max is None)
			
 
				+        ):
			
 
				+            range_str = self.type._describe_range()
			
 
				+
			
 
				+            if range_str:
			
 
				+                extra.append(range_str)
			
 
				+
			
 
				+        if self.required:
			
 
				+            extra.append(_("required"))
			
 
				+
			
 
				+        if extra:
			
 
				+            extra_str = "; ".join(extra)
			
 
				+            help = f"{help}  [{extra_str}]" if help else f"[{extra_str}]"
			
 
				+
			
 
				+        return ("; " if any_prefix_is_slash else " / ").join(rv), help
			
 
				+
			
 
				+    @t.overload
			
 
				+    def get_default(
			
 
				+        self, ctx: Context, call: "te.Literal[True]" = True
			
 
				+    ) -> t.Optional[t.Any]:
			
 
				+        ...
			
 
				+
			
 
				+    @t.overload
			
 
				+    def get_default(
			
 
				+        self, ctx: Context, call: bool = ...
			
 
				+    ) -> t.Optional[t.Union[t.Any, t.Callable[[], t.Any]]]:
			
 
				+        ...
			
 
				+
			
 
				+    def get_default(
			
 
				+        self, ctx: Context, call: bool = True
			
 
				+    ) -> t.Optional[t.Union[t.Any, t.Callable[[], t.Any]]]:
			
 
				+        # If we're a non boolean flag our default is more complex because
			
 
				+        # we need to look at all flags in the same group to figure out
			
 
				+        # if we're the default one in which case we return the flag
			
 
				+        # value as default.
			
 
				+        if self.is_flag and not self.is_bool_flag:
			
 
				+            for param in ctx.command.params:
			
 
				+                if param.name == self.name and param.default:
			
 
				+                    return t.cast(Option, param).flag_value
			
 
				+
			
 
				+            return None
			
 
				+
			
 
				+        return super().get_default(ctx, call=call)
			
 
				+
			
 
				+    def prompt_for_value(self, ctx: Context) -> t.Any:
			
 
				+        """This is an alternative flow that can be activated in the full
			
 
				+        value processing if a value does not exist.  It will prompt the
			
 
				+        user until a valid value exists and then returns the processed
			
 
				+        value as result.
			
 
				+        """
			
 
				+        assert self.prompt is not None
			
 
				+
			
 
				+        # Calculate the default before prompting anything to be stable.
			
 
				+        default = self.get_default(ctx)
			
 
				+
			
 
				+        # If this is a prompt for a flag we need to handle this
			
 
				+        # differently.
			
 
				+        if self.is_bool_flag:
			
 
				+            return confirm(self.prompt, default)
			
 
				+
			
 
				+        return prompt(
			
 
				+            self.prompt,
			
 
				+            default=default,
			
 
				+            type=self.type,
			
 
				+            hide_input=self.hide_input,
			
 
				+            show_choices=self.show_choices,
			
 
				+            confirmation_prompt=self.confirmation_prompt,
			
 
				+            value_proc=lambda x: self.process_value(ctx, x),
			
 
				+        )
			
 
				+
			
 
				+    def resolve_envvar_value(self, ctx: Context) -> t.Optional[str]:
			
 
				+        rv = super().resolve_envvar_value(ctx)
			
 
				+
			
 
				+        if rv is not None:
			
 
				+            return rv
			
 
				+
			
 
				+        if (
			
 
				+            self.allow_from_autoenv
			
 
				+            and ctx.auto_envvar_prefix is not None
			
 
				+            and self.name is not None
			
 
				+        ):
			
 
				+            envvar = f"{ctx.auto_envvar_prefix}_{self.name.upper()}"
			
 
				+            rv = os.environ.get(envvar)
			
 
				+
			
 
				+            if rv:
			
 
				+                return rv
			
 
				+
			
 
				+        return None
			
 
				+
			
 
				+    def value_from_envvar(self, ctx: Context) -> t.Optional[t.Any]:
			
 
				+        rv: t.Optional[t.Any] = self.resolve_envvar_value(ctx)
			
 
				+
			
 
				+        if rv is None:
			
 
				+            return None
			
 
				+
			
 
				+        value_depth = (self.nargs != 1) + bool(self.multiple)
			
 
				+
			
 
				+        if value_depth > 0:
			
 
				+            rv = self.type.split_envvar_value(rv)
			
 
				+
			
 
				+            if self.multiple and self.nargs != 1:
			
 
				+                rv = batch(rv, self.nargs)
			
 
				+
			
 
				+        return rv
			
 
				+
			
 
				+    def consume_value(
			
 
				+        self, ctx: Context, opts: t.Mapping[str, "Parameter"]
			
 
				+    ) -> t.Tuple[t.Any, ParameterSource]:
			
 
				+        value, source = super().consume_value(ctx, opts)
			
 
				+
			
 
				+        # The parser will emit a sentinel value if the option can be
			
 
				+        # given as a flag without a value. This is different from None
			
 
				+        # to distinguish from the flag not being given at all.
			
 
				+        if value is _flag_needs_value:
			
 
				+            if self.prompt is not None and not ctx.resilient_parsing:
			
 
				+                value = self.prompt_for_value(ctx)
			
 
				+                source = ParameterSource.PROMPT
			
 
				+            else:
			
 
				+                value = self.flag_value
			
 
				+                source = ParameterSource.COMMANDLINE
			
 
				+
			
 
				+        elif (
			
 
				+            self.multiple
			
 
				+            and value is not None
			
 
				+            and any(v is _flag_needs_value for v in value)
			
 
				+        ):
			
 
				+            value = [self.flag_value if v is _flag_needs_value else v for v in value]
			
 
				+            source = ParameterSource.COMMANDLINE
			
 
				+
			
 
				+        # The value wasn't set, or used the param's default, prompt if
			
 
				+        # prompting is enabled.
			
 
				+        elif (
			
 
				+            source in {None, ParameterSource.DEFAULT}
			
 
				+            and self.prompt is not None
			
 
				+            and (self.required or self.prompt_required)
			
 
				+            and not ctx.resilient_parsing
			
 
				+        ):
			
 
				+            value = self.prompt_for_value(ctx)
			
 
				+            source = ParameterSource.PROMPT
			
 
				+
			
 
				+        return value, source
			
 
				+
			
 
				+
			
 
				+class Argument(Parameter):
			
 
				+    """Arguments are positional parameters to a command.  They generally
			
 
				+    provide fewer features than options but can have infinite ``nargs``
			
 
				+    and are required by default.
			
 
				+
			
 
				+    All parameters are passed onwards to the constructor of :class:`Parameter`.
			
 
				+    """
			
 
				+
			
 
				+    param_type_name = "argument"
			
 
				+
			
 
				+    def __init__(
			
 
				+        self,
			
 
				+        param_decls: t.Sequence[str],
			
 
				+        required: t.Optional[bool] = None,
			
 
				+        **attrs: t.Any,
			
 
				+    ) -> None:
			
 
				+        if required is None:
			
 
				+            if attrs.get("default") is not None:
			
 
				+                required = False
			
 
				+            else:
			
 
				+                required = attrs.get("nargs", 1) > 0
			
 
				+
			
 
				+        if "multiple" in attrs:
			
 
				+            raise TypeError("__init__() got an unexpected keyword argument 'multiple'.")
			
 
				+
			
 
				+        super().__init__(param_decls, required=required, **attrs)
			
 
				+
			
 
				+        if __debug__:
			
 
				+            if self.default is not None and self.nargs == -1:
			
 
				+                raise TypeError("'default' is not supported for nargs=-1.")
			
 
				+
			
 
				+    @property
			
 
				+    def human_readable_name(self) -> str:
			
 
				+        if self.metavar is not None:
			
 
				+            return self.metavar
			
 
				+        return self.name.upper()  # type: ignore
			
 
				+
			
 
				+    def make_metavar(self) -> str:
			
 
				+        if self.metavar is not None:
			
 
				+            return self.metavar
			
 
				+        var = self.type.get_metavar(self)
			
 
				+        if not var:
			
 
				+            var = self.name.upper()  # type: ignore
			
 
				+        if not self.required:
			
 
				+            var = f"[{var}]"
			
 
				+        if self.nargs != 1:
			
 
				+            var += "..."
			
 
				+        return var
			
 
				+
			
 
				+    def _parse_decls(
			
 
				+        self, decls: t.Sequence[str], expose_value: bool
			
 
				+    ) -> t.Tuple[t.Optional[str], t.List[str], t.List[str]]:
			
 
				+        if not decls:
			
 
				+            if not expose_value:
			
 
				+                return None, [], []
			
 
				+            raise TypeError("Could not determine name for argument")
			
 
				+        if len(decls) == 1:
			
 
				+            name = arg = decls[0]
			
 
				+            name = name.replace("-", "_").lower()
			
 
				+        else:
			
 
				+            raise TypeError(
			
 
				+                "Arguments take exactly one parameter declaration, got"
			
 
				+                f" {len(decls)}."
			
 
				+            )
			
 
				+        return name, [arg], []
			
 
				+
			
 
				+    def get_usage_pieces(self, ctx: Context) -> t.List[str]:
			
 
				+        return [self.make_metavar()]
			
 
				+
			
 
				+    def get_error_hint(self, ctx: Context) -> str:
			
 
				+        return f"'{self.make_metavar()}'"
			
 
				+
			
 
				+    def add_to_parser(self, parser: OptionParser, ctx: Context) -> None:
			
 
				+        parser.add_argument(dest=self.name, nargs=self.nargs, obj=self)
			
--- a/courses/flask/microblog/env/Lib/site-packages/click/decorators.py
+++ b/courses/flask/microblog/env/Lib/site-packages/click/decorators.py
@@ -0,0 +1,561 @@
 
				+import inspect
			
 
				+import types
			
 
				+import typing as t
			
 
				+from functools import update_wrapper
			
 
				+from gettext import gettext as _
			
 
				+
			
 
				+from .core import Argument
			
 
				+from .core import Command
			
 
				+from .core import Context
			
 
				+from .core import Group
			
 
				+from .core import Option
			
 
				+from .core import Parameter
			
 
				+from .globals import get_current_context
			
 
				+from .utils import echo
			
 
				+
			
 
				+if t.TYPE_CHECKING:
			
 
				+    import typing_extensions as te
			
 
				+
			
 
				+    P = te.ParamSpec("P")
			
 
				+
			
 
				+R = t.TypeVar("R")
			
 
				+T = t.TypeVar("T")
			
 
				+_AnyCallable = t.Callable[..., t.Any]
			
 
				+FC = t.TypeVar("FC", bound=t.Union[_AnyCallable, Command])
			
 
				+
			
 
				+
			
 
				+def pass_context(f: "t.Callable[te.Concatenate[Context, P], R]") -> "t.Callable[P, R]":
			
 
				+    """Marks a callback as wanting to receive the current context
			
 
				+    object as first argument.
			
 
				+    """
			
 
				+
			
 
				+    def new_func(*args: "P.args", **kwargs: "P.kwargs") -> "R":
			
 
				+        return f(get_current_context(), *args, **kwargs)
			
 
				+
			
 
				+    return update_wrapper(new_func, f)
			
 
				+
			
 
				+
			
 
				+def pass_obj(f: "t.Callable[te.Concatenate[t.Any, P], R]") -> "t.Callable[P, R]":
			
 
				+    """Similar to :func:`pass_context`, but only pass the object on the
			
 
				+    context onwards (:attr:`Context.obj`).  This is useful if that object
			
 
				+    represents the state of a nested system.
			
 
				+    """
			
 
				+
			
 
				+    def new_func(*args: "P.args", **kwargs: "P.kwargs") -> "R":
			
 
				+        return f(get_current_context().obj, *args, **kwargs)
			
 
				+
			
 
				+    return update_wrapper(new_func, f)
			
 
				+
			
 
				+
			
 
				+def make_pass_decorator(
			
 
				+    object_type: t.Type[T], ensure: bool = False
			
 
				+) -> t.Callable[["t.Callable[te.Concatenate[T, P], R]"], "t.Callable[P, R]"]:
			
 
				+    """Given an object type this creates a decorator that will work
			
 
				+    similar to :func:`pass_obj` but instead of passing the object of the
			
 
				+    current context, it will find the innermost context of type
			
 
				+    :func:`object_type`.
			
 
				+
			
 
				+    This generates a decorator that works roughly like this::
			
 
				+
			
 
				+        from functools import update_wrapper
			
 
				+
			
 
				+        def decorator(f):
			
 
				+            @pass_context
			
 
				+            def new_func(ctx, *args, **kwargs):
			
 
				+                obj = ctx.find_object(object_type)
			
 
				+                return ctx.invoke(f, obj, *args, **kwargs)
			
 
				+            return update_wrapper(new_func, f)
			
 
				+        return decorator
			
 
				+
			
 
				+    :param object_type: the type of the object to pass.
			
 
				+    :param ensure: if set to `True`, a new object will be created and
			
 
				+                   remembered on the context if it's not there yet.
			
 
				+    """
			
 
				+
			
 
				+    def decorator(f: "t.Callable[te.Concatenate[T, P], R]") -> "t.Callable[P, R]":
			
 
				+        def new_func(*args: "P.args", **kwargs: "P.kwargs") -> "R":
			
 
				+            ctx = get_current_context()
			
 
				+
			
 
				+            obj: t.Optional[T]
			
 
				+            if ensure:
			
 
				+                obj = ctx.ensure_object(object_type)
			
 
				+            else:
			
 
				+                obj = ctx.find_object(object_type)
			
 
				+
			
 
				+            if obj is None:
			
 
				+                raise RuntimeError(
			
 
				+                    "Managed to invoke callback without a context"
			
 
				+                    f" object of type {object_type.__name__!r}"
			
 
				+                    " existing."
			
 
				+                )
			
 
				+
			
 
				+            return ctx.invoke(f, obj, *args, **kwargs)
			
 
				+
			
 
				+        return update_wrapper(new_func, f)
			
 
				+
			
 
				+    return decorator  # type: ignore[return-value]
			
 
				+
			
 
				+
			
 
				+def pass_meta_key(
			
 
				+    key: str, *, doc_description: t.Optional[str] = None
			
 
				+) -> "t.Callable[[t.Callable[te.Concatenate[t.Any, P], R]], t.Callable[P, R]]":
			
 
				+    """Create a decorator that passes a key from
			
 
				+    :attr:`click.Context.meta` as the first argument to the decorated
			
 
				+    function.
			
 
				+
			
 
				+    :param key: Key in ``Context.meta`` to pass.
			
 
				+    :param doc_description: Description of the object being passed,
			
 
				+        inserted into the decorator's docstring. Defaults to "the 'key'
			
 
				+        key from Context.meta".
			
 
				+
			
 
				+    .. versionadded:: 8.0
			
 
				+    """
			
 
				+
			
 
				+    def decorator(f: "t.Callable[te.Concatenate[t.Any, P], R]") -> "t.Callable[P, R]":
			
 
				+        def new_func(*args: "P.args", **kwargs: "P.kwargs") -> R:
			
 
				+            ctx = get_current_context()
			
 
				+            obj = ctx.meta[key]
			
 
				+            return ctx.invoke(f, obj, *args, **kwargs)
			
 
				+
			
 
				+        return update_wrapper(new_func, f)
			
 
				+
			
 
				+    if doc_description is None:
			
 
				+        doc_description = f"the {key!r} key from :attr:`click.Context.meta`"
			
 
				+
			
 
				+    decorator.__doc__ = (
			
 
				+        f"Decorator that passes {doc_description} as the first argument"
			
 
				+        " to the decorated function."
			
 
				+    )
			
 
				+    return decorator  # type: ignore[return-value]
			
 
				+
			
 
				+
			
 
				+CmdType = t.TypeVar("CmdType", bound=Command)
			
 
				+
			
 
				+
			
 
				+# variant: no call, directly as decorator for a function.
			
 
				+@t.overload
			
 
				+def command(name: _AnyCallable) -> Command:
			
 
				+    ...
			
 
				+
			
 
				+
			
 
				+# variant: with positional name and with positional or keyword cls argument:
			
 
				+# @command(namearg, CommandCls, ...) or @command(namearg, cls=CommandCls, ...)
			
 
				+@t.overload
			
 
				+def command(
			
 
				+    name: t.Optional[str],
			
 
				+    cls: t.Type[CmdType],
			
 
				+    **attrs: t.Any,
			
 
				+) -> t.Callable[[_AnyCallable], CmdType]:
			
 
				+    ...
			
 
				+
			
 
				+
			
 
				+# variant: name omitted, cls _must_ be a keyword argument, @command(cls=CommandCls, ...)
			
 
				+@t.overload
			
 
				+def command(
			
 
				+    name: None = None,
			
 
				+    *,
			
 
				+    cls: t.Type[CmdType],
			
 
				+    **attrs: t.Any,
			
 
				+) -> t.Callable[[_AnyCallable], CmdType]:
			
 
				+    ...
			
 
				+
			
 
				+
			
 
				+# variant: with optional string name, no cls argument provided.
			
 
				+@t.overload
			
 
				+def command(
			
 
				+    name: t.Optional[str] = ..., cls: None = None, **attrs: t.Any
			
 
				+) -> t.Callable[[_AnyCallable], Command]:
			
 
				+    ...
			
 
				+
			
 
				+
			
 
				+def command(
			
 
				+    name: t.Union[t.Optional[str], _AnyCallable] = None,
			
 
				+    cls: t.Optional[t.Type[CmdType]] = None,
			
 
				+    **attrs: t.Any,
			
 
				+) -> t.Union[Command, t.Callable[[_AnyCallable], t.Union[Command, CmdType]]]:
			
 
				+    r"""Creates a new :class:`Command` and uses the decorated function as
			
 
				+    callback.  This will also automatically attach all decorated
			
 
				+    :func:`option`\s and :func:`argument`\s as parameters to the command.
			
 
				+
			
 
				+    The name of the command defaults to the name of the function with
			
 
				+    underscores replaced by dashes.  If you want to change that, you can
			
 
				+    pass the intended name as the first argument.
			
 
				+
			
 
				+    All keyword arguments are forwarded to the underlying command class.
			
 
				+    For the ``params`` argument, any decorated params are appended to
			
 
				+    the end of the list.
			
 
				+
			
 
				+    Once decorated the function turns into a :class:`Command` instance
			
 
				+    that can be invoked as a command line utility or be attached to a
			
 
				+    command :class:`Group`.
			
 
				+
			
 
				+    :param name: the name of the command.  This defaults to the function
			
 
				+                 name with underscores replaced by dashes.
			
 
				+    :param cls: the command class to instantiate.  This defaults to
			
 
				+                :class:`Command`.
			
 
				+
			
 
				+    .. versionchanged:: 8.1
			
 
				+        This decorator can be applied without parentheses.
			
 
				+
			
 
				+    .. versionchanged:: 8.1
			
 
				+        The ``params`` argument can be used. Decorated params are
			
 
				+        appended to the end of the list.
			
 
				+    """
			
 
				+
			
 
				+    func: t.Optional[t.Callable[[_AnyCallable], t.Any]] = None
			
 
				+
			
 
				+    if callable(name):
			
 
				+        func = name
			
 
				+        name = None
			
 
				+        assert cls is None, "Use 'command(cls=cls)(callable)' to specify a class."
			
 
				+        assert not attrs, "Use 'command(**kwargs)(callable)' to provide arguments."
			
 
				+
			
 
				+    if cls is None:
			
 
				+        cls = t.cast(t.Type[CmdType], Command)
			
 
				+
			
 
				+    def decorator(f: _AnyCallable) -> CmdType:
			
 
				+        if isinstance(f, Command):
			
 
				+            raise TypeError("Attempted to convert a callback into a command twice.")
			
 
				+
			
 
				+        attr_params = attrs.pop("params", None)
			
 
				+        params = attr_params if attr_params is not None else []
			
 
				+
			
 
				+        try:
			
 
				+            decorator_params = f.__click_params__  # type: ignore
			
 
				+        except AttributeError:
			
 
				+            pass
			
 
				+        else:
			
 
				+            del f.__click_params__  # type: ignore
			
 
				+            params.extend(reversed(decorator_params))
			
 
				+
			
 
				+        if attrs.get("help") is None:
			
 
				+            attrs["help"] = f.__doc__
			
 
				+
			
 
				+        if t.TYPE_CHECKING:
			
 
				+            assert cls is not None
			
 
				+            assert not callable(name)
			
 
				+
			
 
				+        cmd = cls(
			
 
				+            name=name or f.__name__.lower().replace("_", "-"),
			
 
				+            callback=f,
			
 
				+            params=params,
			
 
				+            **attrs,
			
 
				+        )
			
 
				+        cmd.__doc__ = f.__doc__
			
 
				+        return cmd
			
 
				+
			
 
				+    if func is not None:
			
 
				+        return decorator(func)
			
 
				+
			
 
				+    return decorator
			
 
				+
			
 
				+
			
 
				+GrpType = t.TypeVar("GrpType", bound=Group)
			
 
				+
			
 
				+
			
 
				+# variant: no call, directly as decorator for a function.
			
 
				+@t.overload
			
 
				+def group(name: _AnyCallable) -> Group:
			
 
				+    ...
			
 
				+
			
 
				+
			
 
				+# variant: with positional name and with positional or keyword cls argument:
			
 
				+# @group(namearg, GroupCls, ...) or @group(namearg, cls=GroupCls, ...)
			
 
				+@t.overload
			
 
				+def group(
			
 
				+    name: t.Optional[str],
			
 
				+    cls: t.Type[GrpType],
			
 
				+    **attrs: t.Any,
			
 
				+) -> t.Callable[[_AnyCallable], GrpType]:
			
 
				+    ...
			
 
				+
			
 
				+
			
 
				+# variant: name omitted, cls _must_ be a keyword argument, @group(cmd=GroupCls, ...)
			
 
				+@t.overload
			
 
				+def group(
			
 
				+    name: None = None,
			
 
				+    *,
			
 
				+    cls: t.Type[GrpType],
			
 
				+    **attrs: t.Any,
			
 
				+) -> t.Callable[[_AnyCallable], GrpType]:
			
 
				+    ...
			
 
				+
			
 
				+
			
 
				+# variant: with optional string name, no cls argument provided.
			
 
				+@t.overload
			
 
				+def group(
			
 
				+    name: t.Optional[str] = ..., cls: None = None, **attrs: t.Any
			
 
				+) -> t.Callable[[_AnyCallable], Group]:
			
 
				+    ...
			
 
				+
			
 
				+
			
 
				+def group(
			
 
				+    name: t.Union[str, _AnyCallable, None] = None,
			
 
				+    cls: t.Optional[t.Type[GrpType]] = None,
			
 
				+    **attrs: t.Any,
			
 
				+) -> t.Union[Group, t.Callable[[_AnyCallable], t.Union[Group, GrpType]]]:
			
 
				+    """Creates a new :class:`Group` with a function as callback.  This
			
 
				+    works otherwise the same as :func:`command` just that the `cls`
			
 
				+    parameter is set to :class:`Group`.
			
 
				+
			
 
				+    .. versionchanged:: 8.1
			
 
				+        This decorator can be applied without parentheses.
			
 
				+    """
			
 
				+    if cls is None:
			
 
				+        cls = t.cast(t.Type[GrpType], Group)
			
 
				+
			
 
				+    if callable(name):
			
 
				+        return command(cls=cls, **attrs)(name)
			
 
				+
			
 
				+    return command(name, cls, **attrs)
			
 
				+
			
 
				+
			
 
				+def _param_memo(f: t.Callable[..., t.Any], param: Parameter) -> None:
			
 
				+    if isinstance(f, Command):
			
 
				+        f.params.append(param)
			
 
				+    else:
			
 
				+        if not hasattr(f, "__click_params__"):
			
 
				+            f.__click_params__ = []  # type: ignore
			
 
				+
			
 
				+        f.__click_params__.append(param)  # type: ignore
			
 
				+
			
 
				+
			
 
				+def argument(
			
 
				+    *param_decls: str, cls: t.Optional[t.Type[Argument]] = None, **attrs: t.Any
			
 
				+) -> t.Callable[[FC], FC]:
			
 
				+    """Attaches an argument to the command.  All positional arguments are
			
 
				+    passed as parameter declarations to :class:`Argument`; all keyword
			
 
				+    arguments are forwarded unchanged (except ``cls``).
			
 
				+    This is equivalent to creating an :class:`Argument` instance manually
			
 
				+    and attaching it to the :attr:`Command.params` list.
			
 
				+
			
 
				+    For the default argument class, refer to :class:`Argument` and
			
 
				+    :class:`Parameter` for descriptions of parameters.
			
 
				+
			
 
				+    :param cls: the argument class to instantiate.  This defaults to
			
 
				+                :class:`Argument`.
			
 
				+    :param param_decls: Passed as positional arguments to the constructor of
			
 
				+        ``cls``.
			
 
				+    :param attrs: Passed as keyword arguments to the constructor of ``cls``.
			
 
				+    """
			
 
				+    if cls is None:
			
 
				+        cls = Argument
			
 
				+
			
 
				+    def decorator(f: FC) -> FC:
			
 
				+        _param_memo(f, cls(param_decls, **attrs))
			
 
				+        return f
			
 
				+
			
 
				+    return decorator
			
 
				+
			
 
				+
			
 
				+def option(
			
 
				+    *param_decls: str, cls: t.Optional[t.Type[Option]] = None, **attrs: t.Any
			
 
				+) -> t.Callable[[FC], FC]:
			
 
				+    """Attaches an option to the command.  All positional arguments are
			
 
				+    passed as parameter declarations to :class:`Option`; all keyword
			
 
				+    arguments are forwarded unchanged (except ``cls``).
			
 
				+    This is equivalent to creating an :class:`Option` instance manually
			
 
				+    and attaching it to the :attr:`Command.params` list.
			
 
				+
			
 
				+    For the default option class, refer to :class:`Option` and
			
 
				+    :class:`Parameter` for descriptions of parameters.
			
 
				+
			
 
				+    :param cls: the option class to instantiate.  This defaults to
			
 
				+                :class:`Option`.
			
 
				+    :param param_decls: Passed as positional arguments to the constructor of
			
 
				+        ``cls``.
			
 
				+    :param attrs: Passed as keyword arguments to the constructor of ``cls``.
			
 
				+    """
			
 
				+    if cls is None:
			
 
				+        cls = Option
			
 
				+
			
 
				+    def decorator(f: FC) -> FC:
			
 
				+        _param_memo(f, cls(param_decls, **attrs))
			
 
				+        return f
			
 
				+
			
 
				+    return decorator
			
 
				+
			
 
				+
			
 
				+def confirmation_option(*param_decls: str, **kwargs: t.Any) -> t.Callable[[FC], FC]:
			
 
				+    """Add a ``--yes`` option which shows a prompt before continuing if
			
 
				+    not passed. If the prompt is declined, the program will exit.
			
 
				+
			
 
				+    :param param_decls: One or more option names. Defaults to the single
			
 
				+        value ``"--yes"``.
			
 
				+    :param kwargs: Extra arguments are passed to :func:`option`.
			
 
				+    """
			
 
				+
			
 
				+    def callback(ctx: Context, param: Parameter, value: bool) -> None:
			
 
				+        if not value:
			
 
				+            ctx.abort()
			
 
				+
			
 
				+    if not param_decls:
			
 
				+        param_decls = ("--yes",)
			
 
				+
			
 
				+    kwargs.setdefault("is_flag", True)
			
 
				+    kwargs.setdefault("callback", callback)
			
 
				+    kwargs.setdefault("expose_value", False)
			
 
				+    kwargs.setdefault("prompt", "Do you want to continue?")
			
 
				+    kwargs.setdefault("help", "Confirm the action without prompting.")
			
 
				+    return option(*param_decls, **kwargs)
			
 
				+
			
 
				+
			
 
				+def password_option(*param_decls: str, **kwargs: t.Any) -> t.Callable[[FC], FC]:
			
 
				+    """Add a ``--password`` option which prompts for a password, hiding
			
 
				+    input and asking to enter the value again for confirmation.
			
 
				+
			
 
				+    :param param_decls: One or more option names. Defaults to the single
			
 
				+        value ``"--password"``.
			
 
				+    :param kwargs: Extra arguments are passed to :func:`option`.
			
 
				+    """
			
 
				+    if not param_decls:
			
 
				+        param_decls = ("--password",)
			
 
				+
			
 
				+    kwargs.setdefault("prompt", True)
			
 
				+    kwargs.setdefault("confirmation_prompt", True)
			
 
				+    kwargs.setdefault("hide_input", True)
			
 
				+    return option(*param_decls, **kwargs)
			
 
				+
			
 
				+
			
 
				+def version_option(
			
 
				+    version: t.Optional[str] = None,
			
 
				+    *param_decls: str,
			
 
				+    package_name: t.Optional[str] = None,
			
 
				+    prog_name: t.Optional[str] = None,
			
 
				+    message: t.Optional[str] = None,
			
 
				+    **kwargs: t.Any,
			
 
				+) -> t.Callable[[FC], FC]:
			
 
				+    """Add a ``--version`` option which immediately prints the version
			
 
				+    number and exits the program.
			
 
				+
			
 
				+    If ``version`` is not provided, Click will try to detect it using
			
 
				+    :func:`importlib.metadata.version` to get the version for the
			
 
				+    ``package_name``. On Python < 3.8, the ``importlib_metadata``
			
 
				+    backport must be installed.
			
 
				+
			
 
				+    If ``package_name`` is not provided, Click will try to detect it by
			
 
				+    inspecting the stack frames. This will be used to detect the
			
 
				+    version, so it must match the name of the installed package.
			
 
				+
			
 
				+    :param version: The version number to show. If not provided, Click
			
 
				+        will try to detect it.
			
 
				+    :param param_decls: One or more option names. Defaults to the single
			
 
				+        value ``"--version"``.
			
 
				+    :param package_name: The package name to detect the version from. If
			
 
				+        not provided, Click will try to detect it.
			
 
				+    :param prog_name: The name of the CLI to show in the message. If not
			
 
				+        provided, it will be detected from the command.
			
 
				+    :param message: The message to show. The values ``%(prog)s``,
			
 
				+        ``%(package)s``, and ``%(version)s`` are available. Defaults to
			
 
				+        ``"%(prog)s, version %(version)s"``.
			
 
				+    :param kwargs: Extra arguments are passed to :func:`option`.
			
 
				+    :raise RuntimeError: ``version`` could not be detected.
			
 
				+
			
 
				+    .. versionchanged:: 8.0
			
 
				+        Add the ``package_name`` parameter, and the ``%(package)s``
			
 
				+        value for messages.
			
 
				+
			
 
				+    .. versionchanged:: 8.0
			
 
				+        Use :mod:`importlib.metadata` instead of ``pkg_resources``. The
			
 
				+        version is detected based on the package name, not the entry
			
 
				+        point name. The Python package name must match the installed
			
 
				+        package name, or be passed with ``package_name=``.
			
 
				+    """
			
 
				+    if message is None:
			
 
				+        message = _("%(prog)s, version %(version)s")
			
 
				+
			
 
				+    if version is None and package_name is None:
			
 
				+        frame = inspect.currentframe()
			
 
				+        f_back = frame.f_back if frame is not None else None
			
 
				+        f_globals = f_back.f_globals if f_back is not None else None
			
 
				+        # break reference cycle
			
 
				+        # https://docs.python.org/3/library/inspect.html#the-interpreter-stack
			
 
				+        del frame
			
 
				+
			
 
				+        if f_globals is not None:
			
 
				+            package_name = f_globals.get("__name__")
			
 
				+
			
 
				+            if package_name == "__main__":
			
 
				+                package_name = f_globals.get("__package__")
			
 
				+
			
 
				+            if package_name:
			
 
				+                package_name = package_name.partition(".")[0]
			
 
				+
			
 
				+    def callback(ctx: Context, param: Parameter, value: bool) -> None:
			
 
				+        if not value or ctx.resilient_parsing:
			
 
				+            return
			
 
				+
			
 
				+        nonlocal prog_name
			
 
				+        nonlocal version
			
 
				+
			
 
				+        if prog_name is None:
			
 
				+            prog_name = ctx.find_root().info_name
			
 
				+
			
 
				+        if version is None and package_name is not None:
			
 
				+            metadata: t.Optional[types.ModuleType]
			
 
				+
			
 
				+            try:
			
 
				+                from importlib import metadata  # type: ignore
			
 
				+            except ImportError:
			
 
				+                # Python < 3.8
			
 
				+                import importlib_metadata as metadata  # type: ignore
			
 
				+
			
 
				+            try:
			
 
				+                version = metadata.version(package_name)  # type: ignore
			
 
				+            except metadata.PackageNotFoundError:  # type: ignore
			
 
				+                raise RuntimeError(
			
 
				+                    f"{package_name!r} is not installed. Try passing"
			
 
				+                    " 'package_name' instead."
			
 
				+                ) from None
			
 
				+
			
 
				+        if version is None:
			
 
				+            raise RuntimeError(
			
 
				+                f"Could not determine the version for {package_name!r} automatically."
			
 
				+            )
			
 
				+
			
 
				+        echo(
			
 
				+            message % {"prog": prog_name, "package": package_name, "version": version},
			
 
				+            color=ctx.color,
			
 
				+        )
			
 
				+        ctx.exit()
			
 
				+
			
 
				+    if not param_decls:
			
 
				+        param_decls = ("--version",)
			
 
				+
			
 
				+    kwargs.setdefault("is_flag", True)
			
 
				+    kwargs.setdefault("expose_value", False)
			
 
				+    kwargs.setdefault("is_eager", True)
			
 
				+    kwargs.setdefault("help", _("Show the version and exit."))
			
 
				+    kwargs["callback"] = callback
			
 
				+    return option(*param_decls, **kwargs)
			
 
				+
			
 
				+
			
 
				+def help_option(*param_decls: str, **kwargs: t.Any) -> t.Callable[[FC], FC]:
			
 
				+    """Add a ``--help`` option which immediately prints the help page
			
 
				+    and exits the program.
			
 
				+
			
 
				+    This is usually unnecessary, as the ``--help`` option is added to
			
 
				+    each command automatically unless ``add_help_option=False`` is
			
 
				+    passed.
			
 
				+
			
 
				+    :param param_decls: One or more option names. Defaults to the single
			
 
				+        value ``"--help"``.
			
 
				+    :param kwargs: Extra arguments are passed to :func:`option`.
			
 
				+    """
			
 
				+
			
 
				+    def callback(ctx: Context, param: Parameter, value: bool) -> None:
			
 
				+        if not value or ctx.resilient_parsing:
			
 
				+            return
			
 
				+
			
 
				+        echo(ctx.get_help(), color=ctx.color)
			
 
				+        ctx.exit()
			
 
				+
			
 
				+    if not param_decls:
			
 
				+        param_decls = ("--help",)
			
 
				+
			
 
				+    kwargs.setdefault("is_flag", True)
			
 
				+    kwargs.setdefault("expose_value", False)
			
 
				+    kwargs.setdefault("is_eager", True)
			
 
				+    kwargs.setdefault("help", _("Show this message and exit."))
			
 
				+    kwargs["callback"] = callback
			
 
				+    return option(*param_decls, **kwargs)
			
--- a/courses/flask/microblog/env/Lib/site-packages/click/exceptions.py
+++ b/courses/flask/microblog/env/Lib/site-packages/click/exceptions.py
@@ -0,0 +1,288 @@
 
				+import typing as t
			
 
				+from gettext import gettext as _
			
 
				+from gettext import ngettext
			
 
				+
			
 
				+from ._compat import get_text_stderr
			
 
				+from .utils import echo
			
 
				+from .utils import format_filename
			
 
				+
			
 
				+if t.TYPE_CHECKING:
			
 
				+    from .core import Command
			
 
				+    from .core import Context
			
 
				+    from .core import Parameter
			
 
				+
			
 
				+
			
 
				+def _join_param_hints(
			
 
				+    param_hint: t.Optional[t.Union[t.Sequence[str], str]]
			
 
				+) -> t.Optional[str]:
			
 
				+    if param_hint is not None and not isinstance(param_hint, str):
			
 
				+        return " / ".join(repr(x) for x in param_hint)
			
 
				+
			
 
				+    return param_hint
			
 
				+
			
 
				+
			
 
				+class ClickException(Exception):
			
 
				+    """An exception that Click can handle and show to the user."""
			
 
				+
			
 
				+    #: The exit code for this exception.
			
 
				+    exit_code = 1
			
 
				+
			
 
				+    def __init__(self, message: str) -> None:
			
 
				+        super().__init__(message)
			
 
				+        self.message = message
			
 
				+
			
 
				+    def format_message(self) -> str:
			
 
				+        return self.message
			
 
				+
			
 
				+    def __str__(self) -> str:
			
 
				+        return self.message
			
 
				+
			
 
				+    def show(self, file: t.Optional[t.IO[t.Any]] = None) -> None:
			
 
				+        if file is None:
			
 
				+            file = get_text_stderr()
			
 
				+
			
 
				+        echo(_("Error: {message}").format(message=self.format_message()), file=file)
			
 
				+
			
 
				+
			
 
				+class UsageError(ClickException):
			
 
				+    """An internal exception that signals a usage error.  This typically
			
 
				+    aborts any further handling.
			
 
				+
			
 
				+    :param message: the error message to display.
			
 
				+    :param ctx: optionally the context that caused this error.  Click will
			
 
				+                fill in the context automatically in some situations.
			
 
				+    """
			
 
				+
			
 
				+    exit_code = 2
			
 
				+
			
 
				+    def __init__(self, message: str, ctx: t.Optional["Context"] = None) -> None:
			
 
				+        super().__init__(message)
			
 
				+        self.ctx = ctx
			
 
				+        self.cmd: t.Optional["Command"] = self.ctx.command if self.ctx else None
			
 
				+
			
 
				+    def show(self, file: t.Optional[t.IO[t.Any]] = None) -> None:
			
 
				+        if file is None:
			
 
				+            file = get_text_stderr()
			
 
				+        color = None
			
 
				+        hint = ""
			
 
				+        if (
			
 
				+            self.ctx is not None
			
 
				+            and self.ctx.command.get_help_option(self.ctx) is not None
			
 
				+        ):
			
 
				+            hint = _("Try '{command} {option}' for help.").format(
			
 
				+                command=self.ctx.command_path, option=self.ctx.help_option_names[0]
			
 
				+            )
			
 
				+            hint = f"{hint}\n"
			
 
				+        if self.ctx is not None:
			
 
				+            color = self.ctx.color
			
 
				+            echo(f"{self.ctx.get_usage()}\n{hint}", file=file, color=color)
			
 
				+        echo(
			
 
				+            _("Error: {message}").format(message=self.format_message()),
			
 
				+            file=file,
			
 
				+            color=color,
			
 
				+        )
			
 
				+
			
 
				+
			
 
				+class BadParameter(UsageError):
			
 
				+    """An exception that formats out a standardized error message for a
			
 
				+    bad parameter.  This is useful when thrown from a callback or type as
			
 
				+    Click will attach contextual information to it (for instance, which
			
 
				+    parameter it is).
			
 
				+
			
 
				+    .. versionadded:: 2.0
			
 
				+
			
 
				+    :param param: the parameter object that caused this error.  This can
			
 
				+                  be left out, and Click will attach this info itself
			
 
				+                  if possible.
			
 
				+    :param param_hint: a string that shows up as parameter name.  This
			
 
				+                       can be used as alternative to `param` in cases
			
 
				+                       where custom validation should happen.  If it is
			
 
				+                       a string it's used as such, if it's a list then
			
 
				+                       each item is quoted and separated.
			
 
				+    """
			
 
				+
			
 
				+    def __init__(
			
 
				+        self,
			
 
				+        message: str,
			
 
				+        ctx: t.Optional["Context"] = None,
			
 
				+        param: t.Optional["Parameter"] = None,
			
 
				+        param_hint: t.Optional[str] = None,
			
 
				+    ) -> None:
			
 
				+        super().__init__(message, ctx)
			
 
				+        self.param = param
			
 
				+        self.param_hint = param_hint
			
 
				+
			
 
				+    def format_message(self) -> str:
			
 
				+        if self.param_hint is not None:
			
 
				+            param_hint = self.param_hint
			
 
				+        elif self.param is not None:
			
 
				+            param_hint = self.param.get_error_hint(self.ctx)  # type: ignore
			
 
				+        else:
			
 
				+            return _("Invalid value: {message}").format(message=self.message)
			
 
				+
			
 
				+        return _("Invalid value for {param_hint}: {message}").format(
			
 
				+            param_hint=_join_param_hints(param_hint), message=self.message
			
 
				+        )
			
 
				+
			
 
				+
			
 
				+class MissingParameter(BadParameter):
			
 
				+    """Raised if click required an option or argument but it was not
			
 
				+    provided when invoking the script.
			
 
				+
			
 
				+    .. versionadded:: 4.0
			
 
				+
			
 
				+    :param param_type: a string that indicates the type of the parameter.
			
 
				+                       The default is to inherit the parameter type from
			
 
				+                       the given `param`.  Valid values are ``'parameter'``,
			
 
				+                       ``'option'`` or ``'argument'``.
			
 
				+    """
			
 
				+
			
 
				+    def __init__(
			
 
				+        self,
			
 
				+        message: t.Optional[str] = None,
			
 
				+        ctx: t.Optional["Context"] = None,
			
 
				+        param: t.Optional["Parameter"] = None,
			
 
				+        param_hint: t.Optional[str] = None,
			
 
				+        param_type: t.Optional[str] = None,
			
 
				+    ) -> None:
			
 
				+        super().__init__(message or "", ctx, param, param_hint)
			
 
				+        self.param_type = param_type
			
 
				+
			
 
				+    def format_message(self) -> str:
			
 
				+        if self.param_hint is not None:
			
 
				+            param_hint: t.Optional[str] = self.param_hint
			
 
				+        elif self.param is not None:
			
 
				+            param_hint = self.param.get_error_hint(self.ctx)  # type: ignore
			
 
				+        else:
			
 
				+            param_hint = None
			
 
				+
			
 
				+        param_hint = _join_param_hints(param_hint)
			
 
				+        param_hint = f" {param_hint}" if param_hint else ""
			
 
				+
			
 
				+        param_type = self.param_type
			
 
				+        if param_type is None and self.param is not None:
			
 
				+            param_type = self.param.param_type_name
			
 
				+
			
 
				+        msg = self.message
			
 
				+        if self.param is not None:
			
 
				+            msg_extra = self.param.type.get_missing_message(self.param)
			
 
				+            if msg_extra:
			
 
				+                if msg:
			
 
				+                    msg += f". {msg_extra}"
			
 
				+                else:
			
 
				+                    msg = msg_extra
			
 
				+
			
 
				+        msg = f" {msg}" if msg else ""
			
 
				+
			
 
				+        # Translate param_type for known types.
			
 
				+        if param_type == "argument":
			
 
				+            missing = _("Missing argument")
			
 
				+        elif param_type == "option":
			
 
				+            missing = _("Missing option")
			
 
				+        elif param_type == "parameter":
			
 
				+            missing = _("Missing parameter")
			
 
				+        else:
			
 
				+            missing = _("Missing {param_type}").format(param_type=param_type)
			
 
				+
			
 
				+        return f"{missing}{param_hint}.{msg}"
			
 
				+
			
 
				+    def __str__(self) -> str:
			
 
				+        if not self.message:
			
 
				+            param_name = self.param.name if self.param else None
			
 
				+            return _("Missing parameter: {param_name}").format(param_name=param_name)
			
 
				+        else:
			
 
				+            return self.message
			
 
				+
			
 
				+
			
 
				+class NoSuchOption(UsageError):
			
 
				+    """Raised if click attempted to handle an option that does not
			
 
				+    exist.
			
 
				+
			
 
				+    .. versionadded:: 4.0
			
 
				+    """
			
 
				+
			
 
				+    def __init__(
			
 
				+        self,
			
 
				+        option_name: str,
			
 
				+        message: t.Optional[str] = None,
			
 
				+        possibilities: t.Optional[t.Sequence[str]] = None,
			
 
				+        ctx: t.Optional["Context"] = None,
			
 
				+    ) -> None:
			
 
				+        if message is None:
			
 
				+            message = _("No such option: {name}").format(name=option_name)
			
 
				+
			
 
				+        super().__init__(message, ctx)
			
 
				+        self.option_name = option_name
			
 
				+        self.possibilities = possibilities
			
 
				+
			
 
				+    def format_message(self) -> str:
			
 
				+        if not self.possibilities:
			
 
				+            return self.message
			
 
				+
			
 
				+        possibility_str = ", ".join(sorted(self.possibilities))
			
 
				+        suggest = ngettext(
			
 
				+            "Did you mean {possibility}?",
			
 
				+            "(Possible options: {possibilities})",
			
 
				+            len(self.possibilities),
			
 
				+        ).format(possibility=possibility_str, possibilities=possibility_str)
			
 
				+        return f"{self.message} {suggest}"
			
 
				+
			
 
				+
			
 
				+class BadOptionUsage(UsageError):
			
 
				+    """Raised if an option is generally supplied but the use of the option
			
 
				+    was incorrect.  This is for instance raised if the number of arguments
			
 
				+    for an option is not correct.
			
 
				+
			
 
				+    .. versionadded:: 4.0
			
 
				+
			
 
				+    :param option_name: the name of the option being used incorrectly.
			
 
				+    """
			
 
				+
			
 
				+    def __init__(
			
 
				+        self, option_name: str, message: str, ctx: t.Optional["Context"] = None
			
 
				+    ) -> None:
			
 
				+        super().__init__(message, ctx)
			
 
				+        self.option_name = option_name
			
 
				+
			
 
				+
			
 
				+class BadArgumentUsage(UsageError):
			
 
				+    """Raised if an argument is generally supplied but the use of the argument
			
 
				+    was incorrect.  This is for instance raised if the number of values
			
 
				+    for an argument is not correct.
			
 
				+
			
 
				+    .. versionadded:: 6.0
			
 
				+    """
			
 
				+
			
 
				+
			
 
				+class FileError(ClickException):
			
 
				+    """Raised if a file cannot be opened."""
			
 
				+
			
 
				+    def __init__(self, filename: str, hint: t.Optional[str] = None) -> None:
			
 
				+        if hint is None:
			
 
				+            hint = _("unknown error")
			
 
				+
			
 
				+        super().__init__(hint)
			
 
				+        self.ui_filename: str = format_filename(filename)
			
 
				+        self.filename = filename
			
 
				+
			
 
				+    def format_message(self) -> str:
			
 
				+        return _("Could not open file {filename!r}: {message}").format(
			
 
				+            filename=self.ui_filename, message=self.message
			
 
				+        )
			
 
				+
			
 
				+
			
 
				+class Abort(RuntimeError):
			
 
				+    """An internal signalling exception that signals Click to abort."""
			
 
				+
			
 
				+
			
 
				+class Exit(RuntimeError):
			
 
				+    """An exception that indicates that the application should exit with some
			
 
				+    status code.
			
 
				+
			
 
				+    :param code: the status code to exit with.
			
 
				+    """
			
 
				+
			
 
				+    __slots__ = ("exit_code",)
			
 
				+
			
 
				+    def __init__(self, code: int = 0) -> None:
			
 
				+        self.exit_code: int = code
			
--- a/courses/flask/microblog/env/Lib/site-packages/click/formatting.py
+++ b/courses/flask/microblog/env/Lib/site-packages/click/formatting.py
@@ -0,0 +1,301 @@
 
				+import typing as t
			
 
				+from contextlib import contextmanager
			
 
				+from gettext import gettext as _
			
 
				+
			
 
				+from ._compat import term_len
			
 
				+from .parser import split_opt
			
 
				+
			
 
				+# Can force a width.  This is used by the test system
			
 
				+FORCED_WIDTH: t.Optional[int] = None
			
 
				+
			
 
				+
			
 
				+def measure_table(rows: t.Iterable[t.Tuple[str, str]]) -> t.Tuple[int, ...]:
			
 
				+    widths: t.Dict[int, int] = {}
			
 
				+
			
 
				+    for row in rows:
			
 
				+        for idx, col in enumerate(row):
			
 
				+            widths[idx] = max(widths.get(idx, 0), term_len(col))
			
 
				+
			
 
				+    return tuple(y for x, y in sorted(widths.items()))
			
 
				+
			
 
				+
			
 
				+def iter_rows(
			
 
				+    rows: t.Iterable[t.Tuple[str, str]], col_count: int
			
 
				+) -> t.Iterator[t.Tuple[str, ...]]:
			
 
				+    for row in rows:
			
 
				+        yield row + ("",) * (col_count - len(row))
			
 
				+
			
 
				+
			
 
				+def wrap_text(
			
 
				+    text: str,
			
 
				+    width: int = 78,
			
 
				+    initial_indent: str = "",
			
 
				+    subsequent_indent: str = "",
			
 
				+    preserve_paragraphs: bool = False,
			
 
				+) -> str:
			
 
				+    """A helper function that intelligently wraps text.  By default, it
			
 
				+    assumes that it operates on a single paragraph of text but if the
			
 
				+    `preserve_paragraphs` parameter is provided it will intelligently
			
 
				+    handle paragraphs (defined by two empty lines).
			
 
				+
			
 
				+    If paragraphs are handled, a paragraph can be prefixed with an empty
			
 
				+    line containing the ``\\b`` character (``\\x08``) to indicate that
			
 
				+    no rewrapping should happen in that block.
			
 
				+
			
 
				+    :param text: the text that should be rewrapped.
			
 
				+    :param width: the maximum width for the text.
			
 
				+    :param initial_indent: the initial indent that should be placed on the
			
 
				+                           first line as a string.
			
 
				+    :param subsequent_indent: the indent string that should be placed on
			
 
				+                              each consecutive line.
			
 
				+    :param preserve_paragraphs: if this flag is set then the wrapping will
			
 
				+                                intelligently handle paragraphs.
			
 
				+    """
			
 
				+    from ._textwrap import TextWrapper
			
 
				+
			
 
				+    text = text.expandtabs()
			
 
				+    wrapper = TextWrapper(
			
 
				+        width,
			
 
				+        initial_indent=initial_indent,
			
 
				+        subsequent_indent=subsequent_indent,
			
 
				+        replace_whitespace=False,
			
 
				+    )
			
 
				+    if not preserve_paragraphs:
			
 
				+        return wrapper.fill(text)
			
 
				+
			
 
				+    p: t.List[t.Tuple[int, bool, str]] = []
			
 
				+    buf: t.List[str] = []
			
 
				+    indent = None
			
 
				+
			
 
				+    def _flush_par() -> None:
			
 
				+        if not buf:
			
 
				+            return
			
 
				+        if buf[0].strip() == "\b":
			
 
				+            p.append((indent or 0, True, "\n".join(buf[1:])))
			
 
				+        else:
			
 
				+            p.append((indent or 0, False, " ".join(buf)))
			
 
				+        del buf[:]
			
 
				+
			
 
				+    for line in text.splitlines():
			
 
				+        if not line:
			
 
				+            _flush_par()
			
 
				+            indent = None
			
 
				+        else:
			
 
				+            if indent is None:
			
 
				+                orig_len = term_len(line)
			
 
				+                line = line.lstrip()
			
 
				+                indent = orig_len - term_len(line)
			
 
				+            buf.append(line)
			
 
				+    _flush_par()
			
 
				+
			
 
				+    rv = []
			
 
				+    for indent, raw, text in p:
			
 
				+        with wrapper.extra_indent(" " * indent):
			
 
				+            if raw:
			
 
				+                rv.append(wrapper.indent_only(text))
			
 
				+            else:
			
 
				+                rv.append(wrapper.fill(text))
			
 
				+
			
 
				+    return "\n\n".join(rv)
			
 
				+
			
 
				+
			
 
				+class HelpFormatter:
			
 
				+    """This class helps with formatting text-based help pages.  It's
			
 
				+    usually just needed for very special internal cases, but it's also
			
 
				+    exposed so that developers can write their own fancy outputs.
			
 
				+
			
 
				+    At present, it always writes into memory.
			
 
				+
			
 
				+    :param indent_increment: the additional increment for each level.
			
 
				+    :param width: the width for the text.  This defaults to the terminal
			
 
				+                  width clamped to a maximum of 78.
			
 
				+    """
			
 
				+
			
 
				+    def __init__(
			
 
				+        self,
			
 
				+        indent_increment: int = 2,
			
 
				+        width: t.Optional[int] = None,
			
 
				+        max_width: t.Optional[int] = None,
			
 
				+    ) -> None:
			
 
				+        import shutil
			
 
				+
			
 
				+        self.indent_increment = indent_increment
			
 
				+        if max_width is None:
			
 
				+            max_width = 80
			
 
				+        if width is None:
			
 
				+            width = FORCED_WIDTH
			
 
				+            if width is None:
			
 
				+                width = max(min(shutil.get_terminal_size().columns, max_width) - 2, 50)
			
 
				+        self.width = width
			
 
				+        self.current_indent = 0
			
 
				+        self.buffer: t.List[str] = []
			
 
				+
			
 
				+    def write(self, string: str) -> None:
			
 
				+        """Writes a unicode string into the internal buffer."""
			
 
				+        self.buffer.append(string)
			
 
				+
			
 
				+    def indent(self) -> None:
			
 
				+        """Increases the indentation."""
			
 
				+        self.current_indent += self.indent_increment
			
 
				+
			
 
				+    def dedent(self) -> None:
			
 
				+        """Decreases the indentation."""
			
 
				+        self.current_indent -= self.indent_increment
			
 
				+
			
 
				+    def write_usage(
			
 
				+        self, prog: str, args: str = "", prefix: t.Optional[str] = None
			
 
				+    ) -> None:
			
 
				+        """Writes a usage line into the buffer.
			
 
				+
			
 
				+        :param prog: the program name.
			
 
				+        :param args: whitespace separated list of arguments.
			
 
				+        :param prefix: The prefix for the first line. Defaults to
			
 
				+            ``"Usage: "``.
			
 
				+        """
			
 
				+        if prefix is None:
			
 
				+            prefix = f"{_('Usage:')} "
			
 
				+
			
 
				+        usage_prefix = f"{prefix:>{self.current_indent}}{prog} "
			
 
				+        text_width = self.width - self.current_indent
			
 
				+
			
 
				+        if text_width >= (term_len(usage_prefix) + 20):
			
 
				+            # The arguments will fit to the right of the prefix.
			
 
				+            indent = " " * term_len(usage_prefix)
			
 
				+            self.write(
			
 
				+                wrap_text(
			
 
				+                    args,
			
 
				+                    text_width,
			
 
				+                    initial_indent=usage_prefix,
			
 
				+                    subsequent_indent=indent,
			
 
				+                )
			
 
				+            )
			
 
				+        else:
			
 
				+            # The prefix is too long, put the arguments on the next line.
			
 
				+            self.write(usage_prefix)
			
 
				+            self.write("\n")
			
 
				+            indent = " " * (max(self.current_indent, term_len(prefix)) + 4)
			
 
				+            self.write(
			
 
				+                wrap_text(
			
 
				+                    args, text_width, initial_indent=indent, subsequent_indent=indent
			
 
				+                )
			
 
				+            )
			
 
				+
			
 
				+        self.write("\n")
			
 
				+
			
 
				+    def write_heading(self, heading: str) -> None:
			
 
				+        """Writes a heading into the buffer."""
			
 
				+        self.write(f"{'':>{self.current_indent}}{heading}:\n")
			
 
				+
			
 
				+    def write_paragraph(self) -> None:
			
 
				+        """Writes a paragraph into the buffer."""
			
 
				+        if self.buffer:
			
 
				+            self.write("\n")
			
 
				+
			
 
				+    def write_text(self, text: str) -> None:
			
 
				+        """Writes re-indented text into the buffer.  This rewraps and
			
 
				+        preserves paragraphs.
			
 
				+        """
			
 
				+        indent = " " * self.current_indent
			
 
				+        self.write(
			
 
				+            wrap_text(
			
 
				+                text,
			
 
				+                self.width,
			
 
				+                initial_indent=indent,
			
 
				+                subsequent_indent=indent,
			
 
				+                preserve_paragraphs=True,
			
 
				+            )
			
 
				+        )
			
 
				+        self.write("\n")
			
 
				+
			
 
				+    def write_dl(
			
 
				+        self,
			
 
				+        rows: t.Sequence[t.Tuple[str, str]],
			
 
				+        col_max: int = 30,
			
 
				+        col_spacing: int = 2,
			
 
				+    ) -> None:
			
 
				+        """Writes a definition list into the buffer.  This is how options
			
 
				+        and commands are usually formatted.
			
 
				+
			
 
				+        :param rows: a list of two item tuples for the terms and values.
			
 
				+        :param col_max: the maximum width of the first column.
			
 
				+        :param col_spacing: the number of spaces between the first and
			
 
				+                            second column.
			
 
				+        """
			
 
				+        rows = list(rows)
			
 
				+        widths = measure_table(rows)
			
 
				+        if len(widths) != 2:
			
 
				+            raise TypeError("Expected two columns for definition list")
			
 
				+
			
 
				+        first_col = min(widths[0], col_max) + col_spacing
			
 
				+
			
 
				+        for first, second in iter_rows(rows, len(widths)):
			
 
				+            self.write(f"{'':>{self.current_indent}}{first}")
			
 
				+            if not second:
			
 
				+                self.write("\n")
			
 
				+                continue
			
 
				+            if term_len(first) <= first_col - col_spacing:
			
 
				+                self.write(" " * (first_col - term_len(first)))
			
 
				+            else:
			
 
				+                self.write("\n")
			
 
				+                self.write(" " * (first_col + self.current_indent))
			
 
				+
			
 
				+            text_width = max(self.width - first_col - 2, 10)
			
 
				+            wrapped_text = wrap_text(second, text_width, preserve_paragraphs=True)
			
 
				+            lines = wrapped_text.splitlines()
			
 
				+
			
 
				+            if lines:
			
 
				+                self.write(f"{lines[0]}\n")
			
 
				+
			
 
				+                for line in lines[1:]:
			
 
				+                    self.write(f"{'':>{first_col + self.current_indent}}{line}\n")
			
 
				+            else:
			
 
				+                self.write("\n")
			
 
				+
			
 
				+    @contextmanager
			
 
				+    def section(self, name: str) -> t.Iterator[None]:
			
 
				+        """Helpful context manager that writes a paragraph, a heading,
			
 
				+        and the indents.
			
 
				+
			
 
				+        :param name: the section name that is written as heading.
			
 
				+        """
			
 
				+        self.write_paragraph()
			
 
				+        self.write_heading(name)
			
 
				+        self.indent()
			
 
				+        try:
			
 
				+            yield
			
 
				+        finally:
			
 
				+            self.dedent()
			
 
				+
			
 
				+    @contextmanager
			
 
				+    def indentation(self) -> t.Iterator[None]:
			
 
				+        """A context manager that increases the indentation."""
			
 
				+        self.indent()
			
 
				+        try:
			
 
				+            yield
			
 
				+        finally:
			
 
				+            self.dedent()
			
 
				+
			
 
				+    def getvalue(self) -> str:
			
 
				+        """Returns the buffer contents."""
			
 
				+        return "".join(self.buffer)
			
 
				+
			
 
				+
			
 
				+def join_options(options: t.Sequence[str]) -> t.Tuple[str, bool]:
			
 
				+    """Given a list of option strings this joins them in the most appropriate
			
 
				+    way and returns them in the form ``(formatted_string,
			
 
				+    any_prefix_is_slash)`` where the second item in the tuple is a flag that
			
 
				+    indicates if any of the option prefixes was a slash.
			
 
				+    """
			
 
				+    rv = []
			
 
				+    any_prefix_is_slash = False
			
 
				+
			
 
				+    for opt in options:
			
 
				+        prefix = split_opt(opt)[0]
			
 
				+
			
 
				+        if prefix == "/":
			
 
				+            any_prefix_is_slash = True
			
 
				+
			
 
				+        rv.append((len(prefix), opt))
			
 
				+
			
 
				+    rv.sort(key=lambda x: x[0])
			
 
				+    return ", ".join(x[1] for x in rv), any_prefix_is_slash
			
--- a/courses/flask/microblog/env/Lib/site-packages/click/globals.py
+++ b/courses/flask/microblog/env/Lib/site-packages/click/globals.py
@@ -0,0 +1,68 @@
 
				+import typing as t
			
 
				+from threading import local
			
 
				+
			
 
				+if t.TYPE_CHECKING:
			
 
				+    import typing_extensions as te
			
 
				+    from .core import Context
			
 
				+
			
 
				+_local = local()
			
 
				+
			
 
				+
			
 
				+@t.overload
			
 
				+def get_current_context(silent: "te.Literal[False]" = False) -> "Context":
			
 
				+    ...
			
 
				+
			
 
				+
			
 
				+@t.overload
			
 
				+def get_current_context(silent: bool = ...) -> t.Optional["Context"]:
			
 
				+    ...
			
 
				+
			
 
				+
			
 
				+def get_current_context(silent: bool = False) -> t.Optional["Context"]:
			
 
				+    """Returns the current click context.  This can be used as a way to
			
 
				+    access the current context object from anywhere.  This is a more implicit
			
 
				+    alternative to the :func:`pass_context` decorator.  This function is
			
 
				+    primarily useful for helpers such as :func:`echo` which might be
			
 
				+    interested in changing its behavior based on the current context.
			
 
				+
			
 
				+    To push the current context, :meth:`Context.scope` can be used.
			
 
				+
			
 
				+    .. versionadded:: 5.0
			
 
				+
			
 
				+    :param silent: if set to `True` the return value is `None` if no context
			
 
				+                   is available.  The default behavior is to raise a
			
 
				+                   :exc:`RuntimeError`.
			
 
				+    """
			
 
				+    try:
			
 
				+        return t.cast("Context", _local.stack[-1])
			
 
				+    except (AttributeError, IndexError) as e:
			
 
				+        if not silent:
			
 
				+            raise RuntimeError("There is no active click context.") from e
			
 
				+
			
 
				+    return None
			
 
				+
			
 
				+
			
 
				+def push_context(ctx: "Context") -> None:
			
 
				+    """Pushes a new context to the current stack."""
			
 
				+    _local.__dict__.setdefault("stack", []).append(ctx)
			
 
				+
			
 
				+
			
 
				+def pop_context() -> None:
			
 
				+    """Removes the top level from the stack."""
			
 
				+    _local.stack.pop()
			
 
				+
			
 
				+
			
 
				+def resolve_color_default(color: t.Optional[bool] = None) -> t.Optional[bool]:
			
 
				+    """Internal helper to get the default value of the color flag.  If a
			
 
				+    value is passed it's returned unchanged, otherwise it's looked up from
			
 
				+    the current context.
			
 
				+    """
			
 
				+    if color is not None:
			
 
				+        return color
			
 
				+
			
 
				+    ctx = get_current_context(silent=True)
			
 
				+
			
 
				+    if ctx is not None:
			
 
				+        return ctx.color
			
 
				+
			
 
				+    return None
			
--- a/courses/flask/microblog/env/Lib/site-packages/click/parser.py
+++ b/courses/flask/microblog/env/Lib/site-packages/click/parser.py
@@ -0,0 +1,529 @@
 
				+"""
			
 
				+This module started out as largely a copy paste from the stdlib's
			
 
				+optparse module with the features removed that we do not need from
			
 
				+optparse because we implement them in Click on a higher level (for
			
 
				+instance type handling, help formatting and a lot more).
			
 
				+
			
 
				+The plan is to remove more and more from here over time.
			
 
				+
			
 
				+The reason this is a different module and not optparse from the stdlib
			
 
				+is that there are differences in 2.x and 3.x about the error messages
			
 
				+generated and optparse in the stdlib uses gettext for no good reason
			
 
				+and might cause us issues.
			
 
				+
			
 
				+Click uses parts of optparse written by Gregory P. Ward and maintained
			
 
				+by the Python Software Foundation. This is limited to code in parser.py.
			
 
				+
			
 
				+Copyright 2001-2006 Gregory P. Ward. All rights reserved.
			
 
				+Copyright 2002-2006 Python Software Foundation. All rights reserved.
			
 
				+"""
			
 
				+# This code uses parts of optparse written by Gregory P. Ward and
			
 
				+# maintained by the Python Software Foundation.
			
 
				+# Copyright 2001-2006 Gregory P. Ward
			
 
				+# Copyright 2002-2006 Python Software Foundation
			
 
				+import typing as t
			
 
				+from collections import deque
			
 
				+from gettext import gettext as _
			
 
				+from gettext import ngettext
			
 
				+
			
 
				+from .exceptions import BadArgumentUsage
			
 
				+from .exceptions import BadOptionUsage
			
 
				+from .exceptions import NoSuchOption
			
 
				+from .exceptions import UsageError
			
 
				+
			
 
				+if t.TYPE_CHECKING:
			
 
				+    import typing_extensions as te
			
 
				+    from .core import Argument as CoreArgument
			
 
				+    from .core import Context
			
 
				+    from .core import Option as CoreOption
			
 
				+    from .core import Parameter as CoreParameter
			
 
				+
			
 
				+V = t.TypeVar("V")
			
 
				+
			
 
				+# Sentinel value that indicates an option was passed as a flag without a
			
 
				+# value but is not a flag option. Option.consume_value uses this to
			
 
				+# prompt or use the flag_value.
			
 
				+_flag_needs_value = object()
			
 
				+
			
 
				+
			
 
				+def _unpack_args(
			
 
				+    args: t.Sequence[str], nargs_spec: t.Sequence[int]
			
 
				+) -> t.Tuple[t.Sequence[t.Union[str, t.Sequence[t.Optional[str]], None]], t.List[str]]:
			
 
				+    """Given an iterable of arguments and an iterable of nargs specifications,
			
 
				+    it returns a tuple with all the unpacked arguments at the first index
			
 
				+    and all remaining arguments as the second.
			
 
				+
			
 
				+    The nargs specification is the number of arguments that should be consumed
			
 
				+    or `-1` to indicate that this position should eat up all the remainders.
			
 
				+
			
 
				+    Missing items are filled with `None`.
			
 
				+    """
			
 
				+    args = deque(args)
			
 
				+    nargs_spec = deque(nargs_spec)
			
 
				+    rv: t.List[t.Union[str, t.Tuple[t.Optional[str], ...], None]] = []
			
 
				+    spos: t.Optional[int] = None
			
 
				+
			
 
				+    def _fetch(c: "te.Deque[V]") -> t.Optional[V]:
			
 
				+        try:
			
 
				+            if spos is None:
			
 
				+                return c.popleft()
			
 
				+            else:
			
 
				+                return c.pop()
			
 
				+        except IndexError:
			
 
				+            return None
			
 
				+
			
 
				+    while nargs_spec:
			
 
				+        nargs = _fetch(nargs_spec)
			
 
				+
			
 
				+        if nargs is None:
			
 
				+            continue
			
 
				+
			
 
				+        if nargs == 1:
			
 
				+            rv.append(_fetch(args))
			
 
				+        elif nargs > 1:
			
 
				+            x = [_fetch(args) for _ in range(nargs)]
			
 
				+
			
 
				+            # If we're reversed, we're pulling in the arguments in reverse,
			
 
				+            # so we need to turn them around.
			
 
				+            if spos is not None:
			
 
				+                x.reverse()
			
 
				+
			
 
				+            rv.append(tuple(x))
			
 
				+        elif nargs < 0:
			
 
				+            if spos is not None:
			
 
				+                raise TypeError("Cannot have two nargs < 0")
			
 
				+
			
 
				+            spos = len(rv)
			
 
				+            rv.append(None)
			
 
				+
			
 
				+    # spos is the position of the wildcard (star).  If it's not `None`,
			
 
				+    # we fill it with the remainder.
			
 
				+    if spos is not None:
			
 
				+        rv[spos] = tuple(args)
			
 
				+        args = []
			
 
				+        rv[spos + 1 :] = reversed(rv[spos + 1 :])
			
 
				+
			
 
				+    return tuple(rv), list(args)
			
 
				+
			
 
				+
			
 
				+def split_opt(opt: str) -> t.Tuple[str, str]:
			
 
				+    first = opt[:1]
			
 
				+    if first.isalnum():
			
 
				+        return "", opt
			
 
				+    if opt[1:2] == first:
			
 
				+        return opt[:2], opt[2:]
			
 
				+    return first, opt[1:]
			
 
				+
			
 
				+
			
 
				+def normalize_opt(opt: str, ctx: t.Optional["Context"]) -> str:
			
 
				+    if ctx is None or ctx.token_normalize_func is None:
			
 
				+        return opt
			
 
				+    prefix, opt = split_opt(opt)
			
 
				+    return f"{prefix}{ctx.token_normalize_func(opt)}"
			
 
				+
			
 
				+
			
 
				+def split_arg_string(string: str) -> t.List[str]:
			
 
				+    """Split an argument string as with :func:`shlex.split`, but don't
			
 
				+    fail if the string is incomplete. Ignores a missing closing quote or
			
 
				+    incomplete escape sequence and uses the partial token as-is.
			
 
				+
			
 
				+    .. code-block:: python
			
 
				+
			
 
				+        split_arg_string("example 'my file")
			
 
				+        ["example", "my file"]
			
 
				+
			
 
				+        split_arg_string("example my\\")
			
 
				+        ["example", "my"]
			
 
				+
			
 
				+    :param string: String to split.
			
 
				+    """
			
 
				+    import shlex
			
 
				+
			
 
				+    lex = shlex.shlex(string, posix=True)
			
 
				+    lex.whitespace_split = True
			
 
				+    lex.commenters = ""
			
 
				+    out = []
			
 
				+
			
 
				+    try:
			
 
				+        for token in lex:
			
 
				+            out.append(token)
			
 
				+    except ValueError:
			
 
				+        # Raised when end-of-string is reached in an invalid state. Use
			
 
				+        # the partial token as-is. The quote or escape character is in
			
 
				+        # lex.state, not lex.token.
			
 
				+        out.append(lex.token)
			
 
				+
			
 
				+    return out
			
 
				+
			
 
				+
			
 
				+class Option:
			
 
				+    def __init__(
			
 
				+        self,
			
 
				+        obj: "CoreOption",
			
 
				+        opts: t.Sequence[str],
			
 
				+        dest: t.Optional[str],
			
 
				+        action: t.Optional[str] = None,
			
 
				+        nargs: int = 1,
			
 
				+        const: t.Optional[t.Any] = None,
			
 
				+    ):
			
 
				+        self._short_opts = []
			
 
				+        self._long_opts = []
			
 
				+        self.prefixes: t.Set[str] = set()
			
 
				+
			
 
				+        for opt in opts:
			
 
				+            prefix, value = split_opt(opt)
			
 
				+            if not prefix:
			
 
				+                raise ValueError(f"Invalid start character for option ({opt})")
			
 
				+            self.prefixes.add(prefix[0])
			
 
				+            if len(prefix) == 1 and len(value) == 1:
			
 
				+                self._short_opts.append(opt)
			
 
				+            else:
			
 
				+                self._long_opts.append(opt)
			
 
				+                self.prefixes.add(prefix)
			
 
				+
			
 
				+        if action is None:
			
 
				+            action = "store"
			
 
				+
			
 
				+        self.dest = dest
			
 
				+        self.action = action
			
 
				+        self.nargs = nargs
			
 
				+        self.const = const
			
 
				+        self.obj = obj
			
 
				+
			
 
				+    @property
			
 
				+    def takes_value(self) -> bool:
			
 
				+        return self.action in ("store", "append")
			
 
				+
			
 
				+    def process(self, value: t.Any, state: "ParsingState") -> None:
			
 
				+        if self.action == "store":
			
 
				+            state.opts[self.dest] = value  # type: ignore
			
 
				+        elif self.action == "store_const":
			
 
				+            state.opts[self.dest] = self.const  # type: ignore
			
 
				+        elif self.action == "append":
			
 
				+            state.opts.setdefault(self.dest, []).append(value)  # type: ignore
			
 
				+        elif self.action == "append_const":
			
 
				+            state.opts.setdefault(self.dest, []).append(self.const)  # type: ignore
			
 
				+        elif self.action == "count":
			
 
				+            state.opts[self.dest] = state.opts.get(self.dest, 0) + 1  # type: ignore
			
 
				+        else:
			
 
				+            raise ValueError(f"unknown action '{self.action}'")
			
 
				+        state.order.append(self.obj)
			
 
				+
			
 
				+
			
 
				+class Argument:
			
 
				+    def __init__(self, obj: "CoreArgument", dest: t.Optional[str], nargs: int = 1):
			
 
				+        self.dest = dest
			
 
				+        self.nargs = nargs
			
 
				+        self.obj = obj
			
 
				+
			
 
				+    def process(
			
 
				+        self,
			
 
				+        value: t.Union[t.Optional[str], t.Sequence[t.Optional[str]]],
			
 
				+        state: "ParsingState",
			
 
				+    ) -> None:
			
 
				+        if self.nargs > 1:
			
 
				+            assert value is not None
			
 
				+            holes = sum(1 for x in value if x is None)
			
 
				+            if holes == len(value):
			
 
				+                value = None
			
 
				+            elif holes != 0:
			
 
				+                raise BadArgumentUsage(
			
 
				+                    _("Argument {name!r} takes {nargs} values.").format(
			
 
				+                        name=self.dest, nargs=self.nargs
			
 
				+                    )
			
 
				+                )
			
 
				+
			
 
				+        if self.nargs == -1 and self.obj.envvar is not None and value == ():
			
 
				+            # Replace empty tuple with None so that a value from the
			
 
				+            # environment may be tried.
			
 
				+            value = None
			
 
				+
			
 
				+        state.opts[self.dest] = value  # type: ignore
			
 
				+        state.order.append(self.obj)
			
 
				+
			
 
				+
			
 
				+class ParsingState:
			
 
				+    def __init__(self, rargs: t.List[str]) -> None:
			
 
				+        self.opts: t.Dict[str, t.Any] = {}
			
 
				+        self.largs: t.List[str] = []
			
 
				+        self.rargs = rargs
			
 
				+        self.order: t.List["CoreParameter"] = []
			
 
				+
			
 
				+
			
 
				+class OptionParser:
			
 
				+    """The option parser is an internal class that is ultimately used to
			
 
				+    parse options and arguments.  It's modelled after optparse and brings
			
 
				+    a similar but vastly simplified API.  It should generally not be used
			
 
				+    directly as the high level Click classes wrap it for you.
			
 
				+
			
 
				+    It's not nearly as extensible as optparse or argparse as it does not
			
 
				+    implement features that are implemented on a higher level (such as
			
 
				+    types or defaults).
			
 
				+
			
 
				+    :param ctx: optionally the :class:`~click.Context` where this parser
			
 
				+                should go with.
			
 
				+    """
			
 
				+
			
 
				+    def __init__(self, ctx: t.Optional["Context"] = None) -> None:
			
 
				+        #: The :class:`~click.Context` for this parser.  This might be
			
 
				+        #: `None` for some advanced use cases.
			
 
				+        self.ctx = ctx
			
 
				+        #: This controls how the parser deals with interspersed arguments.
			
 
				+        #: If this is set to `False`, the parser will stop on the first
			
 
				+        #: non-option.  Click uses this to implement nested subcommands
			
 
				+        #: safely.
			
 
				+        self.allow_interspersed_args: bool = True
			
 
				+        #: This tells the parser how to deal with unknown options.  By
			
 
				+        #: default it will error out (which is sensible), but there is a
			
 
				+        #: second mode where it will ignore it and continue processing
			
 
				+        #: after shifting all the unknown options into the resulting args.
			
 
				+        self.ignore_unknown_options: bool = False
			
 
				+
			
 
				+        if ctx is not None:
			
 
				+            self.allow_interspersed_args = ctx.allow_interspersed_args
			
 
				+            self.ignore_unknown_options = ctx.ignore_unknown_options
			
 
				+
			
 
				+        self._short_opt: t.Dict[str, Option] = {}
			
 
				+        self._long_opt: t.Dict[str, Option] = {}
			
 
				+        self._opt_prefixes = {"-", "--"}
			
 
				+        self._args: t.List[Argument] = []
			
 
				+
			
 
				+    def add_option(
			
 
				+        self,
			
 
				+        obj: "CoreOption",
			
 
				+        opts: t.Sequence[str],
			
 
				+        dest: t.Optional[str],
			
 
				+        action: t.Optional[str] = None,
			
 
				+        nargs: int = 1,
			
 
				+        const: t.Optional[t.Any] = None,
			
 
				+    ) -> None:
			
 
				+        """Adds a new option named `dest` to the parser.  The destination
			
 
				+        is not inferred (unlike with optparse) and needs to be explicitly
			
 
				+        provided.  Action can be any of ``store``, ``store_const``,
			
 
				+        ``append``, ``append_const`` or ``count``.
			
 
				+
			
 
				+        The `obj` can be used to identify the option in the order list
			
 
				+        that is returned from the parser.
			
 
				+        """
			
 
				+        opts = [normalize_opt(opt, self.ctx) for opt in opts]
			
 
				+        option = Option(obj, opts, dest, action=action, nargs=nargs, const=const)
			
 
				+        self._opt_prefixes.update(option.prefixes)
			
 
				+        for opt in option._short_opts:
			
 
				+            self._short_opt[opt] = option
			
 
				+        for opt in option._long_opts:
			
 
				+            self._long_opt[opt] = option
			
 
				+
			
 
				+    def add_argument(
			
 
				+        self, obj: "CoreArgument", dest: t.Optional[str], nargs: int = 1
			
 
				+    ) -> None:
			
 
				+        """Adds a positional argument named `dest` to the parser.
			
 
				+
			
 
				+        The `obj` can be used to identify the option in the order list
			
 
				+        that is returned from the parser.
			
 
				+        """
			
 
				+        self._args.append(Argument(obj, dest=dest, nargs=nargs))
			
 
				+
			
 
				+    def parse_args(
			
 
				+        self, args: t.List[str]
			
 
				+    ) -> t.Tuple[t.Dict[str, t.Any], t.List[str], t.List["CoreParameter"]]:
			
 
				+        """Parses positional arguments and returns ``(values, args, order)``
			
 
				+        for the parsed options and arguments as well as the leftover
			
 
				+        arguments if there are any.  The order is a list of objects as they
			
 
				+        appear on the command line.  If arguments appear multiple times they
			
 
				+        will be memorized multiple times as well.
			
 
				+        """
			
 
				+        state = ParsingState(args)
			
 
				+        try:
			
 
				+            self._process_args_for_options(state)
			
 
				+            self._process_args_for_args(state)
			
 
				+        except UsageError:
			
 
				+            if self.ctx is None or not self.ctx.resilient_parsing:
			
 
				+                raise
			
 
				+        return state.opts, state.largs, state.order
			
 
				+
			
 
				+    def _process_args_for_args(self, state: ParsingState) -> None:
			
 
				+        pargs, args = _unpack_args(
			
 
				+            state.largs + state.rargs, [x.nargs for x in self._args]
			
 
				+        )
			
 
				+
			
 
				+        for idx, arg in enumerate(self._args):
			
 
				+            arg.process(pargs[idx], state)
			
 
				+
			
 
				+        state.largs = args
			
 
				+        state.rargs = []
			
 
				+
			
 
				+    def _process_args_for_options(self, state: ParsingState) -> None:
			
 
				+        while state.rargs:
			
 
				+            arg = state.rargs.pop(0)
			
 
				+            arglen = len(arg)
			
 
				+            # Double dashes always handled explicitly regardless of what
			
 
				+            # prefixes are valid.
			
 
				+            if arg == "--":
			
 
				+                return
			
 
				+            elif arg[:1] in self._opt_prefixes and arglen > 1:
			
 
				+                self._process_opts(arg, state)
			
 
				+            elif self.allow_interspersed_args:
			
 
				+                state.largs.append(arg)
			
 
				+            else:
			
 
				+                state.rargs.insert(0, arg)
			
 
				+                return
			
 
				+
			
 
				+        # Say this is the original argument list:
			
 
				+        # [arg0, arg1, ..., arg(i-1), arg(i), arg(i+1), ..., arg(N-1)]
			
 
				+        #                            ^
			
 
				+        # (we are about to process arg(i)).
			
 
				+        #
			
 
				+        # Then rargs is [arg(i), ..., arg(N-1)] and largs is a *subset* of
			
 
				+        # [arg0, ..., arg(i-1)] (any options and their arguments will have
			
 
				+        # been removed from largs).
			
 
				+        #
			
 
				+        # The while loop will usually consume 1 or more arguments per pass.
			
 
				+        # If it consumes 1 (eg. arg is an option that takes no arguments),
			
 
				+        # then after _process_arg() is done the situation is:
			
 
				+        #
			
 
				+        #   largs = subset of [arg0, ..., arg(i)]
			
 
				+        #   rargs = [arg(i+1), ..., arg(N-1)]
			
 
				+        #
			
 
				+        # If allow_interspersed_args is false, largs will always be
			
 
				+        # *empty* -- still a subset of [arg0, ..., arg(i-1)], but
			
 
				+        # not a very interesting subset!
			
 
				+
			
 
				+    def _match_long_opt(
			
 
				+        self, opt: str, explicit_value: t.Optional[str], state: ParsingState
			
 
				+    ) -> None:
			
 
				+        if opt not in self._long_opt:
			
 
				+            from difflib import get_close_matches
			
 
				+
			
 
				+            possibilities = get_close_matches(opt, self._long_opt)
			
 
				+            raise NoSuchOption(opt, possibilities=possibilities, ctx=self.ctx)
			
 
				+
			
 
				+        option = self._long_opt[opt]
			
 
				+        if option.takes_value:
			
 
				+            # At this point it's safe to modify rargs by injecting the
			
 
				+            # explicit value, because no exception is raised in this
			
 
				+            # branch.  This means that the inserted value will be fully
			
 
				+            # consumed.
			
 
				+            if explicit_value is not None:
			
 
				+                state.rargs.insert(0, explicit_value)
			
 
				+
			
 
				+            value = self._get_value_from_state(opt, option, state)
			
 
				+
			
 
				+        elif explicit_value is not None:
			
 
				+            raise BadOptionUsage(
			
 
				+                opt, _("Option {name!r} does not take a value.").format(name=opt)
			
 
				+            )
			
 
				+
			
 
				+        else:
			
 
				+            value = None
			
 
				+
			
 
				+        option.process(value, state)
			
 
				+
			
 
				+    def _match_short_opt(self, arg: str, state: ParsingState) -> None:
			
 
				+        stop = False
			
 
				+        i = 1
			
 
				+        prefix = arg[0]
			
 
				+        unknown_options = []
			
 
				+
			
 
				+        for ch in arg[1:]:
			
 
				+            opt = normalize_opt(f"{prefix}{ch}", self.ctx)
			
 
				+            option = self._short_opt.get(opt)
			
 
				+            i += 1
			
 
				+
			
 
				+            if not option:
			
 
				+                if self.ignore_unknown_options:
			
 
				+                    unknown_options.append(ch)
			
 
				+                    continue
			
 
				+                raise NoSuchOption(opt, ctx=self.ctx)
			
 
				+            if option.takes_value:
			
 
				+                # Any characters left in arg?  Pretend they're the
			
 
				+                # next arg, and stop consuming characters of arg.
			
 
				+                if i < len(arg):
			
 
				+                    state.rargs.insert(0, arg[i:])
			
 
				+                    stop = True
			
 
				+
			
 
				+                value = self._get_value_from_state(opt, option, state)
			
 
				+
			
 
				+            else:
			
 
				+                value = None
			
 
				+
			
 
				+            option.process(value, state)
			
 
				+
			
 
				+            if stop:
			
 
				+                break
			
 
				+
			
 
				+        # If we got any unknown options we recombine the string of the
			
 
				+        # remaining options and re-attach the prefix, then report that
			
 
				+        # to the state as new larg.  This way there is basic combinatorics
			
 
				+        # that can be achieved while still ignoring unknown arguments.
			
 
				+        if self.ignore_unknown_options and unknown_options:
			
 
				+            state.largs.append(f"{prefix}{''.join(unknown_options)}")
			
 
				+
			
 
				+    def _get_value_from_state(
			
 
				+        self, option_name: str, option: Option, state: ParsingState
			
 
				+    ) -> t.Any:
			
 
				+        nargs = option.nargs
			
 
				+
			
 
				+        if len(state.rargs) < nargs:
			
 
				+            if option.obj._flag_needs_value:
			
 
				+                # Option allows omitting the value.
			
 
				+                value = _flag_needs_value
			
 
				+            else:
			
 
				+                raise BadOptionUsage(
			
 
				+                    option_name,
			
 
				+                    ngettext(
			
 
				+                        "Option {name!r} requires an argument.",
			
 
				+                        "Option {name!r} requires {nargs} arguments.",
			
 
				+                        nargs,
			
 
				+                    ).format(name=option_name, nargs=nargs),
			
 
				+                )
			
 
				+        elif nargs == 1:
			
 
				+            next_rarg = state.rargs[0]
			
 
				+
			
 
				+            if (
			
 
				+                option.obj._flag_needs_value
			
 
				+                and isinstance(next_rarg, str)
			
 
				+                and next_rarg[:1] in self._opt_prefixes
			
 
				+                and len(next_rarg) > 1
			
 
				+            ):
			
 
				+                # The next arg looks like the start of an option, don't
			
 
				+                # use it as the value if omitting the value is allowed.
			
 
				+                value = _flag_needs_value
			
 
				+            else:
			
 
				+                value = state.rargs.pop(0)
			
 
				+        else:
			
 
				+            value = tuple(state.rargs[:nargs])
			
 
				+            del state.rargs[:nargs]
			
 
				+
			
 
				+        return value
			
 
				+
			
 
				+    def _process_opts(self, arg: str, state: ParsingState) -> None:
			
 
				+        explicit_value = None
			
 
				+        # Long option handling happens in two parts.  The first part is
			
 
				+        # supporting explicitly attached values.  In any case, we will try
			
 
				+        # to long match the option first.
			
 
				+        if "=" in arg:
			
 
				+            long_opt, explicit_value = arg.split("=", 1)
			
 
				+        else:
			
 
				+            long_opt = arg
			
 
				+        norm_long_opt = normalize_opt(long_opt, self.ctx)
			
 
				+
			
 
				+        # At this point we will match the (assumed) long option through
			
 
				+        # the long option matching code.  Note that this allows options
			
 
				+        # like "-foo" to be matched as long options.
			
 
				+        try:
			
 
				+            self._match_long_opt(norm_long_opt, explicit_value, state)
			
 
				+        except NoSuchOption:
			
 
				+            # At this point the long option matching failed, and we need
			
 
				+            # to try with short options.  However there is a special rule
			
 
				+            # which says, that if we have a two character options prefix
			
 
				+            # (applies to "--foo" for instance), we do not dispatch to the
			
 
				+            # short option code and will instead raise the no option
			
 
				+            # error.
			
 
				+            if arg[:2] not in self._opt_prefixes:
			
 
				+                self._match_short_opt(arg, state)
			
 
				+                return
			
 
				+
			
 
				+            if not self.ignore_unknown_options:
			
 
				+                raise
			
 
				+
			
 
				+            state.largs.append(arg)
			
--- a/courses/flask/microblog/env/Lib/site-packages/click/py.typed
+++ b/courses/flask/microblog/env/Lib/site-packages/click/py.typed
--- a/courses/flask/microblog/env/Lib/site-packages/click/shell_completion.py
+++ b/courses/flask/microblog/env/Lib/site-packages/click/shell_completion.py
@@ -0,0 +1,596 @@
 
				+import os
			
 
				+import re
			
 
				+import typing as t
			
 
				+from gettext import gettext as _
			
 
				+
			
 
				+from .core import Argument
			
 
				+from .core import BaseCommand
			
 
				+from .core import Context
			
 
				+from .core import MultiCommand
			
 
				+from .core import Option
			
 
				+from .core import Parameter
			
 
				+from .core import ParameterSource
			
 
				+from .parser import split_arg_string
			
 
				+from .utils import echo
			
 
				+
			
 
				+
			
 
				+def shell_complete(
			
 
				+    cli: BaseCommand,
			
 
				+    ctx_args: t.MutableMapping[str, t.Any],
			
 
				+    prog_name: str,
			
 
				+    complete_var: str,
			
 
				+    instruction: str,
			
 
				+) -> int:
			
 
				+    """Perform shell completion for the given CLI program.
			
 
				+
			
 
				+    :param cli: Command being called.
			
 
				+    :param ctx_args: Extra arguments to pass to
			
 
				+        ``cli.make_context``.
			
 
				+    :param prog_name: Name of the executable in the shell.
			
 
				+    :param complete_var: Name of the environment variable that holds
			
 
				+        the completion instruction.
			
 
				+    :param instruction: Value of ``complete_var`` with the completion
			
 
				+        instruction and shell, in the form ``instruction_shell``.
			
 
				+    :return: Status code to exit with.
			
 
				+    """
			
 
				+    shell, _, instruction = instruction.partition("_")
			
 
				+    comp_cls = get_completion_class(shell)
			
 
				+
			
 
				+    if comp_cls is None:
			
 
				+        return 1
			
 
				+
			
 
				+    comp = comp_cls(cli, ctx_args, prog_name, complete_var)
			
 
				+
			
 
				+    if instruction == "source":
			
 
				+        echo(comp.source())
			
 
				+        return 0
			
 
				+
			
 
				+    if instruction == "complete":
			
 
				+        echo(comp.complete())
			
 
				+        return 0
			
 
				+
			
 
				+    return 1
			
 
				+
			
 
				+
			
 
				+class CompletionItem:
			
 
				+    """Represents a completion value and metadata about the value. The
			
 
				+    default metadata is ``type`` to indicate special shell handling,
			
 
				+    and ``help`` if a shell supports showing a help string next to the
			
 
				+    value.
			
 
				+
			
 
				+    Arbitrary parameters can be passed when creating the object, and
			
 
				+    accessed using ``item.attr``. If an attribute wasn't passed,
			
 
				+    accessing it returns ``None``.
			
 
				+
			
 
				+    :param value: The completion suggestion.
			
 
				+    :param type: Tells the shell script to provide special completion
			
 
				+        support for the type. Click uses ``"dir"`` and ``"file"``.
			
 
				+    :param help: String shown next to the value if supported.
			
 
				+    :param kwargs: Arbitrary metadata. The built-in implementations
			
 
				+        don't use this, but custom type completions paired with custom
			
 
				+        shell support could use it.
			
 
				+    """
			
 
				+
			
 
				+    __slots__ = ("value", "type", "help", "_info")
			
 
				+
			
 
				+    def __init__(
			
 
				+        self,
			
 
				+        value: t.Any,
			
 
				+        type: str = "plain",
			
 
				+        help: t.Optional[str] = None,
			
 
				+        **kwargs: t.Any,
			
 
				+    ) -> None:
			
 
				+        self.value: t.Any = value
			
 
				+        self.type: str = type
			
 
				+        self.help: t.Optional[str] = help
			
 
				+        self._info = kwargs
			
 
				+
			
 
				+    def __getattr__(self, name: str) -> t.Any:
			
 
				+        return self._info.get(name)
			
 
				+
			
 
				+
			
 
				+# Only Bash >= 4.4 has the nosort option.
			
 
				+_SOURCE_BASH = """\
			
 
				+%(complete_func)s() {
			
 
				+    local IFS=$'\\n'
			
 
				+    local response
			
 
				+
			
 
				+    response=$(env COMP_WORDS="${COMP_WORDS[*]}" COMP_CWORD=$COMP_CWORD \
			
 
				+%(complete_var)s=bash_complete $1)
			
 
				+
			
 
				+    for completion in $response; do
			
 
				+        IFS=',' read type value <<< "$completion"
			
 
				+
			
 
				+        if [[ $type == 'dir' ]]; then
			
 
				+            COMPREPLY=()
			
 
				+            compopt -o dirnames
			
 
				+        elif [[ $type == 'file' ]]; then
			
 
				+            COMPREPLY=()
			
 
				+            compopt -o default
			
 
				+        elif [[ $type == 'plain' ]]; then
			
 
				+            COMPREPLY+=($value)
			
 
				+        fi
			
 
				+    done
			
 
				+
			
 
				+    return 0
			
 
				+}
			
 
				+
			
 
				+%(complete_func)s_setup() {
			
 
				+    complete -o nosort -F %(complete_func)s %(prog_name)s
			
 
				+}
			
 
				+
			
 
				+%(complete_func)s_setup;
			
 
				+"""
			
 
				+
			
 
				+_SOURCE_ZSH = """\
			
 
				+#compdef %(prog_name)s
			
 
				+
			
 
				+%(complete_func)s() {
			
 
				+    local -a completions
			
 
				+    local -a completions_with_descriptions
			
 
				+    local -a response
			
 
				+    (( ! $+commands[%(prog_name)s] )) && return 1
			
 
				+
			
 
				+    response=("${(@f)$(env COMP_WORDS="${words[*]}" COMP_CWORD=$((CURRENT-1)) \
			
 
				+%(complete_var)s=zsh_complete %(prog_name)s)}")
			
 
				+
			
 
				+    for type key descr in ${response}; do
			
 
				+        if [[ "$type" == "plain" ]]; then
			
 
				+            if [[ "$descr" == "_" ]]; then
			
 
				+                completions+=("$key")
			
 
				+            else
			
 
				+                completions_with_descriptions+=("$key":"$descr")
			
 
				+            fi
			
 
				+        elif [[ "$type" == "dir" ]]; then
			
 
				+            _path_files -/
			
 
				+        elif [[ "$type" == "file" ]]; then
			
 
				+            _path_files -f
			
 
				+        fi
			
 
				+    done
			
 
				+
			
 
				+    if [ -n "$completions_with_descriptions" ]; then
			
 
				+        _describe -V unsorted completions_with_descriptions -U
			
 
				+    fi
			
 
				+
			
 
				+    if [ -n "$completions" ]; then
			
 
				+        compadd -U -V unsorted -a completions
			
 
				+    fi
			
 
				+}
			
 
				+
			
 
				+if [[ $zsh_eval_context[-1] == loadautofunc ]]; then
			
 
				+    # autoload from fpath, call function directly
			
 
				+    %(complete_func)s "$@"
			
 
				+else
			
 
				+    # eval/source/. command, register function for later
			
 
				+    compdef %(complete_func)s %(prog_name)s
			
 
				+fi
			
 
				+"""
			
 
				+
			
 
				+_SOURCE_FISH = """\
			
 
				+function %(complete_func)s;
			
 
				+    set -l response (env %(complete_var)s=fish_complete COMP_WORDS=(commandline -cp) \
			
 
				+COMP_CWORD=(commandline -t) %(prog_name)s);
			
 
				+
			
 
				+    for completion in $response;
			
 
				+        set -l metadata (string split "," $completion);
			
 
				+
			
 
				+        if test $metadata[1] = "dir";
			
 
				+            __fish_complete_directories $metadata[2];
			
 
				+        else if test $metadata[1] = "file";
			
 
				+            __fish_complete_path $metadata[2];
			
 
				+        else if test $metadata[1] = "plain";
			
 
				+            echo $metadata[2];
			
 
				+        end;
			
 
				+    end;
			
 
				+end;
			
 
				+
			
 
				+complete --no-files --command %(prog_name)s --arguments \
			
 
				+"(%(complete_func)s)";
			
 
				+"""
			
 
				+
			
 
				+
			
 
				+class ShellComplete:
			
 
				+    """Base class for providing shell completion support. A subclass for
			
 
				+    a given shell will override attributes and methods to implement the
			
 
				+    completion instructions (``source`` and ``complete``).
			
 
				+
			
 
				+    :param cli: Command being called.
			
 
				+    :param prog_name: Name of the executable in the shell.
			
 
				+    :param complete_var: Name of the environment variable that holds
			
 
				+        the completion instruction.
			
 
				+
			
 
				+    .. versionadded:: 8.0
			
 
				+    """
			
 
				+
			
 
				+    name: t.ClassVar[str]
			
 
				+    """Name to register the shell as with :func:`add_completion_class`.
			
 
				+    This is used in completion instructions (``{name}_source`` and
			
 
				+    ``{name}_complete``).
			
 
				+    """
			
 
				+
			
 
				+    source_template: t.ClassVar[str]
			
 
				+    """Completion script template formatted by :meth:`source`. This must
			
 
				+    be provided by subclasses.
			
 
				+    """
			
 
				+
			
 
				+    def __init__(
			
 
				+        self,
			
 
				+        cli: BaseCommand,
			
 
				+        ctx_args: t.MutableMapping[str, t.Any],
			
 
				+        prog_name: str,
			
 
				+        complete_var: str,
			
 
				+    ) -> None:
			
 
				+        self.cli = cli
			
 
				+        self.ctx_args = ctx_args
			
 
				+        self.prog_name = prog_name
			
 
				+        self.complete_var = complete_var
			
 
				+
			
 
				+    @property
			
 
				+    def func_name(self) -> str:
			
 
				+        """The name of the shell function defined by the completion
			
 
				+        script.
			
 
				+        """
			
 
				+        safe_name = re.sub(r"\W*", "", self.prog_name.replace("-", "_"), flags=re.ASCII)
			
 
				+        return f"_{safe_name}_completion"
			
 
				+
			
 
				+    def source_vars(self) -> t.Dict[str, t.Any]:
			
 
				+        """Vars for formatting :attr:`source_template`.
			
 
				+
			
 
				+        By default this provides ``complete_func``, ``complete_var``,
			
 
				+        and ``prog_name``.
			
 
				+        """
			
 
				+        return {
			
 
				+            "complete_func": self.func_name,
			
 
				+            "complete_var": self.complete_var,
			
 
				+            "prog_name": self.prog_name,
			
 
				+        }
			
 
				+
			
 
				+    def source(self) -> str:
			
 
				+        """Produce the shell script that defines the completion
			
 
				+        function. By default this ``%``-style formats
			
 
				+        :attr:`source_template` with the dict returned by
			
 
				+        :meth:`source_vars`.
			
 
				+        """
			
 
				+        return self.source_template % self.source_vars()
			
 
				+
			
 
				+    def get_completion_args(self) -> t.Tuple[t.List[str], str]:
			
 
				+        """Use the env vars defined by the shell script to return a
			
 
				+        tuple of ``args, incomplete``. This must be implemented by
			
 
				+        subclasses.
			
 
				+        """
			
 
				+        raise NotImplementedError
			
 
				+
			
 
				+    def get_completions(
			
 
				+        self, args: t.List[str], incomplete: str
			
 
				+    ) -> t.List[CompletionItem]:
			
 
				+        """Determine the context and last complete command or parameter
			
 
				+        from the complete args. Call that object's ``shell_complete``
			
 
				+        method to get the completions for the incomplete value.
			
 
				+
			
 
				+        :param args: List of complete args before the incomplete value.
			
 
				+        :param incomplete: Value being completed. May be empty.
			
 
				+        """
			
 
				+        ctx = _resolve_context(self.cli, self.ctx_args, self.prog_name, args)
			
 
				+        obj, incomplete = _resolve_incomplete(ctx, args, incomplete)
			
 
				+        return obj.shell_complete(ctx, incomplete)
			
 
				+
			
 
				+    def format_completion(self, item: CompletionItem) -> str:
			
 
				+        """Format a completion item into the form recognized by the
			
 
				+        shell script. This must be implemented by subclasses.
			
 
				+
			
 
				+        :param item: Completion item to format.
			
 
				+        """
			
 
				+        raise NotImplementedError
			
 
				+
			
 
				+    def complete(self) -> str:
			
 
				+        """Produce the completion data to send back to the shell.
			
 
				+
			
 
				+        By default this calls :meth:`get_completion_args`, gets the
			
 
				+        completions, then calls :meth:`format_completion` for each
			
 
				+        completion.
			
 
				+        """
			
 
				+        args, incomplete = self.get_completion_args()
			
 
				+        completions = self.get_completions(args, incomplete)
			
 
				+        out = [self.format_completion(item) for item in completions]
			
 
				+        return "\n".join(out)
			
 
				+
			
 
				+
			
 
				+class BashComplete(ShellComplete):
			
 
				+    """Shell completion for Bash."""
			
 
				+
			
 
				+    name = "bash"
			
 
				+    source_template = _SOURCE_BASH
			
 
				+
			
 
				+    @staticmethod
			
 
				+    def _check_version() -> None:
			
 
				+        import subprocess
			
 
				+
			
 
				+        output = subprocess.run(
			
 
				+            ["bash", "-c", 'echo "${BASH_VERSION}"'], stdout=subprocess.PIPE
			
 
				+        )
			
 
				+        match = re.search(r"^(\d+)\.(\d+)\.\d+", output.stdout.decode())
			
 
				+
			
 
				+        if match is not None:
			
 
				+            major, minor = match.groups()
			
 
				+
			
 
				+            if major < "4" or major == "4" and minor < "4":
			
 
				+                echo(
			
 
				+                    _(
			
 
				+                        "Shell completion is not supported for Bash"
			
 
				+                        " versions older than 4.4."
			
 
				+                    ),
			
 
				+                    err=True,
			
 
				+                )
			
 
				+        else:
			
 
				+            echo(
			
 
				+                _("Couldn't detect Bash version, shell completion is not supported."),
			
 
				+                err=True,
			
 
				+            )
			
 
				+
			
 
				+    def source(self) -> str:
			
 
				+        self._check_version()
			
 
				+        return super().source()
			
 
				+
			
 
				+    def get_completion_args(self) -> t.Tuple[t.List[str], str]:
			
 
				+        cwords = split_arg_string(os.environ["COMP_WORDS"])
			
 
				+        cword = int(os.environ["COMP_CWORD"])
			
 
				+        args = cwords[1:cword]
			
 
				+
			
 
				+        try:
			
 
				+            incomplete = cwords[cword]
			
 
				+        except IndexError:
			
 
				+            incomplete = ""
			
 
				+
			
 
				+        return args, incomplete
			
 
				+
			
 
				+    def format_completion(self, item: CompletionItem) -> str:
			
 
				+        return f"{item.type},{item.value}"
			
 
				+
			
 
				+
			
 
				+class ZshComplete(ShellComplete):
			
 
				+    """Shell completion for Zsh."""
			
 
				+
			
 
				+    name = "zsh"
			
 
				+    source_template = _SOURCE_ZSH
			
 
				+
			
 
				+    def get_completion_args(self) -> t.Tuple[t.List[str], str]:
			
 
				+        cwords = split_arg_string(os.environ["COMP_WORDS"])
			
 
				+        cword = int(os.environ["COMP_CWORD"])
			
 
				+        args = cwords[1:cword]
			
 
				+
			
 
				+        try:
			
 
				+            incomplete = cwords[cword]
			
 
				+        except IndexError:
			
 
				+            incomplete = ""
			
 
				+
			
 
				+        return args, incomplete
			
 
				+
			
 
				+    def format_completion(self, item: CompletionItem) -> str:
			
 
				+        return f"{item.type}\n{item.value}\n{item.help if item.help else '_'}"
			
 
				+
			
 
				+
			
 
				+class FishComplete(ShellComplete):
			
 
				+    """Shell completion for Fish."""
			
 
				+
			
 
				+    name = "fish"
			
 
				+    source_template = _SOURCE_FISH
			
 
				+
			
 
				+    def get_completion_args(self) -> t.Tuple[t.List[str], str]:
			
 
				+        cwords = split_arg_string(os.environ["COMP_WORDS"])
			
 
				+        incomplete = os.environ["COMP_CWORD"]
			
 
				+        args = cwords[1:]
			
 
				+
			
 
				+        # Fish stores the partial word in both COMP_WORDS and
			
 
				+        # COMP_CWORD, remove it from complete args.
			
 
				+        if incomplete and args and args[-1] == incomplete:
			
 
				+            args.pop()
			
 
				+
			
 
				+        return args, incomplete
			
 
				+
			
 
				+    def format_completion(self, item: CompletionItem) -> str:
			
 
				+        if item.help:
			
 
				+            return f"{item.type},{item.value}\t{item.help}"
			
 
				+
			
 
				+        return f"{item.type},{item.value}"
			
 
				+
			
 
				+
			
 
				+ShellCompleteType = t.TypeVar("ShellCompleteType", bound=t.Type[ShellComplete])
			
 
				+
			
 
				+
			
 
				+_available_shells: t.Dict[str, t.Type[ShellComplete]] = {
			
 
				+    "bash": BashComplete,
			
 
				+    "fish": FishComplete,
			
 
				+    "zsh": ZshComplete,
			
 
				+}
			
 
				+
			
 
				+
			
 
				+def add_completion_class(
			
 
				+    cls: ShellCompleteType, name: t.Optional[str] = None
			
 
				+) -> ShellCompleteType:
			
 
				+    """Register a :class:`ShellComplete` subclass under the given name.
			
 
				+    The name will be provided by the completion instruction environment
			
 
				+    variable during completion.
			
 
				+
			
 
				+    :param cls: The completion class that will handle completion for the
			
 
				+        shell.
			
 
				+    :param name: Name to register the class under. Defaults to the
			
 
				+        class's ``name`` attribute.
			
 
				+    """
			
 
				+    if name is None:
			
 
				+        name = cls.name
			
 
				+
			
 
				+    _available_shells[name] = cls
			
 
				+
			
 
				+    return cls
			
 
				+
			
 
				+
			
 
				+def get_completion_class(shell: str) -> t.Optional[t.Type[ShellComplete]]:
			
 
				+    """Look up a registered :class:`ShellComplete` subclass by the name
			
 
				+    provided by the completion instruction environment variable. If the
			
 
				+    name isn't registered, returns ``None``.
			
 
				+
			
 
				+    :param shell: Name the class is registered under.
			
 
				+    """
			
 
				+    return _available_shells.get(shell)
			
 
				+
			
 
				+
			
 
				+def _is_incomplete_argument(ctx: Context, param: Parameter) -> bool:
			
 
				+    """Determine if the given parameter is an argument that can still
			
 
				+    accept values.
			
 
				+
			
 
				+    :param ctx: Invocation context for the command represented by the
			
 
				+        parsed complete args.
			
 
				+    :param param: Argument object being checked.
			
 
				+    """
			
 
				+    if not isinstance(param, Argument):
			
 
				+        return False
			
 
				+
			
 
				+    assert param.name is not None
			
 
				+    # Will be None if expose_value is False.
			
 
				+    value = ctx.params.get(param.name)
			
 
				+    return (
			
 
				+        param.nargs == -1
			
 
				+        or ctx.get_parameter_source(param.name) is not ParameterSource.COMMANDLINE
			
 
				+        or (
			
 
				+            param.nargs > 1
			
 
				+            and isinstance(value, (tuple, list))
			
 
				+            and len(value) < param.nargs
			
 
				+        )
			
 
				+    )
			
 
				+
			
 
				+
			
 
				+def _start_of_option(ctx: Context, value: str) -> bool:
			
 
				+    """Check if the value looks like the start of an option."""
			
 
				+    if not value:
			
 
				+        return False
			
 
				+
			
 
				+    c = value[0]
			
 
				+    return c in ctx._opt_prefixes
			
 
				+
			
 
				+
			
 
				+def _is_incomplete_option(ctx: Context, args: t.List[str], param: Parameter) -> bool:
			
 
				+    """Determine if the given parameter is an option that needs a value.
			
 
				+
			
 
				+    :param args: List of complete args before the incomplete value.
			
 
				+    :param param: Option object being checked.
			
 
				+    """
			
 
				+    if not isinstance(param, Option):
			
 
				+        return False
			
 
				+
			
 
				+    if param.is_flag or param.count:
			
 
				+        return False
			
 
				+
			
 
				+    last_option = None
			
 
				+
			
 
				+    for index, arg in enumerate(reversed(args)):
			
 
				+        if index + 1 > param.nargs:
			
 
				+            break
			
 
				+
			
 
				+        if _start_of_option(ctx, arg):
			
 
				+            last_option = arg
			
 
				+
			
 
				+    return last_option is not None and last_option in param.opts
			
 
				+
			
 
				+
			
 
				+def _resolve_context(
			
 
				+    cli: BaseCommand,
			
 
				+    ctx_args: t.MutableMapping[str, t.Any],
			
 
				+    prog_name: str,
			
 
				+    args: t.List[str],
			
 
				+) -> Context:
			
 
				+    """Produce the context hierarchy starting with the command and
			
 
				+    traversing the complete arguments. This only follows the commands,
			
 
				+    it doesn't trigger input prompts or callbacks.
			
 
				+
			
 
				+    :param cli: Command being called.
			
 
				+    :param prog_name: Name of the executable in the shell.
			
 
				+    :param args: List of complete args before the incomplete value.
			
 
				+    """
			
 
				+    ctx_args["resilient_parsing"] = True
			
 
				+    ctx = cli.make_context(prog_name, args.copy(), **ctx_args)
			
 
				+    args = ctx.protected_args + ctx.args
			
 
				+
			
 
				+    while args:
			
 
				+        command = ctx.command
			
 
				+
			
 
				+        if isinstance(command, MultiCommand):
			
 
				+            if not command.chain:
			
 
				+                name, cmd, args = command.resolve_command(ctx, args)
			
 
				+
			
 
				+                if cmd is None:
			
 
				+                    return ctx
			
 
				+
			
 
				+                ctx = cmd.make_context(name, args, parent=ctx, resilient_parsing=True)
			
 
				+                args = ctx.protected_args + ctx.args
			
 
				+            else:
			
 
				+                sub_ctx = ctx
			
 
				+
			
 
				+                while args:
			
 
				+                    name, cmd, args = command.resolve_command(ctx, args)
			
 
				+
			
 
				+                    if cmd is None:
			
 
				+                        return ctx
			
 
				+
			
 
				+                    sub_ctx = cmd.make_context(
			
 
				+                        name,
			
 
				+                        args,
			
 
				+                        parent=ctx,
			
 
				+                        allow_extra_args=True,
			
 
				+                        allow_interspersed_args=False,
			
 
				+                        resilient_parsing=True,
			
 
				+                    )
			
 
				+                    args = sub_ctx.args
			
 
				+
			
 
				+                ctx = sub_ctx
			
 
				+                args = [*sub_ctx.protected_args, *sub_ctx.args]
			
 
				+        else:
			
 
				+            break
			
 
				+
			
 
				+    return ctx
			
 
				+
			
 
				+
			
 
				+def _resolve_incomplete(
			
 
				+    ctx: Context, args: t.List[str], incomplete: str
			
 
				+) -> t.Tuple[t.Union[BaseCommand, Parameter], str]:
			
 
				+    """Find the Click object that will handle the completion of the
			
 
				+    incomplete value. Return the object and the incomplete value.
			
 
				+
			
 
				+    :param ctx: Invocation context for the command represented by
			
 
				+        the parsed complete args.
			
 
				+    :param args: List of complete args before the incomplete value.
			
 
				+    :param incomplete: Value being completed. May be empty.
			
 
				+    """
			
 
				+    # Different shells treat an "=" between a long option name and
			
 
				+    # value differently. Might keep the value joined, return the "="
			
 
				+    # as a separate item, or return the split name and value. Always
			
 
				+    # split and discard the "=" to make completion easier.
			
 
				+    if incomplete == "=":
			
 
				+        incomplete = ""
			
 
				+    elif "=" in incomplete and _start_of_option(ctx, incomplete):
			
 
				+        name, _, incomplete = incomplete.partition("=")
			
 
				+        args.append(name)
			
 
				+
			
 
				+    # The "--" marker tells Click to stop treating values as options
			
 
				+    # even if they start with the option character. If it hasn't been
			
 
				+    # given and the incomplete arg looks like an option, the current
			
 
				+    # command will provide option name completions.
			
 
				+    if "--" not in args and _start_of_option(ctx, incomplete):
			
 
				+        return ctx.command, incomplete
			
 
				+
			
 
				+    params = ctx.command.get_params(ctx)
			
 
				+
			
 
				+    # If the last complete arg is an option name with an incomplete
			
 
				+    # value, the option will provide value completions.
			
 
				+    for param in params:
			
 
				+        if _is_incomplete_option(ctx, args, param):
			
 
				+            return param, incomplete
			
 
				+
			
 
				+    # It's not an option name or value. The first argument without a
			
 
				+    # parsed value will provide value completions.
			
 
				+    for param in params:
			
 
				+        if _is_incomplete_argument(ctx, param):
			
 
				+            return param, incomplete
			
 
				+
			
 
				+    # There were no unparsed arguments, the command may be a group that
			
 
				+    # will provide command name completions.
			
 
				+    return ctx.command, incomplete
			
--- a/courses/flask/microblog/env/Lib/site-packages/click/termui.py
+++ b/courses/flask/microblog/env/Lib/site-packages/click/termui.py
@@ -0,0 +1,784 @@
 
				+import inspect
			
 
				+import io
			
 
				+import itertools
			
 
				+import sys
			
 
				+import typing as t
			
 
				+from gettext import gettext as _
			
 
				+
			
 
				+from ._compat import isatty
			
 
				+from ._compat import strip_ansi
			
 
				+from .exceptions import Abort
			
 
				+from .exceptions import UsageError
			
 
				+from .globals import resolve_color_default
			
 
				+from .types import Choice
			
 
				+from .types import convert_type
			
 
				+from .types import ParamType
			
 
				+from .utils import echo
			
 
				+from .utils import LazyFile
			
 
				+
			
 
				+if t.TYPE_CHECKING:
			
 
				+    from ._termui_impl import ProgressBar
			
 
				+
			
 
				+V = t.TypeVar("V")
			
 
				+
			
 
				+# The prompt functions to use.  The doc tools currently override these
			
 
				+# functions to customize how they work.
			
 
				+visible_prompt_func: t.Callable[[str], str] = input
			
 
				+
			
 
				+_ansi_colors = {
			
 
				+    "black": 30,
			
 
				+    "red": 31,
			
 
				+    "green": 32,
			
 
				+    "yellow": 33,
			
 
				+    "blue": 34,
			
 
				+    "magenta": 35,
			
 
				+    "cyan": 36,
			
 
				+    "white": 37,
			
 
				+    "reset": 39,
			
 
				+    "bright_black": 90,
			
 
				+    "bright_red": 91,
			
 
				+    "bright_green": 92,
			
 
				+    "bright_yellow": 93,
			
 
				+    "bright_blue": 94,
			
 
				+    "bright_magenta": 95,
			
 
				+    "bright_cyan": 96,
			
 
				+    "bright_white": 97,
			
 
				+}
			
 
				+_ansi_reset_all = "\033[0m"
			
 
				+
			
 
				+
			
 
				+def hidden_prompt_func(prompt: str) -> str:
			
 
				+    import getpass
			
 
				+
			
 
				+    return getpass.getpass(prompt)
			
 
				+
			
 
				+
			
 
				+def _build_prompt(
			
 
				+    text: str,
			
 
				+    suffix: str,
			
 
				+    show_default: bool = False,
			
 
				+    default: t.Optional[t.Any] = None,
			
 
				+    show_choices: bool = True,
			
 
				+    type: t.Optional[ParamType] = None,
			
 
				+) -> str:
			
 
				+    prompt = text
			
 
				+    if type is not None and show_choices and isinstance(type, Choice):
			
 
				+        prompt += f" ({', '.join(map(str, type.choices))})"
			
 
				+    if default is not None and show_default:
			
 
				+        prompt = f"{prompt} [{_format_default(default)}]"
			
 
				+    return f"{prompt}{suffix}"
			
 
				+
			
 
				+
			
 
				+def _format_default(default: t.Any) -> t.Any:
			
 
				+    if isinstance(default, (io.IOBase, LazyFile)) and hasattr(default, "name"):
			
 
				+        return default.name
			
 
				+
			
 
				+    return default
			
 
				+
			
 
				+
			
 
				+def prompt(
			
 
				+    text: str,
			
 
				+    default: t.Optional[t.Any] = None,
			
 
				+    hide_input: bool = False,
			
 
				+    confirmation_prompt: t.Union[bool, str] = False,
			
 
				+    type: t.Optional[t.Union[ParamType, t.Any]] = None,
			
 
				+    value_proc: t.Optional[t.Callable[[str], t.Any]] = None,
			
 
				+    prompt_suffix: str = ": ",
			
 
				+    show_default: bool = True,
			
 
				+    err: bool = False,
			
 
				+    show_choices: bool = True,
			
 
				+) -> t.Any:
			
 
				+    """Prompts a user for input.  This is a convenience function that can
			
 
				+    be used to prompt a user for input later.
			
 
				+
			
 
				+    If the user aborts the input by sending an interrupt signal, this
			
 
				+    function will catch it and raise a :exc:`Abort` exception.
			
 
				+
			
 
				+    :param text: the text to show for the prompt.
			
 
				+    :param default: the default value to use if no input happens.  If this
			
 
				+                    is not given it will prompt until it's aborted.
			
 
				+    :param hide_input: if this is set to true then the input value will
			
 
				+                       be hidden.
			
 
				+    :param confirmation_prompt: Prompt a second time to confirm the
			
 
				+        value. Can be set to a string instead of ``True`` to customize
			
 
				+        the message.
			
 
				+    :param type: the type to use to check the value against.
			
 
				+    :param value_proc: if this parameter is provided it's a function that
			
 
				+                       is invoked instead of the type conversion to
			
 
				+                       convert a value.
			
 
				+    :param prompt_suffix: a suffix that should be added to the prompt.
			
 
				+    :param show_default: shows or hides the default value in the prompt.
			
 
				+    :param err: if set to true the file defaults to ``stderr`` instead of
			
 
				+                ``stdout``, the same as with echo.
			
 
				+    :param show_choices: Show or hide choices if the passed type is a Choice.
			
 
				+                         For example if type is a Choice of either day or week,
			
 
				+                         show_choices is true and text is "Group by" then the
			
 
				+                         prompt will be "Group by (day, week): ".
			
 
				+
			
 
				+    .. versionadded:: 8.0
			
 
				+        ``confirmation_prompt`` can be a custom string.
			
 
				+
			
 
				+    .. versionadded:: 7.0
			
 
				+        Added the ``show_choices`` parameter.
			
 
				+
			
 
				+    .. versionadded:: 6.0
			
 
				+        Added unicode support for cmd.exe on Windows.
			
 
				+
			
 
				+    .. versionadded:: 4.0
			
 
				+        Added the `err` parameter.
			
 
				+
			
 
				+    """
			
 
				+
			
 
				+    def prompt_func(text: str) -> str:
			
 
				+        f = hidden_prompt_func if hide_input else visible_prompt_func
			
 
				+        try:
			
 
				+            # Write the prompt separately so that we get nice
			
 
				+            # coloring through colorama on Windows
			
 
				+            echo(text.rstrip(" "), nl=False, err=err)
			
 
				+            # Echo a space to stdout to work around an issue where
			
 
				+            # readline causes backspace to clear the whole line.
			
 
				+            return f(" ")
			
 
				+        except (KeyboardInterrupt, EOFError):
			
 
				+            # getpass doesn't print a newline if the user aborts input with ^C.
			
 
				+            # Allegedly this behavior is inherited from getpass(3).
			
 
				+            # A doc bug has been filed at https://bugs.python.org/issue24711
			
 
				+            if hide_input:
			
 
				+                echo(None, err=err)
			
 
				+            raise Abort() from None
			
 
				+
			
 
				+    if value_proc is None:
			
 
				+        value_proc = convert_type(type, default)
			
 
				+
			
 
				+    prompt = _build_prompt(
			
 
				+        text, prompt_suffix, show_default, default, show_choices, type
			
 
				+    )
			
 
				+
			
 
				+    if confirmation_prompt:
			
 
				+        if confirmation_prompt is True:
			
 
				+            confirmation_prompt = _("Repeat for confirmation")
			
 
				+
			
 
				+        confirmation_prompt = _build_prompt(confirmation_prompt, prompt_suffix)
			
 
				+
			
 
				+    while True:
			
 
				+        while True:
			
 
				+            value = prompt_func(prompt)
			
 
				+            if value:
			
 
				+                break
			
 
				+            elif default is not None:
			
 
				+                value = default
			
 
				+                break
			
 
				+        try:
			
 
				+            result = value_proc(value)
			
 
				+        except UsageError as e:
			
 
				+            if hide_input:
			
 
				+                echo(_("Error: The value you entered was invalid."), err=err)
			
 
				+            else:
			
 
				+                echo(_("Error: {e.message}").format(e=e), err=err)  # noqa: B306
			
 
				+            continue
			
 
				+        if not confirmation_prompt:
			
 
				+            return result
			
 
				+        while True:
			
 
				+            value2 = prompt_func(confirmation_prompt)
			
 
				+            is_empty = not value and not value2
			
 
				+            if value2 or is_empty:
			
 
				+                break
			
 
				+        if value == value2:
			
 
				+            return result
			
 
				+        echo(_("Error: The two entered values do not match."), err=err)
			
 
				+
			
 
				+
			
 
				+def confirm(
			
 
				+    text: str,
			
 
				+    default: t.Optional[bool] = False,
			
 
				+    abort: bool = False,
			
 
				+    prompt_suffix: str = ": ",
			
 
				+    show_default: bool = True,
			
 
				+    err: bool = False,
			
 
				+) -> bool:
			
 
				+    """Prompts for confirmation (yes/no question).
			
 
				+
			
 
				+    If the user aborts the input by sending a interrupt signal this
			
 
				+    function will catch it and raise a :exc:`Abort` exception.
			
 
				+
			
 
				+    :param text: the question to ask.
			
 
				+    :param default: The default value to use when no input is given. If
			
 
				+        ``None``, repeat until input is given.
			
 
				+    :param abort: if this is set to `True` a negative answer aborts the
			
 
				+                  exception by raising :exc:`Abort`.
			
 
				+    :param prompt_suffix: a suffix that should be added to the prompt.
			
 
				+    :param show_default: shows or hides the default value in the prompt.
			
 
				+    :param err: if set to true the file defaults to ``stderr`` instead of
			
 
				+                ``stdout``, the same as with echo.
			
 
				+
			
 
				+    .. versionchanged:: 8.0
			
 
				+        Repeat until input is given if ``default`` is ``None``.
			
 
				+
			
 
				+    .. versionadded:: 4.0
			
 
				+        Added the ``err`` parameter.
			
 
				+    """
			
 
				+    prompt = _build_prompt(
			
 
				+        text,
			
 
				+        prompt_suffix,
			
 
				+        show_default,
			
 
				+        "y/n" if default is None else ("Y/n" if default else "y/N"),
			
 
				+    )
			
 
				+
			
 
				+    while True:
			
 
				+        try:
			
 
				+            # Write the prompt separately so that we get nice
			
 
				+            # coloring through colorama on Windows
			
 
				+            echo(prompt.rstrip(" "), nl=False, err=err)
			
 
				+            # Echo a space to stdout to work around an issue where
			
 
				+            # readline causes backspace to clear the whole line.
			
 
				+            value = visible_prompt_func(" ").lower().strip()
			
 
				+        except (KeyboardInterrupt, EOFError):
			
 
				+            raise Abort() from None
			
 
				+        if value in ("y", "yes"):
			
 
				+            rv = True
			
 
				+        elif value in ("n", "no"):
			
 
				+            rv = False
			
 
				+        elif default is not None and value == "":
			
 
				+            rv = default
			
 
				+        else:
			
 
				+            echo(_("Error: invalid input"), err=err)
			
 
				+            continue
			
 
				+        break
			
 
				+    if abort and not rv:
			
 
				+        raise Abort()
			
 
				+    return rv
			
 
				+
			
 
				+
			
 
				+def echo_via_pager(
			
 
				+    text_or_generator: t.Union[t.Iterable[str], t.Callable[[], t.Iterable[str]], str],
			
 
				+    color: t.Optional[bool] = None,
			
 
				+) -> None:
			
 
				+    """This function takes a text and shows it via an environment specific
			
 
				+    pager on stdout.
			
 
				+
			
 
				+    .. versionchanged:: 3.0
			
 
				+       Added the `color` flag.
			
 
				+
			
 
				+    :param text_or_generator: the text to page, or alternatively, a
			
 
				+                              generator emitting the text to page.
			
 
				+    :param color: controls if the pager supports ANSI colors or not.  The
			
 
				+                  default is autodetection.
			
 
				+    """
			
 
				+    color = resolve_color_default(color)
			
 
				+
			
 
				+    if inspect.isgeneratorfunction(text_or_generator):
			
 
				+        i = t.cast(t.Callable[[], t.Iterable[str]], text_or_generator)()
			
 
				+    elif isinstance(text_or_generator, str):
			
 
				+        i = [text_or_generator]
			
 
				+    else:
			
 
				+        i = iter(t.cast(t.Iterable[str], text_or_generator))
			
 
				+
			
 
				+    # convert every element of i to a text type if necessary
			
 
				+    text_generator = (el if isinstance(el, str) else str(el) for el in i)
			
 
				+
			
 
				+    from ._termui_impl import pager
			
 
				+
			
 
				+    return pager(itertools.chain(text_generator, "\n"), color)
			
 
				+
			
 
				+
			
 
				+def progressbar(
			
 
				+    iterable: t.Optional[t.Iterable[V]] = None,
			
 
				+    length: t.Optional[int] = None,
			
 
				+    label: t.Optional[str] = None,
			
 
				+    show_eta: bool = True,
			
 
				+    show_percent: t.Optional[bool] = None,
			
 
				+    show_pos: bool = False,
			
 
				+    item_show_func: t.Optional[t.Callable[[t.Optional[V]], t.Optional[str]]] = None,
			
 
				+    fill_char: str = "#",
			
 
				+    empty_char: str = "-",
			
 
				+    bar_template: str = "%(label)s  [%(bar)s]  %(info)s",
			
 
				+    info_sep: str = "  ",
			
 
				+    width: int = 36,
			
 
				+    file: t.Optional[t.TextIO] = None,
			
 
				+    color: t.Optional[bool] = None,
			
 
				+    update_min_steps: int = 1,
			
 
				+) -> "ProgressBar[V]":
			
 
				+    """This function creates an iterable context manager that can be used
			
 
				+    to iterate over something while showing a progress bar.  It will
			
 
				+    either iterate over the `iterable` or `length` items (that are counted
			
 
				+    up).  While iteration happens, this function will print a rendered
			
 
				+    progress bar to the given `file` (defaults to stdout) and will attempt
			
 
				+    to calculate remaining time and more.  By default, this progress bar
			
 
				+    will not be rendered if the file is not a terminal.
			
 
				+
			
 
				+    The context manager creates the progress bar.  When the context
			
 
				+    manager is entered the progress bar is already created.  With every
			
 
				+    iteration over the progress bar, the iterable passed to the bar is
			
 
				+    advanced and the bar is updated.  When the context manager exits,
			
 
				+    a newline is printed and the progress bar is finalized on screen.
			
 
				+
			
 
				+    Note: The progress bar is currently designed for use cases where the
			
 
				+    total progress can be expected to take at least several seconds.
			
 
				+    Because of this, the ProgressBar class object won't display
			
 
				+    progress that is considered too fast, and progress where the time
			
 
				+    between steps is less than a second.
			
 
				+
			
 
				+    No printing must happen or the progress bar will be unintentionally
			
 
				+    destroyed.
			
 
				+
			
 
				+    Example usage::
			
 
				+
			
 
				+        with progressbar(items) as bar:
			
 
				+            for item in bar:
			
 
				+                do_something_with(item)
			
 
				+
			
 
				+    Alternatively, if no iterable is specified, one can manually update the
			
 
				+    progress bar through the `update()` method instead of directly
			
 
				+    iterating over the progress bar.  The update method accepts the number
			
 
				+    of steps to increment the bar with::
			
 
				+
			
 
				+        with progressbar(length=chunks.total_bytes) as bar:
			
 
				+            for chunk in chunks:
			
 
				+                process_chunk(chunk)
			
 
				+                bar.update(chunks.bytes)
			
 
				+
			
 
				+    The ``update()`` method also takes an optional value specifying the
			
 
				+    ``current_item`` at the new position. This is useful when used
			
 
				+    together with ``item_show_func`` to customize the output for each
			
 
				+    manual step::
			
 
				+
			
 
				+        with click.progressbar(
			
 
				+            length=total_size,
			
 
				+            label='Unzipping archive',
			
 
				+            item_show_func=lambda a: a.filename
			
 
				+        ) as bar:
			
 
				+            for archive in zip_file:
			
 
				+                archive.extract()
			
 
				+                bar.update(archive.size, archive)
			
 
				+
			
 
				+    :param iterable: an iterable to iterate over.  If not provided the length
			
 
				+                     is required.
			
 
				+    :param length: the number of items to iterate over.  By default the
			
 
				+                   progressbar will attempt to ask the iterator about its
			
 
				+                   length, which might or might not work.  If an iterable is
			
 
				+                   also provided this parameter can be used to override the
			
 
				+                   length.  If an iterable is not provided the progress bar
			
 
				+                   will iterate over a range of that length.
			
 
				+    :param label: the label to show next to the progress bar.
			
 
				+    :param show_eta: enables or disables the estimated time display.  This is
			
 
				+                     automatically disabled if the length cannot be
			
 
				+                     determined.
			
 
				+    :param show_percent: enables or disables the percentage display.  The
			
 
				+                         default is `True` if the iterable has a length or
			
 
				+                         `False` if not.
			
 
				+    :param show_pos: enables or disables the absolute position display.  The
			
 
				+                     default is `False`.
			
 
				+    :param item_show_func: A function called with the current item which
			
 
				+        can return a string to show next to the progress bar. If the
			
 
				+        function returns ``None`` nothing is shown. The current item can
			
 
				+        be ``None``, such as when entering and exiting the bar.
			
 
				+    :param fill_char: the character to use to show the filled part of the
			
 
				+                      progress bar.
			
 
				+    :param empty_char: the character to use to show the non-filled part of
			
 
				+                       the progress bar.
			
 
				+    :param bar_template: the format string to use as template for the bar.
			
 
				+                         The parameters in it are ``label`` for the label,
			
 
				+                         ``bar`` for the progress bar and ``info`` for the
			
 
				+                         info section.
			
 
				+    :param info_sep: the separator between multiple info items (eta etc.)
			
 
				+    :param width: the width of the progress bar in characters, 0 means full
			
 
				+                  terminal width
			
 
				+    :param file: The file to write to. If this is not a terminal then
			
 
				+        only the label is printed.
			
 
				+    :param color: controls if the terminal supports ANSI colors or not.  The
			
 
				+                  default is autodetection.  This is only needed if ANSI
			
 
				+                  codes are included anywhere in the progress bar output
			
 
				+                  which is not the case by default.
			
 
				+    :param update_min_steps: Render only when this many updates have
			
 
				+        completed. This allows tuning for very fast iterators.
			
 
				+
			
 
				+    .. versionchanged:: 8.0
			
 
				+        Output is shown even if execution time is less than 0.5 seconds.
			
 
				+
			
 
				+    .. versionchanged:: 8.0
			
 
				+        ``item_show_func`` shows the current item, not the previous one.
			
 
				+
			
 
				+    .. versionchanged:: 8.0
			
 
				+        Labels are echoed if the output is not a TTY. Reverts a change
			
 
				+        in 7.0 that removed all output.
			
 
				+
			
 
				+    .. versionadded:: 8.0
			
 
				+       Added the ``update_min_steps`` parameter.
			
 
				+
			
 
				+    .. versionchanged:: 4.0
			
 
				+        Added the ``color`` parameter. Added the ``update`` method to
			
 
				+        the object.
			
 
				+
			
 
				+    .. versionadded:: 2.0
			
 
				+    """
			
 
				+    from ._termui_impl import ProgressBar
			
 
				+
			
 
				+    color = resolve_color_default(color)
			
 
				+    return ProgressBar(
			
 
				+        iterable=iterable,
			
 
				+        length=length,
			
 
				+        show_eta=show_eta,
			
 
				+        show_percent=show_percent,
			
 
				+        show_pos=show_pos,
			
 
				+        item_show_func=item_show_func,
			
 
				+        fill_char=fill_char,
			
 
				+        empty_char=empty_char,
			
 
				+        bar_template=bar_template,
			
 
				+        info_sep=info_sep,
			
 
				+        file=file,
			
 
				+        label=label,
			
 
				+        width=width,
			
 
				+        color=color,
			
 
				+        update_min_steps=update_min_steps,
			
 
				+    )
			
 
				+
			
 
				+
			
 
				+def clear() -> None:
			
 
				+    """Clears the terminal screen.  This will have the effect of clearing
			
 
				+    the whole visible space of the terminal and moving the cursor to the
			
 
				+    top left.  This does not do anything if not connected to a terminal.
			
 
				+
			
 
				+    .. versionadded:: 2.0
			
 
				+    """
			
 
				+    if not isatty(sys.stdout):
			
 
				+        return
			
 
				+
			
 
				+    # ANSI escape \033[2J clears the screen, \033[1;1H moves the cursor
			
 
				+    echo("\033[2J\033[1;1H", nl=False)
			
 
				+
			
 
				+
			
 
				+def _interpret_color(
			
 
				+    color: t.Union[int, t.Tuple[int, int, int], str], offset: int = 0
			
 
				+) -> str:
			
 
				+    if isinstance(color, int):
			
 
				+        return f"{38 + offset};5;{color:d}"
			
 
				+
			
 
				+    if isinstance(color, (tuple, list)):
			
 
				+        r, g, b = color
			
 
				+        return f"{38 + offset};2;{r:d};{g:d};{b:d}"
			
 
				+
			
 
				+    return str(_ansi_colors[color] + offset)
			
 
				+
			
 
				+
			
 
				+def style(
			
 
				+    text: t.Any,
			
 
				+    fg: t.Optional[t.Union[int, t.Tuple[int, int, int], str]] = None,
			
 
				+    bg: t.Optional[t.Union[int, t.Tuple[int, int, int], str]] = None,
			
 
				+    bold: t.Optional[bool] = None,
			
 
				+    dim: t.Optional[bool] = None,
			
 
				+    underline: t.Optional[bool] = None,
			
 
				+    overline: t.Optional[bool] = None,
			
 
				+    italic: t.Optional[bool] = None,
			
 
				+    blink: t.Optional[bool] = None,
			
 
				+    reverse: t.Optional[bool] = None,
			
 
				+    strikethrough: t.Optional[bool] = None,
			
 
				+    reset: bool = True,
			
 
				+) -> str:
			
 
				+    """Styles a text with ANSI styles and returns the new string.  By
			
 
				+    default the styling is self contained which means that at the end
			
 
				+    of the string a reset code is issued.  This can be prevented by
			
 
				+    passing ``reset=False``.
			
 
				+
			
 
				+    Examples::
			
 
				+
			
 
				+        click.echo(click.style('Hello World!', fg='green'))
			
 
				+        click.echo(click.style('ATTENTION!', blink=True))
			
 
				+        click.echo(click.style('Some things', reverse=True, fg='cyan'))
			
 
				+        click.echo(click.style('More colors', fg=(255, 12, 128), bg=117))
			
 
				+
			
 
				+    Supported color names:
			
 
				+
			
 
				+    * ``black`` (might be a gray)
			
 
				+    * ``red``
			
 
				+    * ``green``
			
 
				+    * ``yellow`` (might be an orange)
			
 
				+    * ``blue``
			
 
				+    * ``magenta``
			
 
				+    * ``cyan``
			
 
				+    * ``white`` (might be light gray)
			
 
				+    * ``bright_black``
			
 
				+    * ``bright_red``
			
 
				+    * ``bright_green``
			
 
				+    * ``bright_yellow``
			
 
				+    * ``bright_blue``
			
 
				+    * ``bright_magenta``
			
 
				+    * ``bright_cyan``
			
 
				+    * ``bright_white``
			
 
				+    * ``reset`` (reset the color code only)
			
 
				+
			
 
				+    If the terminal supports it, color may also be specified as:
			
 
				+
			
 
				+    -   An integer in the interval [0, 255]. The terminal must support
			
 
				+        8-bit/256-color mode.
			
 
				+    -   An RGB tuple of three integers in [0, 255]. The terminal must
			
 
				+        support 24-bit/true-color mode.
			
 
				+
			
 
				+    See https://en.wikipedia.org/wiki/ANSI_color and
			
 
				+    https://gist.github.com/XVilka/8346728 for more information.
			
 
				+
			
 
				+    :param text: the string to style with ansi codes.
			
 
				+    :param fg: if provided this will become the foreground color.
			
 
				+    :param bg: if provided this will become the background color.
			
 
				+    :param bold: if provided this will enable or disable bold mode.
			
 
				+    :param dim: if provided this will enable or disable dim mode.  This is
			
 
				+                badly supported.
			
 
				+    :param underline: if provided this will enable or disable underline.
			
 
				+    :param overline: if provided this will enable or disable overline.
			
 
				+    :param italic: if provided this will enable or disable italic.
			
 
				+    :param blink: if provided this will enable or disable blinking.
			
 
				+    :param reverse: if provided this will enable or disable inverse
			
 
				+                    rendering (foreground becomes background and the
			
 
				+                    other way round).
			
 
				+    :param strikethrough: if provided this will enable or disable
			
 
				+        striking through text.
			
 
				+    :param reset: by default a reset-all code is added at the end of the
			
 
				+                  string which means that styles do not carry over.  This
			
 
				+                  can be disabled to compose styles.
			
 
				+
			
 
				+    .. versionchanged:: 8.0
			
 
				+        A non-string ``message`` is converted to a string.
			
 
				+
			
 
				+    .. versionchanged:: 8.0
			
 
				+       Added support for 256 and RGB color codes.
			
 
				+
			
 
				+    .. versionchanged:: 8.0
			
 
				+        Added the ``strikethrough``, ``italic``, and ``overline``
			
 
				+        parameters.
			
 
				+
			
 
				+    .. versionchanged:: 7.0
			
 
				+        Added support for bright colors.
			
 
				+
			
 
				+    .. versionadded:: 2.0
			
 
				+    """
			
 
				+    if not isinstance(text, str):
			
 
				+        text = str(text)
			
 
				+
			
 
				+    bits = []
			
 
				+
			
 
				+    if fg:
			
 
				+        try:
			
 
				+            bits.append(f"\033[{_interpret_color(fg)}m")
			
 
				+        except KeyError:
			
 
				+            raise TypeError(f"Unknown color {fg!r}") from None
			
 
				+
			
 
				+    if bg:
			
 
				+        try:
			
 
				+            bits.append(f"\033[{_interpret_color(bg, 10)}m")
			
 
				+        except KeyError:
			
 
				+            raise TypeError(f"Unknown color {bg!r}") from None
			
 
				+
			
 
				+    if bold is not None:
			
 
				+        bits.append(f"\033[{1 if bold else 22}m")
			
 
				+    if dim is not None:
			
 
				+        bits.append(f"\033[{2 if dim else 22}m")
			
 
				+    if underline is not None:
			
 
				+        bits.append(f"\033[{4 if underline else 24}m")
			
 
				+    if overline is not None:
			
 
				+        bits.append(f"\033[{53 if overline else 55}m")
			
 
				+    if italic is not None:
			
 
				+        bits.append(f"\033[{3 if italic else 23}m")
			
 
				+    if blink is not None:
			
 
				+        bits.append(f"\033[{5 if blink else 25}m")
			
 
				+    if reverse is not None:
			
 
				+        bits.append(f"\033[{7 if reverse else 27}m")
			
 
				+    if strikethrough is not None:
			
 
				+        bits.append(f"\033[{9 if strikethrough else 29}m")
			
 
				+    bits.append(text)
			
 
				+    if reset:
			
 
				+        bits.append(_ansi_reset_all)
			
 
				+    return "".join(bits)
			
 
				+
			
 
				+
			
 
				+def unstyle(text: str) -> str:
			
 
				+    """Removes ANSI styling information from a string.  Usually it's not
			
 
				+    necessary to use this function as Click's echo function will
			
 
				+    automatically remove styling if necessary.
			
 
				+
			
 
				+    .. versionadded:: 2.0
			
 
				+
			
 
				+    :param text: the text to remove style information from.
			
 
				+    """
			
 
				+    return strip_ansi(text)
			
 
				+
			
 
				+
			
 
				+def secho(
			
 
				+    message: t.Optional[t.Any] = None,
			
 
				+    file: t.Optional[t.IO[t.AnyStr]] = None,
			
 
				+    nl: bool = True,
			
 
				+    err: bool = False,
			
 
				+    color: t.Optional[bool] = None,
			
 
				+    **styles: t.Any,
			
 
				+) -> None:
			
 
				+    """This function combines :func:`echo` and :func:`style` into one
			
 
				+    call.  As such the following two calls are the same::
			
 
				+
			
 
				+        click.secho('Hello World!', fg='green')
			
 
				+        click.echo(click.style('Hello World!', fg='green'))
			
 
				+
			
 
				+    All keyword arguments are forwarded to the underlying functions
			
 
				+    depending on which one they go with.
			
 
				+
			
 
				+    Non-string types will be converted to :class:`str`. However,
			
 
				+    :class:`bytes` are passed directly to :meth:`echo` without applying
			
 
				+    style. If you want to style bytes that represent text, call
			
 
				+    :meth:`bytes.decode` first.
			
 
				+
			
 
				+    .. versionchanged:: 8.0
			
 
				+        A non-string ``message`` is converted to a string. Bytes are
			
 
				+        passed through without style applied.
			
 
				+
			
 
				+    .. versionadded:: 2.0
			
 
				+    """
			
 
				+    if message is not None and not isinstance(message, (bytes, bytearray)):
			
 
				+        message = style(message, **styles)
			
 
				+
			
 
				+    return echo(message, file=file, nl=nl, err=err, color=color)
			
 
				+
			
 
				+
			
 
				+def edit(
			
 
				+    text: t.Optional[t.AnyStr] = None,
			
 
				+    editor: t.Optional[str] = None,
			
 
				+    env: t.Optional[t.Mapping[str, str]] = None,
			
 
				+    require_save: bool = True,
			
 
				+    extension: str = ".txt",
			
 
				+    filename: t.Optional[str] = None,
			
 
				+) -> t.Optional[t.AnyStr]:
			
 
				+    r"""Edits the given text in the defined editor.  If an editor is given
			
 
				+    (should be the full path to the executable but the regular operating
			
 
				+    system search path is used for finding the executable) it overrides
			
 
				+    the detected editor.  Optionally, some environment variables can be
			
 
				+    used.  If the editor is closed without changes, `None` is returned.  In
			
 
				+    case a file is edited directly the return value is always `None` and
			
 
				+    `require_save` and `extension` are ignored.
			
 
				+
			
 
				+    If the editor cannot be opened a :exc:`UsageError` is raised.
			
 
				+
			
 
				+    Note for Windows: to simplify cross-platform usage, the newlines are
			
 
				+    automatically converted from POSIX to Windows and vice versa.  As such,
			
 
				+    the message here will have ``\n`` as newline markers.
			
 
				+
			
 
				+    :param text: the text to edit.
			
 
				+    :param editor: optionally the editor to use.  Defaults to automatic
			
 
				+                   detection.
			
 
				+    :param env: environment variables to forward to the editor.
			
 
				+    :param require_save: if this is true, then not saving in the editor
			
 
				+                         will make the return value become `None`.
			
 
				+    :param extension: the extension to tell the editor about.  This defaults
			
 
				+                      to `.txt` but changing this might change syntax
			
 
				+                      highlighting.
			
 
				+    :param filename: if provided it will edit this file instead of the
			
 
				+                     provided text contents.  It will not use a temporary
			
 
				+                     file as an indirection in that case.
			
 
				+    """
			
 
				+    from ._termui_impl import Editor
			
 
				+
			
 
				+    ed = Editor(editor=editor, env=env, require_save=require_save, extension=extension)
			
 
				+
			
 
				+    if filename is None:
			
 
				+        return ed.edit(text)
			
 
				+
			
 
				+    ed.edit_file(filename)
			
 
				+    return None
			
 
				+
			
 
				+
			
 
				+def launch(url: str, wait: bool = False, locate: bool = False) -> int:
			
 
				+    """This function launches the given URL (or filename) in the default
			
 
				+    viewer application for this file type.  If this is an executable, it
			
 
				+    might launch the executable in a new session.  The return value is
			
 
				+    the exit code of the launched application.  Usually, ``0`` indicates
			
 
				+    success.
			
 
				+
			
 
				+    Examples::
			
 
				+
			
 
				+        click.launch('https://click.palletsprojects.com/')
			
 
				+        click.launch('/my/downloaded/file', locate=True)
			
 
				+
			
 
				+    .. versionadded:: 2.0
			
 
				+
			
 
				+    :param url: URL or filename of the thing to launch.
			
 
				+    :param wait: Wait for the program to exit before returning. This
			
 
				+        only works if the launched program blocks. In particular,
			
 
				+        ``xdg-open`` on Linux does not block.
			
 
				+    :param locate: if this is set to `True` then instead of launching the
			
 
				+                   application associated with the URL it will attempt to
			
 
				+                   launch a file manager with the file located.  This
			
 
				+                   might have weird effects if the URL does not point to
			
 
				+                   the filesystem.
			
 
				+    """
			
 
				+    from ._termui_impl import open_url
			
 
				+
			
 
				+    return open_url(url, wait=wait, locate=locate)
			
 
				+
			
 
				+
			
 
				+# If this is provided, getchar() calls into this instead.  This is used
			
 
				+# for unittesting purposes.
			
 
				+_getchar: t.Optional[t.Callable[[bool], str]] = None
			
 
				+
			
 
				+
			
 
				+def getchar(echo: bool = False) -> str:
			
 
				+    """Fetches a single character from the terminal and returns it.  This
			
 
				+    will always return a unicode character and under certain rare
			
 
				+    circumstances this might return more than one character.  The
			
 
				+    situations which more than one character is returned is when for
			
 
				+    whatever reason multiple characters end up in the terminal buffer or
			
 
				+    standard input was not actually a terminal.
			
 
				+
			
 
				+    Note that this will always read from the terminal, even if something
			
 
				+    is piped into the standard input.
			
 
				+
			
 
				+    Note for Windows: in rare cases when typing non-ASCII characters, this
			
 
				+    function might wait for a second character and then return both at once.
			
 
				+    This is because certain Unicode characters look like special-key markers.
			
 
				+
			
 
				+    .. versionadded:: 2.0
			
 
				+
			
 
				+    :param echo: if set to `True`, the character read will also show up on
			
 
				+                 the terminal.  The default is to not show it.
			
 
				+    """
			
 
				+    global _getchar
			
 
				+
			
 
				+    if _getchar is None:
			
 
				+        from ._termui_impl import getchar as f
			
 
				+
			
 
				+        _getchar = f
			
 
				+
			
 
				+    return _getchar(echo)
			
 
				+
			
 
				+
			
 
				+def raw_terminal() -> t.ContextManager[int]:
			
 
				+    from ._termui_impl import raw_terminal as f
			
 
				+
			
 
				+    return f()
			
 
				+
			
 
				+
			
 
				+def pause(info: t.Optional[str] = None, err: bool = False) -> None:
			
 
				+    """This command stops execution and waits for the user to press any
			
 
				+    key to continue.  This is similar to the Windows batch "pause"
			
 
				+    command.  If the program is not run through a terminal, this command
			
 
				+    will instead do nothing.
			
 
				+
			
 
				+    .. versionadded:: 2.0
			
 
				+
			
 
				+    .. versionadded:: 4.0
			
 
				+       Added the `err` parameter.
			
 
				+
			
 
				+    :param info: The message to print before pausing. Defaults to
			
 
				+        ``"Press any key to continue..."``.
			
 
				+    :param err: if set to message goes to ``stderr`` instead of
			
 
				+                ``stdout``, the same as with echo.
			
 
				+    """
			
 
				+    if not isatty(sys.stdin) or not isatty(sys.stdout):
			
 
				+        return
			
 
				+
			
 
				+    if info is None:
			
 
				+        info = _("Press any key to continue...")
			
 
				+
			
 
				+    try:
			
 
				+        if info:
			
 
				+            echo(info, nl=False, err=err)
			
 
				+        try:
			
 
				+            getchar()
			
 
				+        except (KeyboardInterrupt, EOFError):
			
 
				+            pass
			
 
				+    finally:
			
 
				+        if info:
			
 
				+            echo(err=err)
			
--- a/courses/flask/microblog/env/Lib/site-packages/click/testing.py
+++ b/courses/flask/microblog/env/Lib/site-packages/click/testing.py
@@ -0,0 +1,479 @@
 
				+import contextlib
			
 
				+import io
			
 
				+import os
			
 
				+import shlex
			
 
				+import shutil
			
 
				+import sys
			
 
				+import tempfile
			
 
				+import typing as t
			
 
				+from types import TracebackType
			
 
				+
			
 
				+from . import formatting
			
 
				+from . import termui
			
 
				+from . import utils
			
 
				+from ._compat import _find_binary_reader
			
 
				+
			
 
				+if t.TYPE_CHECKING:
			
 
				+    from .core import BaseCommand
			
 
				+
			
 
				+
			
 
				+class EchoingStdin:
			
 
				+    def __init__(self, input: t.BinaryIO, output: t.BinaryIO) -> None:
			
 
				+        self._input = input
			
 
				+        self._output = output
			
 
				+        self._paused = False
			
 
				+
			
 
				+    def __getattr__(self, x: str) -> t.Any:
			
 
				+        return getattr(self._input, x)
			
 
				+
			
 
				+    def _echo(self, rv: bytes) -> bytes:
			
 
				+        if not self._paused:
			
 
				+            self._output.write(rv)
			
 
				+
			
 
				+        return rv
			
 
				+
			
 
				+    def read(self, n: int = -1) -> bytes:
			
 
				+        return self._echo(self._input.read(n))
			
 
				+
			
 
				+    def read1(self, n: int = -1) -> bytes:
			
 
				+        return self._echo(self._input.read1(n))  # type: ignore
			
 
				+
			
 
				+    def readline(self, n: int = -1) -> bytes:
			
 
				+        return self._echo(self._input.readline(n))
			
 
				+
			
 
				+    def readlines(self) -> t.List[bytes]:
			
 
				+        return [self._echo(x) for x in self._input.readlines()]
			
 
				+
			
 
				+    def __iter__(self) -> t.Iterator[bytes]:
			
 
				+        return iter(self._echo(x) for x in self._input)
			
 
				+
			
 
				+    def __repr__(self) -> str:
			
 
				+        return repr(self._input)
			
 
				+
			
 
				+
			
 
				+@contextlib.contextmanager
			
 
				+def _pause_echo(stream: t.Optional[EchoingStdin]) -> t.Iterator[None]:
			
 
				+    if stream is None:
			
 
				+        yield
			
 
				+    else:
			
 
				+        stream._paused = True
			
 
				+        yield
			
 
				+        stream._paused = False
			
 
				+
			
 
				+
			
 
				+class _NamedTextIOWrapper(io.TextIOWrapper):
			
 
				+    def __init__(
			
 
				+        self, buffer: t.BinaryIO, name: str, mode: str, **kwargs: t.Any
			
 
				+    ) -> None:
			
 
				+        super().__init__(buffer, **kwargs)
			
 
				+        self._name = name
			
 
				+        self._mode = mode
			
 
				+
			
 
				+    @property
			
 
				+    def name(self) -> str:
			
 
				+        return self._name
			
 
				+
			
 
				+    @property
			
 
				+    def mode(self) -> str:
			
 
				+        return self._mode
			
 
				+
			
 
				+
			
 
				+def make_input_stream(
			
 
				+    input: t.Optional[t.Union[str, bytes, t.IO[t.Any]]], charset: str
			
 
				+) -> t.BinaryIO:
			
 
				+    # Is already an input stream.
			
 
				+    if hasattr(input, "read"):
			
 
				+        rv = _find_binary_reader(t.cast(t.IO[t.Any], input))
			
 
				+
			
 
				+        if rv is not None:
			
 
				+            return rv
			
 
				+
			
 
				+        raise TypeError("Could not find binary reader for input stream.")
			
 
				+
			
 
				+    if input is None:
			
 
				+        input = b""
			
 
				+    elif isinstance(input, str):
			
 
				+        input = input.encode(charset)
			
 
				+
			
 
				+    return io.BytesIO(input)
			
 
				+
			
 
				+
			
 
				+class Result:
			
 
				+    """Holds the captured result of an invoked CLI script."""
			
 
				+
			
 
				+    def __init__(
			
 
				+        self,
			
 
				+        runner: "CliRunner",
			
 
				+        stdout_bytes: bytes,
			
 
				+        stderr_bytes: t.Optional[bytes],
			
 
				+        return_value: t.Any,
			
 
				+        exit_code: int,
			
 
				+        exception: t.Optional[BaseException],
			
 
				+        exc_info: t.Optional[
			
 
				+            t.Tuple[t.Type[BaseException], BaseException, TracebackType]
			
 
				+        ] = None,
			
 
				+    ):
			
 
				+        #: The runner that created the result
			
 
				+        self.runner = runner
			
 
				+        #: The standard output as bytes.
			
 
				+        self.stdout_bytes = stdout_bytes
			
 
				+        #: The standard error as bytes, or None if not available
			
 
				+        self.stderr_bytes = stderr_bytes
			
 
				+        #: The value returned from the invoked command.
			
 
				+        #:
			
 
				+        #: .. versionadded:: 8.0
			
 
				+        self.return_value = return_value
			
 
				+        #: The exit code as integer.
			
 
				+        self.exit_code = exit_code
			
 
				+        #: The exception that happened if one did.
			
 
				+        self.exception = exception
			
 
				+        #: The traceback
			
 
				+        self.exc_info = exc_info
			
 
				+
			
 
				+    @property
			
 
				+    def output(self) -> str:
			
 
				+        """The (standard) output as unicode string."""
			
 
				+        return self.stdout
			
 
				+
			
 
				+    @property
			
 
				+    def stdout(self) -> str:
			
 
				+        """The standard output as unicode string."""
			
 
				+        return self.stdout_bytes.decode(self.runner.charset, "replace").replace(
			
 
				+            "\r\n", "\n"
			
 
				+        )
			
 
				+
			
 
				+    @property
			
 
				+    def stderr(self) -> str:
			
 
				+        """The standard error as unicode string."""
			
 
				+        if self.stderr_bytes is None:
			
 
				+            raise ValueError("stderr not separately captured")
			
 
				+        return self.stderr_bytes.decode(self.runner.charset, "replace").replace(
			
 
				+            "\r\n", "\n"
			
 
				+        )
			
 
				+
			
 
				+    def __repr__(self) -> str:
			
 
				+        exc_str = repr(self.exception) if self.exception else "okay"
			
 
				+        return f"<{type(self).__name__} {exc_str}>"
			
 
				+
			
 
				+
			
 
				+class CliRunner:
			
 
				+    """The CLI runner provides functionality to invoke a Click command line
			
 
				+    script for unittesting purposes in a isolated environment.  This only
			
 
				+    works in single-threaded systems without any concurrency as it changes the
			
 
				+    global interpreter state.
			
 
				+
			
 
				+    :param charset: the character set for the input and output data.
			
 
				+    :param env: a dictionary with environment variables for overriding.
			
 
				+    :param echo_stdin: if this is set to `True`, then reading from stdin writes
			
 
				+                       to stdout.  This is useful for showing examples in
			
 
				+                       some circumstances.  Note that regular prompts
			
 
				+                       will automatically echo the input.
			
 
				+    :param mix_stderr: if this is set to `False`, then stdout and stderr are
			
 
				+                       preserved as independent streams.  This is useful for
			
 
				+                       Unix-philosophy apps that have predictable stdout and
			
 
				+                       noisy stderr, such that each may be measured
			
 
				+                       independently
			
 
				+    """
			
 
				+
			
 
				+    def __init__(
			
 
				+        self,
			
 
				+        charset: str = "utf-8",
			
 
				+        env: t.Optional[t.Mapping[str, t.Optional[str]]] = None,
			
 
				+        echo_stdin: bool = False,
			
 
				+        mix_stderr: bool = True,
			
 
				+    ) -> None:
			
 
				+        self.charset = charset
			
 
				+        self.env: t.Mapping[str, t.Optional[str]] = env or {}
			
 
				+        self.echo_stdin = echo_stdin
			
 
				+        self.mix_stderr = mix_stderr
			
 
				+
			
 
				+    def get_default_prog_name(self, cli: "BaseCommand") -> str:
			
 
				+        """Given a command object it will return the default program name
			
 
				+        for it.  The default is the `name` attribute or ``"root"`` if not
			
 
				+        set.
			
 
				+        """
			
 
				+        return cli.name or "root"
			
 
				+
			
 
				+    def make_env(
			
 
				+        self, overrides: t.Optional[t.Mapping[str, t.Optional[str]]] = None
			
 
				+    ) -> t.Mapping[str, t.Optional[str]]:
			
 
				+        """Returns the environment overrides for invoking a script."""
			
 
				+        rv = dict(self.env)
			
 
				+        if overrides:
			
 
				+            rv.update(overrides)
			
 
				+        return rv
			
 
				+
			
 
				+    @contextlib.contextmanager
			
 
				+    def isolation(
			
 
				+        self,
			
 
				+        input: t.Optional[t.Union[str, bytes, t.IO[t.Any]]] = None,
			
 
				+        env: t.Optional[t.Mapping[str, t.Optional[str]]] = None,
			
 
				+        color: bool = False,
			
 
				+    ) -> t.Iterator[t.Tuple[io.BytesIO, t.Optional[io.BytesIO]]]:
			
 
				+        """A context manager that sets up the isolation for invoking of a
			
 
				+        command line tool.  This sets up stdin with the given input data
			
 
				+        and `os.environ` with the overrides from the given dictionary.
			
 
				+        This also rebinds some internals in Click to be mocked (like the
			
 
				+        prompt functionality).
			
 
				+
			
 
				+        This is automatically done in the :meth:`invoke` method.
			
 
				+
			
 
				+        :param input: the input stream to put into sys.stdin.
			
 
				+        :param env: the environment overrides as dictionary.
			
 
				+        :param color: whether the output should contain color codes. The
			
 
				+                      application can still override this explicitly.
			
 
				+
			
 
				+        .. versionchanged:: 8.0
			
 
				+            ``stderr`` is opened with ``errors="backslashreplace"``
			
 
				+            instead of the default ``"strict"``.
			
 
				+
			
 
				+        .. versionchanged:: 4.0
			
 
				+            Added the ``color`` parameter.
			
 
				+        """
			
 
				+        bytes_input = make_input_stream(input, self.charset)
			
 
				+        echo_input = None
			
 
				+
			
 
				+        old_stdin = sys.stdin
			
 
				+        old_stdout = sys.stdout
			
 
				+        old_stderr = sys.stderr
			
 
				+        old_forced_width = formatting.FORCED_WIDTH
			
 
				+        formatting.FORCED_WIDTH = 80
			
 
				+
			
 
				+        env = self.make_env(env)
			
 
				+
			
 
				+        bytes_output = io.BytesIO()
			
 
				+
			
 
				+        if self.echo_stdin:
			
 
				+            bytes_input = echo_input = t.cast(
			
 
				+                t.BinaryIO, EchoingStdin(bytes_input, bytes_output)
			
 
				+            )
			
 
				+
			
 
				+        sys.stdin = text_input = _NamedTextIOWrapper(
			
 
				+            bytes_input, encoding=self.charset, name="<stdin>", mode="r"
			
 
				+        )
			
 
				+
			
 
				+        if self.echo_stdin:
			
 
				+            # Force unbuffered reads, otherwise TextIOWrapper reads a
			
 
				+            # large chunk which is echoed early.
			
 
				+            text_input._CHUNK_SIZE = 1  # type: ignore
			
 
				+
			
 
				+        sys.stdout = _NamedTextIOWrapper(
			
 
				+            bytes_output, encoding=self.charset, name="<stdout>", mode="w"
			
 
				+        )
			
 
				+
			
 
				+        bytes_error = None
			
 
				+        if self.mix_stderr:
			
 
				+            sys.stderr = sys.stdout
			
 
				+        else:
			
 
				+            bytes_error = io.BytesIO()
			
 
				+            sys.stderr = _NamedTextIOWrapper(
			
 
				+                bytes_error,
			
 
				+                encoding=self.charset,
			
 
				+                name="<stderr>",
			
 
				+                mode="w",
			
 
				+                errors="backslashreplace",
			
 
				+            )
			
 
				+
			
 
				+        @_pause_echo(echo_input)  # type: ignore
			
 
				+        def visible_input(prompt: t.Optional[str] = None) -> str:
			
 
				+            sys.stdout.write(prompt or "")
			
 
				+            val = text_input.readline().rstrip("\r\n")
			
 
				+            sys.stdout.write(f"{val}\n")
			
 
				+            sys.stdout.flush()
			
 
				+            return val
			
 
				+
			
 
				+        @_pause_echo(echo_input)  # type: ignore
			
 
				+        def hidden_input(prompt: t.Optional[str] = None) -> str:
			
 
				+            sys.stdout.write(f"{prompt or ''}\n")
			
 
				+            sys.stdout.flush()
			
 
				+            return text_input.readline().rstrip("\r\n")
			
 
				+
			
 
				+        @_pause_echo(echo_input)  # type: ignore
			
 
				+        def _getchar(echo: bool) -> str:
			
 
				+            char = sys.stdin.read(1)
			
 
				+
			
 
				+            if echo:
			
 
				+                sys.stdout.write(char)
			
 
				+
			
 
				+            sys.stdout.flush()
			
 
				+            return char
			
 
				+
			
 
				+        default_color = color
			
 
				+
			
 
				+        def should_strip_ansi(
			
 
				+            stream: t.Optional[t.IO[t.Any]] = None, color: t.Optional[bool] = None
			
 
				+        ) -> bool:
			
 
				+            if color is None:
			
 
				+                return not default_color
			
 
				+            return not color
			
 
				+
			
 
				+        old_visible_prompt_func = termui.visible_prompt_func
			
 
				+        old_hidden_prompt_func = termui.hidden_prompt_func
			
 
				+        old__getchar_func = termui._getchar
			
 
				+        old_should_strip_ansi = utils.should_strip_ansi  # type: ignore
			
 
				+        termui.visible_prompt_func = visible_input
			
 
				+        termui.hidden_prompt_func = hidden_input
			
 
				+        termui._getchar = _getchar
			
 
				+        utils.should_strip_ansi = should_strip_ansi  # type: ignore
			
 
				+
			
 
				+        old_env = {}
			
 
				+        try:
			
 
				+            for key, value in env.items():
			
 
				+                old_env[key] = os.environ.get(key)
			
 
				+                if value is None:
			
 
				+                    try:
			
 
				+                        del os.environ[key]
			
 
				+                    except Exception:
			
 
				+                        pass
			
 
				+                else:
			
 
				+                    os.environ[key] = value
			
 
				+            yield (bytes_output, bytes_error)
			
 
				+        finally:
			
 
				+            for key, value in old_env.items():
			
 
				+                if value is None:
			
 
				+                    try:
			
 
				+                        del os.environ[key]
			
 
				+                    except Exception:
			
 
				+                        pass
			
 
				+                else:
			
 
				+                    os.environ[key] = value
			
 
				+            sys.stdout = old_stdout
			
 
				+            sys.stderr = old_stderr
			
 
				+            sys.stdin = old_stdin
			
 
				+            termui.visible_prompt_func = old_visible_prompt_func
			
 
				+            termui.hidden_prompt_func = old_hidden_prompt_func
			
 
				+            termui._getchar = old__getchar_func
			
 
				+            utils.should_strip_ansi = old_should_strip_ansi  # type: ignore
			
 
				+            formatting.FORCED_WIDTH = old_forced_width
			
 
				+
			
 
				+    def invoke(
			
 
				+        self,
			
 
				+        cli: "BaseCommand",
			
 
				+        args: t.Optional[t.Union[str, t.Sequence[str]]] = None,
			
 
				+        input: t.Optional[t.Union[str, bytes, t.IO[t.Any]]] = None,
			
 
				+        env: t.Optional[t.Mapping[str, t.Optional[str]]] = None,
			
 
				+        catch_exceptions: bool = True,
			
 
				+        color: bool = False,
			
 
				+        **extra: t.Any,
			
 
				+    ) -> Result:
			
 
				+        """Invokes a command in an isolated environment.  The arguments are
			
 
				+        forwarded directly to the command line script, the `extra` keyword
			
 
				+        arguments are passed to the :meth:`~clickpkg.Command.main` function of
			
 
				+        the command.
			
 
				+
			
 
				+        This returns a :class:`Result` object.
			
 
				+
			
 
				+        :param cli: the command to invoke
			
 
				+        :param args: the arguments to invoke. It may be given as an iterable
			
 
				+                     or a string. When given as string it will be interpreted
			
 
				+                     as a Unix shell command. More details at
			
 
				+                     :func:`shlex.split`.
			
 
				+        :param input: the input data for `sys.stdin`.
			
 
				+        :param env: the environment overrides.
			
 
				+        :param catch_exceptions: Whether to catch any other exceptions than
			
 
				+                                 ``SystemExit``.
			
 
				+        :param extra: the keyword arguments to pass to :meth:`main`.
			
 
				+        :param color: whether the output should contain color codes. The
			
 
				+                      application can still override this explicitly.
			
 
				+
			
 
				+        .. versionchanged:: 8.0
			
 
				+            The result object has the ``return_value`` attribute with
			
 
				+            the value returned from the invoked command.
			
 
				+
			
 
				+        .. versionchanged:: 4.0
			
 
				+            Added the ``color`` parameter.
			
 
				+
			
 
				+        .. versionchanged:: 3.0
			
 
				+            Added the ``catch_exceptions`` parameter.
			
 
				+
			
 
				+        .. versionchanged:: 3.0
			
 
				+            The result object has the ``exc_info`` attribute with the
			
 
				+            traceback if available.
			
 
				+        """
			
 
				+        exc_info = None
			
 
				+        with self.isolation(input=input, env=env, color=color) as outstreams:
			
 
				+            return_value = None
			
 
				+            exception: t.Optional[BaseException] = None
			
 
				+            exit_code = 0
			
 
				+
			
 
				+            if isinstance(args, str):
			
 
				+                args = shlex.split(args)
			
 
				+
			
 
				+            try:
			
 
				+                prog_name = extra.pop("prog_name")
			
 
				+            except KeyError:
			
 
				+                prog_name = self.get_default_prog_name(cli)
			
 
				+
			
 
				+            try:
			
 
				+                return_value = cli.main(args=args or (), prog_name=prog_name, **extra)
			
 
				+            except SystemExit as e:
			
 
				+                exc_info = sys.exc_info()
			
 
				+                e_code = t.cast(t.Optional[t.Union[int, t.Any]], e.code)
			
 
				+
			
 
				+                if e_code is None:
			
 
				+                    e_code = 0
			
 
				+
			
 
				+                if e_code != 0:
			
 
				+                    exception = e
			
 
				+
			
 
				+                if not isinstance(e_code, int):
			
 
				+                    sys.stdout.write(str(e_code))
			
 
				+                    sys.stdout.write("\n")
			
 
				+                    e_code = 1
			
 
				+
			
 
				+                exit_code = e_code
			
 
				+
			
 
				+            except Exception as e:
			
 
				+                if not catch_exceptions:
			
 
				+                    raise
			
 
				+                exception = e
			
 
				+                exit_code = 1
			
 
				+                exc_info = sys.exc_info()
			
 
				+            finally:
			
 
				+                sys.stdout.flush()
			
 
				+                stdout = outstreams[0].getvalue()
			
 
				+                if self.mix_stderr:
			
 
				+                    stderr = None
			
 
				+                else:
			
 
				+                    stderr = outstreams[1].getvalue()  # type: ignore
			
 
				+
			
 
				+        return Result(
			
 
				+            runner=self,
			
 
				+            stdout_bytes=stdout,
			
 
				+            stderr_bytes=stderr,
			
 
				+            return_value=return_value,
			
 
				+            exit_code=exit_code,
			
 
				+            exception=exception,
			
 
				+            exc_info=exc_info,  # type: ignore
			
 
				+        )
			
 
				+
			
 
				+    @contextlib.contextmanager
			
 
				+    def isolated_filesystem(
			
 
				+        self, temp_dir: t.Optional[t.Union[str, "os.PathLike[str]"]] = None
			
 
				+    ) -> t.Iterator[str]:
			
 
				+        """A context manager that creates a temporary directory and
			
 
				+        changes the current working directory to it. This isolates tests
			
 
				+        that affect the contents of the CWD to prevent them from
			
 
				+        interfering with each other.
			
 
				+
			
 
				+        :param temp_dir: Create the temporary directory under this
			
 
				+            directory. If given, the created directory is not removed
			
 
				+            when exiting.
			
 
				+
			
 
				+        .. versionchanged:: 8.0
			
 
				+            Added the ``temp_dir`` parameter.
			
 
				+        """
			
 
				+        cwd = os.getcwd()
			
 
				+        dt = tempfile.mkdtemp(dir=temp_dir)
			
 
				+        os.chdir(dt)
			
 
				+
			
 
				+        try:
			
 
				+            yield dt
			
 
				+        finally:
			
 
				+            os.chdir(cwd)
			
 
				+
			
 
				+            if temp_dir is None:
			
 
				+                try:
			
 
				+                    shutil.rmtree(dt)
			
 
				+                except OSError:  # noqa: B014
			
 
				+                    pass
			
--- a/courses/flask/microblog/env/Lib/site-packages/click/types.py
+++ b/courses/flask/microblog/env/Lib/site-packages/click/types.py
@@ -0,0 +1,1089 @@
 
				+import os
			
 
				+import stat
			
 
				+import sys
			
 
				+import typing as t
			
 
				+from datetime import datetime
			
 
				+from gettext import gettext as _
			
 
				+from gettext import ngettext
			
 
				+
			
 
				+from ._compat import _get_argv_encoding
			
 
				+from ._compat import open_stream
			
 
				+from .exceptions import BadParameter
			
 
				+from .utils import format_filename
			
 
				+from .utils import LazyFile
			
 
				+from .utils import safecall
			
 
				+
			
 
				+if t.TYPE_CHECKING:
			
 
				+    import typing_extensions as te
			
 
				+    from .core import Context
			
 
				+    from .core import Parameter
			
 
				+    from .shell_completion import CompletionItem
			
 
				+
			
 
				+
			
 
				+class ParamType:
			
 
				+    """Represents the type of a parameter. Validates and converts values
			
 
				+    from the command line or Python into the correct type.
			
 
				+
			
 
				+    To implement a custom type, subclass and implement at least the
			
 
				+    following:
			
 
				+
			
 
				+    -   The :attr:`name` class attribute must be set.
			
 
				+    -   Calling an instance of the type with ``None`` must return
			
 
				+        ``None``. This is already implemented by default.
			
 
				+    -   :meth:`convert` must convert string values to the correct type.
			
 
				+    -   :meth:`convert` must accept values that are already the correct
			
 
				+        type.
			
 
				+    -   It must be able to convert a value if the ``ctx`` and ``param``
			
 
				+        arguments are ``None``. This can occur when converting prompt
			
 
				+        input.
			
 
				+    """
			
 
				+
			
 
				+    is_composite: t.ClassVar[bool] = False
			
 
				+    arity: t.ClassVar[int] = 1
			
 
				+
			
 
				+    #: the descriptive name of this type
			
 
				+    name: str
			
 
				+
			
 
				+    #: if a list of this type is expected and the value is pulled from a
			
 
				+    #: string environment variable, this is what splits it up.  `None`
			
 
				+    #: means any whitespace.  For all parameters the general rule is that
			
 
				+    #: whitespace splits them up.  The exception are paths and files which
			
 
				+    #: are split by ``os.path.pathsep`` by default (":" on Unix and ";" on
			
 
				+    #: Windows).
			
 
				+    envvar_list_splitter: t.ClassVar[t.Optional[str]] = None
			
 
				+
			
 
				+    def to_info_dict(self) -> t.Dict[str, t.Any]:
			
 
				+        """Gather information that could be useful for a tool generating
			
 
				+        user-facing documentation.
			
 
				+
			
 
				+        Use :meth:`click.Context.to_info_dict` to traverse the entire
			
 
				+        CLI structure.
			
 
				+
			
 
				+        .. versionadded:: 8.0
			
 
				+        """
			
 
				+        # The class name without the "ParamType" suffix.
			
 
				+        param_type = type(self).__name__.partition("ParamType")[0]
			
 
				+        param_type = param_type.partition("ParameterType")[0]
			
 
				+
			
 
				+        # Custom subclasses might not remember to set a name.
			
 
				+        if hasattr(self, "name"):
			
 
				+            name = self.name
			
 
				+        else:
			
 
				+            name = param_type
			
 
				+
			
 
				+        return {"param_type": param_type, "name": name}
			
 
				+
			
 
				+    def __call__(
			
 
				+        self,
			
 
				+        value: t.Any,
			
 
				+        param: t.Optional["Parameter"] = None,
			
 
				+        ctx: t.Optional["Context"] = None,
			
 
				+    ) -> t.Any:
			
 
				+        if value is not None:
			
 
				+            return self.convert(value, param, ctx)
			
 
				+
			
 
				+    def get_metavar(self, param: "Parameter") -> t.Optional[str]:
			
 
				+        """Returns the metavar default for this param if it provides one."""
			
 
				+
			
 
				+    def get_missing_message(self, param: "Parameter") -> t.Optional[str]:
			
 
				+        """Optionally might return extra information about a missing
			
 
				+        parameter.
			
 
				+
			
 
				+        .. versionadded:: 2.0
			
 
				+        """
			
 
				+
			
 
				+    def convert(
			
 
				+        self, value: t.Any, param: t.Optional["Parameter"], ctx: t.Optional["Context"]
			
 
				+    ) -> t.Any:
			
 
				+        """Convert the value to the correct type. This is not called if
			
 
				+        the value is ``None`` (the missing value).
			
 
				+
			
 
				+        This must accept string values from the command line, as well as
			
 
				+        values that are already the correct type. It may also convert
			
 
				+        other compatible types.
			
 
				+
			
 
				+        The ``param`` and ``ctx`` arguments may be ``None`` in certain
			
 
				+        situations, such as when converting prompt input.
			
 
				+
			
 
				+        If the value cannot be converted, call :meth:`fail` with a
			
 
				+        descriptive message.
			
 
				+
			
 
				+        :param value: The value to convert.
			
 
				+        :param param: The parameter that is using this type to convert
			
 
				+            its value. May be ``None``.
			
 
				+        :param ctx: The current context that arrived at this value. May
			
 
				+            be ``None``.
			
 
				+        """
			
 
				+        return value
			
 
				+
			
 
				+    def split_envvar_value(self, rv: str) -> t.Sequence[str]:
			
 
				+        """Given a value from an environment variable this splits it up
			
 
				+        into small chunks depending on the defined envvar list splitter.
			
 
				+
			
 
				+        If the splitter is set to `None`, which means that whitespace splits,
			
 
				+        then leading and trailing whitespace is ignored.  Otherwise, leading
			
 
				+        and trailing splitters usually lead to empty items being included.
			
 
				+        """
			
 
				+        return (rv or "").split(self.envvar_list_splitter)
			
 
				+
			
 
				+    def fail(
			
 
				+        self,
			
 
				+        message: str,
			
 
				+        param: t.Optional["Parameter"] = None,
			
 
				+        ctx: t.Optional["Context"] = None,
			
 
				+    ) -> "t.NoReturn":
			
 
				+        """Helper method to fail with an invalid value message."""
			
 
				+        raise BadParameter(message, ctx=ctx, param=param)
			
 
				+
			
 
				+    def shell_complete(
			
 
				+        self, ctx: "Context", param: "Parameter", incomplete: str
			
 
				+    ) -> t.List["CompletionItem"]:
			
 
				+        """Return a list of
			
 
				+        :class:`~click.shell_completion.CompletionItem` objects for the
			
 
				+        incomplete value. Most types do not provide completions, but
			
 
				+        some do, and this allows custom types to provide custom
			
 
				+        completions as well.
			
 
				+
			
 
				+        :param ctx: Invocation context for this command.
			
 
				+        :param param: The parameter that is requesting completion.
			
 
				+        :param incomplete: Value being completed. May be empty.
			
 
				+
			
 
				+        .. versionadded:: 8.0
			
 
				+        """
			
 
				+        return []
			
 
				+
			
 
				+
			
 
				+class CompositeParamType(ParamType):
			
 
				+    is_composite = True
			
 
				+
			
 
				+    @property
			
 
				+    def arity(self) -> int:  # type: ignore
			
 
				+        raise NotImplementedError()
			
 
				+
			
 
				+
			
 
				+class FuncParamType(ParamType):
			
 
				+    def __init__(self, func: t.Callable[[t.Any], t.Any]) -> None:
			
 
				+        self.name: str = func.__name__
			
 
				+        self.func = func
			
 
				+
			
 
				+    def to_info_dict(self) -> t.Dict[str, t.Any]:
			
 
				+        info_dict = super().to_info_dict()
			
 
				+        info_dict["func"] = self.func
			
 
				+        return info_dict
			
 
				+
			
 
				+    def convert(
			
 
				+        self, value: t.Any, param: t.Optional["Parameter"], ctx: t.Optional["Context"]
			
 
				+    ) -> t.Any:
			
 
				+        try:
			
 
				+            return self.func(value)
			
 
				+        except ValueError:
			
 
				+            try:
			
 
				+                value = str(value)
			
 
				+            except UnicodeError:
			
 
				+                value = value.decode("utf-8", "replace")
			
 
				+
			
 
				+            self.fail(value, param, ctx)
			
 
				+
			
 
				+
			
 
				+class UnprocessedParamType(ParamType):
			
 
				+    name = "text"
			
 
				+
			
 
				+    def convert(
			
 
				+        self, value: t.Any, param: t.Optional["Parameter"], ctx: t.Optional["Context"]
			
 
				+    ) -> t.Any:
			
 
				+        return value
			
 
				+
			
 
				+    def __repr__(self) -> str:
			
 
				+        return "UNPROCESSED"
			
 
				+
			
 
				+
			
 
				+class StringParamType(ParamType):
			
 
				+    name = "text"
			
 
				+
			
 
				+    def convert(
			
 
				+        self, value: t.Any, param: t.Optional["Parameter"], ctx: t.Optional["Context"]
			
 
				+    ) -> t.Any:
			
 
				+        if isinstance(value, bytes):
			
 
				+            enc = _get_argv_encoding()
			
 
				+            try:
			
 
				+                value = value.decode(enc)
			
 
				+            except UnicodeError:
			
 
				+                fs_enc = sys.getfilesystemencoding()
			
 
				+                if fs_enc != enc:
			
 
				+                    try:
			
 
				+                        value = value.decode(fs_enc)
			
 
				+                    except UnicodeError:
			
 
				+                        value = value.decode("utf-8", "replace")
			
 
				+                else:
			
 
				+                    value = value.decode("utf-8", "replace")
			
 
				+            return value
			
 
				+        return str(value)
			
 
				+
			
 
				+    def __repr__(self) -> str:
			
 
				+        return "STRING"
			
 
				+
			
 
				+
			
 
				+class Choice(ParamType):
			
 
				+    """The choice type allows a value to be checked against a fixed set
			
 
				+    of supported values. All of these values have to be strings.
			
 
				+
			
 
				+    You should only pass a list or tuple of choices. Other iterables
			
 
				+    (like generators) may lead to surprising results.
			
 
				+
			
 
				+    The resulting value will always be one of the originally passed choices
			
 
				+    regardless of ``case_sensitive`` or any ``ctx.token_normalize_func``
			
 
				+    being specified.
			
 
				+
			
 
				+    See :ref:`choice-opts` for an example.
			
 
				+
			
 
				+    :param case_sensitive: Set to false to make choices case
			
 
				+        insensitive. Defaults to true.
			
 
				+    """
			
 
				+
			
 
				+    name = "choice"
			
 
				+
			
 
				+    def __init__(self, choices: t.Sequence[str], case_sensitive: bool = True) -> None:
			
 
				+        self.choices = choices
			
 
				+        self.case_sensitive = case_sensitive
			
 
				+
			
 
				+    def to_info_dict(self) -> t.Dict[str, t.Any]:
			
 
				+        info_dict = super().to_info_dict()
			
 
				+        info_dict["choices"] = self.choices
			
 
				+        info_dict["case_sensitive"] = self.case_sensitive
			
 
				+        return info_dict
			
 
				+
			
 
				+    def get_metavar(self, param: "Parameter") -> str:
			
 
				+        choices_str = "|".join(self.choices)
			
 
				+
			
 
				+        # Use curly braces to indicate a required argument.
			
 
				+        if param.required and param.param_type_name == "argument":
			
 
				+            return f"{{{choices_str}}}"
			
 
				+
			
 
				+        # Use square braces to indicate an option or optional argument.
			
 
				+        return f"[{choices_str}]"
			
 
				+
			
 
				+    def get_missing_message(self, param: "Parameter") -> str:
			
 
				+        return _("Choose from:\n\t{choices}").format(choices=",\n\t".join(self.choices))
			
 
				+
			
 
				+    def convert(
			
 
				+        self, value: t.Any, param: t.Optional["Parameter"], ctx: t.Optional["Context"]
			
 
				+    ) -> t.Any:
			
 
				+        # Match through normalization and case sensitivity
			
 
				+        # first do token_normalize_func, then lowercase
			
 
				+        # preserve original `value` to produce an accurate message in
			
 
				+        # `self.fail`
			
 
				+        normed_value = value
			
 
				+        normed_choices = {choice: choice for choice in self.choices}
			
 
				+
			
 
				+        if ctx is not None and ctx.token_normalize_func is not None:
			
 
				+            normed_value = ctx.token_normalize_func(value)
			
 
				+            normed_choices = {
			
 
				+                ctx.token_normalize_func(normed_choice): original
			
 
				+                for normed_choice, original in normed_choices.items()
			
 
				+            }
			
 
				+
			
 
				+        if not self.case_sensitive:
			
 
				+            normed_value = normed_value.casefold()
			
 
				+            normed_choices = {
			
 
				+                normed_choice.casefold(): original
			
 
				+                for normed_choice, original in normed_choices.items()
			
 
				+            }
			
 
				+
			
 
				+        if normed_value in normed_choices:
			
 
				+            return normed_choices[normed_value]
			
 
				+
			
 
				+        choices_str = ", ".join(map(repr, self.choices))
			
 
				+        self.fail(
			
 
				+            ngettext(
			
 
				+                "{value!r} is not {choice}.",
			
 
				+                "{value!r} is not one of {choices}.",
			
 
				+                len(self.choices),
			
 
				+            ).format(value=value, choice=choices_str, choices=choices_str),
			
 
				+            param,
			
 
				+            ctx,
			
 
				+        )
			
 
				+
			
 
				+    def __repr__(self) -> str:
			
 
				+        return f"Choice({list(self.choices)})"
			
 
				+
			
 
				+    def shell_complete(
			
 
				+        self, ctx: "Context", param: "Parameter", incomplete: str
			
 
				+    ) -> t.List["CompletionItem"]:
			
 
				+        """Complete choices that start with the incomplete value.
			
 
				+
			
 
				+        :param ctx: Invocation context for this command.
			
 
				+        :param param: The parameter that is requesting completion.
			
 
				+        :param incomplete: Value being completed. May be empty.
			
 
				+
			
 
				+        .. versionadded:: 8.0
			
 
				+        """
			
 
				+        from click.shell_completion import CompletionItem
			
 
				+
			
 
				+        str_choices = map(str, self.choices)
			
 
				+
			
 
				+        if self.case_sensitive:
			
 
				+            matched = (c for c in str_choices if c.startswith(incomplete))
			
 
				+        else:
			
 
				+            incomplete = incomplete.lower()
			
 
				+            matched = (c for c in str_choices if c.lower().startswith(incomplete))
			
 
				+
			
 
				+        return [CompletionItem(c) for c in matched]
			
 
				+
			
 
				+
			
 
				+class DateTime(ParamType):
			
 
				+    """The DateTime type converts date strings into `datetime` objects.
			
 
				+
			
 
				+    The format strings which are checked are configurable, but default to some
			
 
				+    common (non-timezone aware) ISO 8601 formats.
			
 
				+
			
 
				+    When specifying *DateTime* formats, you should only pass a list or a tuple.
			
 
				+    Other iterables, like generators, may lead to surprising results.
			
 
				+
			
 
				+    The format strings are processed using ``datetime.strptime``, and this
			
 
				+    consequently defines the format strings which are allowed.
			
 
				+
			
 
				+    Parsing is tried using each format, in order, and the first format which
			
 
				+    parses successfully is used.
			
 
				+
			
 
				+    :param formats: A list or tuple of date format strings, in the order in
			
 
				+                    which they should be tried. Defaults to
			
 
				+                    ``'%Y-%m-%d'``, ``'%Y-%m-%dT%H:%M:%S'``,
			
 
				+                    ``'%Y-%m-%d %H:%M:%S'``.
			
 
				+    """
			
 
				+
			
 
				+    name = "datetime"
			
 
				+
			
 
				+    def __init__(self, formats: t.Optional[t.Sequence[str]] = None):
			
 
				+        self.formats: t.Sequence[str] = formats or [
			
 
				+            "%Y-%m-%d",
			
 
				+            "%Y-%m-%dT%H:%M:%S",
			
 
				+            "%Y-%m-%d %H:%M:%S",
			
 
				+        ]
			
 
				+
			
 
				+    def to_info_dict(self) -> t.Dict[str, t.Any]:
			
 
				+        info_dict = super().to_info_dict()
			
 
				+        info_dict["formats"] = self.formats
			
 
				+        return info_dict
			
 
				+
			
 
				+    def get_metavar(self, param: "Parameter") -> str:
			
 
				+        return f"[{'|'.join(self.formats)}]"
			
 
				+
			
 
				+    def _try_to_convert_date(self, value: t.Any, format: str) -> t.Optional[datetime]:
			
 
				+        try:
			
 
				+            return datetime.strptime(value, format)
			
 
				+        except ValueError:
			
 
				+            return None
			
 
				+
			
 
				+    def convert(
			
 
				+        self, value: t.Any, param: t.Optional["Parameter"], ctx: t.Optional["Context"]
			
 
				+    ) -> t.Any:
			
 
				+        if isinstance(value, datetime):
			
 
				+            return value
			
 
				+
			
 
				+        for format in self.formats:
			
 
				+            converted = self._try_to_convert_date(value, format)
			
 
				+
			
 
				+            if converted is not None:
			
 
				+                return converted
			
 
				+
			
 
				+        formats_str = ", ".join(map(repr, self.formats))
			
 
				+        self.fail(
			
 
				+            ngettext(
			
 
				+                "{value!r} does not match the format {format}.",
			
 
				+                "{value!r} does not match the formats {formats}.",
			
 
				+                len(self.formats),
			
 
				+            ).format(value=value, format=formats_str, formats=formats_str),
			
 
				+            param,
			
 
				+            ctx,
			
 
				+        )
			
 
				+
			
 
				+    def __repr__(self) -> str:
			
 
				+        return "DateTime"
			
 
				+
			
 
				+
			
 
				+class _NumberParamTypeBase(ParamType):
			
 
				+    _number_class: t.ClassVar[t.Type[t.Any]]
			
 
				+
			
 
				+    def convert(
			
 
				+        self, value: t.Any, param: t.Optional["Parameter"], ctx: t.Optional["Context"]
			
 
				+    ) -> t.Any:
			
 
				+        try:
			
 
				+            return self._number_class(value)
			
 
				+        except ValueError:
			
 
				+            self.fail(
			
 
				+                _("{value!r} is not a valid {number_type}.").format(
			
 
				+                    value=value, number_type=self.name
			
 
				+                ),
			
 
				+                param,
			
 
				+                ctx,
			
 
				+            )
			
 
				+
			
 
				+
			
 
				+class _NumberRangeBase(_NumberParamTypeBase):
			
 
				+    def __init__(
			
 
				+        self,
			
 
				+        min: t.Optional[float] = None,
			
 
				+        max: t.Optional[float] = None,
			
 
				+        min_open: bool = False,
			
 
				+        max_open: bool = False,
			
 
				+        clamp: bool = False,
			
 
				+    ) -> None:
			
 
				+        self.min = min
			
 
				+        self.max = max
			
 
				+        self.min_open = min_open
			
 
				+        self.max_open = max_open
			
 
				+        self.clamp = clamp
			
 
				+
			
 
				+    def to_info_dict(self) -> t.Dict[str, t.Any]:
			
 
				+        info_dict = super().to_info_dict()
			
 
				+        info_dict.update(
			
 
				+            min=self.min,
			
 
				+            max=self.max,
			
 
				+            min_open=self.min_open,
			
 
				+            max_open=self.max_open,
			
 
				+            clamp=self.clamp,
			
 
				+        )
			
 
				+        return info_dict
			
 
				+
			
 
				+    def convert(
			
 
				+        self, value: t.Any, param: t.Optional["Parameter"], ctx: t.Optional["Context"]
			
 
				+    ) -> t.Any:
			
 
				+        import operator
			
 
				+
			
 
				+        rv = super().convert(value, param, ctx)
			
 
				+        lt_min: bool = self.min is not None and (
			
 
				+            operator.le if self.min_open else operator.lt
			
 
				+        )(rv, self.min)
			
 
				+        gt_max: bool = self.max is not None and (
			
 
				+            operator.ge if self.max_open else operator.gt
			
 
				+        )(rv, self.max)
			
 
				+
			
 
				+        if self.clamp:
			
 
				+            if lt_min:
			
 
				+                return self._clamp(self.min, 1, self.min_open)  # type: ignore
			
 
				+
			
 
				+            if gt_max:
			
 
				+                return self._clamp(self.max, -1, self.max_open)  # type: ignore
			
 
				+
			
 
				+        if lt_min or gt_max:
			
 
				+            self.fail(
			
 
				+                _("{value} is not in the range {range}.").format(
			
 
				+                    value=rv, range=self._describe_range()
			
 
				+                ),
			
 
				+                param,
			
 
				+                ctx,
			
 
				+            )
			
 
				+
			
 
				+        return rv
			
 
				+
			
 
				+    def _clamp(self, bound: float, dir: "te.Literal[1, -1]", open: bool) -> float:
			
 
				+        """Find the valid value to clamp to bound in the given
			
 
				+        direction.
			
 
				+
			
 
				+        :param bound: The boundary value.
			
 
				+        :param dir: 1 or -1 indicating the direction to move.
			
 
				+        :param open: If true, the range does not include the bound.
			
 
				+        """
			
 
				+        raise NotImplementedError
			
 
				+
			
 
				+    def _describe_range(self) -> str:
			
 
				+        """Describe the range for use in help text."""
			
 
				+        if self.min is None:
			
 
				+            op = "<" if self.max_open else "<="
			
 
				+            return f"x{op}{self.max}"
			
 
				+
			
 
				+        if self.max is None:
			
 
				+            op = ">" if self.min_open else ">="
			
 
				+            return f"x{op}{self.min}"
			
 
				+
			
 
				+        lop = "<" if self.min_open else "<="
			
 
				+        rop = "<" if self.max_open else "<="
			
 
				+        return f"{self.min}{lop}x{rop}{self.max}"
			
 
				+
			
 
				+    def __repr__(self) -> str:
			
 
				+        clamp = " clamped" if self.clamp else ""
			
 
				+        return f"<{type(self).__name__} {self._describe_range()}{clamp}>"
			
 
				+
			
 
				+
			
 
				+class IntParamType(_NumberParamTypeBase):
			
 
				+    name = "integer"
			
 
				+    _number_class = int
			
 
				+
			
 
				+    def __repr__(self) -> str:
			
 
				+        return "INT"
			
 
				+
			
 
				+
			
 
				+class IntRange(_NumberRangeBase, IntParamType):
			
 
				+    """Restrict an :data:`click.INT` value to a range of accepted
			
 
				+    values. See :ref:`ranges`.
			
 
				+
			
 
				+    If ``min`` or ``max`` are not passed, any value is accepted in that
			
 
				+    direction. If ``min_open`` or ``max_open`` are enabled, the
			
 
				+    corresponding boundary is not included in the range.
			
 
				+
			
 
				+    If ``clamp`` is enabled, a value outside the range is clamped to the
			
 
				+    boundary instead of failing.
			
 
				+
			
 
				+    .. versionchanged:: 8.0
			
 
				+        Added the ``min_open`` and ``max_open`` parameters.
			
 
				+    """
			
 
				+
			
 
				+    name = "integer range"
			
 
				+
			
 
				+    def _clamp(  # type: ignore
			
 
				+        self, bound: int, dir: "te.Literal[1, -1]", open: bool
			
 
				+    ) -> int:
			
 
				+        if not open:
			
 
				+            return bound
			
 
				+
			
 
				+        return bound + dir
			
 
				+
			
 
				+
			
 
				+class FloatParamType(_NumberParamTypeBase):
			
 
				+    name = "float"
			
 
				+    _number_class = float
			
 
				+
			
 
				+    def __repr__(self) -> str:
			
 
				+        return "FLOAT"
			
 
				+
			
 
				+
			
 
				+class FloatRange(_NumberRangeBase, FloatParamType):
			
 
				+    """Restrict a :data:`click.FLOAT` value to a range of accepted
			
 
				+    values. See :ref:`ranges`.
			
 
				+
			
 
				+    If ``min`` or ``max`` are not passed, any value is accepted in that
			
 
				+    direction. If ``min_open`` or ``max_open`` are enabled, the
			
 
				+    corresponding boundary is not included in the range.
			
 
				+
			
 
				+    If ``clamp`` is enabled, a value outside the range is clamped to the
			
 
				+    boundary instead of failing. This is not supported if either
			
 
				+    boundary is marked ``open``.
			
 
				+
			
 
				+    .. versionchanged:: 8.0
			
 
				+        Added the ``min_open`` and ``max_open`` parameters.
			
 
				+    """
			
 
				+
			
 
				+    name = "float range"
			
 
				+
			
 
				+    def __init__(
			
 
				+        self,
			
 
				+        min: t.Optional[float] = None,
			
 
				+        max: t.Optional[float] = None,
			
 
				+        min_open: bool = False,
			
 
				+        max_open: bool = False,
			
 
				+        clamp: bool = False,
			
 
				+    ) -> None:
			
 
				+        super().__init__(
			
 
				+            min=min, max=max, min_open=min_open, max_open=max_open, clamp=clamp
			
 
				+        )
			
 
				+
			
 
				+        if (min_open or max_open) and clamp:
			
 
				+            raise TypeError("Clamping is not supported for open bounds.")
			
 
				+
			
 
				+    def _clamp(self, bound: float, dir: "te.Literal[1, -1]", open: bool) -> float:
			
 
				+        if not open:
			
 
				+            return bound
			
 
				+
			
 
				+        # Could use Python 3.9's math.nextafter here, but clamping an
			
 
				+        # open float range doesn't seem to be particularly useful. It's
			
 
				+        # left up to the user to write a callback to do it if needed.
			
 
				+        raise RuntimeError("Clamping is not supported for open bounds.")
			
 
				+
			
 
				+
			
 
				+class BoolParamType(ParamType):
			
 
				+    name = "boolean"
			
 
				+
			
 
				+    def convert(
			
 
				+        self, value: t.Any, param: t.Optional["Parameter"], ctx: t.Optional["Context"]
			
 
				+    ) -> t.Any:
			
 
				+        if value in {False, True}:
			
 
				+            return bool(value)
			
 
				+
			
 
				+        norm = value.strip().lower()
			
 
				+
			
 
				+        if norm in {"1", "true", "t", "yes", "y", "on"}:
			
 
				+            return True
			
 
				+
			
 
				+        if norm in {"0", "false", "f", "no", "n", "off"}:
			
 
				+            return False
			
 
				+
			
 
				+        self.fail(
			
 
				+            _("{value!r} is not a valid boolean.").format(value=value), param, ctx
			
 
				+        )
			
 
				+
			
 
				+    def __repr__(self) -> str:
			
 
				+        return "BOOL"
			
 
				+
			
 
				+
			
 
				+class UUIDParameterType(ParamType):
			
 
				+    name = "uuid"
			
 
				+
			
 
				+    def convert(
			
 
				+        self, value: t.Any, param: t.Optional["Parameter"], ctx: t.Optional["Context"]
			
 
				+    ) -> t.Any:
			
 
				+        import uuid
			
 
				+
			
 
				+        if isinstance(value, uuid.UUID):
			
 
				+            return value
			
 
				+
			
 
				+        value = value.strip()
			
 
				+
			
 
				+        try:
			
 
				+            return uuid.UUID(value)
			
 
				+        except ValueError:
			
 
				+            self.fail(
			
 
				+                _("{value!r} is not a valid UUID.").format(value=value), param, ctx
			
 
				+            )
			
 
				+
			
 
				+    def __repr__(self) -> str:
			
 
				+        return "UUID"
			
 
				+
			
 
				+
			
 
				+class File(ParamType):
			
 
				+    """Declares a parameter to be a file for reading or writing.  The file
			
 
				+    is automatically closed once the context tears down (after the command
			
 
				+    finished working).
			
 
				+
			
 
				+    Files can be opened for reading or writing.  The special value ``-``
			
 
				+    indicates stdin or stdout depending on the mode.
			
 
				+
			
 
				+    By default, the file is opened for reading text data, but it can also be
			
 
				+    opened in binary mode or for writing.  The encoding parameter can be used
			
 
				+    to force a specific encoding.
			
 
				+
			
 
				+    The `lazy` flag controls if the file should be opened immediately or upon
			
 
				+    first IO. The default is to be non-lazy for standard input and output
			
 
				+    streams as well as files opened for reading, `lazy` otherwise. When opening a
			
 
				+    file lazily for reading, it is still opened temporarily for validation, but
			
 
				+    will not be held open until first IO. lazy is mainly useful when opening
			
 
				+    for writing to avoid creating the file until it is needed.
			
 
				+
			
 
				+    Starting with Click 2.0, files can also be opened atomically in which
			
 
				+    case all writes go into a separate file in the same folder and upon
			
 
				+    completion the file will be moved over to the original location.  This
			
 
				+    is useful if a file regularly read by other users is modified.
			
 
				+
			
 
				+    See :ref:`file-args` for more information.
			
 
				+    """
			
 
				+
			
 
				+    name = "filename"
			
 
				+    envvar_list_splitter: t.ClassVar[str] = os.path.pathsep
			
 
				+
			
 
				+    def __init__(
			
 
				+        self,
			
 
				+        mode: str = "r",
			
 
				+        encoding: t.Optional[str] = None,
			
 
				+        errors: t.Optional[str] = "strict",
			
 
				+        lazy: t.Optional[bool] = None,
			
 
				+        atomic: bool = False,
			
 
				+    ) -> None:
			
 
				+        self.mode = mode
			
 
				+        self.encoding = encoding
			
 
				+        self.errors = errors
			
 
				+        self.lazy = lazy
			
 
				+        self.atomic = atomic
			
 
				+
			
 
				+    def to_info_dict(self) -> t.Dict[str, t.Any]:
			
 
				+        info_dict = super().to_info_dict()
			
 
				+        info_dict.update(mode=self.mode, encoding=self.encoding)
			
 
				+        return info_dict
			
 
				+
			
 
				+    def resolve_lazy_flag(self, value: "t.Union[str, os.PathLike[str]]") -> bool:
			
 
				+        if self.lazy is not None:
			
 
				+            return self.lazy
			
 
				+        if os.fspath(value) == "-":
			
 
				+            return False
			
 
				+        elif "w" in self.mode:
			
 
				+            return True
			
 
				+        return False
			
 
				+
			
 
				+    def convert(
			
 
				+        self,
			
 
				+        value: t.Union[str, "os.PathLike[str]", t.IO[t.Any]],
			
 
				+        param: t.Optional["Parameter"],
			
 
				+        ctx: t.Optional["Context"],
			
 
				+    ) -> t.IO[t.Any]:
			
 
				+        if _is_file_like(value):
			
 
				+            return value
			
 
				+
			
 
				+        value = t.cast("t.Union[str, os.PathLike[str]]", value)
			
 
				+
			
 
				+        try:
			
 
				+            lazy = self.resolve_lazy_flag(value)
			
 
				+
			
 
				+            if lazy:
			
 
				+                lf = LazyFile(
			
 
				+                    value, self.mode, self.encoding, self.errors, atomic=self.atomic
			
 
				+                )
			
 
				+
			
 
				+                if ctx is not None:
			
 
				+                    ctx.call_on_close(lf.close_intelligently)
			
 
				+
			
 
				+                return t.cast(t.IO[t.Any], lf)
			
 
				+
			
 
				+            f, should_close = open_stream(
			
 
				+                value, self.mode, self.encoding, self.errors, atomic=self.atomic
			
 
				+            )
			
 
				+
			
 
				+            # If a context is provided, we automatically close the file
			
 
				+            # at the end of the context execution (or flush out).  If a
			
 
				+            # context does not exist, it's the caller's responsibility to
			
 
				+            # properly close the file.  This for instance happens when the
			
 
				+            # type is used with prompts.
			
 
				+            if ctx is not None:
			
 
				+                if should_close:
			
 
				+                    ctx.call_on_close(safecall(f.close))
			
 
				+                else:
			
 
				+                    ctx.call_on_close(safecall(f.flush))
			
 
				+
			
 
				+            return f
			
 
				+        except OSError as e:  # noqa: B014
			
 
				+            self.fail(f"'{format_filename(value)}': {e.strerror}", param, ctx)
			
 
				+
			
 
				+    def shell_complete(
			
 
				+        self, ctx: "Context", param: "Parameter", incomplete: str
			
 
				+    ) -> t.List["CompletionItem"]:
			
 
				+        """Return a special completion marker that tells the completion
			
 
				+        system to use the shell to provide file path completions.
			
 
				+
			
 
				+        :param ctx: Invocation context for this command.
			
 
				+        :param param: The parameter that is requesting completion.
			
 
				+        :param incomplete: Value being completed. May be empty.
			
 
				+
			
 
				+        .. versionadded:: 8.0
			
 
				+        """
			
 
				+        from click.shell_completion import CompletionItem
			
 
				+
			
 
				+        return [CompletionItem(incomplete, type="file")]
			
 
				+
			
 
				+
			
 
				+def _is_file_like(value: t.Any) -> "te.TypeGuard[t.IO[t.Any]]":
			
 
				+    return hasattr(value, "read") or hasattr(value, "write")
			
 
				+
			
 
				+
			
 
				+class Path(ParamType):
			
 
				+    """The ``Path`` type is similar to the :class:`File` type, but
			
 
				+    returns the filename instead of an open file. Various checks can be
			
 
				+    enabled to validate the type of file and permissions.
			
 
				+
			
 
				+    :param exists: The file or directory needs to exist for the value to
			
 
				+        be valid. If this is not set to ``True``, and the file does not
			
 
				+        exist, then all further checks are silently skipped.
			
 
				+    :param file_okay: Allow a file as a value.
			
 
				+    :param dir_okay: Allow a directory as a value.
			
 
				+    :param readable: if true, a readable check is performed.
			
 
				+    :param writable: if true, a writable check is performed.
			
 
				+    :param executable: if true, an executable check is performed.
			
 
				+    :param resolve_path: Make the value absolute and resolve any
			
 
				+        symlinks. A ``~`` is not expanded, as this is supposed to be
			
 
				+        done by the shell only.
			
 
				+    :param allow_dash: Allow a single dash as a value, which indicates
			
 
				+        a standard stream (but does not open it). Use
			
 
				+        :func:`~click.open_file` to handle opening this value.
			
 
				+    :param path_type: Convert the incoming path value to this type. If
			
 
				+        ``None``, keep Python's default, which is ``str``. Useful to
			
 
				+        convert to :class:`pathlib.Path`.
			
 
				+
			
 
				+    .. versionchanged:: 8.1
			
 
				+        Added the ``executable`` parameter.
			
 
				+
			
 
				+    .. versionchanged:: 8.0
			
 
				+        Allow passing ``path_type=pathlib.Path``.
			
 
				+
			
 
				+    .. versionchanged:: 6.0
			
 
				+        Added the ``allow_dash`` parameter.
			
 
				+    """
			
 
				+
			
 
				+    envvar_list_splitter: t.ClassVar[str] = os.path.pathsep
			
 
				+
			
 
				+    def __init__(
			
 
				+        self,
			
 
				+        exists: bool = False,
			
 
				+        file_okay: bool = True,
			
 
				+        dir_okay: bool = True,
			
 
				+        writable: bool = False,
			
 
				+        readable: bool = True,
			
 
				+        resolve_path: bool = False,
			
 
				+        allow_dash: bool = False,
			
 
				+        path_type: t.Optional[t.Type[t.Any]] = None,
			
 
				+        executable: bool = False,
			
 
				+    ):
			
 
				+        self.exists = exists
			
 
				+        self.file_okay = file_okay
			
 
				+        self.dir_okay = dir_okay
			
 
				+        self.readable = readable
			
 
				+        self.writable = writable
			
 
				+        self.executable = executable
			
 
				+        self.resolve_path = resolve_path
			
 
				+        self.allow_dash = allow_dash
			
 
				+        self.type = path_type
			
 
				+
			
 
				+        if self.file_okay and not self.dir_okay:
			
 
				+            self.name: str = _("file")
			
 
				+        elif self.dir_okay and not self.file_okay:
			
 
				+            self.name = _("directory")
			
 
				+        else:
			
 
				+            self.name = _("path")
			
 
				+
			
 
				+    def to_info_dict(self) -> t.Dict[str, t.Any]:
			
 
				+        info_dict = super().to_info_dict()
			
 
				+        info_dict.update(
			
 
				+            exists=self.exists,
			
 
				+            file_okay=self.file_okay,
			
 
				+            dir_okay=self.dir_okay,
			
 
				+            writable=self.writable,
			
 
				+            readable=self.readable,
			
 
				+            allow_dash=self.allow_dash,
			
 
				+        )
			
 
				+        return info_dict
			
 
				+
			
 
				+    def coerce_path_result(
			
 
				+        self, value: "t.Union[str, os.PathLike[str]]"
			
 
				+    ) -> "t.Union[str, bytes, os.PathLike[str]]":
			
 
				+        if self.type is not None and not isinstance(value, self.type):
			
 
				+            if self.type is str:
			
 
				+                return os.fsdecode(value)
			
 
				+            elif self.type is bytes:
			
 
				+                return os.fsencode(value)
			
 
				+            else:
			
 
				+                return t.cast("os.PathLike[str]", self.type(value))
			
 
				+
			
 
				+        return value
			
 
				+
			
 
				+    def convert(
			
 
				+        self,
			
 
				+        value: "t.Union[str, os.PathLike[str]]",
			
 
				+        param: t.Optional["Parameter"],
			
 
				+        ctx: t.Optional["Context"],
			
 
				+    ) -> "t.Union[str, bytes, os.PathLike[str]]":
			
 
				+        rv = value
			
 
				+
			
 
				+        is_dash = self.file_okay and self.allow_dash and rv in (b"-", "-")
			
 
				+
			
 
				+        if not is_dash:
			
 
				+            if self.resolve_path:
			
 
				+                # os.path.realpath doesn't resolve symlinks on Windows
			
 
				+                # until Python 3.8. Use pathlib for now.
			
 
				+                import pathlib
			
 
				+
			
 
				+                rv = os.fsdecode(pathlib.Path(rv).resolve())
			
 
				+
			
 
				+            try:
			
 
				+                st = os.stat(rv)
			
 
				+            except OSError:
			
 
				+                if not self.exists:
			
 
				+                    return self.coerce_path_result(rv)
			
 
				+                self.fail(
			
 
				+                    _("{name} {filename!r} does not exist.").format(
			
 
				+                        name=self.name.title(), filename=format_filename(value)
			
 
				+                    ),
			
 
				+                    param,
			
 
				+                    ctx,
			
 
				+                )
			
 
				+
			
 
				+            if not self.file_okay and stat.S_ISREG(st.st_mode):
			
 
				+                self.fail(
			
 
				+                    _("{name} {filename!r} is a file.").format(
			
 
				+                        name=self.name.title(), filename=format_filename(value)
			
 
				+                    ),
			
 
				+                    param,
			
 
				+                    ctx,
			
 
				+                )
			
 
				+            if not self.dir_okay and stat.S_ISDIR(st.st_mode):
			
 
				+                self.fail(
			
 
				+                    _("{name} '{filename}' is a directory.").format(
			
 
				+                        name=self.name.title(), filename=format_filename(value)
			
 
				+                    ),
			
 
				+                    param,
			
 
				+                    ctx,
			
 
				+                )
			
 
				+
			
 
				+            if self.readable and not os.access(rv, os.R_OK):
			
 
				+                self.fail(
			
 
				+                    _("{name} {filename!r} is not readable.").format(
			
 
				+                        name=self.name.title(), filename=format_filename(value)
			
 
				+                    ),
			
 
				+                    param,
			
 
				+                    ctx,
			
 
				+                )
			
 
				+
			
 
				+            if self.writable and not os.access(rv, os.W_OK):
			
 
				+                self.fail(
			
 
				+                    _("{name} {filename!r} is not writable.").format(
			
 
				+                        name=self.name.title(), filename=format_filename(value)
			
 
				+                    ),
			
 
				+                    param,
			
 
				+                    ctx,
			
 
				+                )
			
 
				+
			
 
				+            if self.executable and not os.access(value, os.X_OK):
			
 
				+                self.fail(
			
 
				+                    _("{name} {filename!r} is not executable.").format(
			
 
				+                        name=self.name.title(), filename=format_filename(value)
			
 
				+                    ),
			
 
				+                    param,
			
 
				+                    ctx,
			
 
				+                )
			
 
				+
			
 
				+        return self.coerce_path_result(rv)
			
 
				+
			
 
				+    def shell_complete(
			
 
				+        self, ctx: "Context", param: "Parameter", incomplete: str
			
 
				+    ) -> t.List["CompletionItem"]:
			
 
				+        """Return a special completion marker that tells the completion
			
 
				+        system to use the shell to provide path completions for only
			
 
				+        directories or any paths.
			
 
				+
			
 
				+        :param ctx: Invocation context for this command.
			
 
				+        :param param: The parameter that is requesting completion.
			
 
				+        :param incomplete: Value being completed. May be empty.
			
 
				+
			
 
				+        .. versionadded:: 8.0
			
 
				+        """
			
 
				+        from click.shell_completion import CompletionItem
			
 
				+
			
 
				+        type = "dir" if self.dir_okay and not self.file_okay else "file"
			
 
				+        return [CompletionItem(incomplete, type=type)]
			
 
				+
			
 
				+
			
 
				+class Tuple(CompositeParamType):
			
 
				+    """The default behavior of Click is to apply a type on a value directly.
			
 
				+    This works well in most cases, except for when `nargs` is set to a fixed
			
 
				+    count and different types should be used for different items.  In this
			
 
				+    case the :class:`Tuple` type can be used.  This type can only be used
			
 
				+    if `nargs` is set to a fixed number.
			
 
				+
			
 
				+    For more information see :ref:`tuple-type`.
			
 
				+
			
 
				+    This can be selected by using a Python tuple literal as a type.
			
 
				+
			
 
				+    :param types: a list of types that should be used for the tuple items.
			
 
				+    """
			
 
				+
			
 
				+    def __init__(self, types: t.Sequence[t.Union[t.Type[t.Any], ParamType]]) -> None:
			
 
				+        self.types: t.Sequence[ParamType] = [convert_type(ty) for ty in types]
			
 
				+
			
 
				+    def to_info_dict(self) -> t.Dict[str, t.Any]:
			
 
				+        info_dict = super().to_info_dict()
			
 
				+        info_dict["types"] = [t.to_info_dict() for t in self.types]
			
 
				+        return info_dict
			
 
				+
			
 
				+    @property
			
 
				+    def name(self) -> str:  # type: ignore
			
 
				+        return f"<{' '.join(ty.name for ty in self.types)}>"
			
 
				+
			
 
				+    @property
			
 
				+    def arity(self) -> int:  # type: ignore
			
 
				+        return len(self.types)
			
 
				+
			
 
				+    def convert(
			
 
				+        self, value: t.Any, param: t.Optional["Parameter"], ctx: t.Optional["Context"]
			
 
				+    ) -> t.Any:
			
 
				+        len_type = len(self.types)
			
 
				+        len_value = len(value)
			
 
				+
			
 
				+        if len_value != len_type:
			
 
				+            self.fail(
			
 
				+                ngettext(
			
 
				+                    "{len_type} values are required, but {len_value} was given.",
			
 
				+                    "{len_type} values are required, but {len_value} were given.",
			
 
				+                    len_value,
			
 
				+                ).format(len_type=len_type, len_value=len_value),
			
 
				+                param=param,
			
 
				+                ctx=ctx,
			
 
				+            )
			
 
				+
			
 
				+        return tuple(ty(x, param, ctx) for ty, x in zip(self.types, value))
			
 
				+
			
 
				+
			
 
				+def convert_type(ty: t.Optional[t.Any], default: t.Optional[t.Any] = None) -> ParamType:
			
 
				+    """Find the most appropriate :class:`ParamType` for the given Python
			
 
				+    type. If the type isn't provided, it can be inferred from a default
			
 
				+    value.
			
 
				+    """
			
 
				+    guessed_type = False
			
 
				+
			
 
				+    if ty is None and default is not None:
			
 
				+        if isinstance(default, (tuple, list)):
			
 
				+            # If the default is empty, ty will remain None and will
			
 
				+            # return STRING.
			
 
				+            if default:
			
 
				+                item = default[0]
			
 
				+
			
 
				+                # A tuple of tuples needs to detect the inner types.
			
 
				+                # Can't call convert recursively because that would
			
 
				+                # incorrectly unwind the tuple to a single type.
			
 
				+                if isinstance(item, (tuple, list)):
			
 
				+                    ty = tuple(map(type, item))
			
 
				+                else:
			
 
				+                    ty = type(item)
			
 
				+        else:
			
 
				+            ty = type(default)
			
 
				+
			
 
				+        guessed_type = True
			
 
				+
			
 
				+    if isinstance(ty, tuple):
			
 
				+        return Tuple(ty)
			
 
				+
			
 
				+    if isinstance(ty, ParamType):
			
 
				+        return ty
			
 
				+
			
 
				+    if ty is str or ty is None:
			
 
				+        return STRING
			
 
				+
			
 
				+    if ty is int:
			
 
				+        return INT
			
 
				+
			
 
				+    if ty is float:
			
 
				+        return FLOAT
			
 
				+
			
 
				+    if ty is bool:
			
 
				+        return BOOL
			
 
				+
			
 
				+    if guessed_type:
			
 
				+        return STRING
			
 
				+
			
 
				+    if __debug__:
			
 
				+        try:
			
 
				+            if issubclass(ty, ParamType):
			
 
				+                raise AssertionError(
			
 
				+                    f"Attempted to use an uninstantiated parameter type ({ty})."
			
 
				+                )
			
 
				+        except TypeError:
			
 
				+            # ty is an instance (correct), so issubclass fails.
			
 
				+            pass
			
 
				+
			
 
				+    return FuncParamType(ty)
			
 
				+
			
 
				+
			
 
				+#: A dummy parameter type that just does nothing.  From a user's
			
 
				+#: perspective this appears to just be the same as `STRING` but
			
 
				+#: internally no string conversion takes place if the input was bytes.
			
 
				+#: This is usually useful when working with file paths as they can
			
 
				+#: appear in bytes and unicode.
			
 
				+#:
			
 
				+#: For path related uses the :class:`Path` type is a better choice but
			
 
				+#: there are situations where an unprocessed type is useful which is why
			
 
				+#: it is is provided.
			
 
				+#:
			
 
				+#: .. versionadded:: 4.0
			
 
				+UNPROCESSED = UnprocessedParamType()
			
 
				+
			
 
				+#: A unicode string parameter type which is the implicit default.  This
			
 
				+#: can also be selected by using ``str`` as type.
			
 
				+STRING = StringParamType()
			
 
				+
			
 
				+#: An integer parameter.  This can also be selected by using ``int`` as
			
 
				+#: type.
			
 
				+INT = IntParamType()
			
 
				+
			
 
				+#: A floating point value parameter.  This can also be selected by using
			
 
				+#: ``float`` as type.
			
 
				+FLOAT = FloatParamType()
			
 
				+
			
 
				+#: A boolean parameter.  This is the default for boolean flags.  This can
			
 
				+#: also be selected by using ``bool`` as a type.
			
 
				+BOOL = BoolParamType()
			
 
				+
			
 
				+#: A UUID parameter.
			
 
				+UUID = UUIDParameterType()
			
--- a/courses/flask/microblog/env/Lib/site-packages/click/utils.py
+++ b/courses/flask/microblog/env/Lib/site-packages/click/utils.py
@@ -0,0 +1,624 @@
 
				+import os
			
 
				+import re
			
 
				+import sys
			
 
				+import typing as t
			
 
				+from functools import update_wrapper
			
 
				+from types import ModuleType
			
 
				+from types import TracebackType
			
 
				+
			
 
				+from ._compat import _default_text_stderr
			
 
				+from ._compat import _default_text_stdout
			
 
				+from ._compat import _find_binary_writer
			
 
				+from ._compat import auto_wrap_for_ansi
			
 
				+from ._compat import binary_streams
			
 
				+from ._compat import open_stream
			
 
				+from ._compat import should_strip_ansi
			
 
				+from ._compat import strip_ansi
			
 
				+from ._compat import text_streams
			
 
				+from ._compat import WIN
			
 
				+from .globals import resolve_color_default
			
 
				+
			
 
				+if t.TYPE_CHECKING:
			
 
				+    import typing_extensions as te
			
 
				+
			
 
				+    P = te.ParamSpec("P")
			
 
				+
			
 
				+R = t.TypeVar("R")
			
 
				+
			
 
				+
			
 
				+def _posixify(name: str) -> str:
			
 
				+    return "-".join(name.split()).lower()
			
 
				+
			
 
				+
			
 
				+def safecall(func: "t.Callable[P, R]") -> "t.Callable[P, t.Optional[R]]":
			
 
				+    """Wraps a function so that it swallows exceptions."""
			
 
				+
			
 
				+    def wrapper(*args: "P.args", **kwargs: "P.kwargs") -> t.Optional[R]:
			
 
				+        try:
			
 
				+            return func(*args, **kwargs)
			
 
				+        except Exception:
			
 
				+            pass
			
 
				+        return None
			
 
				+
			
 
				+    return update_wrapper(wrapper, func)
			
 
				+
			
 
				+
			
 
				+def make_str(value: t.Any) -> str:
			
 
				+    """Converts a value into a valid string."""
			
 
				+    if isinstance(value, bytes):
			
 
				+        try:
			
 
				+            return value.decode(sys.getfilesystemencoding())
			
 
				+        except UnicodeError:
			
 
				+            return value.decode("utf-8", "replace")
			
 
				+    return str(value)
			
 
				+
			
 
				+
			
 
				+def make_default_short_help(help: str, max_length: int = 45) -> str:
			
 
				+    """Returns a condensed version of help string."""
			
 
				+    # Consider only the first paragraph.
			
 
				+    paragraph_end = help.find("\n\n")
			
 
				+
			
 
				+    if paragraph_end != -1:
			
 
				+        help = help[:paragraph_end]
			
 
				+
			
 
				+    # Collapse newlines, tabs, and spaces.
			
 
				+    words = help.split()
			
 
				+
			
 
				+    if not words:
			
 
				+        return ""
			
 
				+
			
 
				+    # The first paragraph started with a "no rewrap" marker, ignore it.
			
 
				+    if words[0] == "\b":
			
 
				+        words = words[1:]
			
 
				+
			
 
				+    total_length = 0
			
 
				+    last_index = len(words) - 1
			
 
				+
			
 
				+    for i, word in enumerate(words):
			
 
				+        total_length += len(word) + (i > 0)
			
 
				+
			
 
				+        if total_length > max_length:  # too long, truncate
			
 
				+            break
			
 
				+
			
 
				+        if word[-1] == ".":  # sentence end, truncate without "..."
			
 
				+            return " ".join(words[: i + 1])
			
 
				+
			
 
				+        if total_length == max_length and i != last_index:
			
 
				+            break  # not at sentence end, truncate with "..."
			
 
				+    else:
			
 
				+        return " ".join(words)  # no truncation needed
			
 
				+
			
 
				+    # Account for the length of the suffix.
			
 
				+    total_length += len("...")
			
 
				+
			
 
				+    # remove words until the length is short enough
			
 
				+    while i > 0:
			
 
				+        total_length -= len(words[i]) + (i > 0)
			
 
				+
			
 
				+        if total_length <= max_length:
			
 
				+            break
			
 
				+
			
 
				+        i -= 1
			
 
				+
			
 
				+    return " ".join(words[:i]) + "..."
			
 
				+
			
 
				+
			
 
				+class LazyFile:
			
 
				+    """A lazy file works like a regular file but it does not fully open
			
 
				+    the file but it does perform some basic checks early to see if the
			
 
				+    filename parameter does make sense.  This is useful for safely opening
			
 
				+    files for writing.
			
 
				+    """
			
 
				+
			
 
				+    def __init__(
			
 
				+        self,
			
 
				+        filename: t.Union[str, "os.PathLike[str]"],
			
 
				+        mode: str = "r",
			
 
				+        encoding: t.Optional[str] = None,
			
 
				+        errors: t.Optional[str] = "strict",
			
 
				+        atomic: bool = False,
			
 
				+    ):
			
 
				+        self.name: str = os.fspath(filename)
			
 
				+        self.mode = mode
			
 
				+        self.encoding = encoding
			
 
				+        self.errors = errors
			
 
				+        self.atomic = atomic
			
 
				+        self._f: t.Optional[t.IO[t.Any]]
			
 
				+        self.should_close: bool
			
 
				+
			
 
				+        if self.name == "-":
			
 
				+            self._f, self.should_close = open_stream(filename, mode, encoding, errors)
			
 
				+        else:
			
 
				+            if "r" in mode:
			
 
				+                # Open and close the file in case we're opening it for
			
 
				+                # reading so that we can catch at least some errors in
			
 
				+                # some cases early.
			
 
				+                open(filename, mode).close()
			
 
				+            self._f = None
			
 
				+            self.should_close = True
			
 
				+
			
 
				+    def __getattr__(self, name: str) -> t.Any:
			
 
				+        return getattr(self.open(), name)
			
 
				+
			
 
				+    def __repr__(self) -> str:
			
 
				+        if self._f is not None:
			
 
				+            return repr(self._f)
			
 
				+        return f"<unopened file '{format_filename(self.name)}' {self.mode}>"
			
 
				+
			
 
				+    def open(self) -> t.IO[t.Any]:
			
 
				+        """Opens the file if it's not yet open.  This call might fail with
			
 
				+        a :exc:`FileError`.  Not handling this error will produce an error
			
 
				+        that Click shows.
			
 
				+        """
			
 
				+        if self._f is not None:
			
 
				+            return self._f
			
 
				+        try:
			
 
				+            rv, self.should_close = open_stream(
			
 
				+                self.name, self.mode, self.encoding, self.errors, atomic=self.atomic
			
 
				+            )
			
 
				+        except OSError as e:  # noqa: E402
			
 
				+            from .exceptions import FileError
			
 
				+
			
 
				+            raise FileError(self.name, hint=e.strerror) from e
			
 
				+        self._f = rv
			
 
				+        return rv
			
 
				+
			
 
				+    def close(self) -> None:
			
 
				+        """Closes the underlying file, no matter what."""
			
 
				+        if self._f is not None:
			
 
				+            self._f.close()
			
 
				+
			
 
				+    def close_intelligently(self) -> None:
			
 
				+        """This function only closes the file if it was opened by the lazy
			
 
				+        file wrapper.  For instance this will never close stdin.
			
 
				+        """
			
 
				+        if self.should_close:
			
 
				+            self.close()
			
 
				+
			
 
				+    def __enter__(self) -> "LazyFile":
			
 
				+        return self
			
 
				+
			
 
				+    def __exit__(
			
 
				+        self,
			
 
				+        exc_type: t.Optional[t.Type[BaseException]],
			
 
				+        exc_value: t.Optional[BaseException],
			
 
				+        tb: t.Optional[TracebackType],
			
 
				+    ) -> None:
			
 
				+        self.close_intelligently()
			
 
				+
			
 
				+    def __iter__(self) -> t.Iterator[t.AnyStr]:
			
 
				+        self.open()
			
 
				+        return iter(self._f)  # type: ignore
			
 
				+
			
 
				+
			
 
				+class KeepOpenFile:
			
 
				+    def __init__(self, file: t.IO[t.Any]) -> None:
			
 
				+        self._file: t.IO[t.Any] = file
			
 
				+
			
 
				+    def __getattr__(self, name: str) -> t.Any:
			
 
				+        return getattr(self._file, name)
			
 
				+
			
 
				+    def __enter__(self) -> "KeepOpenFile":
			
 
				+        return self
			
 
				+
			
 
				+    def __exit__(
			
 
				+        self,
			
 
				+        exc_type: t.Optional[t.Type[BaseException]],
			
 
				+        exc_value: t.Optional[BaseException],
			
 
				+        tb: t.Optional[TracebackType],
			
 
				+    ) -> None:
			
 
				+        pass
			
 
				+
			
 
				+    def __repr__(self) -> str:
			
 
				+        return repr(self._file)
			
 
				+
			
 
				+    def __iter__(self) -> t.Iterator[t.AnyStr]:
			
 
				+        return iter(self._file)
			
 
				+
			
 
				+
			
 
				+def echo(
			
 
				+    message: t.Optional[t.Any] = None,
			
 
				+    file: t.Optional[t.IO[t.Any]] = None,
			
 
				+    nl: bool = True,
			
 
				+    err: bool = False,
			
 
				+    color: t.Optional[bool] = None,
			
 
				+) -> None:
			
 
				+    """Print a message and newline to stdout or a file. This should be
			
 
				+    used instead of :func:`print` because it provides better support
			
 
				+    for different data, files, and environments.
			
 
				+
			
 
				+    Compared to :func:`print`, this does the following:
			
 
				+
			
 
				+    -   Ensures that the output encoding is not misconfigured on Linux.
			
 
				+    -   Supports Unicode in the Windows console.
			
 
				+    -   Supports writing to binary outputs, and supports writing bytes
			
 
				+        to text outputs.
			
 
				+    -   Supports colors and styles on Windows.
			
 
				+    -   Removes ANSI color and style codes if the output does not look
			
 
				+        like an interactive terminal.
			
 
				+    -   Always flushes the output.
			
 
				+
			
 
				+    :param message: The string or bytes to output. Other objects are
			
 
				+        converted to strings.
			
 
				+    :param file: The file to write to. Defaults to ``stdout``.
			
 
				+    :param err: Write to ``stderr`` instead of ``stdout``.
			
 
				+    :param nl: Print a newline after the message. Enabled by default.
			
 
				+    :param color: Force showing or hiding colors and other styles. By
			
 
				+        default Click will remove color if the output does not look like
			
 
				+        an interactive terminal.
			
 
				+
			
 
				+    .. versionchanged:: 6.0
			
 
				+        Support Unicode output on the Windows console. Click does not
			
 
				+        modify ``sys.stdout``, so ``sys.stdout.write()`` and ``print()``
			
 
				+        will still not support Unicode.
			
 
				+
			
 
				+    .. versionchanged:: 4.0
			
 
				+        Added the ``color`` parameter.
			
 
				+
			
 
				+    .. versionadded:: 3.0
			
 
				+        Added the ``err`` parameter.
			
 
				+
			
 
				+    .. versionchanged:: 2.0
			
 
				+        Support colors on Windows if colorama is installed.
			
 
				+    """
			
 
				+    if file is None:
			
 
				+        if err:
			
 
				+            file = _default_text_stderr()
			
 
				+        else:
			
 
				+            file = _default_text_stdout()
			
 
				+
			
 
				+        # There are no standard streams attached to write to. For example,
			
 
				+        # pythonw on Windows.
			
 
				+        if file is None:
			
 
				+            return
			
 
				+
			
 
				+    # Convert non bytes/text into the native string type.
			
 
				+    if message is not None and not isinstance(message, (str, bytes, bytearray)):
			
 
				+        out: t.Optional[t.Union[str, bytes]] = str(message)
			
 
				+    else:
			
 
				+        out = message
			
 
				+
			
 
				+    if nl:
			
 
				+        out = out or ""
			
 
				+        if isinstance(out, str):
			
 
				+            out += "\n"
			
 
				+        else:
			
 
				+            out += b"\n"
			
 
				+
			
 
				+    if not out:
			
 
				+        file.flush()
			
 
				+        return
			
 
				+
			
 
				+    # If there is a message and the value looks like bytes, we manually
			
 
				+    # need to find the binary stream and write the message in there.
			
 
				+    # This is done separately so that most stream types will work as you
			
 
				+    # would expect. Eg: you can write to StringIO for other cases.
			
 
				+    if isinstance(out, (bytes, bytearray)):
			
 
				+        binary_file = _find_binary_writer(file)
			
 
				+
			
 
				+        if binary_file is not None:
			
 
				+            file.flush()
			
 
				+            binary_file.write(out)
			
 
				+            binary_file.flush()
			
 
				+            return
			
 
				+
			
 
				+    # ANSI style code support. For no message or bytes, nothing happens.
			
 
				+    # When outputting to a file instead of a terminal, strip codes.
			
 
				+    else:
			
 
				+        color = resolve_color_default(color)
			
 
				+
			
 
				+        if should_strip_ansi(file, color):
			
 
				+            out = strip_ansi(out)
			
 
				+        elif WIN:
			
 
				+            if auto_wrap_for_ansi is not None:
			
 
				+                file = auto_wrap_for_ansi(file)  # type: ignore
			
 
				+            elif not color:
			
 
				+                out = strip_ansi(out)
			
 
				+
			
 
				+    file.write(out)  # type: ignore
			
 
				+    file.flush()
			
 
				+
			
 
				+
			
 
				+def get_binary_stream(name: "te.Literal['stdin', 'stdout', 'stderr']") -> t.BinaryIO:
			
 
				+    """Returns a system stream for byte processing.
			
 
				+
			
 
				+    :param name: the name of the stream to open.  Valid names are ``'stdin'``,
			
 
				+                 ``'stdout'`` and ``'stderr'``
			
 
				+    """
			
 
				+    opener = binary_streams.get(name)
			
 
				+    if opener is None:
			
 
				+        raise TypeError(f"Unknown standard stream '{name}'")
			
 
				+    return opener()
			
 
				+
			
 
				+
			
 
				+def get_text_stream(
			
 
				+    name: "te.Literal['stdin', 'stdout', 'stderr']",
			
 
				+    encoding: t.Optional[str] = None,
			
 
				+    errors: t.Optional[str] = "strict",
			
 
				+) -> t.TextIO:
			
 
				+    """Returns a system stream for text processing.  This usually returns
			
 
				+    a wrapped stream around a binary stream returned from
			
 
				+    :func:`get_binary_stream` but it also can take shortcuts for already
			
 
				+    correctly configured streams.
			
 
				+
			
 
				+    :param name: the name of the stream to open.  Valid names are ``'stdin'``,
			
 
				+                 ``'stdout'`` and ``'stderr'``
			
 
				+    :param encoding: overrides the detected default encoding.
			
 
				+    :param errors: overrides the default error mode.
			
 
				+    """
			
 
				+    opener = text_streams.get(name)
			
 
				+    if opener is None:
			
 
				+        raise TypeError(f"Unknown standard stream '{name}'")
			
 
				+    return opener(encoding, errors)
			
 
				+
			
 
				+
			
 
				+def open_file(
			
 
				+    filename: str,
			
 
				+    mode: str = "r",
			
 
				+    encoding: t.Optional[str] = None,
			
 
				+    errors: t.Optional[str] = "strict",
			
 
				+    lazy: bool = False,
			
 
				+    atomic: bool = False,
			
 
				+) -> t.IO[t.Any]:
			
 
				+    """Open a file, with extra behavior to handle ``'-'`` to indicate
			
 
				+    a standard stream, lazy open on write, and atomic write. Similar to
			
 
				+    the behavior of the :class:`~click.File` param type.
			
 
				+
			
 
				+    If ``'-'`` is given to open ``stdout`` or ``stdin``, the stream is
			
 
				+    wrapped so that using it in a context manager will not close it.
			
 
				+    This makes it possible to use the function without accidentally
			
 
				+    closing a standard stream:
			
 
				+
			
 
				+    .. code-block:: python
			
 
				+
			
 
				+        with open_file(filename) as f:
			
 
				+            ...
			
 
				+
			
 
				+    :param filename: The name of the file to open, or ``'-'`` for
			
 
				+        ``stdin``/``stdout``.
			
 
				+    :param mode: The mode in which to open the file.
			
 
				+    :param encoding: The encoding to decode or encode a file opened in
			
 
				+        text mode.
			
 
				+    :param errors: The error handling mode.
			
 
				+    :param lazy: Wait to open the file until it is accessed. For read
			
 
				+        mode, the file is temporarily opened to raise access errors
			
 
				+        early, then closed until it is read again.
			
 
				+    :param atomic: Write to a temporary file and replace the given file
			
 
				+        on close.
			
 
				+
			
 
				+    .. versionadded:: 3.0
			
 
				+    """
			
 
				+    if lazy:
			
 
				+        return t.cast(
			
 
				+            t.IO[t.Any], LazyFile(filename, mode, encoding, errors, atomic=atomic)
			
 
				+        )
			
 
				+
			
 
				+    f, should_close = open_stream(filename, mode, encoding, errors, atomic=atomic)
			
 
				+
			
 
				+    if not should_close:
			
 
				+        f = t.cast(t.IO[t.Any], KeepOpenFile(f))
			
 
				+
			
 
				+    return f
			
 
				+
			
 
				+
			
 
				+def format_filename(
			
 
				+    filename: "t.Union[str, bytes, os.PathLike[str], os.PathLike[bytes]]",
			
 
				+    shorten: bool = False,
			
 
				+) -> str:
			
 
				+    """Format a filename as a string for display. Ensures the filename can be
			
 
				+    displayed by replacing any invalid bytes or surrogate escapes in the name
			
 
				+    with the replacement character ``�``.
			
 
				+
			
 
				+    Invalid bytes or surrogate escapes will raise an error when written to a
			
 
				+    stream with ``errors="strict". This will typically happen with ``stdout``
			
 
				+    when the locale is something like ``en_GB.UTF-8``.
			
 
				+
			
 
				+    Many scenarios *are* safe to write surrogates though, due to PEP 538 and
			
 
				+    PEP 540, including:
			
 
				+
			
 
				+    -   Writing to ``stderr``, which uses ``errors="backslashreplace"``.
			
 
				+    -   The system has ``LANG=C.UTF-8``, ``C``, or ``POSIX``. Python opens
			
 
				+        stdout and stderr with ``errors="surrogateescape"``.
			
 
				+    -   None of ``LANG/LC_*`` are set. Python assumes ``LANG=C.UTF-8``.
			
 
				+    -   Python is started in UTF-8 mode  with  ``PYTHONUTF8=1`` or ``-X utf8``.
			
 
				+        Python opens stdout and stderr with ``errors="surrogateescape"``.
			
 
				+
			
 
				+    :param filename: formats a filename for UI display.  This will also convert
			
 
				+                     the filename into unicode without failing.
			
 
				+    :param shorten: this optionally shortens the filename to strip of the
			
 
				+                    path that leads up to it.
			
 
				+    """
			
 
				+    if shorten:
			
 
				+        filename = os.path.basename(filename)
			
 
				+    else:
			
 
				+        filename = os.fspath(filename)
			
 
				+
			
 
				+    if isinstance(filename, bytes):
			
 
				+        filename = filename.decode(sys.getfilesystemencoding(), "replace")
			
 
				+    else:
			
 
				+        filename = filename.encode("utf-8", "surrogateescape").decode(
			
 
				+            "utf-8", "replace"
			
 
				+        )
			
 
				+
			
 
				+    return filename
			
 
				+
			
 
				+
			
 
				+def get_app_dir(app_name: str, roaming: bool = True, force_posix: bool = False) -> str:
			
 
				+    r"""Returns the config folder for the application.  The default behavior
			
 
				+    is to return whatever is most appropriate for the operating system.
			
 
				+
			
 
				+    To give you an idea, for an app called ``"Foo Bar"``, something like
			
 
				+    the following folders could be returned:
			
 
				+
			
 
				+    Mac OS X:
			
 
				+      ``~/Library/Application Support/Foo Bar``
			
 
				+    Mac OS X (POSIX):
			
 
				+      ``~/.foo-bar``
			
 
				+    Unix:
			
 
				+      ``~/.config/foo-bar``
			
 
				+    Unix (POSIX):
			
 
				+      ``~/.foo-bar``
			
 
				+    Windows (roaming):
			
 
				+      ``C:\Users\<user>\AppData\Roaming\Foo Bar``
			
 
				+    Windows (not roaming):
			
 
				+      ``C:\Users\<user>\AppData\Local\Foo Bar``
			
 
				+
			
 
				+    .. versionadded:: 2.0
			
 
				+
			
 
				+    :param app_name: the application name.  This should be properly capitalized
			
 
				+                     and can contain whitespace.
			
 
				+    :param roaming: controls if the folder should be roaming or not on Windows.
			
 
				+                    Has no effect otherwise.
			
 
				+    :param force_posix: if this is set to `True` then on any POSIX system the
			
 
				+                        folder will be stored in the home folder with a leading
			
 
				+                        dot instead of the XDG config home or darwin's
			
 
				+                        application support folder.
			
 
				+    """
			
 
				+    if WIN:
			
 
				+        key = "APPDATA" if roaming else "LOCALAPPDATA"
			
 
				+        folder = os.environ.get(key)
			
 
				+        if folder is None:
			
 
				+            folder = os.path.expanduser("~")
			
 
				+        return os.path.join(folder, app_name)
			
 
				+    if force_posix:
			
 
				+        return os.path.join(os.path.expanduser(f"~/.{_posixify(app_name)}"))
			
 
				+    if sys.platform == "darwin":
			
 
				+        return os.path.join(
			
 
				+            os.path.expanduser("~/Library/Application Support"), app_name
			
 
				+        )
			
 
				+    return os.path.join(
			
 
				+        os.environ.get("XDG_CONFIG_HOME", os.path.expanduser("~/.config")),
			
 
				+        _posixify(app_name),
			
 
				+    )
			
 
				+
			
 
				+
			
 
				+class PacifyFlushWrapper:
			
 
				+    """This wrapper is used to catch and suppress BrokenPipeErrors resulting
			
 
				+    from ``.flush()`` being called on broken pipe during the shutdown/final-GC
			
 
				+    of the Python interpreter. Notably ``.flush()`` is always called on
			
 
				+    ``sys.stdout`` and ``sys.stderr``. So as to have minimal impact on any
			
 
				+    other cleanup code, and the case where the underlying file is not a broken
			
 
				+    pipe, all calls and attributes are proxied.
			
 
				+    """
			
 
				+
			
 
				+    def __init__(self, wrapped: t.IO[t.Any]) -> None:
			
 
				+        self.wrapped = wrapped
			
 
				+
			
 
				+    def flush(self) -> None:
			
 
				+        try:
			
 
				+            self.wrapped.flush()
			
 
				+        except OSError as e:
			
 
				+            import errno
			
 
				+
			
 
				+            if e.errno != errno.EPIPE:
			
 
				+                raise
			
 
				+
			
 
				+    def __getattr__(self, attr: str) -> t.Any:
			
 
				+        return getattr(self.wrapped, attr)
			
 
				+
			
 
				+
			
 
				+def _detect_program_name(
			
 
				+    path: t.Optional[str] = None, _main: t.Optional[ModuleType] = None
			
 
				+) -> str:
			
 
				+    """Determine the command used to run the program, for use in help
			
 
				+    text. If a file or entry point was executed, the file name is
			
 
				+    returned. If ``python -m`` was used to execute a module or package,
			
 
				+    ``python -m name`` is returned.
			
 
				+
			
 
				+    This doesn't try to be too precise, the goal is to give a concise
			
 
				+    name for help text. Files are only shown as their name without the
			
 
				+    path. ``python`` is only shown for modules, and the full path to
			
 
				+    ``sys.executable`` is not shown.
			
 
				+
			
 
				+    :param path: The Python file being executed. Python puts this in
			
 
				+        ``sys.argv[0]``, which is used by default.
			
 
				+    :param _main: The ``__main__`` module. This should only be passed
			
 
				+        during internal testing.
			
 
				+
			
 
				+    .. versionadded:: 8.0
			
 
				+        Based on command args detection in the Werkzeug reloader.
			
 
				+
			
 
				+    :meta private:
			
 
				+    """
			
 
				+    if _main is None:
			
 
				+        _main = sys.modules["__main__"]
			
 
				+
			
 
				+    if not path:
			
 
				+        path = sys.argv[0]
			
 
				+
			
 
				+    # The value of __package__ indicates how Python was called. It may
			
 
				+    # not exist if a setuptools script is installed as an egg. It may be
			
 
				+    # set incorrectly for entry points created with pip on Windows.
			
 
				+    # It is set to "" inside a Shiv or PEX zipapp.
			
 
				+    if getattr(_main, "__package__", None) in {None, ""} or (
			
 
				+        os.name == "nt"
			
 
				+        and _main.__package__ == ""
			
 
				+        and not os.path.exists(path)
			
 
				+        and os.path.exists(f"{path}.exe")
			
 
				+    ):
			
 
				+        # Executed a file, like "python app.py".
			
 
				+        return os.path.basename(path)
			
 
				+
			
 
				+    # Executed a module, like "python -m example".
			
 
				+    # Rewritten by Python from "-m script" to "/path/to/script.py".
			
 
				+    # Need to look at main module to determine how it was executed.
			
 
				+    py_module = t.cast(str, _main.__package__)
			
 
				+    name = os.path.splitext(os.path.basename(path))[0]
			
 
				+
			
 
				+    # A submodule like "example.cli".
			
 
				+    if name != "__main__":
			
 
				+        py_module = f"{py_module}.{name}"
			
 
				+
			
 
				+    return f"python -m {py_module.lstrip('.')}"
			
 
				+
			
 
				+
			
 
				+def _expand_args(
			
 
				+    args: t.Iterable[str],
			
 
				+    *,
			
 
				+    user: bool = True,
			
 
				+    env: bool = True,
			
 
				+    glob_recursive: bool = True,
			
 
				+) -> t.List[str]:
			
 
				+    """Simulate Unix shell expansion with Python functions.
			
 
				+
			
 
				+    See :func:`glob.glob`, :func:`os.path.expanduser`, and
			
 
				+    :func:`os.path.expandvars`.
			
 
				+
			
 
				+    This is intended for use on Windows, where the shell does not do any
			
 
				+    expansion. It may not exactly match what a Unix shell would do.
			
 
				+
			
 
				+    :param args: List of command line arguments to expand.
			
 
				+    :param user: Expand user home directory.
			
 
				+    :param env: Expand environment variables.
			
 
				+    :param glob_recursive: ``**`` matches directories recursively.
			
 
				+
			
 
				+    .. versionchanged:: 8.1
			
 
				+        Invalid glob patterns are treated as empty expansions rather
			
 
				+        than raising an error.
			
 
				+
			
 
				+    .. versionadded:: 8.0
			
 
				+
			
 
				+    :meta private:
			
 
				+    """
			
 
				+    from glob import glob
			
 
				+
			
 
				+    out = []
			
 
				+
			
 
				+    for arg in args:
			
 
				+        if user:
			
 
				+            arg = os.path.expanduser(arg)
			
 
				+
			
 
				+        if env:
			
 
				+            arg = os.path.expandvars(arg)
			
 
				+
			
 
				+        try:
			
 
				+            matches = glob(arg, recursive=glob_recursive)
			
 
				+        except re.error:
			
 
				+            matches = []
			
 
				+
			
 
				+        if not matches:
			
 
				+            out.append(arg)
			
 
				+        else:
			
 
				+            out.extend(matches)
			
 
				+
			
 
				+    return out
			
--- a/courses/flask/microblog/env/Lib/site-packages/colorama-0.4.6.dist-info/INSTALLER
+++ b/courses/flask/microblog/env/Lib/site-packages/colorama-0.4.6.dist-info/INSTALLER
@@ -0,0 +1 @@
 
				+pip
			
--- a/courses/flask/microblog/env/Lib/site-packages/colorama-0.4.6.dist-info/METADATA
+++ b/courses/flask/microblog/env/Lib/site-packages/colorama-0.4.6.dist-info/METADATA
@@ -0,0 +1,441 @@
 
				+Metadata-Version: 2.1
			
 
				+Name: colorama
			
 
				+Version: 0.4.6
			
 
				+Summary: Cross-platform colored terminal text.
			
 
				+Project-URL: Homepage, https://github.com/tartley/colorama
			
 
				+Author-email: Jonathan Hartley <tartley@tartley.com>
			
 
				+License-File: LICENSE.txt
			
 
				+Keywords: ansi,color,colour,crossplatform,terminal,text,windows,xplatform
			
 
				+Classifier: Development Status :: 5 - Production/Stable
			
 
				+Classifier: Environment :: Console
			
 
				+Classifier: Intended Audience :: Developers
			
 
				+Classifier: License :: OSI Approved :: BSD License
			
 
				+Classifier: Operating System :: OS Independent
			
 
				+Classifier: Programming Language :: Python
			
 
				+Classifier: Programming Language :: Python :: 2
			
 
				+Classifier: Programming Language :: Python :: 2.7
			
 
				+Classifier: Programming Language :: Python :: 3
			
 
				+Classifier: Programming Language :: Python :: 3.7
			
 
				+Classifier: Programming Language :: Python :: 3.8
			
 
				+Classifier: Programming Language :: Python :: 3.9
			
 
				+Classifier: Programming Language :: Python :: 3.10
			
 
				+Classifier: Programming Language :: Python :: Implementation :: CPython
			
 
				+Classifier: Programming Language :: Python :: Implementation :: PyPy
			
 
				+Classifier: Topic :: Terminals
			
 
				+Requires-Python: !=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*,!=3.5.*,!=3.6.*,>=2.7
			
 
				+Description-Content-Type: text/x-rst
			
 
				+
			
 
				+.. image:: https://img.shields.io/pypi/v/colorama.svg
			
 
				+    :target: https://pypi.org/project/colorama/
			
 
				+    :alt: Latest Version
			
 
				+
			
 
				+.. image:: https://img.shields.io/pypi/pyversions/colorama.svg
			
 
				+    :target: https://pypi.org/project/colorama/
			
 
				+    :alt: Supported Python versions
			
 
				+
			
 
				+.. image:: https://github.com/tartley/colorama/actions/workflows/test.yml/badge.svg
			
 
				+    :target: https://github.com/tartley/colorama/actions/workflows/test.yml
			
 
				+    :alt: Build Status
			
 
				+
			
 
				+Colorama
			
 
				+========
			
 
				+
			
 
				+Makes ANSI escape character sequences (for producing colored terminal text and
			
 
				+cursor positioning) work under MS Windows.
			
 
				+
			
 
				+.. |donate| image:: https://www.paypalobjects.com/en_US/i/btn/btn_donate_SM.gif
			
 
				+  :target: https://www.paypal.com/cgi-bin/webscr?cmd=_donations&business=2MZ9D2GMLYCUJ&item_name=Colorama&currency_code=USD
			
 
				+  :alt: Donate with Paypal
			
 
				+
			
 
				+`PyPI for releases <https://pypi.org/project/colorama/>`_ |
			
 
				+`Github for source <https://github.com/tartley/colorama>`_ |
			
 
				+`Colorama for enterprise on Tidelift <https://github.com/tartley/colorama/blob/master/ENTERPRISE.md>`_
			
 
				+
			
 
				+If you find Colorama useful, please |donate| to the authors. Thank you!
			
 
				+
			
 
				+Installation
			
 
				+------------
			
 
				+
			
 
				+Tested on CPython 2.7, 3.7, 3.8, 3.9 and 3.10 and Pypy 2.7 and 3.8.
			
 
				+
			
 
				+No requirements other than the standard library.
			
 
				+
			
 
				+.. code-block:: bash
			
 
				+
			
 
				+    pip install colorama
			
 
				+    # or
			
 
				+    conda install -c anaconda colorama
			
 
				+
			
 
				+Description
			
 
				+-----------
			
 
				+
			
 
				+ANSI escape character sequences have long been used to produce colored terminal
			
 
				+text and cursor positioning on Unix and Macs. Colorama makes this work on
			
 
				+Windows, too, by wrapping ``stdout``, stripping ANSI sequences it finds (which
			
 
				+would appear as gobbledygook in the output), and converting them into the
			
 
				+appropriate win32 calls to modify the state of the terminal. On other platforms,
			
 
				+Colorama does nothing.
			
 
				+
			
 
				+This has the upshot of providing a simple cross-platform API for printing
			
 
				+colored terminal text from Python, and has the happy side-effect that existing
			
 
				+applications or libraries which use ANSI sequences to produce colored output on
			
 
				+Linux or Macs can now also work on Windows, simply by calling
			
 
				+``colorama.just_fix_windows_console()`` (since v0.4.6) or ``colorama.init()``
			
 
				+(all versions, but may have other side-effects – see below).
			
 
				+
			
 
				+An alternative approach is to install ``ansi.sys`` on Windows machines, which
			
 
				+provides the same behaviour for all applications running in terminals. Colorama
			
 
				+is intended for situations where that isn't easy (e.g., maybe your app doesn't
			
 
				+have an installer.)
			
 
				+
			
 
				+Demo scripts in the source code repository print some colored text using
			
 
				+ANSI sequences. Compare their output under Gnome-terminal's built in ANSI
			
 
				+handling, versus on Windows Command-Prompt using Colorama:
			
 
				+
			
 
				+.. image:: https://github.com/tartley/colorama/raw/master/screenshots/ubuntu-demo.png
			
 
				+    :width: 661
			
 
				+    :height: 357
			
 
				+    :alt: ANSI sequences on Ubuntu under gnome-terminal.
			
 
				+
			
 
				+.. image:: https://github.com/tartley/colorama/raw/master/screenshots/windows-demo.png
			
 
				+    :width: 668
			
 
				+    :height: 325
			
 
				+    :alt: Same ANSI sequences on Windows, using Colorama.
			
 
				+
			
 
				+These screenshots show that, on Windows, Colorama does not support ANSI 'dim
			
 
				+text'; it looks the same as 'normal text'.
			
 
				+
			
 
				+Usage
			
 
				+-----
			
 
				+
			
 
				+Initialisation
			
 
				+..............
			
 
				+
			
 
				+If the only thing you want from Colorama is to get ANSI escapes to work on
			
 
				+Windows, then run:
			
 
				+
			
 
				+.. code-block:: python
			
 
				+
			
 
				+    from colorama import just_fix_windows_console
			
 
				+    just_fix_windows_console()
			
 
				+
			
 
				+If you're on a recent version of Windows 10 or better, and your stdout/stderr
			
 
				+are pointing to a Windows console, then this will flip the magic configuration
			
 
				+switch to enable Windows' built-in ANSI support.
			
 
				+
			
 
				+If you're on an older version of Windows, and your stdout/stderr are pointing to
			
 
				+a Windows console, then this will wrap ``sys.stdout`` and/or ``sys.stderr`` in a
			
 
				+magic file object that intercepts ANSI escape sequences and issues the
			
 
				+appropriate Win32 calls to emulate them.
			
 
				+
			
 
				+In all other circumstances, it does nothing whatsoever. Basically the idea is
			
 
				+that this makes Windows act like Unix with respect to ANSI escape handling.
			
 
				+
			
 
				+It's safe to call this function multiple times. It's safe to call this function
			
 
				+on non-Windows platforms, but it won't do anything. It's safe to call this
			
 
				+function when one or both of your stdout/stderr are redirected to a file – it
			
 
				+won't do anything to those streams.
			
 
				+
			
 
				+Alternatively, you can use the older interface with more features (but also more
			
 
				+potential footguns):
			
 
				+
			
 
				+.. code-block:: python
			
 
				+
			
 
				+    from colorama import init
			
 
				+    init()
			
 
				+
			
 
				+This does the same thing as ``just_fix_windows_console``, except for the
			
 
				+following differences:
			
 
				+
			
 
				+- It's not safe to call ``init`` multiple times; you can end up with multiple
			
 
				+  layers of wrapping and broken ANSI support.
			
 
				+
			
 
				+- Colorama will apply a heuristic to guess whether stdout/stderr support ANSI,
			
 
				+  and if it thinks they don't, then it will wrap ``sys.stdout`` and
			
 
				+  ``sys.stderr`` in a magic file object that strips out ANSI escape sequences
			
 
				+  before printing them. This happens on all platforms, and can be convenient if
			
 
				+  you want to write your code to emit ANSI escape sequences unconditionally, and
			
 
				+  let Colorama decide whether they should actually be output. But note that
			
 
				+  Colorama's heuristic is not particularly clever.
			
 
				+
			
 
				+- ``init`` also accepts explicit keyword args to enable/disable various
			
 
				+  functionality – see below.
			
 
				+
			
 
				+To stop using Colorama before your program exits, simply call ``deinit()``.
			
 
				+This will restore ``stdout`` and ``stderr`` to their original values, so that
			
 
				+Colorama is disabled. To resume using Colorama again, call ``reinit()``; it is
			
 
				+cheaper than calling ``init()`` again (but does the same thing).
			
 
				+
			
 
				+Most users should depend on ``colorama >= 0.4.6``, and use
			
 
				+``just_fix_windows_console``. The old ``init`` interface will be supported
			
 
				+indefinitely for backwards compatibility, but we don't plan to fix any issues
			
 
				+with it, also for backwards compatibility.
			
 
				+
			
 
				+Colored Output
			
 
				+..............
			
 
				+
			
 
				+Cross-platform printing of colored text can then be done using Colorama's
			
 
				+constant shorthand for ANSI escape sequences. These are deliberately
			
 
				+rudimentary, see below.
			
 
				+
			
 
				+.. code-block:: python
			
 
				+
			
 
				+    from colorama import Fore, Back, Style
			
 
				+    print(Fore.RED + 'some red text')
			
 
				+    print(Back.GREEN + 'and with a green background')
			
 
				+    print(Style.DIM + 'and in dim text')
			
 
				+    print(Style.RESET_ALL)
			
 
				+    print('back to normal now')
			
 
				+
			
 
				+...or simply by manually printing ANSI sequences from your own code:
			
 
				+
			
 
				+.. code-block:: python
			
 
				+
			
 
				+    print('\033[31m' + 'some red text')
			
 
				+    print('\033[39m') # and reset to default color
			
 
				+
			
 
				+...or, Colorama can be used in conjunction with existing ANSI libraries
			
 
				+such as the venerable `Termcolor <https://pypi.org/project/termcolor/>`_
			
 
				+the fabulous `Blessings <https://pypi.org/project/blessings/>`_,
			
 
				+or the incredible `_Rich <https://pypi.org/project/rich/>`_.
			
 
				+
			
 
				+If you wish Colorama's Fore, Back and Style constants were more capable,
			
 
				+then consider using one of the above highly capable libraries to generate
			
 
				+colors, etc, and use Colorama just for its primary purpose: to convert
			
 
				+those ANSI sequences to also work on Windows:
			
 
				+
			
 
				+SIMILARLY, do not send PRs adding the generation of new ANSI types to Colorama.
			
 
				+We are only interested in converting ANSI codes to win32 API calls, not
			
 
				+shortcuts like the above to generate ANSI characters.
			
 
				+
			
 
				+.. code-block:: python
			
 
				+
			
 
				+    from colorama import just_fix_windows_console
			
 
				+    from termcolor import colored
			
 
				+
			
 
				+    # use Colorama to make Termcolor work on Windows too
			
 
				+    just_fix_windows_console()
			
 
				+
			
 
				+    # then use Termcolor for all colored text output
			
 
				+    print(colored('Hello, World!', 'green', 'on_red'))
			
 
				+
			
 
				+Available formatting constants are::
			
 
				+
			
 
				+    Fore: BLACK, RED, GREEN, YELLOW, BLUE, MAGENTA, CYAN, WHITE, RESET.
			
 
				+    Back: BLACK, RED, GREEN, YELLOW, BLUE, MAGENTA, CYAN, WHITE, RESET.
			
 
				+    Style: DIM, NORMAL, BRIGHT, RESET_ALL
			
 
				+
			
 
				+``Style.RESET_ALL`` resets foreground, background, and brightness. Colorama will
			
 
				+perform this reset automatically on program exit.
			
 
				+
			
 
				+These are fairly well supported, but not part of the standard::
			
 
				+
			
 
				+    Fore: LIGHTBLACK_EX, LIGHTRED_EX, LIGHTGREEN_EX, LIGHTYELLOW_EX, LIGHTBLUE_EX, LIGHTMAGENTA_EX, LIGHTCYAN_EX, LIGHTWHITE_EX
			
 
				+    Back: LIGHTBLACK_EX, LIGHTRED_EX, LIGHTGREEN_EX, LIGHTYELLOW_EX, LIGHTBLUE_EX, LIGHTMAGENTA_EX, LIGHTCYAN_EX, LIGHTWHITE_EX
			
 
				+
			
 
				+Cursor Positioning
			
 
				+..................
			
 
				+
			
 
				+ANSI codes to reposition the cursor are supported. See ``demos/demo06.py`` for
			
 
				+an example of how to generate them.
			
 
				+
			
 
				+Init Keyword Args
			
 
				+.................
			
 
				+
			
 
				+``init()`` accepts some ``**kwargs`` to override default behaviour.
			
 
				+
			
 
				+init(autoreset=False):
			
 
				+    If you find yourself repeatedly sending reset sequences to turn off color
			
 
				+    changes at the end of every print, then ``init(autoreset=True)`` will
			
 
				+    automate that:
			
 
				+
			
 
				+    .. code-block:: python
			
 
				+
			
 
				+        from colorama import init
			
 
				+        init(autoreset=True)
			
 
				+        print(Fore.RED + 'some red text')
			
 
				+        print('automatically back to default color again')
			
 
				+
			
 
				+init(strip=None):
			
 
				+    Pass ``True`` or ``False`` to override whether ANSI codes should be
			
 
				+    stripped from the output. The default behaviour is to strip if on Windows
			
 
				+    or if output is redirected (not a tty).
			
 
				+
			
 
				+init(convert=None):
			
 
				+    Pass ``True`` or ``False`` to override whether to convert ANSI codes in the
			
 
				+    output into win32 calls. The default behaviour is to convert if on Windows
			
 
				+    and output is to a tty (terminal).
			
 
				+
			
 
				+init(wrap=True):
			
 
				+    On Windows, Colorama works by replacing ``sys.stdout`` and ``sys.stderr``
			
 
				+    with proxy objects, which override the ``.write()`` method to do their work.
			
 
				+    If this wrapping causes you problems, then this can be disabled by passing
			
 
				+    ``init(wrap=False)``. The default behaviour is to wrap if ``autoreset`` or
			
 
				+    ``strip`` or ``convert`` are True.
			
 
				+
			
 
				+    When wrapping is disabled, colored printing on non-Windows platforms will
			
 
				+    continue to work as normal. To do cross-platform colored output, you can
			
 
				+    use Colorama's ``AnsiToWin32`` proxy directly:
			
 
				+
			
 
				+    .. code-block:: python
			
 
				+
			
 
				+        import sys
			
 
				+        from colorama import init, AnsiToWin32
			
 
				+        init(wrap=False)
			
 
				+        stream = AnsiToWin32(sys.stderr).stream
			
 
				+
			
 
				+        # Python 2
			
 
				+        print >>stream, Fore.BLUE + 'blue text on stderr'
			
 
				+
			
 
				+        # Python 3
			
 
				+        print(Fore.BLUE + 'blue text on stderr', file=stream)
			
 
				+
			
 
				+Recognised ANSI Sequences
			
 
				+.........................
			
 
				+
			
 
				+ANSI sequences generally take the form::
			
 
				+
			
 
				+    ESC [ <param> ; <param> ... <command>
			
 
				+
			
 
				+Where ``<param>`` is an integer, and ``<command>`` is a single letter. Zero or
			
 
				+more params are passed to a ``<command>``. If no params are passed, it is
			
 
				+generally synonymous with passing a single zero. No spaces exist in the
			
 
				+sequence; they have been inserted here simply to read more easily.
			
 
				+
			
 
				+The only ANSI sequences that Colorama converts into win32 calls are::
			
 
				+
			
 
				+    ESC [ 0 m       # reset all (colors and brightness)
			
 
				+    ESC [ 1 m       # bright
			
 
				+    ESC [ 2 m       # dim (looks same as normal brightness)
			
 
				+    ESC [ 22 m      # normal brightness
			
 
				+
			
 
				+    # FOREGROUND:
			
 
				+    ESC [ 30 m      # black
			
 
				+    ESC [ 31 m      # red
			
 
				+    ESC [ 32 m      # green
			
 
				+    ESC [ 33 m      # yellow
			
 
				+    ESC [ 34 m      # blue
			
 
				+    ESC [ 35 m      # magenta
			
 
				+    ESC [ 36 m      # cyan
			
 
				+    ESC [ 37 m      # white
			
 
				+    ESC [ 39 m      # reset
			
 
				+
			
 
				+    # BACKGROUND
			
 
				+    ESC [ 40 m      # black
			
 
				+    ESC [ 41 m      # red
			
 
				+    ESC [ 42 m      # green
			
 
				+    ESC [ 43 m      # yellow
			
 
				+    ESC [ 44 m      # blue
			
 
				+    ESC [ 45 m      # magenta
			
 
				+    ESC [ 46 m      # cyan
			
 
				+    ESC [ 47 m      # white
			
 
				+    ESC [ 49 m      # reset
			
 
				+
			
 
				+    # cursor positioning
			
 
				+    ESC [ y;x H     # position cursor at x across, y down
			
 
				+    ESC [ y;x f     # position cursor at x across, y down
			
 
				+    ESC [ n A       # move cursor n lines up
			
 
				+    ESC [ n B       # move cursor n lines down
			
 
				+    ESC [ n C       # move cursor n characters forward
			
 
				+    ESC [ n D       # move cursor n characters backward
			
 
				+
			
 
				+    # clear the screen
			
 
				+    ESC [ mode J    # clear the screen
			
 
				+
			
 
				+    # clear the line
			
 
				+    ESC [ mode K    # clear the line
			
 
				+
			
 
				+Multiple numeric params to the ``'m'`` command can be combined into a single
			
 
				+sequence::
			
 
				+
			
 
				+    ESC [ 36 ; 45 ; 1 m     # bright cyan text on magenta background
			
 
				+
			
 
				+All other ANSI sequences of the form ``ESC [ <param> ; <param> ... <command>``
			
 
				+are silently stripped from the output on Windows.
			
 
				+
			
 
				+Any other form of ANSI sequence, such as single-character codes or alternative
			
 
				+initial characters, are not recognised or stripped. It would be cool to add
			
 
				+them though. Let me know if it would be useful for you, via the Issues on
			
 
				+GitHub.
			
 
				+
			
 
				+Status & Known Problems
			
 
				+-----------------------
			
 
				+
			
 
				+I've personally only tested it on Windows XP (CMD, Console2), Ubuntu
			
 
				+(gnome-terminal, xterm), and OS X.
			
 
				+
			
 
				+Some valid ANSI sequences aren't recognised.
			
 
				+
			
 
				+If you're hacking on the code, see `README-hacking.md`_. ESPECIALLY, see the
			
 
				+explanation there of why we do not want PRs that allow Colorama to generate new
			
 
				+types of ANSI codes.
			
 
				+
			
 
				+See outstanding issues and wish-list:
			
 
				+https://github.com/tartley/colorama/issues
			
 
				+
			
 
				+If anything doesn't work for you, or doesn't do what you expected or hoped for,
			
 
				+I'd love to hear about it on that issues list, would be delighted by patches,
			
 
				+and would be happy to grant commit access to anyone who submits a working patch
			
 
				+or two.
			
 
				+
			
 
				+.. _README-hacking.md: README-hacking.md
			
 
				+
			
 
				+License
			
 
				+-------
			
 
				+
			
 
				+Copyright Jonathan Hartley & Arnon Yaari, 2013-2020. BSD 3-Clause license; see
			
 
				+LICENSE file.
			
 
				+
			
 
				+Professional support
			
 
				+--------------------
			
 
				+
			
 
				+.. |tideliftlogo| image:: https://cdn2.hubspot.net/hubfs/4008838/website/logos/logos_for_download/Tidelift_primary-shorthand-logo.png
			
 
				+   :alt: Tidelift
			
 
				+   :target: https://tidelift.com/subscription/pkg/pypi-colorama?utm_source=pypi-colorama&utm_medium=referral&utm_campaign=readme
			
 
				+
			
 
				+.. list-table::
			
 
				+   :widths: 10 100
			
 
				+
			
 
				+   * - |tideliftlogo|
			
 
				+     - Professional support for colorama is available as part of the
			
 
				+       `Tidelift Subscription`_.
			
 
				+       Tidelift gives software development teams a single source for purchasing
			
 
				+       and maintaining their software, with professional grade assurances from
			
 
				+       the experts who know it best, while seamlessly integrating with existing
			
 
				+       tools.
			
 
				+
			
 
				+.. _Tidelift Subscription: https://tidelift.com/subscription/pkg/pypi-colorama?utm_source=pypi-colorama&utm_medium=referral&utm_campaign=readme
			
 
				+
			
 
				+Thanks
			
 
				+------
			
 
				+
			
 
				+See the CHANGELOG for more thanks!
			
 
				+
			
 
				+* Marc Schlaich (schlamar) for a ``setup.py`` fix for Python2.5.
			
 
				+* Marc Abramowitz, reported & fixed a crash on exit with closed ``stdout``,
			
 
				+  providing a solution to issue #7's setuptools/distutils debate,
			
 
				+  and other fixes.
			
 
				+* User 'eryksun', for guidance on correctly instantiating ``ctypes.windll``.
			
 
				+* Matthew McCormick for politely pointing out a longstanding crash on non-Win.
			
 
				+* Ben Hoyt, for a magnificent fix under 64-bit Windows.
			
 
				+* Jesse at Empty Square for submitting a fix for examples in the README.
			
 
				+* User 'jamessp', an observant documentation fix for cursor positioning.
			
 
				+* User 'vaal1239', Dave Mckee & Lackner Kristof for a tiny but much-needed Win7
			
 
				+  fix.
			
 
				+* Julien Stuyck, for wisely suggesting Python3 compatible updates to README.
			
 
				+* Daniel Griffith for multiple fabulous patches.
			
 
				+* Oscar Lesta for a valuable fix to stop ANSI chars being sent to non-tty
			
 
				+  output.
			
 
				+* Roger Binns, for many suggestions, valuable feedback, & bug reports.
			
 
				+* Tim Golden for thought and much appreciated feedback on the initial idea.
			
 
				+* User 'Zearin' for updates to the README file.
			
 
				+* John Szakmeister for adding support for light colors
			
 
				+* Charles Merriam for adding documentation to demos
			
 
				+* Jurko for a fix on 64-bit Windows CPython2.5 w/o ctypes
			
 
				+* Florian Bruhin for a fix when stdout or stderr are None
			
 
				+* Thomas Weininger for fixing ValueError on Windows
			
 
				+* Remi Rampin for better Github integration and fixes to the README file
			
 
				+* Simeon Visser for closing a file handle using 'with' and updating classifiers
			
 
				+  to include Python 3.3 and 3.4
			
 
				+* Andy Neff for fixing RESET of LIGHT_EX colors.
			
 
				+* Jonathan Hartley for the initial idea and implementation.
			
--- a/courses/flask/microblog/env/Lib/site-packages/colorama-0.4.6.dist-info/RECORD
+++ b/courses/flask/microblog/env/Lib/site-packages/colorama-0.4.6.dist-info/RECORD
@@ -0,0 +1,31 @@
 
				+colorama-0.4.6.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4

			
 
				+colorama-0.4.6.dist-info/METADATA,sha256=e67SnrUMOym9sz_4TjF3vxvAV4T3aF7NyqRHHH3YEMw,17158

			
 
				+colorama-0.4.6.dist-info/RECORD,,

			
 
				+colorama-0.4.6.dist-info/WHEEL,sha256=cdcF4Fbd0FPtw2EMIOwH-3rSOTUdTCeOSXRMD1iLUb8,105

			
 
				+colorama-0.4.6.dist-info/licenses/LICENSE.txt,sha256=ysNcAmhuXQSlpxQL-zs25zrtSWZW6JEQLkKIhteTAxg,1491

			
 
				+colorama/__init__.py,sha256=wePQA4U20tKgYARySLEC047ucNX-g8pRLpYBuiHlLb8,266

			
 
				+colorama/__pycache__/__init__.cpython-310.pyc,,

			
 
				+colorama/__pycache__/ansi.cpython-310.pyc,,

			
 
				+colorama/__pycache__/ansitowin32.cpython-310.pyc,,

			
 
				+colorama/__pycache__/initialise.cpython-310.pyc,,

			
 
				+colorama/__pycache__/win32.cpython-310.pyc,,

			
 
				+colorama/__pycache__/winterm.cpython-310.pyc,,

			
 
				+colorama/ansi.py,sha256=Top4EeEuaQdBWdteKMEcGOTeKeF19Q-Wo_6_Cj5kOzQ,2522

			
 
				+colorama/ansitowin32.py,sha256=vPNYa3OZbxjbuFyaVo0Tmhmy1FZ1lKMWCnT7odXpItk,11128

			
 
				+colorama/initialise.py,sha256=-hIny86ClXo39ixh5iSCfUIa2f_h_bgKRDW7gqs-KLU,3325

			
 
				+colorama/tests/__init__.py,sha256=MkgPAEzGQd-Rq0w0PZXSX2LadRWhUECcisJY8lSrm4Q,75

			
 
				+colorama/tests/__pycache__/__init__.cpython-310.pyc,,

			
 
				+colorama/tests/__pycache__/ansi_test.cpython-310.pyc,,

			
 
				+colorama/tests/__pycache__/ansitowin32_test.cpython-310.pyc,,

			
 
				+colorama/tests/__pycache__/initialise_test.cpython-310.pyc,,

			
 
				+colorama/tests/__pycache__/isatty_test.cpython-310.pyc,,

			
 
				+colorama/tests/__pycache__/utils.cpython-310.pyc,,

			
 
				+colorama/tests/__pycache__/winterm_test.cpython-310.pyc,,

			
 
				+colorama/tests/ansi_test.py,sha256=FeViDrUINIZcr505PAxvU4AjXz1asEiALs9GXMhwRaE,2839

			
 
				+colorama/tests/ansitowin32_test.py,sha256=RN7AIhMJ5EqDsYaCjVo-o4u8JzDD4ukJbmevWKS70rY,10678

			
 
				+colorama/tests/initialise_test.py,sha256=BbPy-XfyHwJ6zKozuQOvNvQZzsx9vdb_0bYXn7hsBTc,6741

			
 
				+colorama/tests/isatty_test.py,sha256=Pg26LRpv0yQDB5Ac-sxgVXG7hsA1NYvapFgApZfYzZg,1866

			
 
				+colorama/tests/utils.py,sha256=1IIRylG39z5-dzq09R_ngufxyPZxgldNbrxKxUGwGKE,1079

			
 
				+colorama/tests/winterm_test.py,sha256=qoWFPEjym5gm2RuMwpf3pOis3a5r_PJZFCzK254JL8A,3709

			
 
				+colorama/win32.py,sha256=YQOKwMTwtGBbsY4dL5HYTvwTeP9wIQra5MvPNddpxZs,6181

			
 
				+colorama/winterm.py,sha256=XCQFDHjPi6AHYNdZwy0tA02H-Jh48Jp-HvCjeLeLp3U,7134

			
--- a/courses/flask/microblog/env/Lib/site-packages/colorama-0.4.6.dist-info/WHEEL
+++ b/courses/flask/microblog/env/Lib/site-packages/colorama-0.4.6.dist-info/WHEEL
@@ -0,0 +1,5 @@
 
				+Wheel-Version: 1.0
			
 
				+Generator: hatchling 1.11.1
			
 
				+Root-Is-Purelib: true
			
 
				+Tag: py2-none-any
			
 
				+Tag: py3-none-any
			
--- a/courses/flask/microblog/env/Lib/site-packages/colorama-0.4.6.dist-info/licenses/LICENSE.txt
+++ b/courses/flask/microblog/env/Lib/site-packages/colorama-0.4.6.dist-info/licenses/LICENSE.txt
@@ -0,0 +1,27 @@
 
				+Copyright (c) 2010 Jonathan Hartley
			
 
				+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 binary 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.
			
 
				+
			
 
				+* Neither the name of the copyright holders, nor those of its contributors
			
 
				+  may be used to endorse or promote products derived from this software without
			
 
				+  specific prior written permission.
			
 
				+
			
 
				+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 HOLDER 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.
			
--- a/courses/flask/microblog/env/Lib/site-packages/colorama/__init__.py
+++ b/courses/flask/microblog/env/Lib/site-packages/colorama/__init__.py
@@ -0,0 +1,7 @@
 
				+# Copyright Jonathan Hartley 2013. BSD 3-Clause license, see LICENSE file.
			
 
				+from .initialise import init, deinit, reinit, colorama_text, just_fix_windows_console
			
 
				+from .ansi import Fore, Back, Style, Cursor
			
 
				+from .ansitowin32 import AnsiToWin32
			
 
				+
			
 
				+__version__ = '0.4.6'
			
 
				+
			
--- a/courses/flask/microblog/env/Lib/site-packages/colorama/__pycache__/__init__.cpython-310.pyc
+++ b/courses/flask/microblog/env/Lib/site-packages/colorama/__pycache__/__init__.cpython-310.pyc
--- a/courses/flask/microblog/env/Lib/site-packages/colorama/__pycache__/ansi.cpython-310.pyc
+++ b/courses/flask/microblog/env/Lib/site-packages/colorama/__pycache__/ansi.cpython-310.pyc
--- a/courses/flask/microblog/env/Lib/site-packages/colorama/__pycache__/ansitowin32.cpython-310.pyc
+++ b/courses/flask/microblog/env/Lib/site-packages/colorama/__pycache__/ansitowin32.cpython-310.pyc
--- a/courses/flask/microblog/env/Lib/site-packages/colorama/__pycache__/initialise.cpython-310.pyc
+++ b/courses/flask/microblog/env/Lib/site-packages/colorama/__pycache__/initialise.cpython-310.pyc
--- a/courses/flask/microblog/env/Lib/site-packages/colorama/__pycache__/win32.cpython-310.pyc
+++ b/courses/flask/microblog/env/Lib/site-packages/colorama/__pycache__/win32.cpython-310.pyc
--- a/courses/flask/microblog/env/Lib/site-packages/colorama/__pycache__/winterm.cpython-310.pyc
+++ b/courses/flask/microblog/env/Lib/site-packages/colorama/__pycache__/winterm.cpython-310.pyc
--- a/courses/flask/microblog/env/Lib/site-packages/colorama/ansi.py
+++ b/courses/flask/microblog/env/Lib/site-packages/colorama/ansi.py
@@ -0,0 +1,102 @@
 
				+# Copyright Jonathan Hartley 2013. BSD 3-Clause license, see LICENSE file.
			
 
				+'''
			
 
				+This module generates ANSI character codes to printing colors to terminals.
			
 
				+See: http://en.wikipedia.org/wiki/ANSI_escape_code
			
 
				+'''
			
 
				+
			
 
				+CSI = '\033['
			
 
				+OSC = '\033]'
			
 
				+BEL = '\a'
			
 
				+
			
 
				+
			
 
				+def code_to_chars(code):
			
 
				+    return CSI + str(code) + 'm'
			
 
				+
			
 
				+def set_title(title):
			
 
				+    return OSC + '2;' + title + BEL
			
 
				+
			
 
				+def clear_screen(mode=2):
			
 
				+    return CSI + str(mode) + 'J'
			
 
				+
			
 
				+def clear_line(mode=2):
			
 
				+    return CSI + str(mode) + 'K'
			
 
				+
			
 
				+
			
 
				+class AnsiCodes(object):
			
 
				+    def __init__(self):
			
 
				+        # the subclasses declare class attributes which are numbers.
			
 
				+        # Upon instantiation we define instance attributes, which are the same
			
 
				+        # as the class attributes but wrapped with the ANSI escape sequence
			
 
				+        for name in dir(self):
			
 
				+            if not name.startswith('_'):
			
 
				+                value = getattr(self, name)
			
 
				+                setattr(self, name, code_to_chars(value))
			
 
				+
			
 
				+
			
 
				+class AnsiCursor(object):
			
 
				+    def UP(self, n=1):
			
 
				+        return CSI + str(n) + 'A'
			
 
				+    def DOWN(self, n=1):
			
 
				+        return CSI + str(n) + 'B'
			
 
				+    def FORWARD(self, n=1):
			
 
				+        return CSI + str(n) + 'C'
			
 
				+    def BACK(self, n=1):
			
 
				+        return CSI + str(n) + 'D'
			
 
				+    def POS(self, x=1, y=1):
			
 
				+        return CSI + str(y) + ';' + str(x) + 'H'
			
 
				+
			
 
				+
			
 
				+class AnsiFore(AnsiCodes):
			
 
				+    BLACK           = 30
			
 
				+    RED             = 31
			
 
				+    GREEN           = 32
			
 
				+    YELLOW          = 33
			
 
				+    BLUE            = 34
			
 
				+    MAGENTA         = 35
			
 
				+    CYAN            = 36
			
 
				+    WHITE           = 37
			
 
				+    RESET           = 39
			
 
				+
			
 
				+    # These are fairly well supported, but not part of the standard.
			
 
				+    LIGHTBLACK_EX   = 90
			
 
				+    LIGHTRED_EX     = 91
			
 
				+    LIGHTGREEN_EX   = 92
			
 
				+    LIGHTYELLOW_EX  = 93
			
 
				+    LIGHTBLUE_EX    = 94
			
 
				+    LIGHTMAGENTA_EX = 95
			
 
				+    LIGHTCYAN_EX    = 96
			
 
				+    LIGHTWHITE_EX   = 97
			
 
				+
			
 
				+
			
 
				+class AnsiBack(AnsiCodes):
			
 
				+    BLACK           = 40
			
 
				+    RED             = 41
			
 
				+    GREEN           = 42
			
 
				+    YELLOW          = 43
			
 
				+    BLUE            = 44
			
 
				+    MAGENTA         = 45
			
 
				+    CYAN            = 46
			
 
				+    WHITE           = 47
			
 
				+    RESET           = 49
			
 
				+
			
 
				+    # These are fairly well supported, but not part of the standard.
			
 
				+    LIGHTBLACK_EX   = 100
			
 
				+    LIGHTRED_EX     = 101
			
 
				+    LIGHTGREEN_EX   = 102
			
 
				+    LIGHTYELLOW_EX  = 103
			
 
				+    LIGHTBLUE_EX    = 104
			
 
				+    LIGHTMAGENTA_EX = 105
			
 
				+    LIGHTCYAN_EX    = 106
			
 
				+    LIGHTWHITE_EX   = 107
			
 
				+
			
 
				+
			
 
				+class AnsiStyle(AnsiCodes):
			
 
				+    BRIGHT    = 1
			
 
				+    DIM       = 2
			
 
				+    NORMAL    = 22
			
 
				+    RESET_ALL = 0
			
 
				+
			
 
				+Fore   = AnsiFore()
			
 
				+Back   = AnsiBack()
			
 
				+Style  = AnsiStyle()
			
 
				+Cursor = AnsiCursor()
			
--- a/courses/flask/microblog/env/Lib/site-packages/colorama/ansitowin32.py
+++ b/courses/flask/microblog/env/Lib/site-packages/colorama/ansitowin32.py
@@ -0,0 +1,277 @@
 
				+# Copyright Jonathan Hartley 2013. BSD 3-Clause license, see LICENSE file.
			
 
				+import re
			
 
				+import sys
			
 
				+import os
			
 
				+
			
 
				+from .ansi import AnsiFore, AnsiBack, AnsiStyle, Style, BEL
			
 
				+from .winterm import enable_vt_processing, WinTerm, WinColor, WinStyle
			
 
				+from .win32 import windll, winapi_test
			
 
				+
			
 
				+
			
 
				+winterm = None
			
 
				+if windll is not None:
			
 
				+    winterm = WinTerm()
			
 
				+
			
 
				+
			
 
				+class StreamWrapper(object):
			
 
				+    '''
			
 
				+    Wraps a stream (such as stdout), acting as a transparent proxy for all
			
 
				+    attribute access apart from method 'write()', which is delegated to our
			
 
				+    Converter instance.
			
 
				+    '''
			
 
				+    def __init__(self, wrapped, converter):
			
 
				+        # double-underscore everything to prevent clashes with names of
			
 
				+        # attributes on the wrapped stream object.
			
 
				+        self.__wrapped = wrapped
			
 
				+        self.__convertor = converter
			
 
				+
			
 
				+    def __getattr__(self, name):
			
 
				+        return getattr(self.__wrapped, name)
			
 
				+
			
 
				+    def __enter__(self, *args, **kwargs):
			
 
				+        # special method lookup bypasses __getattr__/__getattribute__, see
			
 
				+        # https://stackoverflow.com/questions/12632894/why-doesnt-getattr-work-with-exit
			
 
				+        # thus, contextlib magic methods are not proxied via __getattr__
			
 
				+        return self.__wrapped.__enter__(*args, **kwargs)
			
 
				+
			
 
				+    def __exit__(self, *args, **kwargs):
			
 
				+        return self.__wrapped.__exit__(*args, **kwargs)
			
 
				+
			
 
				+    def __setstate__(self, state):
			
 
				+        self.__dict__ = state
			
 
				+
			
 
				+    def __getstate__(self):
			
 
				+        return self.__dict__
			
 
				+
			
 
				+    def write(self, text):
			
 
				+        self.__convertor.write(text)
			
 
				+
			
 
				+    def isatty(self):
			
 
				+        stream = self.__wrapped
			
 
				+        if 'PYCHARM_HOSTED' in os.environ:
			
 
				+            if stream is not None and (stream is sys.__stdout__ or stream is sys.__stderr__):
			
 
				+                return True
			
 
				+        try:
			
 
				+            stream_isatty = stream.isatty
			
 
				+        except AttributeError:
			
 
				+            return False
			
 
				+        else:
			
 
				+            return stream_isatty()
			
 
				+
			
 
				+    @property
			
 
				+    def closed(self):
			
 
				+        stream = self.__wrapped
			
 
				+        try:
			
 
				+            return stream.closed
			
 
				+        # AttributeError in the case that the stream doesn't support being closed
			
 
				+        # ValueError for the case that the stream has already been detached when atexit runs
			
 
				+        except (AttributeError, ValueError):
			
 
				+            return True
			
 
				+
			
 
				+
			
 
				+class AnsiToWin32(object):
			
 
				+    '''
			
 
				+    Implements a 'write()' method which, on Windows, will strip ANSI character
			
 
				+    sequences from the text, and if outputting to a tty, will convert them into
			
 
				+    win32 function calls.
			
 
				+    '''
			
 
				+    ANSI_CSI_RE = re.compile('\001?\033\\[((?:\\d|;)*)([a-zA-Z])\002?')   # Control Sequence Introducer
			
 
				+    ANSI_OSC_RE = re.compile('\001?\033\\]([^\a]*)(\a)\002?')             # Operating System Command
			
 
				+
			
 
				+    def __init__(self, wrapped, convert=None, strip=None, autoreset=False):
			
 
				+        # The wrapped stream (normally sys.stdout or sys.stderr)
			
 
				+        self.wrapped = wrapped
			
 
				+
			
 
				+        # should we reset colors to defaults after every .write()
			
 
				+        self.autoreset = autoreset
			
 
				+
			
 
				+        # create the proxy wrapping our output stream
			
 
				+        self.stream = StreamWrapper(wrapped, self)
			
 
				+
			
 
				+        on_windows = os.name == 'nt'
			
 
				+        # We test if the WinAPI works, because even if we are on Windows
			
 
				+        # we may be using a terminal that doesn't support the WinAPI
			
 
				+        # (e.g. Cygwin Terminal). In this case it's up to the terminal
			
 
				+        # to support the ANSI codes.
			
 
				+        conversion_supported = on_windows and winapi_test()
			
 
				+        try:
			
 
				+            fd = wrapped.fileno()
			
 
				+        except Exception:
			
 
				+            fd = -1
			
 
				+        system_has_native_ansi = not on_windows or enable_vt_processing(fd)
			
 
				+        have_tty = not self.stream.closed and self.stream.isatty()
			
 
				+        need_conversion = conversion_supported and not system_has_native_ansi
			
 
				+
			
 
				+        # should we strip ANSI sequences from our output?
			
 
				+        if strip is None:
			
 
				+            strip = need_conversion or not have_tty
			
 
				+        self.strip = strip
			
 
				+
			
 
				+        # should we should convert ANSI sequences into win32 calls?
			
 
				+        if convert is None:
			
 
				+            convert = need_conversion and have_tty
			
 
				+        self.convert = convert
			
 
				+
			
 
				+        # dict of ansi codes to win32 functions and parameters
			
 
				+        self.win32_calls = self.get_win32_calls()
			
 
				+
			
 
				+        # are we wrapping stderr?
			
 
				+        self.on_stderr = self.wrapped is sys.stderr
			
 
				+
			
 
				+    def should_wrap(self):
			
 
				+        '''
			
 
				+        True if this class is actually needed. If false, then the output
			
 
				+        stream will not be affected, nor will win32 calls be issued, so
			
 
				+        wrapping stdout is not actually required. This will generally be
			
 
				+        False on non-Windows platforms, unless optional functionality like
			
 
				+        autoreset has been requested using kwargs to init()
			
 
				+        '''
			
 
				+        return self.convert or self.strip or self.autoreset
			
 
				+
			
 
				+    def get_win32_calls(self):
			
 
				+        if self.convert and winterm:
			
 
				+            return {
			
 
				+                AnsiStyle.RESET_ALL: (winterm.reset_all, ),
			
 
				+                AnsiStyle.BRIGHT: (winterm.style, WinStyle.BRIGHT),
			
 
				+                AnsiStyle.DIM: (winterm.style, WinStyle.NORMAL),
			
 
				+                AnsiStyle.NORMAL: (winterm.style, WinStyle.NORMAL),
			
 
				+                AnsiFore.BLACK: (winterm.fore, WinColor.BLACK),
			
 
				+                AnsiFore.RED: (winterm.fore, WinColor.RED),
			
 
				+                AnsiFore.GREEN: (winterm.fore, WinColor.GREEN),
			
 
				+                AnsiFore.YELLOW: (winterm.fore, WinColor.YELLOW),
			
 
				+                AnsiFore.BLUE: (winterm.fore, WinColor.BLUE),
			
 
				+                AnsiFore.MAGENTA: (winterm.fore, WinColor.MAGENTA),
			
 
				+                AnsiFore.CYAN: (winterm.fore, WinColor.CYAN),
			
 
				+                AnsiFore.WHITE: (winterm.fore, WinColor.GREY),
			
 
				+                AnsiFore.RESET: (winterm.fore, ),
			
 
				+                AnsiFore.LIGHTBLACK_EX: (winterm.fore, WinColor.BLACK, True),
			
 
				+                AnsiFore.LIGHTRED_EX: (winterm.fore, WinColor.RED, True),
			
 
				+                AnsiFore.LIGHTGREEN_EX: (winterm.fore, WinColor.GREEN, True),
			
 
				+                AnsiFore.LIGHTYELLOW_EX: (winterm.fore, WinColor.YELLOW, True),
			
 
				+                AnsiFore.LIGHTBLUE_EX: (winterm.fore, WinColor.BLUE, True),
			
 
				+                AnsiFore.LIGHTMAGENTA_EX: (winterm.fore, WinColor.MAGENTA, True),
			
 
				+                AnsiFore.LIGHTCYAN_EX: (winterm.fore, WinColor.CYAN, True),
			
 
				+                AnsiFore.LIGHTWHITE_EX: (winterm.fore, WinColor.GREY, True),
			
 
				+                AnsiBack.BLACK: (winterm.back, WinColor.BLACK),
			
 
				+                AnsiBack.RED: (winterm.back, WinColor.RED),
			
 
				+                AnsiBack.GREEN: (winterm.back, WinColor.GREEN),
			
 
				+                AnsiBack.YELLOW: (winterm.back, WinColor.YELLOW),
			
 
				+                AnsiBack.BLUE: (winterm.back, WinColor.BLUE),
			
 
				+                AnsiBack.MAGENTA: (winterm.back, WinColor.MAGENTA),
			
 
				+                AnsiBack.CYAN: (winterm.back, WinColor.CYAN),
			
 
				+                AnsiBack.WHITE: (winterm.back, WinColor.GREY),
			
 
				+                AnsiBack.RESET: (winterm.back, ),
			
 
				+                AnsiBack.LIGHTBLACK_EX: (winterm.back, WinColor.BLACK, True),
			
 
				+                AnsiBack.LIGHTRED_EX: (winterm.back, WinColor.RED, True),
			
 
				+                AnsiBack.LIGHTGREEN_EX: (winterm.back, WinColor.GREEN, True),
			
 
				+                AnsiBack.LIGHTYELLOW_EX: (winterm.back, WinColor.YELLOW, True),
			
 
				+                AnsiBack.LIGHTBLUE_EX: (winterm.back, WinColor.BLUE, True),
			
 
				+                AnsiBack.LIGHTMAGENTA_EX: (winterm.back, WinColor.MAGENTA, True),
			
 
				+                AnsiBack.LIGHTCYAN_EX: (winterm.back, WinColor.CYAN, True),
			
 
				+                AnsiBack.LIGHTWHITE_EX: (winterm.back, WinColor.GREY, True),
			
 
				+            }
			
 
				+        return dict()
			
 
				+
			
 
				+    def write(self, text):
			
 
				+        if self.strip or self.convert:
			
 
				+            self.write_and_convert(text)
			
 
				+        else:
			
 
				+            self.wrapped.write(text)
			
 
				+            self.wrapped.flush()
			
 
				+        if self.autoreset:
			
 
				+            self.reset_all()
			
 
				+
			
 
				+
			
 
				+    def reset_all(self):
			
 
				+        if self.convert:
			
 
				+            self.call_win32('m', (0,))
			
 
				+        elif not self.strip and not self.stream.closed:
			
 
				+            self.wrapped.write(Style.RESET_ALL)
			
 
				+
			
 
				+
			
 
				+    def write_and_convert(self, text):
			
 
				+        '''
			
 
				+        Write the given text to our wrapped stream, stripping any ANSI
			
 
				+        sequences from the text, and optionally converting them into win32
			
 
				+        calls.
			
 
				+        '''
			
 
				+        cursor = 0
			
 
				+        text = self.convert_osc(text)
			
 
				+        for match in self.ANSI_CSI_RE.finditer(text):
			
 
				+            start, end = match.span()
			
 
				+            self.write_plain_text(text, cursor, start)
			
 
				+            self.convert_ansi(*match.groups())
			
 
				+            cursor = end
			
 
				+        self.write_plain_text(text, cursor, len(text))
			
 
				+
			
 
				+
			
 
				+    def write_plain_text(self, text, start, end):
			
 
				+        if start < end:
			
 
				+            self.wrapped.write(text[start:end])
			
 
				+            self.wrapped.flush()
			
 
				+
			
 
				+
			
 
				+    def convert_ansi(self, paramstring, command):
			
 
				+        if self.convert:
			
 
				+            params = self.extract_params(command, paramstring)
			
 
				+            self.call_win32(command, params)
			
 
				+
			
 
				+
			
 
				+    def extract_params(self, command, paramstring):
			
 
				+        if command in 'Hf':
			
 
				+            params = tuple(int(p) if len(p) != 0 else 1 for p in paramstring.split(';'))
			
 
				+            while len(params) < 2:
			
 
				+                # defaults:
			
 
				+                params = params + (1,)
			
 
				+        else:
			
 
				+            params = tuple(int(p) for p in paramstring.split(';') if len(p) != 0)
			
 
				+            if len(params) == 0:
			
 
				+                # defaults:
			
 
				+                if command in 'JKm':
			
 
				+                    params = (0,)
			
 
				+                elif command in 'ABCD':
			
 
				+                    params = (1,)
			
 
				+
			
 
				+        return params
			
 
				+
			
 
				+
			
 
				+    def call_win32(self, command, params):
			
 
				+        if command == 'm':
			
 
				+            for param in params:
			
 
				+                if param in self.win32_calls:
			
 
				+                    func_args = self.win32_calls[param]
			
 
				+                    func = func_args[0]
			
 
				+                    args = func_args[1:]
			
 
				+                    kwargs = dict(on_stderr=self.on_stderr)
			
 
				+                    func(*args, **kwargs)
			
 
				+        elif command in 'J':
			
 
				+            winterm.erase_screen(params[0], on_stderr=self.on_stderr)
			
 
				+        elif command in 'K':
			
 
				+            winterm.erase_line(params[0], on_stderr=self.on_stderr)
			
 
				+        elif command in 'Hf':     # cursor position - absolute
			
 
				+            winterm.set_cursor_position(params, on_stderr=self.on_stderr)
			
 
				+        elif command in 'ABCD':   # cursor position - relative
			
 
				+            n = params[0]
			
 
				+            # A - up, B - down, C - forward, D - back
			
 
				+            x, y = {'A': (0, -n), 'B': (0, n), 'C': (n, 0), 'D': (-n, 0)}[command]
			
 
				+            winterm.cursor_adjust(x, y, on_stderr=self.on_stderr)
			
 
				+
			
 
				+
			
 
				+    def convert_osc(self, text):
			
 
				+        for match in self.ANSI_OSC_RE.finditer(text):
			
 
				+            start, end = match.span()
			
 
				+            text = text[:start] + text[end:]
			
 
				+            paramstring, command = match.groups()
			
 
				+            if command == BEL:
			
 
				+                if paramstring.count(";") == 1:
			
 
				+                    params = paramstring.split(";")
			
 
				+                    # 0 - change title and icon (we will only change title)
			
 
				+                    # 1 - change icon (we don't support this)
			
 
				+                    # 2 - change title
			
 
				+                    if params[0] in '02':
			
 
				+                        winterm.set_title(params[1])
			
 
				+        return text
			
 
				+
			
 
				+
			
 
				+    def flush(self):
			
 
				+        self.wrapped.flush()
			
--- a/courses/flask/microblog/env/Lib/site-packages/colorama/initialise.py
+++ b/courses/flask/microblog/env/Lib/site-packages/colorama/initialise.py
@@ -0,0 +1,121 @@
 
				+# Copyright Jonathan Hartley 2013. BSD 3-Clause license, see LICENSE file.
			
 
				+import atexit
			
 
				+import contextlib
			
 
				+import sys
			
 
				+
			
 
				+from .ansitowin32 import AnsiToWin32
			
 
				+
			
 
				+
			
 
				+def _wipe_internal_state_for_tests():
			
 
				+    global orig_stdout, orig_stderr
			
 
				+    orig_stdout = None
			
 
				+    orig_stderr = None
			
 
				+
			
 
				+    global wrapped_stdout, wrapped_stderr
			
 
				+    wrapped_stdout = None
			
 
				+    wrapped_stderr = None
			
 
				+
			
 
				+    global atexit_done
			
 
				+    atexit_done = False
			
 
				+
			
 
				+    global fixed_windows_console
			
 
				+    fixed_windows_console = False
			
 
				+
			
 
				+    try:
			
 
				+        # no-op if it wasn't registered
			
 
				+        atexit.unregister(reset_all)
			
 
				+    except AttributeError:
			
 
				+        # python 2: no atexit.unregister. Oh well, we did our best.
			
 
				+        pass
			
 
				+
			
 
				+
			
 
				+def reset_all():
			
 
				+    if AnsiToWin32 is not None:    # Issue #74: objects might become None at exit
			
 
				+        AnsiToWin32(orig_stdout).reset_all()
			
 
				+
			
 
				+
			
 
				+def init(autoreset=False, convert=None, strip=None, wrap=True):
			
 
				+
			
 
				+    if not wrap and any([autoreset, convert, strip]):
			
 
				+        raise ValueError('wrap=False conflicts with any other arg=True')
			
 
				+
			
 
				+    global wrapped_stdout, wrapped_stderr
			
 
				+    global orig_stdout, orig_stderr
			
 
				+
			
 
				+    orig_stdout = sys.stdout
			
 
				+    orig_stderr = sys.stderr
			
 
				+
			
 
				+    if sys.stdout is None:
			
 
				+        wrapped_stdout = None
			
 
				+    else:
			
 
				+        sys.stdout = wrapped_stdout = \
			
 
				+            wrap_stream(orig_stdout, convert, strip, autoreset, wrap)
			
 
				+    if sys.stderr is None:
			
 
				+        wrapped_stderr = None
			
 
				+    else:
			
 
				+        sys.stderr = wrapped_stderr = \
			
 
				+            wrap_stream(orig_stderr, convert, strip, autoreset, wrap)
			
 
				+
			
 
				+    global atexit_done
			
 
				+    if not atexit_done:
			
 
				+        atexit.register(reset_all)
			
 
				+        atexit_done = True
			
 
				+
			
 
				+
			
 
				+def deinit():
			
 
				+    if orig_stdout is not None:
			
 
				+        sys.stdout = orig_stdout
			
 
				+    if orig_stderr is not None:
			
 
				+        sys.stderr = orig_stderr
			
 
				+
			
 
				+
			
 
				+def just_fix_windows_console():
			
 
				+    global fixed_windows_console
			
 
				+
			
 
				+    if sys.platform != "win32":
			
 
				+        return
			
 
				+    if fixed_windows_console:
			
 
				+        return
			
 
				+    if wrapped_stdout is not None or wrapped_stderr is not None:
			
 
				+        # Someone already ran init() and it did stuff, so we won't second-guess them
			
 
				+        return
			
 
				+
			
 
				+    # On newer versions of Windows, AnsiToWin32.__init__ will implicitly enable the
			
 
				+    # native ANSI support in the console as a side-effect. We only need to actually
			
 
				+    # replace sys.stdout/stderr if we're in the old-style conversion mode.
			
 
				+    new_stdout = AnsiToWin32(sys.stdout, convert=None, strip=None, autoreset=False)
			
 
				+    if new_stdout.convert:
			
 
				+        sys.stdout = new_stdout
			
 
				+    new_stderr = AnsiToWin32(sys.stderr, convert=None, strip=None, autoreset=False)
			
 
				+    if new_stderr.convert:
			
 
				+        sys.stderr = new_stderr
			
 
				+
			
 
				+    fixed_windows_console = True
			
 
				+
			
 
				+@contextlib.contextmanager
			
 
				+def colorama_text(*args, **kwargs):
			
 
				+    init(*args, **kwargs)
			
 
				+    try:
			
 
				+        yield
			
 
				+    finally:
			
 
				+        deinit()
			
 
				+
			
 
				+
			
 
				+def reinit():
			
 
				+    if wrapped_stdout is not None:
			
 
				+        sys.stdout = wrapped_stdout
			
 
				+    if wrapped_stderr is not None:
			
 
				+        sys.stderr = wrapped_stderr
			
 
				+
			
 
				+
			
 
				+def wrap_stream(stream, convert, strip, autoreset, wrap):
			
 
				+    if wrap:
			
 
				+        wrapper = AnsiToWin32(stream,
			
 
				+            convert=convert, strip=strip, autoreset=autoreset)
			
 
				+        if wrapper.should_wrap():
			
 
				+            stream = wrapper.stream
			
 
				+    return stream
			
 
				+
			
 
				+
			
 
				+# Use this for initial setup as well, to reduce code duplication
			
 
				+_wipe_internal_state_for_tests()
			
--- a/courses/flask/microblog/env/Lib/site-packages/colorama/tests/__init__.py
+++ b/courses/flask/microblog/env/Lib/site-packages/colorama/tests/__init__.py
@@ -0,0 +1 @@
 
				+# Copyright Jonathan Hartley 2013. BSD 3-Clause license, see LICENSE file.
			
--- a/courses/flask/microblog/env/Lib/site-packages/colorama/tests/__pycache__/__init__.cpython-310.pyc
+++ b/courses/flask/microblog/env/Lib/site-packages/colorama/tests/__pycache__/__init__.cpython-310.pyc
--- a/courses/flask/microblog/env/Lib/site-packages/colorama/tests/__pycache__/ansi_test.cpython-310.pyc
+++ b/courses/flask/microblog/env/Lib/site-packages/colorama/tests/__pycache__/ansi_test.cpython-310.pyc
--- a/courses/flask/microblog/env/Lib/site-packages/colorama/tests/__pycache__/ansitowin32_test.cpython-310.pyc
+++ b/courses/flask/microblog/env/Lib/site-packages/colorama/tests/__pycache__/ansitowin32_test.cpython-310.pyc
--- a/courses/flask/microblog/env/Lib/site-packages/colorama/tests/__pycache__/initialise_test.cpython-310.pyc
+++ b/courses/flask/microblog/env/Lib/site-packages/colorama/tests/__pycache__/initialise_test.cpython-310.pyc
--- a/courses/flask/microblog/env/Lib/site-packages/colorama/tests/__pycache__/isatty_test.cpython-310.pyc
+++ b/courses/flask/microblog/env/Lib/site-packages/colorama/tests/__pycache__/isatty_test.cpython-310.pyc
--- a/courses/flask/microblog/env/Lib/site-packages/colorama/tests/__pycache__/utils.cpython-310.pyc
+++ b/courses/flask/microblog/env/Lib/site-packages/colorama/tests/__pycache__/utils.cpython-310.pyc
--- a/courses/flask/microblog/env/Lib/site-packages/colorama/tests/__pycache__/winterm_test.cpython-310.pyc
+++ b/courses/flask/microblog/env/Lib/site-packages/colorama/tests/__pycache__/winterm_test.cpython-310.pyc
--- a/courses/flask/microblog/env/Lib/site-packages/colorama/tests/ansi_test.py
+++ b/courses/flask/microblog/env/Lib/site-packages/colorama/tests/ansi_test.py
@@ -0,0 +1,76 @@
 
				+# Copyright Jonathan Hartley 2013. BSD 3-Clause license, see LICENSE file.
			
 
				+import sys
			
 
				+from unittest import TestCase, main
			
 
				+
			
 
				+from ..ansi import Back, Fore, Style
			
 
				+from ..ansitowin32 import AnsiToWin32
			
 
				+
			
 
				+stdout_orig = sys.stdout
			
 
				+stderr_orig = sys.stderr
			
 
				+
			
 
				+
			
 
				+class AnsiTest(TestCase):
			
 
				+
			
 
				+    def setUp(self):
			
 
				+        # sanity check: stdout should be a file or StringIO object.
			
 
				+        # It will only be AnsiToWin32 if init() has previously wrapped it
			
 
				+        self.assertNotEqual(type(sys.stdout), AnsiToWin32)
			
 
				+        self.assertNotEqual(type(sys.stderr), AnsiToWin32)
			
 
				+
			
 
				+    def tearDown(self):
			
 
				+        sys.stdout = stdout_orig
			
 
				+        sys.stderr = stderr_orig
			
 
				+
			
 
				+
			
 
				+    def testForeAttributes(self):
			
 
				+        self.assertEqual(Fore.BLACK, '\033[30m')
			
 
				+        self.assertEqual(Fore.RED, '\033[31m')
			
 
				+        self.assertEqual(Fore.GREEN, '\033[32m')
			
 
				+        self.assertEqual(Fore.YELLOW, '\033[33m')
			
 
				+        self.assertEqual(Fore.BLUE, '\033[34m')
			
 
				+        self.assertEqual(Fore.MAGENTA, '\033[35m')
			
 
				+        self.assertEqual(Fore.CYAN, '\033[36m')
			
 
				+        self.assertEqual(Fore.WHITE, '\033[37m')
			
 
				+        self.assertEqual(Fore.RESET, '\033[39m')
			
 
				+
			
 
				+        # Check the light, extended versions.
			
 
				+        self.assertEqual(Fore.LIGHTBLACK_EX, '\033[90m')
			
 
				+        self.assertEqual(Fore.LIGHTRED_EX, '\033[91m')
			
 
				+        self.assertEqual(Fore.LIGHTGREEN_EX, '\033[92m')
			
 
				+        self.assertEqual(Fore.LIGHTYELLOW_EX, '\033[93m')
			
 
				+        self.assertEqual(Fore.LIGHTBLUE_EX, '\033[94m')
			
 
				+        self.assertEqual(Fore.LIGHTMAGENTA_EX, '\033[95m')
			
 
				+        self.assertEqual(Fore.LIGHTCYAN_EX, '\033[96m')
			
 
				+        self.assertEqual(Fore.LIGHTWHITE_EX, '\033[97m')
			
 
				+
			
 
				+
			
 
				+    def testBackAttributes(self):
			
 
				+        self.assertEqual(Back.BLACK, '\033[40m')
			
 
				+        self.assertEqual(Back.RED, '\033[41m')
			
 
				+        self.assertEqual(Back.GREEN, '\033[42m')
			
 
				+        self.assertEqual(Back.YELLOW, '\033[43m')
			
 
				+        self.assertEqual(Back.BLUE, '\033[44m')
			
 
				+        self.assertEqual(Back.MAGENTA, '\033[45m')
			
 
				+        self.assertEqual(Back.CYAN, '\033[46m')
			
 
				+        self.assertEqual(Back.WHITE, '\033[47m')
			
 
				+        self.assertEqual(Back.RESET, '\033[49m')
			
 
				+
			
 
				+        # Check the light, extended versions.
			
 
				+        self.assertEqual(Back.LIGHTBLACK_EX, '\033[100m')
			
 
				+        self.assertEqual(Back.LIGHTRED_EX, '\033[101m')
			
 
				+        self.assertEqual(Back.LIGHTGREEN_EX, '\033[102m')
			
 
				+        self.assertEqual(Back.LIGHTYELLOW_EX, '\033[103m')
			
 
				+        self.assertEqual(Back.LIGHTBLUE_EX, '\033[104m')
			
 
				+        self.assertEqual(Back.LIGHTMAGENTA_EX, '\033[105m')
			
 
				+        self.assertEqual(Back.LIGHTCYAN_EX, '\033[106m')
			
 
				+        self.assertEqual(Back.LIGHTWHITE_EX, '\033[107m')
			
 
				+
			
 
				+
			
 
				+    def testStyleAttributes(self):
			
 
				+        self.assertEqual(Style.DIM, '\033[2m')
			
 
				+        self.assertEqual(Style.NORMAL, '\033[22m')
			
 
				+        self.assertEqual(Style.BRIGHT, '\033[1m')
			
 
				+
			
 
				+
			
 
				+if __name__ == '__main__':
			
 
				+    main()
		`@@ -0,0 +1 @@`
		`+__import__('_distutils_hack').do_override()`
		`@@ -0,0 +1 @@`
		`+# Copyright Jonathan Hartley 2013. BSD 3-Clause license, see LICENSE file.`