Add files using upload-large-folder tool

.gitattributes

@@ -223,3 +223,6 @@ my_container_sandbox/workspace/anaconda3/lib/python3.8/lib-dynload/select.cpytho
 my_container_sandbox/workspace/anaconda3/lib/libnpps.so filter=lfs diff=lfs merge=lfs -text
 my_container_sandbox/workspace/anaconda3/lib/python3.8/lib-dynload/audioop.cpython-38-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
 my_container_sandbox/workspace/anaconda3/lib/python3.8/lib-dynload/_sha3.cpython-38-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
+my_container_sandbox/workspace/anaconda3/lib/python3.8/lib-dynload/_codecs_jp.cpython-38-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
+my_container_sandbox/workspace/anaconda3/lib/python3.8/lib-dynload/_decimal.cpython-38-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
+my_container_sandbox/workspace/anaconda3/lib/python3.8/lib-dynload/readline.cpython-38-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text

my_container_sandbox/workspace/anaconda3/lib/python3.8/lib-dynload/_codecs_jp.cpython-38-x86_64-linux-gnu.so

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:afed7966a11edf7870e61b2624ef9a9b67b3668d725fc3c6690469513a8de55b
+size 324800

my_container_sandbox/workspace/anaconda3/lib/python3.8/lib-dynload/_decimal.cpython-38-x86_64-linux-gnu.so

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7262bad6fbdb5212a078fa84778d13ec4354aaa882b8192f57b5effdb1506200
+size 1450816

my_container_sandbox/workspace/anaconda3/lib/python3.8/lib-dynload/readline.cpython-38-x86_64-linux-gnu.so

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c86a4d71eb06fe15670233d0f02f65bdb7b6643da49a9e91080fe45aa2948c17
+size 100272

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/PyYAML-6.0.dist-info/INSTALLER

@@ -0,0 +1 @@
+pip

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/PyYAML-6.0.dist-info/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2017-2021 Ingy döt Net
+Copyright (c) 2006-2016 Kirill Simonov
+
+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.

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/PyYAML-6.0.dist-info/METADATA

@@ -0,0 +1,46 @@
+Metadata-Version: 2.1
+Name: PyYAML
+Version: 6.0
+Summary: YAML parser and emitter for Python
+Home-page: https://pyyaml.org/
+Author: Kirill Simonov
+Author-email: xi@resolvent.net
+License: MIT
+Download-URL: https://pypi.org/project/PyYAML/
+Project-URL: Bug Tracker, https://github.com/yaml/pyyaml/issues
+Project-URL: CI, https://github.com/yaml/pyyaml/actions
+Project-URL: Documentation, https://pyyaml.org/wiki/PyYAMLDocumentation
+Project-URL: Mailing lists, http://lists.sourceforge.net/lists/listinfo/yaml-core
+Project-URL: Source Code, https://github.com/yaml/pyyaml
+Platform: Any
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Cython
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.6
+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 :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Text Processing :: Markup
+Requires-Python: >=3.6
+License-File: LICENSE
+
+YAML is a data serialization format designed for human readability
+and interaction with scripting languages.  PyYAML is a YAML parser
+and emitter for Python.
+
+PyYAML features a complete YAML 1.1 parser, Unicode support, pickle
+support, capable extension API, and sensible error messages.  PyYAML
+supports standard YAML tags and provides Python-specific tags that
+allow to represent an arbitrary Python object.
+
+PyYAML is applicable for a broad range of tasks from complex
+configuration files to object serialization and persistence.
+

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/PyYAML-6.0.dist-info/RECORD

@@ -0,0 +1,44 @@
+PyYAML-6.0.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
+PyYAML-6.0.dist-info/LICENSE,sha256=jTko-dxEkP1jVwfLiOsmvXZBAqcoKVQwfT5RZ6V36KQ,1101
+PyYAML-6.0.dist-info/METADATA,sha256=QmHx9kGp_0yezQCXYaft4eEFeJ6W4oyFfYwHDLP1kdg,2006
+PyYAML-6.0.dist-info/RECORD,,
+PyYAML-6.0.dist-info/REQUESTED,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+PyYAML-6.0.dist-info/WHEEL,sha256=RiwktpmF40OphKd3_aIG01PzIOQlJ7dpBn3cFSc9vak,217
+PyYAML-6.0.dist-info/top_level.txt,sha256=rpj0IVMTisAjh_1vG3Ccf9v5jpCQwAz6cD1IVU5ZdhQ,11
+_yaml/__init__.py,sha256=04Ae_5osxahpJHa3XBZUAf4wi6XX32gR8D6X6p64GEA,1402
+_yaml/__pycache__/__init__.cpython-38.pyc,,
+yaml/__init__.py,sha256=NDS7S8XgA72-hY6LRmGzUWTPvzGzjWVrWk-OGA-77AA,12309
+yaml/__pycache__/__init__.cpython-38.pyc,,
+yaml/__pycache__/composer.cpython-38.pyc,,
+yaml/__pycache__/constructor.cpython-38.pyc,,
+yaml/__pycache__/cyaml.cpython-38.pyc,,
+yaml/__pycache__/dumper.cpython-38.pyc,,
+yaml/__pycache__/emitter.cpython-38.pyc,,
+yaml/__pycache__/error.cpython-38.pyc,,
+yaml/__pycache__/events.cpython-38.pyc,,
+yaml/__pycache__/loader.cpython-38.pyc,,
+yaml/__pycache__/nodes.cpython-38.pyc,,
+yaml/__pycache__/parser.cpython-38.pyc,,
+yaml/__pycache__/reader.cpython-38.pyc,,
+yaml/__pycache__/representer.cpython-38.pyc,,
+yaml/__pycache__/resolver.cpython-38.pyc,,
+yaml/__pycache__/scanner.cpython-38.pyc,,
+yaml/__pycache__/serializer.cpython-38.pyc,,
+yaml/__pycache__/tokens.cpython-38.pyc,,
+yaml/_yaml.cpython-38-x86_64-linux-gnu.so,sha256=lMaKSmQZy3WNZSmmU0Wg5Y5ZAs-HR5vItyGVUIsp8Rg,2847784
+yaml/composer.py,sha256=_Ko30Wr6eDWUeUpauUGT3Lcg9QPBnOPVlTnIMRGJ9FM,4883
+yaml/constructor.py,sha256=kNgkfaeLUkwQYY_Q6Ff1Tz2XVw_pG1xVE9Ak7z-viLA,28639
+yaml/cyaml.py,sha256=6ZrAG9fAYvdVe2FK_w0hmXoG7ZYsoYUwapG8CiC72H0,3851
+yaml/dumper.py,sha256=PLctZlYwZLp7XmeUdwRuv4nYOZ2UBnDIUy8-lKfLF-o,2837
+yaml/emitter.py,sha256=jghtaU7eFwg31bG0B7RZea_29Adi9CKmXq_QjgQpCkQ,43006
+yaml/error.py,sha256=Ah9z-toHJUbE9j-M8YpxgSRM5CgLCcwVzJgLLRF2Fxo,2533
+yaml/events.py,sha256=50_TksgQiE4up-lKo_V-nBy-tAIxkIPQxY5qDhKCeHw,2445
+yaml/loader.py,sha256=UVa-zIqmkFSCIYq_PgSGm4NSJttHY2Rf_zQ4_b1fHN0,2061
+yaml/nodes.py,sha256=gPKNj8pKCdh2d4gr3gIYINnPOaOxGhJAUiYhGRnPE84,1440
+yaml/parser.py,sha256=ilWp5vvgoHFGzvOZDItFoGjD6D42nhlZrZyjAwa0oJo,25495
+yaml/reader.py,sha256=0dmzirOiDG4Xo41RnuQS7K9rkY3xjHiVasfDMNTqCNw,6794
+yaml/representer.py,sha256=IuWP-cAW9sHKEnS0gCqSa894k1Bg4cgTxaDwIcbRQ-Y,14190
+yaml/resolver.py,sha256=9L-VYfm4mWHxUD1Vg4X7rjDRK_7VZd6b92wzq7Y2IKY,9004
+yaml/scanner.py,sha256=YEM3iLZSaQwXcQRg2l2R4MdT0zGP2F9eHkKGKnHyWQY,51279
+yaml/serializer.py,sha256=ChuFgmhU01hj4xgI8GaKv6vfM2Bujwa9i7d2FAHj7cA,4165
+yaml/tokens.py,sha256=lTQIzSVw8Mg9wv459-TjiOQe6wVziqaRlqX2_89rp54,2573

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/PyYAML-6.0.dist-info/WHEEL

@@ -0,0 +1,8 @@
+Wheel-Version: 1.0
+Generator: bdist_wheel (0.37.0)
+Root-Is-Purelib: false
+Tag: cp38-cp38-manylinux_2_5_x86_64
+Tag: cp38-cp38-manylinux1_x86_64
+Tag: cp38-cp38-manylinux_2_12_x86_64
+Tag: cp38-cp38-manylinux2010_x86_64
+

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/PyYAML-6.0.dist-info/top_level.txt

@@ -0,0 +1,2 @@
+_yaml
+yaml

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/SimpleITK-2.1.1.2.dist-info/INSTALLER

@@ -0,0 +1 @@
+pip

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/SimpleITK-2.1.1.2.dist-info/METADATA

@@ -0,0 +1,119 @@
+Metadata-Version: 2.1
+Name: SimpleITK
+Version: 2.1.1.2
+Summary: SimpleITK is a simplified interface to the Insight Toolkit (ITK) for image registration and segmentation
+Home-page: http://simpleitk.org/
+Author: Insight Software Consortium
+Author-email: insight-users@itk.org
+License: Apache
+Project-URL: Bug Tracker, https://github.com/SimpleITK/SimpleITK/issues
+Project-URL: Documentation, https://simpleitk.readthedocs.io/en/release/
+Project-URL: Source Code, https://github.com/SimpleITK/SimpleITK
+Keywords: SimpleITK ITK InsightToolkit segmentation registration
+Platform: UNKNOWN
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: C++
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Education
+Classifier: Intended Audience :: Healthcare Industry
+Classifier: Intended Audience :: Science/Research
+Classifier: Topic :: Scientific/Engineering
+Classifier: Topic :: Scientific/Engineering :: Medical Science Apps.
+Classifier: Topic :: Scientific/Engineering :: Information Analysis
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Operating System :: POSIX
+Classifier: Operating System :: Unix
+Classifier: Operating System :: MacOS
+Description-Content-Type: text/markdown
+
+SimpleITK
+=========
+
+|  | CircleCI | ReadTheDocs | AzurePipelines |
+|:-------:|:---------:|:-------------:|:-------------:|
+| release | [![CircleCI](https://circleci.com/gh/SimpleITK/SimpleITK/tree/release.svg?style=shield)](https://circleci.com/gh/SimpleITK/SimpleITK/tree/release) | [![ReadTheDoc](https://readthedocs.org/projects/simpleitk/badge/?version=release)](http://simpleitk.readthedocs.io/en/release/) | [![Build Status](https://dev.azure.com/SimpleITK-DevOps/SimpleITK/_apis/build/status/SimpleITK.SimpleITK?branchName=release)](https://dev.azure.com/SimpleITK-DevOps/SimpleITK/_build/latest?definitionId=2&branchName=release) |
+| master | [![CircleCI](https://circleci.com/gh/SimpleITK/SimpleITK/tree/master.svg?style=shield)](https://circleci.com/gh/SimpleITK/SimpleITK/tree/master) | [![ReadTheDoc](https://readthedocs.org/projects/simpleitk/badge/?version=master)](http://simpleitk.readthedocs.io/en/master/) | [![Build Status](https://dev.azure.com/SimpleITK-DevOps/SimpleITK/_apis/build/status/SimpleITK.SimpleITK?branchName=master)](https://dev.azure.com/SimpleITK-DevOps/SimpleITK/_build/latest?definitionId=2&branchName=master) |
+
+
+SimpleITK is an image analysis toolkit with a large number of components supporting general filtering operations, image segmentation and registration. It is built on top of the Insight Segmentation and Registration Toolkit [ITK](https://www.itk.org) with the intent of providing a simplified interface to ITK. SimpleITK itself is written in C++ but is available for a large number of programming languages. Currently these include:
+
+* [Python](http://www.python.org)
+* [R](https://www.r-project.org)
+* [Java](http://www.java.com)
+* [C#](http://msdn.microsoft.com/en-us/vcsharp/default.aspx)
+* [Lua](http://www.lua.org)
+* [TCL](https://www.tcl.tk/)
+* [Ruby](https://www.ruby-lang.org/en/)
+
+
+Wrapping of the C++ code is accomplished through [SWIG](http://www.swig.org), in principle, any language wrapped by SWIG should be applicable to SimpleITK.
+
+Unlike ITK's support of n-dimensional spatio-temporal images, SimpleITK supports 2D, 3D and 4D images. The dimensionality refers to spatio-temporal dimensions, the voxels can be n-dimensional vectors.
+
+SimpleITK is licensed under the [Apache License](http://www.opensource.org/licenses/apache2.0.php).
+
+Acknowledgments
+--------------
+SimpleITK development has been supported by:
+
+* The Intramural Research Program of the National Institutes of Health, National Institute of Allergy and Infectious Diseases.
+
+* The US National Library of Medicine under the American Recovery and Reinvestment Act (ARRA) and under the Intramural Research Program of the U.S. National Institutes of Health.
+
+* The Insight Software Consortium and the ITK user and developer communities.
+
+
+License and Copyright
+---------------------
+
+The SimpleITK project  is part of the [Insight Software Consortium](https://www.insightsoftwareconsortium.org/)(ISC) a non-profit educational consortium dedicated to promoting and maintaining open-source, freely available software for bio-medical image analysis. The copyright is held by [NumFOCUS](https://numfocus.org/). The SimpleITK software is distributed under the [Apache License 2.0](https://github.com/SimpleITK/SimpleITK/blob/master/LICENSE).
+
+
+How to Cite
+--------
+
+If you found SimpleITK useful in your research, support our efforts by citing
+the relevant publication(s):
+
+R. Beare, B. C. Lowekamp, Z. Yaniv, "Image Segmentation, Registration and
+Characterization in R with SimpleITK", *J Stat Softw*, 86(8), https://doi.org/10.18637/jss.v086.i08, 2018.
+
+Z. Yaniv, B. C. Lowekamp, H. J. Johnson, R. Beare, "SimpleITK Image-Analysis Notebooks: a Collaborative Environment for Education and Reproducible Research", *J Digit Imaging.*, 31(3): 290-303, https://doi.org/10.1007/s10278-017-0037-8, 2018.
+
+B. C. Lowekamp, D. T. Chen, L. Ibáñez, D. Blezek, "The Design of SimpleITK", *Front. Neuroinform.*, 7:45. https://doi.org/10.3389/fninf.2013.00045, 2013.
+
+Documentation
+-------------
+With massive libraries like SimpleITK, good documentation is a must. The documentation for SimpleITK is split up into multiple levels:
+1. [API Documentation](https://simpleitk.org/doxygen/latest/html/) - This contains class and function documentation. The descriptions for functions and classes are primarily borrowed from the original ITK C++ classes.
+2. [SimpleITK Documentation](http://simpleitk.readthedocs.io/en/master/) - This site contains high-level guides (fundamental SimpleITK concepts, common conventions, etc.), details with respect to the toolkit's binary distributions, instructions for building the toolkit, as well as SimpleITK examples in all supported programming languages. [This site replaced the
+[SimpleITK Wiki](https://itk.org/Wiki/SimpleITK)  which is mostly of interest for historical reasons.]
+3. [Juypyter Notebook Repository](http://insightsoftwareconsortium.github.io/SimpleITK-Notebooks/) - This repository contains a collection of Jupyter Notebooks illustrating the use of SimpleITK for educational and research activities. The notebooks demonstrate the use of SimpleITK for interactive image analysis using the Python and R programming languages. Recommended reading, if you are starting with SimpleITK.
+
+
+Support
+-------
+
+SimpleITK provides access to most of the ITK components, but not all. If you are looking for something specific and can't find it, open an issue on GitHub or ask for support on the [forum](https://discourse.itk.org).
+
+Report an Issue
+---------------
+
+Help us improve SimpleITK by reporting issues you encounter. When you report an error, you allow us to address your specific problem, but more importantly you are helping all of the SimpleITK community.
+
+**Thank you for helping making SimpleITK better!**
+
+All issues are reported and managed on the [project's GitHub issue tracker](https://github.com/SimpleITK/SimpleITK/issues). When reporting an issue, please provide as much information as possible to enable us to reproduce the problem.
+
+The following information will allow us to address your issue in a timely manner:
+1. Error message (copy & pasted) and focused description of the problem.
+2. Operating system, and version (e.g. OSX 10.11.6).
+3. Programming language, and version (e.g. Python 2.7.14, R 3.2.3).
+4. Version of SimpleITK (e.g. 1.1.0), just invoke the SimpleITK Version() function.
+5. How did you install SimpleITK, binary distribution (e.g. conda install -c simpleitk simpleitk), or built it from source (e.g. devtools::install_github("SimpleITK/SimpleITKRInstaller")).
+6. A minimal working example which causes the error.
+7. If your code requires input, possibly point to a minimal sized input image.
+
+

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/SimpleITK-2.1.1.2.dist-info/RECORD

@@ -0,0 +1,18 @@
+SimpleITK-2.1.1.2.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
+SimpleITK-2.1.1.2.dist-info/METADATA,sha256=TqEyR4KTBGwNTjrf4iBpPxU8sB-boL05nt7JKmdBFJQ,8065
+SimpleITK-2.1.1.2.dist-info/RECORD,,
+SimpleITK-2.1.1.2.dist-info/REQUESTED,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+SimpleITK-2.1.1.2.dist-info/WHEEL,sha256=VC8YzyxoGiXrzl8xKL9ftgvyZU-Uz6pGPrSATb2mDHw,148
+SimpleITK-2.1.1.2.dist-info/top_level.txt,sha256=B1KR4Uq5HwDUTeXLYhuUE_Ryfnp5j8Tik9KptJj7Wr8,10
+SimpleITK/SimpleITK.py,sha256=TWoLHw7FsHwNbn0f9DIpcsK8MBsT-_KZKBrELYIqYDk,1878079
+SimpleITK/_SimpleITK.cpython-38-x86_64-linux-gnu.so,sha256=lPWMUfuz_9FTYum7joWHH6RBrHWzxHJbA1WQ-8y9SvI,246256112
+SimpleITK/__init__.py,sha256=rcqfwADepv7hsdlUdAnvq6QvDdbh5amE9vd5GpUGiqo,846
+SimpleITK/__pycache__/SimpleITK.cpython-38.pyc,,
+SimpleITK/__pycache__/__init__.cpython-38.pyc,,
+SimpleITK/__pycache__/_version.cpython-38.pyc,,
+SimpleITK/__pycache__/extra.cpython-38.pyc,,
+SimpleITK/_version.py,sha256=tUIfyR11gAIgaIVGlAm84Tq_a8UEnmJfx09IaOkneGw,1520
+SimpleITK/docs/LICENSE,sha256=z8d0m5b2O9McPEK1xHG_dWgUBT6EfBDz6wA0F7xSPTA,11358
+SimpleITK/docs/NOTICE,sha256=CR8SzcM7lSinW9xYMEDEoO_iT0LP4WckdQVYCaP3Y6o,174
+SimpleITK/docs/Readme.md,sha256=v_FwrIFYVrDOBkT2-IPQzp_Koof3ECsLeTHxNdeGSqw,6689
+SimpleITK/extra.py,sha256=FYlEeDulSFfR1GK2IfgqC6M-SmJiFLP7SbtKvVdWZ7E,15978

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/SimpleITK-2.1.1.2.dist-info/WHEEL

@@ -0,0 +1,6 @@
+Wheel-Version: 1.0
+Generator: bdist_wheel (0.37.1)
+Root-Is-Purelib: false
+Tag: cp38-cp38-manylinux_2_12_x86_64
+Tag: cp38-cp38-manylinux2010_x86_64
+

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/SimpleITK-2.1.1.2.dist-info/top_level.txt

@@ -0,0 +1 @@
+SimpleITK

my_container_sandbox/workspace/anaconda3/lib/python3.8/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.3"

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/click/_compat.py

@@ -0,0 +1,626 @@
+import codecs
+import io
+import os
+import re
+import sys
+import typing as t
+from weakref import WeakKeyDictionary
+
+CYGWIN = sys.platform.startswith("cygwin")
+MSYS2 = sys.platform.startswith("win") and ("GCC" in sys.version)
+# Determine local App Engine environment, per Google's own suggestion
+APP_ENGINE = "APPENGINE_RUNTIME" in os.environ and "Development/" in os.environ.get(
+    "SERVER_SOFTWARE", ""
+)
+WIN = sys.platform.startswith("win") and not APP_ENGINE and not MSYS2
+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 get_filesystem_encoding() -> str:
+    return sys.getfilesystemencoding() or sys.getdefaultencoding()
+
+
+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) -> 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, 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, 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.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.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,
+    encoding: t.Optional[str],
+    errors: t.Optional[str],
+    is_binary: t.Callable[[t.IO, bool], bool],
+    find_binary: t.Callable[[t.IO], 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,
+    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,
+    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, int],
+    mode: str,
+    encoding: t.Optional[str],
+    errors: t.Optional[str],
+) -> t.IO:
+    """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: str,
+    mode: str = "r",
+    encoding: t.Optional[str] = None,
+    errors: t.Optional[str] = "strict",
+    atomic: bool = False,
+) -> t.Tuple[t.IO, bool]:
+    binary = "b" in mode
+
+    # 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, af), True
+
+
+class _AtomicFile:
+    def __init__(self, f: t.IO, 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, exc_value, tb):  # type: ignore
+        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) -> bool:
+    while isinstance(stream, (_FixupStream, _NonClosingTextIOWrapper)):
+        stream = stream._stream
+
+    return stream.__class__.__module__.startswith("ipykernel.")
+
+
+def should_strip_ansi(
+    stream: t.Optional[t.IO] = 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(
+        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 get_filesystem_encoding()
+
+    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) -> bool:
+    try:
+        return stream.isatty()
+    except Exception:
+        return False
+
+
+def _make_cached_stream_func(
+    src_func: t.Callable[[], t.TextIO], wrapper_func: t.Callable[[], t.TextIO]
+) -> t.Callable[[], t.TextIO]:
+    cache: t.MutableMapping[t.TextIO, t.TextIO] = WeakKeyDictionary()
+
+    def func() -> t.TextIO:
+        stream = src_func()
+        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,
+}

my_container_sandbox/workspace/anaconda3/lib/python3.8/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)

my_container_sandbox/workspace/anaconda3/lib/python3.8/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)

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/click/decorators.py

@@ -0,0 +1,497 @@
+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
+
+F = t.TypeVar("F", bound=t.Callable[..., t.Any])
+FC = t.TypeVar("FC", bound=t.Union[t.Callable[..., t.Any], Command])
+
+
+def pass_context(f: F) -> F:
+    """Marks a callback as wanting to receive the current context
+    object as first argument.
+    """
+
+    def new_func(*args, **kwargs):  # type: ignore
+        return f(get_current_context(), *args, **kwargs)
+
+    return update_wrapper(t.cast(F, new_func), f)
+
+
+def pass_obj(f: F) -> F:
+    """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, **kwargs):  # type: ignore
+        return f(get_current_context().obj, *args, **kwargs)
+
+    return update_wrapper(t.cast(F, new_func), f)
+
+
+def make_pass_decorator(
+    object_type: t.Type, ensure: bool = False
+) -> "t.Callable[[F], F]":
+    """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: F) -> F:
+        def new_func(*args, **kwargs):  # type: ignore
+            ctx = get_current_context()
+
+            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(t.cast(F, new_func), f)
+
+    return decorator
+
+
+def pass_meta_key(
+    key: str, *, doc_description: t.Optional[str] = None
+) -> "t.Callable[[F], F]":
+    """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: F) -> F:
+        def new_func(*args, **kwargs):  # type: ignore
+            ctx = get_current_context()
+            obj = ctx.meta[key]
+            return ctx.invoke(f, obj, *args, **kwargs)
+
+        return update_wrapper(t.cast(F, 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
+
+
+CmdType = t.TypeVar("CmdType", bound=Command)
+
+
+@t.overload
+def command(
+    __func: t.Callable[..., t.Any],
+) -> Command:
+    ...
+
+
+@t.overload
+def command(
+    name: t.Optional[str] = None,
+    **attrs: t.Any,
+) -> t.Callable[..., Command]:
+    ...
+
+
+@t.overload
+def command(
+    name: t.Optional[str] = None,
+    cls: t.Type[CmdType] = ...,
+    **attrs: t.Any,
+) -> t.Callable[..., CmdType]:
+    ...
+
+
+def command(
+    name: t.Union[str, t.Callable[..., t.Any], None] = None,
+    cls: t.Optional[t.Type[Command]] = None,
+    **attrs: t.Any,
+) -> t.Union[Command, t.Callable[..., Command]]:
+    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[..., 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 = Command
+
+    def decorator(f: t.Callable[..., t.Any]) -> Command:
+        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__
+
+        cmd = cls(  # type: ignore[misc]
+            name=name or f.__name__.lower().replace("_", "-"),  # type: ignore[arg-type]
+            callback=f,
+            params=params,
+            **attrs,
+        )
+        cmd.__doc__ = f.__doc__
+        return cmd
+
+    if func is not None:
+        return decorator(func)
+
+    return decorator
+
+
+@t.overload
+def group(
+    __func: t.Callable[..., t.Any],
+) -> Group:
+    ...
+
+
+@t.overload
+def group(
+    name: t.Optional[str] = None,
+    **attrs: t.Any,
+) -> t.Callable[[F], Group]:
+    ...
+
+
+def group(
+    name: t.Union[str, t.Callable[..., t.Any], None] = None, **attrs: t.Any
+) -> t.Union[Group, t.Callable[[F], Group]]:
+    """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 attrs.get("cls") is None:
+        attrs["cls"] = Group
+
+    if callable(name):
+        grp: t.Callable[[F], Group] = t.cast(Group, command(**attrs))
+        return grp(name)
+
+    return t.cast(Group, command(name, **attrs))
+
+
+def _param_memo(f: FC, 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, **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.
+
+    :param cls: the argument class to instantiate.  This defaults to
+                :class:`Argument`.
+    """
+
+    def decorator(f: FC) -> FC:
+        ArgumentClass = attrs.pop("cls", None) or Argument
+        _param_memo(f, ArgumentClass(param_decls, **attrs))
+        return f
+
+    return decorator
+
+
+def option(*param_decls: str, **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.
+
+    :param cls: the option class to instantiate.  This defaults to
+                :class:`Option`.
+    """
+
+    def decorator(f: FC) -> FC:
+        # Issue 926, copy attrs, so pre-defined options can re-use the same cls=
+        option_attrs = attrs.copy()
+        OptionClass = option_attrs.pop("cls", None) or Option
+        _param_memo(f, OptionClass(param_decls, **option_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(
+            t.cast(str, 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)

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/click/exceptions.py

@@ -0,0 +1,287 @@
+import os
+import typing as t
+from gettext import gettext as _
+from gettext import ngettext
+
+from ._compat import get_text_stderr
+from .utils import echo
+
+if t.TYPE_CHECKING:
+    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] = 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 = self.ctx.command if self.ctx else None
+
+    def show(self, file: t.Optional[t.IO] = 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 = os.fsdecode(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 = code

my_container_sandbox/workspace/anaconda3/lib/python3.8/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

my_container_sandbox/workspace/anaconda3/lib/python3.8/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

my_container_sandbox/workspace/anaconda3/lib/python3.8/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 = 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: str, 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 = 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 = 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 re-combinate 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)

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/click/shell_completion.py

@@ -0,0 +1,580 @@
+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.Dict[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 = value
+        self.type = type
+        self.help = 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
+}
+
+compdef %(complete_func)s %(prog_name)s;
+"""
+
+_SOURCE_FISH = """\
+function %(complete_func)s;
+    set -l response;
+
+    for value in (env %(complete_var)s=fish_complete COMP_WORDS=(commandline -cp) \
+COMP_CWORD=(commandline -t) %(prog_name)s);
+        set response $response $value;
+    end;
+
+    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.Dict[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("-", "_"), 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
+
+    def _check_version(self) -> 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":
+                raise RuntimeError(
+                    _(
+                        "Shell completion is not supported for Bash"
+                        " versions older than 4.4."
+                    )
+                )
+        else:
+            raise RuntimeError(
+                _("Couldn't detect Bash version, shell completion is not supported.")
+            )
+
+    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}"
+
+
+_available_shells: t.Dict[str, t.Type[ShellComplete]] = {
+    "bash": BashComplete,
+    "fish": FishComplete,
+    "zsh": ZshComplete,
+}
+
+
+def add_completion_class(
+    cls: t.Type[ShellComplete], name: t.Optional[str] = None
+) -> None:
+    """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
+
+
+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
+    value = ctx.params[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.Dict[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:
+                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

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/click/termui.py

@@ -0,0 +1,787 @@
+import inspect
+import io
+import itertools
+import os
+import sys
+import typing as t
+from gettext import gettext as _
+
+from ._compat import isatty
+from ._compat import strip_ansi
+from ._compat import WIN
+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  # type: ignore
+
+    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
+    if WIN:
+        os.system("cls")
+    else:
+        sys.stdout.write("\033[2J\033[1;1H")
+
+
+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)

my_container_sandbox/workspace/anaconda3/lib/python3.8/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]], charset: str
+) -> t.BinaryIO:
+    # Is already an input stream.
+    if hasattr(input, "read"):
+        rv = _find_binary_reader(t.cast(t.IO, 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(t.cast(bytes, 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 = 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]] = 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] = 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]] = 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]] = 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)  # type: ignore[type-var]
+        os.chdir(dt)
+
+        try:
+            yield t.cast(str, dt)
+        finally:
+            os.chdir(cwd)
+
+            if temp_dir is None:
+                try:
+                    shutil.rmtree(dt)
+                except OSError:  # noqa: B014
+                    pass

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/click/types.py

@@ -0,0 +1,1073 @@
+import os
+import stat
+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 get_filesystem_encoding
+from ._compat import open_stream
+from .exceptions import BadParameter
+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 = 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 = get_filesystem_encoding()
+                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 = 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]
+
+    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 = 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.Any) -> bool:
+        if self.lazy is not None:
+            return self.lazy
+        if value == "-":
+            return False
+        elif "w" in self.mode:
+            return True
+        return False
+
+    def convert(
+        self, value: t.Any, param: t.Optional["Parameter"], ctx: t.Optional["Context"]
+    ) -> t.Any:
+        try:
+            if hasattr(value, "read") or hasattr(value, "write"):
+                return value
+
+            lazy = self.resolve_lazy_flag(value)
+
+            if lazy:
+                f: t.IO = t.cast(
+                    t.IO,
+                    LazyFile(
+                        value, self.mode, self.encoding, self.errors, atomic=self.atomic
+                    ),
+                )
+
+                if ctx is not None:
+                    ctx.call_on_close(f.close_intelligently)  # type: ignore
+
+                return f
+
+            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"'{os.fsdecode(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")]
+
+
+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 ``type=pathlib.Path``.
+
+    .. versionchanged:: 6.0
+        Added the ``allow_dash`` parameter.
+    """
+
+    envvar_list_splitter = 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] = 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 = _("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, rv: t.Any) -> t.Any:
+        if self.type is not None and not isinstance(rv, self.type):
+            if self.type is str:
+                rv = os.fsdecode(rv)
+            elif self.type is bytes:
+                rv = os.fsencode(rv)
+            else:
+                rv = self.type(rv)
+
+        return rv
+
+    def convert(
+        self, value: t.Any, param: t.Optional["Parameter"], ctx: t.Optional["Context"]
+    ) -> t.Any:
+        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=os.fsdecode(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=os.fsdecode(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=os.fsdecode(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=os.fsdecode(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=os.fsdecode(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=os.fsdecode(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, ParamType]]) -> None:
+        self.types = [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()

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/click/utils.py

@@ -0,0 +1,580 @@
+import os
+import re
+import sys
+import typing as t
+from functools import update_wrapper
+from types import ModuleType
+
+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 get_filesystem_encoding
+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
+
+F = t.TypeVar("F", bound=t.Callable[..., t.Any])
+
+
+def _posixify(name: str) -> str:
+    return "-".join(name.split()).lower()
+
+
+def safecall(func: F) -> F:
+    """Wraps a function so that it swallows exceptions."""
+
+    def wrapper(*args, **kwargs):  # type: ignore
+        try:
+            return func(*args, **kwargs)
+        except Exception:
+            pass
+
+    return update_wrapper(t.cast(F, wrapper), func)
+
+
+def make_str(value: t.Any) -> str:
+    """Converts a value into a valid string."""
+    if isinstance(value, bytes):
+        try:
+            return value.decode(get_filesystem_encoding())
+        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: str,
+        mode: str = "r",
+        encoding: t.Optional[str] = None,
+        errors: t.Optional[str] = "strict",
+        atomic: bool = False,
+    ):
+        self.name = filename
+        self.mode = mode
+        self.encoding = encoding
+        self.errors = errors
+        self.atomic = atomic
+        self._f: t.Optional[t.IO]
+
+        if filename == "-":
+            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 '{self.name}' {self.mode}>"
+
+    def open(self) -> t.IO:
+        """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, exc_value, tb):  # type: ignore
+        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) -> None:
+        self._file = file
+
+    def __getattr__(self, name: str) -> t.Any:
+        return getattr(self._file, name)
+
+    def __enter__(self) -> "KeepOpenFile":
+        return self
+
+    def __exit__(self, exc_type, exc_value, tb):  # type: ignore
+        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()
+
+    # 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:
+    """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, 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, KeepOpenFile(f))
+
+    return f
+
+
+def format_filename(
+    filename: t.Union[str, bytes, os.PathLike], shorten: bool = False
+) -> str:
+    """Formats a filename for user display.  The main purpose of this
+    function is to ensure that the filename can be displayed at all.  This
+    will decode the filename to unicode if necessary in a way that it will
+    not fail.  Optionally, it can shorten the filename to not include the
+    full path to the filename.
+
+    :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)
+
+    return os.fsdecode(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 affect 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) -> 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.
+    if getattr(_main, "__package__", None) is 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

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/fontTools/__init__.py

@@ -0,0 +1,8 @@
+import logging
+from fontTools.misc.loggingTools import configLogger
+
+log = logging.getLogger(__name__)
+
+version = __version__ = "4.34.4"
+
+__all__ = ["version", "log", "configLogger"]

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/fontTools/__main__.py

@@ -0,0 +1,34 @@
+import sys
+
+
+def main(args=None):
+	if args is None:
+		args = sys.argv[1:]
+
+	# TODO Handle library-wide options. Eg.:
+	# --unicodedata
+	# --verbose / other logging stuff
+
+	# TODO Allow a way to run arbitrary modules? Useful for setting
+	# library-wide options and calling another library. Eg.:
+	#
+	#   $ fonttools --unicodedata=... fontmake ...
+	#
+	# This allows for a git-like command where thirdparty commands
+	# can be added.  Should we just try importing the fonttools
+	# module first and try without if it fails?
+
+	if len(sys.argv) < 2:
+		sys.argv.append("help")
+	if sys.argv[1] == "-h" or sys.argv[1] == "--help":
+		sys.argv[1] = "help"
+	mod = 'fontTools.'+sys.argv[1]
+	sys.argv[1] = sys.argv[0] + ' ' + sys.argv[1]
+	del sys.argv[0]
+
+	import runpy
+	runpy.run_module(mod, run_name='__main__')
+
+
+if __name__ == '__main__':
+	sys.exit(main())

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/fontTools/afmLib.py

@@ -0,0 +1,430 @@
+"""Module for reading and writing AFM (Adobe Font Metrics) files.
+
+Note that this has been designed to read in AFM files generated by Fontographer
+and has not been tested on many other files. In particular, it does not
+implement the whole Adobe AFM specification [#f1]_ but, it should read most
+"common" AFM files.
+
+Here is an example of using `afmLib` to read, modify and write an AFM file:
+
+	>>> from fontTools.afmLib import AFM
+	>>> f = AFM("Tests/afmLib/data/TestAFM.afm")
+	>>>
+	>>> # Accessing a pair gets you the kern value
+	>>> f[("V","A")]
+	-60
+	>>>
+	>>> # Accessing a glyph name gets you metrics
+	>>> f["A"]
+	(65, 668, (8, -25, 660, 666))
+	>>> # (charnum, width, bounding box)
+	>>>
+	>>> # Accessing an attribute gets you metadata
+	>>> f.FontName
+	'TestFont-Regular'
+	>>> f.FamilyName
+	'TestFont'
+	>>> f.Weight
+	'Regular'
+	>>> f.XHeight
+	500
+	>>> f.Ascender
+	750
+	>>>
+	>>> # Attributes and items can also be set
+	>>> f[("A","V")] = -150 # Tighten kerning
+	>>> f.FontName = "TestFont Squished"
+	>>>
+	>>> # And the font written out again (remove the # in front)
+	>>> #f.write("testfont-squished.afm")
+
+.. rubric:: Footnotes
+
+.. [#f1] `Adobe Technote 5004 <https://www.adobe.com/content/dam/acom/en/devnet/font/pdfs/5004.AFM_Spec.pdf>`_,
+   Adobe Font Metrics File Format Specification.
+
+"""
+
+
+import re
+
+# every single line starts with a "word"
+identifierRE = re.compile(r"^([A-Za-z]+).*")
+
+# regular expression to parse char lines
+charRE = re.compile(
+		r"(-?\d+)"			# charnum
+		r"\s*;\s*WX\s+"			# ; WX
+		r"(-?\d+)"			# width
+		r"\s*;\s*N\s+"			# ; N
+		r"([.A-Za-z0-9_]+)"		# charname
+		r"\s*;\s*B\s+"			# ; B
+		r"(-?\d+)"			# left
+		r"\s+"
+		r"(-?\d+)"			# bottom
+		r"\s+"
+		r"(-?\d+)"			# right
+		r"\s+"
+		r"(-?\d+)"			# top
+		r"\s*;\s*"			# ;
+		)
+
+# regular expression to parse kerning lines
+kernRE = re.compile(
+		r"([.A-Za-z0-9_]+)"		# leftchar
+		r"\s+"
+		r"([.A-Za-z0-9_]+)"		# rightchar
+		r"\s+"
+		r"(-?\d+)"			# value
+		r"\s*"
+		)
+
+# regular expressions to parse composite info lines of the form:
+# Aacute 2 ; PCC A 0 0 ; PCC acute 182 211 ;
+compositeRE = re.compile(
+		r"([.A-Za-z0-9_]+)"		# char name
+		r"\s+"
+		r"(\d+)"				# number of parts
+		r"\s*;\s*"
+		)
+componentRE = re.compile(
+		r"PCC\s+"			# PPC
+		r"([.A-Za-z0-9_]+)"		# base char name
+		r"\s+"
+		r"(-?\d+)"			# x offset
+		r"\s+"
+		r"(-?\d+)"			# y offset
+		r"\s*;\s*"
+		)
+
+preferredAttributeOrder = [
+		"FontName",
+		"FullName",
+		"FamilyName",
+		"Weight",
+		"ItalicAngle",
+		"IsFixedPitch",
+		"FontBBox",
+		"UnderlinePosition",
+		"UnderlineThickness",
+		"Version",
+		"Notice",
+		"EncodingScheme",
+		"CapHeight",
+		"XHeight",
+		"Ascender",
+		"Descender",
+]
+
+
+class error(Exception):
+	pass
+
+
+class AFM(object):
+
+	_attrs = None
+
+	_keywords = ['StartFontMetrics',
+			'EndFontMetrics',
+			'StartCharMetrics',
+			'EndCharMetrics',
+			'StartKernData',
+			'StartKernPairs',
+			'EndKernPairs',
+			'EndKernData',
+			'StartComposites',
+			'EndComposites',
+			]
+
+	def __init__(self, path=None):
+		"""AFM file reader.
+
+		Instantiating an object with a path name will cause the file to be opened,
+		read, and parsed. Alternatively the path can be left unspecified, and a
+		file can be parsed later with the :meth:`read` method."""
+		self._attrs = {}
+		self._chars = {}
+		self._kerning = {}
+		self._index = {}
+		self._comments = []
+		self._composites = {}
+		if path is not None:
+			self.read(path)
+
+	def read(self, path):
+		"""Opens, reads and parses a file."""
+		lines = readlines(path)
+		for line in lines:
+			if not line.strip():
+				continue
+			m = identifierRE.match(line)
+			if m is None:
+				raise error("syntax error in AFM file: " + repr(line))
+
+			pos = m.regs[1][1]
+			word = line[:pos]
+			rest = line[pos:].strip()
+			if word in self._keywords:
+				continue
+			if word == "C":
+				self.parsechar(rest)
+			elif word == "KPX":
+				self.parsekernpair(rest)
+			elif word == "CC":
+				self.parsecomposite(rest)
+			else:
+				self.parseattr(word, rest)
+
+	def parsechar(self, rest):
+		m = charRE.match(rest)
+		if m is None:
+			raise error("syntax error in AFM file: " + repr(rest))
+		things = []
+		for fr, to in m.regs[1:]:
+			things.append(rest[fr:to])
+		charname = things[2]
+		del things[2]
+		charnum, width, l, b, r, t = (int(thing) for thing in things)
+		self._chars[charname] = charnum, width, (l, b, r, t)
+
+	def parsekernpair(self, rest):
+		m = kernRE.match(rest)
+		if m is None:
+			raise error("syntax error in AFM file: " + repr(rest))
+		things = []
+		for fr, to in m.regs[1:]:
+			things.append(rest[fr:to])
+		leftchar, rightchar, value = things
+		value = int(value)
+		self._kerning[(leftchar, rightchar)] = value
+
+	def parseattr(self, word, rest):
+		if word == "FontBBox":
+			l, b, r, t = [int(thing) for thing in rest.split()]
+			self._attrs[word] = l, b, r, t
+		elif word == "Comment":
+			self._comments.append(rest)
+		else:
+			try:
+				value = int(rest)
+			except (ValueError, OverflowError):
+				self._attrs[word] = rest
+			else:
+				self._attrs[word] = value
+
+	def parsecomposite(self, rest):
+		m = compositeRE.match(rest)
+		if m is None:
+			raise error("syntax error in AFM file: " + repr(rest))
+		charname = m.group(1)
+		ncomponents = int(m.group(2))
+		rest = rest[m.regs[0][1]:]
+		components = []
+		while True:
+			m = componentRE.match(rest)
+			if m is None:
+				raise error("syntax error in AFM file: " + repr(rest))
+			basechar = m.group(1)
+			xoffset = int(m.group(2))
+			yoffset = int(m.group(3))
+			components.append((basechar, xoffset, yoffset))
+			rest = rest[m.regs[0][1]:]
+			if not rest:
+				break
+		assert len(components) == ncomponents
+		self._composites[charname] = components
+
+	def write(self, path, sep='\r'):
+		"""Writes out an AFM font to the given path."""
+		import time
+		lines = [	"StartFontMetrics 2.0",
+				"Comment Generated by afmLib; at %s" % (
+						time.strftime("%m/%d/%Y %H:%M:%S",
+						time.localtime(time.time())))]
+
+		# write comments, assuming (possibly wrongly!) they should
+		# all appear at the top
+		for comment in self._comments:
+			lines.append("Comment " + comment)
+
+		# write attributes, first the ones we know about, in
+		# a preferred order
+		attrs = self._attrs
+		for attr in preferredAttributeOrder:
+			if attr in attrs:
+				value = attrs[attr]
+				if attr == "FontBBox":
+					value = "%s %s %s %s" % value
+				lines.append(attr + " " + str(value))
+		# then write the attributes we don't know about,
+		# in alphabetical order
+		items = sorted(attrs.items())
+		for attr, value in items:
+			if attr in preferredAttributeOrder:
+				continue
+			lines.append(attr + " " + str(value))
+
+		# write char metrics
+		lines.append("StartCharMetrics " + repr(len(self._chars)))
+		items = [(charnum, (charname, width, box)) for charname, (charnum, width, box) in self._chars.items()]
+
+		def myKey(a):
+			"""Custom key function to make sure unencoded chars (-1)
+			end up at the end of the list after sorting."""
+			if a[0] == -1:
+				a = (0xffff,) + a[1:]  # 0xffff is an arbitrary large number
+			return a
+		items.sort(key=myKey)
+
+		for charnum, (charname, width, (l, b, r, t)) in items:
+			lines.append("C %d ; WX %d ; N %s ; B %d %d %d %d ;" %
+					(charnum, width, charname, l, b, r, t))
+		lines.append("EndCharMetrics")
+
+		# write kerning info
+		lines.append("StartKernData")
+		lines.append("StartKernPairs " + repr(len(self._kerning)))
+		items = sorted(self._kerning.items())
+		for (leftchar, rightchar), value in items:
+			lines.append("KPX %s %s %d" % (leftchar, rightchar, value))
+		lines.append("EndKernPairs")
+		lines.append("EndKernData")
+
+		if self._composites:
+			composites = sorted(self._composites.items())
+			lines.append("StartComposites %s" % len(self._composites))
+			for charname, components in composites:
+				line = "CC %s %s ;" % (charname, len(components))
+				for basechar, xoffset, yoffset in components:
+					line = line + " PCC %s %s %s ;" % (basechar, xoffset, yoffset)
+				lines.append(line)
+			lines.append("EndComposites")
+
+		lines.append("EndFontMetrics")
+
+		writelines(path, lines, sep)
+
+	def has_kernpair(self, pair):
+		"""Returns `True` if the given glyph pair (specified as a tuple) exists
+		in the kerning dictionary."""
+		return pair in self._kerning
+
+	def kernpairs(self):
+		"""Returns a list of all kern pairs in the kerning dictionary."""
+		return list(self._kerning.keys())
+
+	def has_char(self, char):
+		"""Returns `True` if the given glyph exists in the font."""
+		return char in self._chars
+
+	def chars(self):
+		"""Returns a list of all glyph names in the font."""
+		return list(self._chars.keys())
+
+	def comments(self):
+		"""Returns all comments from the file."""
+		return self._comments
+
+	def addComment(self, comment):
+		"""Adds a new comment to the file."""
+		self._comments.append(comment)
+
+	def addComposite(self, glyphName, components):
+		"""Specifies that the glyph `glyphName` is made up of the given components.
+		The components list should be of the following form::
+
+			[
+				(glyphname, xOffset, yOffset),
+				...
+			]
+		
+		"""
+		self._composites[glyphName] = components
+
+	def __getattr__(self, attr):
+		if attr in self._attrs:
+			return self._attrs[attr]
+		else:
+			raise AttributeError(attr)
+
+	def __setattr__(self, attr, value):
+		# all attrs *not* starting with "_" are consider to be AFM keywords
+		if attr[:1] == "_":
+			self.__dict__[attr] = value
+		else:
+			self._attrs[attr] = value
+
+	def __delattr__(self, attr):
+		# all attrs *not* starting with "_" are consider to be AFM keywords
+		if attr[:1] == "_":
+			try:
+				del self.__dict__[attr]
+			except KeyError:
+				raise AttributeError(attr)
+		else:
+			try:
+				del self._attrs[attr]
+			except KeyError:
+				raise AttributeError(attr)
+
+	def __getitem__(self, key):
+		if isinstance(key, tuple):
+			# key is a tuple, return the kernpair
+			return self._kerning[key]
+		else:
+			# return the metrics instead
+			return self._chars[key]
+
+	def __setitem__(self, key, value):
+		if isinstance(key, tuple):
+			# key is a tuple, set kernpair
+			self._kerning[key] = value
+		else:
+			# set char metrics
+			self._chars[key] = value
+
+	def __delitem__(self, key):
+		if isinstance(key, tuple):
+			# key is a tuple, del kernpair
+			del self._kerning[key]
+		else:
+			# del char metrics
+			del self._chars[key]
+
+	def __repr__(self):
+		if hasattr(self, "FullName"):
+			return '<AFM object for %s>' % self.FullName
+		else:
+			return '<AFM object at %x>' % id(self)
+
+
+def readlines(path):
+	with open(path, "r", encoding="ascii") as f:
+		data = f.read()
+	return data.splitlines()
+
+def writelines(path, lines, sep='\r'):
+	with open(path, "w", encoding="ascii", newline=sep) as f:
+		f.write("\n".join(lines) + "\n")
+
+
+if __name__ == "__main__":
+	import EasyDialogs
+	path = EasyDialogs.AskFileForOpen()
+	if path:
+		afm = AFM(path)
+		char = 'A'
+		if afm.has_char(char):
+			print(afm[char])	# print charnum, width and boundingbox
+		pair = ('A', 'V')
+		if afm.has_kernpair(pair):
+			print(afm[pair])	# print kerning value for pair
+		print(afm.Version)	# various other afm entries have become attributes
+		print(afm.Weight)
+		# afm.comments() returns a list of all Comment lines found in the AFM
+		print(afm.comments())
+		#print afm.chars()
+		#print afm.kernpairs()
+		print(afm)
+		afm.write(path + ".muck")

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/fontTools/fontBuilder.py

@@ -0,0 +1,958 @@
+__all__ = ["FontBuilder"]
+
+"""
+This module is *experimental*, meaning it still may evolve and change.
+
+The `FontBuilder` class is a convenient helper to construct working TTF or
+OTF fonts from scratch.
+
+Note that the various setup methods cannot be called in arbitrary order,
+due to various interdependencies between OpenType tables. Here is an order
+that works:
+
+    fb = FontBuilder(...)
+    fb.setupGlyphOrder(...)
+    fb.setupCharacterMap(...)
+    fb.setupGlyf(...) --or-- fb.setupCFF(...)
+    fb.setupHorizontalMetrics(...)
+    fb.setupHorizontalHeader()
+    fb.setupNameTable(...)
+    fb.setupOS2()
+    fb.addOpenTypeFeatures(...)
+    fb.setupPost()
+    fb.save(...)
+
+Here is how to build a minimal TTF:
+
+```python
+from fontTools.fontBuilder import FontBuilder
+from fontTools.pens.ttGlyphPen import TTGlyphPen
+
+
+def drawTestGlyph(pen):
+    pen.moveTo((100, 100))
+    pen.lineTo((100, 1000))
+    pen.qCurveTo((200, 900), (400, 900), (500, 1000))
+    pen.lineTo((500, 100))
+    pen.closePath()
+
+
+fb = FontBuilder(1024, isTTF=True)
+fb.setupGlyphOrder([".notdef", ".null", "space", "A", "a"])
+fb.setupCharacterMap({32: "space", 65: "A", 97: "a"})
+advanceWidths = {".notdef": 600, "space": 500, "A": 600, "a": 600, ".null": 0}
+
+familyName = "HelloTestFont"
+styleName = "TotallyNormal"
+version = "0.1"
+
+nameStrings = dict(
+    familyName=dict(en=familyName, nl="HalloTestFont"),
+    styleName=dict(en=styleName, nl="TotaalNormaal"),
+    uniqueFontIdentifier="fontBuilder: " + familyName + "." + styleName,
+    fullName=familyName + "-" + styleName,
+    psName=familyName + "-" + styleName,
+    version="Version " + version,
+)
+
+pen = TTGlyphPen(None)
+drawTestGlyph(pen)
+glyph = pen.glyph()
+glyphs = {".notdef": glyph, "space": glyph, "A": glyph, "a": glyph, ".null": glyph}
+fb.setupGlyf(glyphs)
+metrics = {}
+glyphTable = fb.font["glyf"]
+for gn, advanceWidth in advanceWidths.items():
+    metrics[gn] = (advanceWidth, glyphTable[gn].xMin)
+fb.setupHorizontalMetrics(metrics)
+fb.setupHorizontalHeader(ascent=824, descent=-200)
+fb.setupNameTable(nameStrings)
+fb.setupOS2(sTypoAscender=824, usWinAscent=824, usWinDescent=200)
+fb.setupPost()
+fb.save("test.ttf")
+```
+
+And here's how to build a minimal OTF:
+
+```python
+from fontTools.fontBuilder import FontBuilder
+from fontTools.pens.t2CharStringPen import T2CharStringPen
+
+
+def drawTestGlyph(pen):
+    pen.moveTo((100, 100))
+    pen.lineTo((100, 1000))
+    pen.curveTo((200, 900), (400, 900), (500, 1000))
+    pen.lineTo((500, 100))
+    pen.closePath()
+
+
+fb = FontBuilder(1024, isTTF=False)
+fb.setupGlyphOrder([".notdef", ".null", "space", "A", "a"])
+fb.setupCharacterMap({32: "space", 65: "A", 97: "a"})
+advanceWidths = {".notdef": 600, "space": 500, "A": 600, "a": 600, ".null": 0}
+
+familyName = "HelloTestFont"
+styleName = "TotallyNormal"
+version = "0.1"
+
+nameStrings = dict(
+    familyName=dict(en=familyName, nl="HalloTestFont"),
+    styleName=dict(en=styleName, nl="TotaalNormaal"),
+    uniqueFontIdentifier="fontBuilder: " + familyName + "." + styleName,
+    fullName=familyName + "-" + styleName,
+    psName=familyName + "-" + styleName,
+    version="Version " + version,
+)
+
+pen = T2CharStringPen(600, None)
+drawTestGlyph(pen)
+charString = pen.getCharString()
+charStrings = {
+    ".notdef": charString,
+    "space": charString,
+    "A": charString,
+    "a": charString,
+    ".null": charString,
+}
+fb.setupCFF(nameStrings["psName"], {"FullName": nameStrings["psName"]}, charStrings, {})
+lsb = {gn: cs.calcBounds(None)[0] for gn, cs in charStrings.items()}
+metrics = {}
+for gn, advanceWidth in advanceWidths.items():
+    metrics[gn] = (advanceWidth, lsb[gn])
+fb.setupHorizontalMetrics(metrics)
+fb.setupHorizontalHeader(ascent=824, descent=200)
+fb.setupNameTable(nameStrings)
+fb.setupOS2(sTypoAscender=824, usWinAscent=824, usWinDescent=200)
+fb.setupPost()
+fb.save("test.otf")
+```
+"""
+
+from .ttLib import TTFont, newTable
+from .ttLib.tables._c_m_a_p import cmap_classes
+from .misc.timeTools import timestampNow
+import struct
+from collections import OrderedDict
+
+
+_headDefaults = dict(
+    tableVersion=1.0,
+    fontRevision=1.0,
+    checkSumAdjustment=0,
+    magicNumber=0x5F0F3CF5,
+    flags=0x0003,
+    unitsPerEm=1000,
+    created=0,
+    modified=0,
+    xMin=0,
+    yMin=0,
+    xMax=0,
+    yMax=0,
+    macStyle=0,
+    lowestRecPPEM=3,
+    fontDirectionHint=2,
+    indexToLocFormat=0,
+    glyphDataFormat=0,
+)
+
+_maxpDefaultsTTF = dict(
+    tableVersion=0x00010000,
+    numGlyphs=0,
+    maxPoints=0,
+    maxContours=0,
+    maxCompositePoints=0,
+    maxCompositeContours=0,
+    maxZones=2,
+    maxTwilightPoints=0,
+    maxStorage=0,
+    maxFunctionDefs=0,
+    maxInstructionDefs=0,
+    maxStackElements=0,
+    maxSizeOfInstructions=0,
+    maxComponentElements=0,
+    maxComponentDepth=0,
+)
+_maxpDefaultsOTF = dict(
+    tableVersion=0x00005000,
+    numGlyphs=0,
+)
+
+_postDefaults = dict(
+    formatType=3.0,
+    italicAngle=0,
+    underlinePosition=0,
+    underlineThickness=0,
+    isFixedPitch=0,
+    minMemType42=0,
+    maxMemType42=0,
+    minMemType1=0,
+    maxMemType1=0,
+)
+
+_hheaDefaults = dict(
+    tableVersion=0x00010000,
+    ascent=0,
+    descent=0,
+    lineGap=0,
+    advanceWidthMax=0,
+    minLeftSideBearing=0,
+    minRightSideBearing=0,
+    xMaxExtent=0,
+    caretSlopeRise=1,
+    caretSlopeRun=0,
+    caretOffset=0,
+    reserved0=0,
+    reserved1=0,
+    reserved2=0,
+    reserved3=0,
+    metricDataFormat=0,
+    numberOfHMetrics=0,
+)
+
+_vheaDefaults = dict(
+    tableVersion=0x00010000,
+    ascent=0,
+    descent=0,
+    lineGap=0,
+    advanceHeightMax=0,
+    minTopSideBearing=0,
+    minBottomSideBearing=0,
+    yMaxExtent=0,
+    caretSlopeRise=0,
+    caretSlopeRun=0,
+    reserved0=0,
+    reserved1=0,
+    reserved2=0,
+    reserved3=0,
+    reserved4=0,
+    metricDataFormat=0,
+    numberOfVMetrics=0,
+)
+
+_nameIDs = dict(
+    copyright=0,
+    familyName=1,
+    styleName=2,
+    uniqueFontIdentifier=3,
+    fullName=4,
+    version=5,
+    psName=6,
+    trademark=7,
+    manufacturer=8,
+    designer=9,
+    description=10,
+    vendorURL=11,
+    designerURL=12,
+    licenseDescription=13,
+    licenseInfoURL=14,
+    # reserved = 15,
+    typographicFamily=16,
+    typographicSubfamily=17,
+    compatibleFullName=18,
+    sampleText=19,
+    postScriptCIDFindfontName=20,
+    wwsFamilyName=21,
+    wwsSubfamilyName=22,
+    lightBackgroundPalette=23,
+    darkBackgroundPalette=24,
+    variationsPostScriptNamePrefix=25,
+)
+
+# to insert in setupNameTable doc string:
+# print("\n".join(("%s (nameID %s)" % (k, v)) for k, v in sorted(_nameIDs.items(), key=lambda x: x[1])))
+
+_panoseDefaults = dict(
+    bFamilyType=0,
+    bSerifStyle=0,
+    bWeight=0,
+    bProportion=0,
+    bContrast=0,
+    bStrokeVariation=0,
+    bArmStyle=0,
+    bLetterForm=0,
+    bMidline=0,
+    bXHeight=0,
+)
+
+_OS2Defaults = dict(
+    version=3,
+    xAvgCharWidth=0,
+    usWeightClass=400,
+    usWidthClass=5,
+    fsType=0x0004,  # default: Preview & Print embedding
+    ySubscriptXSize=0,
+    ySubscriptYSize=0,
+    ySubscriptXOffset=0,
+    ySubscriptYOffset=0,
+    ySuperscriptXSize=0,
+    ySuperscriptYSize=0,
+    ySuperscriptXOffset=0,
+    ySuperscriptYOffset=0,
+    yStrikeoutSize=0,
+    yStrikeoutPosition=0,
+    sFamilyClass=0,
+    panose=_panoseDefaults,
+    ulUnicodeRange1=0,
+    ulUnicodeRange2=0,
+    ulUnicodeRange3=0,
+    ulUnicodeRange4=0,
+    achVendID="????",
+    fsSelection=0,
+    usFirstCharIndex=0,
+    usLastCharIndex=0,
+    sTypoAscender=0,
+    sTypoDescender=0,
+    sTypoLineGap=0,
+    usWinAscent=0,
+    usWinDescent=0,
+    ulCodePageRange1=0,
+    ulCodePageRange2=0,
+    sxHeight=0,
+    sCapHeight=0,
+    usDefaultChar=0,  # .notdef
+    usBreakChar=32,  # space
+    usMaxContext=0,
+    usLowerOpticalPointSize=0,
+    usUpperOpticalPointSize=0,
+)
+
+
+class FontBuilder(object):
+    def __init__(self, unitsPerEm=None, font=None, isTTF=True):
+        """Initialize a FontBuilder instance.
+
+        If the `font` argument is not given, a new `TTFont` will be
+        constructed, and `unitsPerEm` must be given. If `isTTF` is True,
+        the font will be a glyf-based TTF; if `isTTF` is False it will be
+        a CFF-based OTF.
+
+        If `font` is given, it must be a `TTFont` instance and `unitsPerEm`
+        must _not_ be given. The `isTTF` argument will be ignored.
+        """
+        if font is None:
+            self.font = TTFont(recalcTimestamp=False)
+            self.isTTF = isTTF
+            now = timestampNow()
+            assert unitsPerEm is not None
+            self.setupHead(unitsPerEm=unitsPerEm, created=now, modified=now)
+            self.setupMaxp()
+        else:
+            assert unitsPerEm is None
+            self.font = font
+            self.isTTF = "glyf" in font
+
+    def save(self, file):
+        """Save the font. The 'file' argument can be either a pathname or a
+        writable file object.
+        """
+        self.font.save(file)
+
+    def _initTableWithValues(self, tableTag, defaults, values):
+        table = self.font[tableTag] = newTable(tableTag)
+        for k, v in defaults.items():
+            setattr(table, k, v)
+        for k, v in values.items():
+            setattr(table, k, v)
+        return table
+
+    def _updateTableWithValues(self, tableTag, values):
+        table = self.font[tableTag]
+        for k, v in values.items():
+            setattr(table, k, v)
+
+    def setupHead(self, **values):
+        """Create a new `head` table and initialize it with default values,
+        which can be overridden by keyword arguments.
+        """
+        self._initTableWithValues("head", _headDefaults, values)
+
+    def updateHead(self, **values):
+        """Update the head table with the fields and values passed as
+        keyword arguments.
+        """
+        self._updateTableWithValues("head", values)
+
+    def setupGlyphOrder(self, glyphOrder):
+        """Set the glyph order for the font."""
+        self.font.setGlyphOrder(glyphOrder)
+
+    def setupCharacterMap(self, cmapping, uvs=None, allowFallback=False):
+        """Build the `cmap` table for the font. The `cmapping` argument should
+        be a dict mapping unicode code points as integers to glyph names.
+
+        The `uvs` argument, when passed, must be a list of tuples, describing
+        Unicode Variation Sequences. These tuples have three elements:
+            (unicodeValue, variationSelector, glyphName)
+        `unicodeValue` and `variationSelector` are integer code points.
+        `glyphName` may be None, to indicate this is the default variation.
+        Text processors will then use the cmap to find the glyph name.
+        Each Unicode Variation Sequence should be an officially supported
+        sequence, but this is not policed.
+        """
+        subTables = []
+        highestUnicode = max(cmapping)
+        if highestUnicode > 0xFFFF:
+            cmapping_3_1 = dict((k, v) for k, v in cmapping.items() if k < 0x10000)
+            subTable_3_10 = buildCmapSubTable(cmapping, 12, 3, 10)
+            subTables.append(subTable_3_10)
+        else:
+            cmapping_3_1 = cmapping
+        format = 4
+        subTable_3_1 = buildCmapSubTable(cmapping_3_1, format, 3, 1)
+        try:
+            subTable_3_1.compile(self.font)
+        except struct.error:
+            # format 4 overflowed, fall back to format 12
+            if not allowFallback:
+                raise ValueError(
+                    "cmap format 4 subtable overflowed; sort glyph order by unicode to fix."
+                )
+            format = 12
+            subTable_3_1 = buildCmapSubTable(cmapping_3_1, format, 3, 1)
+        subTables.append(subTable_3_1)
+        subTable_0_3 = buildCmapSubTable(cmapping_3_1, format, 0, 3)
+        subTables.append(subTable_0_3)
+
+        if uvs is not None:
+            uvsDict = {}
+            for unicodeValue, variationSelector, glyphName in uvs:
+                if cmapping.get(unicodeValue) == glyphName:
+                    # this is a default variation
+                    glyphName = None
+                if variationSelector not in uvsDict:
+                    uvsDict[variationSelector] = []
+                uvsDict[variationSelector].append((unicodeValue, glyphName))
+            uvsSubTable = buildCmapSubTable({}, 14, 0, 5)
+            uvsSubTable.uvsDict = uvsDict
+            subTables.append(uvsSubTable)
+
+        self.font["cmap"] = newTable("cmap")
+        self.font["cmap"].tableVersion = 0
+        self.font["cmap"].tables = subTables
+
+    def setupNameTable(self, nameStrings, windows=True, mac=True):
+        """Create the `name` table for the font. The `nameStrings` argument must
+        be a dict, mapping nameIDs or descriptive names for the nameIDs to name
+        record values. A value is either a string, or a dict, mapping language codes
+        to strings, to allow localized name table entries.
+
+        By default, both Windows (platformID=3) and Macintosh (platformID=1) name
+        records are added, unless any of `windows` or `mac` arguments is False.
+
+        The following descriptive names are available for nameIDs:
+
+            copyright (nameID 0)
+            familyName (nameID 1)
+            styleName (nameID 2)
+            uniqueFontIdentifier (nameID 3)
+            fullName (nameID 4)
+            version (nameID 5)
+            psName (nameID 6)
+            trademark (nameID 7)
+            manufacturer (nameID 8)
+            designer (nameID 9)
+            description (nameID 10)
+            vendorURL (nameID 11)
+            designerURL (nameID 12)
+            licenseDescription (nameID 13)
+            licenseInfoURL (nameID 14)
+            typographicFamily (nameID 16)
+            typographicSubfamily (nameID 17)
+            compatibleFullName (nameID 18)
+            sampleText (nameID 19)
+            postScriptCIDFindfontName (nameID 20)
+            wwsFamilyName (nameID 21)
+            wwsSubfamilyName (nameID 22)
+            lightBackgroundPalette (nameID 23)
+            darkBackgroundPalette (nameID 24)
+            variationsPostScriptNamePrefix (nameID 25)
+        """
+        nameTable = self.font["name"] = newTable("name")
+        nameTable.names = []
+
+        for nameName, nameValue in nameStrings.items():
+            if isinstance(nameName, int):
+                nameID = nameName
+            else:
+                nameID = _nameIDs[nameName]
+            if isinstance(nameValue, str):
+                nameValue = dict(en=nameValue)
+            nameTable.addMultilingualName(
+                nameValue, ttFont=self.font, nameID=nameID, windows=windows, mac=mac
+            )
+
+    def setupOS2(self, **values):
+        """Create a new `OS/2` table and initialize it with default values,
+        which can be overridden by keyword arguments.
+        """
+        self._initTableWithValues("OS/2", _OS2Defaults, values)
+        if "xAvgCharWidth" not in values:
+            assert (
+                "hmtx" in self.font
+            ), "the 'hmtx' table must be setup before the 'OS/2' table"
+            self.font["OS/2"].recalcAvgCharWidth(self.font)
+        if not (
+            "ulUnicodeRange1" in values
+            or "ulUnicodeRange2" in values
+            or "ulUnicodeRange3" in values
+            or "ulUnicodeRange3" in values
+        ):
+            assert (
+                "cmap" in self.font
+            ), "the 'cmap' table must be setup before the 'OS/2' table"
+            self.font["OS/2"].recalcUnicodeRanges(self.font)
+
+    def setupCFF(self, psName, fontInfo, charStringsDict, privateDict):
+        from .cffLib import (
+            CFFFontSet,
+            TopDictIndex,
+            TopDict,
+            CharStrings,
+            GlobalSubrsIndex,
+            PrivateDict,
+        )
+
+        assert not self.isTTF
+        self.font.sfntVersion = "OTTO"
+        fontSet = CFFFontSet()
+        fontSet.major = 1
+        fontSet.minor = 0
+        fontSet.otFont = self.font
+        fontSet.fontNames = [psName]
+        fontSet.topDictIndex = TopDictIndex()
+
+        globalSubrs = GlobalSubrsIndex()
+        fontSet.GlobalSubrs = globalSubrs
+        private = PrivateDict()
+        for key, value in privateDict.items():
+            setattr(private, key, value)
+        fdSelect = None
+        fdArray = None
+
+        topDict = TopDict()
+        topDict.charset = self.font.getGlyphOrder()
+        topDict.Private = private
+        topDict.GlobalSubrs = fontSet.GlobalSubrs
+        for key, value in fontInfo.items():
+            setattr(topDict, key, value)
+        if "FontMatrix" not in fontInfo:
+            scale = 1 / self.font["head"].unitsPerEm
+            topDict.FontMatrix = [scale, 0, 0, scale, 0, 0]
+
+        charStrings = CharStrings(
+            None, topDict.charset, globalSubrs, private, fdSelect, fdArray
+        )
+        for glyphName, charString in charStringsDict.items():
+            charString.private = private
+            charString.globalSubrs = globalSubrs
+            charStrings[glyphName] = charString
+        topDict.CharStrings = charStrings
+
+        fontSet.topDictIndex.append(topDict)
+
+        self.font["CFF "] = newTable("CFF ")
+        self.font["CFF "].cff = fontSet
+
+    def setupCFF2(self, charStringsDict, fdArrayList=None, regions=None):
+        from .cffLib import (
+            CFFFontSet,
+            TopDictIndex,
+            TopDict,
+            CharStrings,
+            GlobalSubrsIndex,
+            PrivateDict,
+            FDArrayIndex,
+            FontDict,
+        )
+
+        assert not self.isTTF
+        self.font.sfntVersion = "OTTO"
+        fontSet = CFFFontSet()
+        fontSet.major = 2
+        fontSet.minor = 0
+
+        cff2GetGlyphOrder = self.font.getGlyphOrder
+        fontSet.topDictIndex = TopDictIndex(None, cff2GetGlyphOrder, None)
+
+        globalSubrs = GlobalSubrsIndex()
+        fontSet.GlobalSubrs = globalSubrs
+
+        if fdArrayList is None:
+            fdArrayList = [{}]
+        fdSelect = None
+        fdArray = FDArrayIndex()
+        fdArray.strings = None
+        fdArray.GlobalSubrs = globalSubrs
+        for privateDict in fdArrayList:
+            fontDict = FontDict()
+            fontDict.setCFF2(True)
+            private = PrivateDict()
+            for key, value in privateDict.items():
+                setattr(private, key, value)
+            fontDict.Private = private
+            fdArray.append(fontDict)
+
+        topDict = TopDict()
+        topDict.cff2GetGlyphOrder = cff2GetGlyphOrder
+        topDict.FDArray = fdArray
+        scale = 1 / self.font["head"].unitsPerEm
+        topDict.FontMatrix = [scale, 0, 0, scale, 0, 0]
+
+        private = fdArray[0].Private
+        charStrings = CharStrings(None, None, globalSubrs, private, fdSelect, fdArray)
+        for glyphName, charString in charStringsDict.items():
+            charString.private = private
+            charString.globalSubrs = globalSubrs
+            charStrings[glyphName] = charString
+        topDict.CharStrings = charStrings
+
+        fontSet.topDictIndex.append(topDict)
+
+        self.font["CFF2"] = newTable("CFF2")
+        self.font["CFF2"].cff = fontSet
+
+        if regions:
+            self.setupCFF2Regions(regions)
+
+    def setupCFF2Regions(self, regions):
+        from .varLib.builder import buildVarRegionList, buildVarData, buildVarStore
+        from .cffLib import VarStoreData
+
+        assert "fvar" in self.font, "fvar must to be set up first"
+        assert "CFF2" in self.font, "CFF2 must to be set up first"
+        axisTags = [a.axisTag for a in self.font["fvar"].axes]
+        varRegionList = buildVarRegionList(regions, axisTags)
+        varData = buildVarData(list(range(len(regions))), None, optimize=False)
+        varStore = buildVarStore(varRegionList, [varData])
+        vstore = VarStoreData(otVarStore=varStore)
+        topDict = self.font["CFF2"].cff.topDictIndex[0]
+        topDict.VarStore = vstore
+        for fontDict in topDict.FDArray:
+            fontDict.Private.vstore = vstore
+
+    def setupGlyf(self, glyphs, calcGlyphBounds=True):
+        """Create the `glyf` table from a dict, that maps glyph names
+        to `fontTools.ttLib.tables._g_l_y_f.Glyph` objects, for example
+        as made by `fontTools.pens.ttGlyphPen.TTGlyphPen`.
+
+        If `calcGlyphBounds` is True, the bounds of all glyphs will be
+        calculated. Only pass False if your glyph objects already have
+        their bounding box values set.
+        """
+        assert self.isTTF
+        self.font["loca"] = newTable("loca")
+        self.font["glyf"] = newTable("glyf")
+        self.font["glyf"].glyphs = glyphs
+        if hasattr(self.font, "glyphOrder"):
+            self.font["glyf"].glyphOrder = self.font.glyphOrder
+        if calcGlyphBounds:
+            self.calcGlyphBounds()
+
+    def setupFvar(self, axes, instances):
+        """Adds an font variations table to the font.
+
+        Args:
+            axes (list): See below.
+            instances (list): See below.
+
+        ``axes`` should be a list of axes, with each axis either supplied as
+        a py:class:`.designspaceLib.AxisDescriptor` object, or a tuple in the
+        format ```tupletag, minValue, defaultValue, maxValue, name``.
+        The ``name`` is either a string, or a dict, mapping language codes
+        to strings, to allow localized name table entries.
+
+        ```instances`` should be a list of instances, with each instance either
+        supplied as a py:class:`.designspaceLib.InstanceDescriptor` object, or a
+        dict with keys ``location`` (mapping of axis tags to float values),
+        ``stylename`` and (optionally) ``postscriptfontname``.
+        The ``stylename`` is either a string, or a dict, mapping language codes
+        to strings, to allow localized name table entries.
+        """
+
+        addFvar(self.font, axes, instances)
+
+    def setupAvar(self, axes):
+        """Adds an axis variations table to the font.
+
+        Args:
+            axes (list): A list of py:class:`.designspaceLib.AxisDescriptor` objects.
+        """
+        from .varLib import _add_avar
+
+        _add_avar(self.font, OrderedDict(enumerate(axes)))  # Only values are used
+
+    def setupGvar(self, variations):
+        gvar = self.font["gvar"] = newTable("gvar")
+        gvar.version = 1
+        gvar.reserved = 0
+        gvar.variations = variations
+
+    def calcGlyphBounds(self):
+        """Calculate the bounding boxes of all glyphs in the `glyf` table.
+        This is usually not called explicitly by client code.
+        """
+        glyphTable = self.font["glyf"]
+        for glyph in glyphTable.glyphs.values():
+            glyph.recalcBounds(glyphTable)
+
+    def setupHorizontalMetrics(self, metrics):
+        """Create a new `hmtx` table, for horizontal metrics.
+
+        The `metrics` argument must be a dict, mapping glyph names to
+        `(width, leftSidebearing)` tuples.
+        """
+        self.setupMetrics("hmtx", metrics)
+
+    def setupVerticalMetrics(self, metrics):
+        """Create a new `vmtx` table, for horizontal metrics.
+
+        The `metrics` argument must be a dict, mapping glyph names to
+        `(height, topSidebearing)` tuples.
+        """
+        self.setupMetrics("vmtx", metrics)
+
+    def setupMetrics(self, tableTag, metrics):
+        """See `setupHorizontalMetrics()` and `setupVerticalMetrics()`."""
+        assert tableTag in ("hmtx", "vmtx")
+        mtxTable = self.font[tableTag] = newTable(tableTag)
+        roundedMetrics = {}
+        for gn in metrics:
+            w, lsb = metrics[gn]
+            roundedMetrics[gn] = int(round(w)), int(round(lsb))
+        mtxTable.metrics = roundedMetrics
+
+    def setupHorizontalHeader(self, **values):
+        """Create a new `hhea` table initialize it with default values,
+        which can be overridden by keyword arguments.
+        """
+        self._initTableWithValues("hhea", _hheaDefaults, values)
+
+    def setupVerticalHeader(self, **values):
+        """Create a new `vhea` table initialize it with default values,
+        which can be overridden by keyword arguments.
+        """
+        self._initTableWithValues("vhea", _vheaDefaults, values)
+
+    def setupVerticalOrigins(self, verticalOrigins, defaultVerticalOrigin=None):
+        """Create a new `VORG` table. The `verticalOrigins` argument must be
+        a dict, mapping glyph names to vertical origin values.
+
+        The `defaultVerticalOrigin` argument should be the most common vertical
+        origin value. If omitted, this value will be derived from the actual
+        values in the `verticalOrigins` argument.
+        """
+        if defaultVerticalOrigin is None:
+            # find the most frequent vorg value
+            bag = {}
+            for gn in verticalOrigins:
+                vorg = verticalOrigins[gn]
+                if vorg not in bag:
+                    bag[vorg] = 1
+                else:
+                    bag[vorg] += 1
+            defaultVerticalOrigin = sorted(
+                bag, key=lambda vorg: bag[vorg], reverse=True
+            )[0]
+        self._initTableWithValues(
+            "VORG",
+            {},
+            dict(VOriginRecords={}, defaultVertOriginY=defaultVerticalOrigin),
+        )
+        vorgTable = self.font["VORG"]
+        vorgTable.majorVersion = 1
+        vorgTable.minorVersion = 0
+        for gn in verticalOrigins:
+            vorgTable[gn] = verticalOrigins[gn]
+
+    def setupPost(self, keepGlyphNames=True, **values):
+        """Create a new `post` table and initialize it with default values,
+        which can be overridden by keyword arguments.
+        """
+        isCFF2 = "CFF2" in self.font
+        postTable = self._initTableWithValues("post", _postDefaults, values)
+        if (self.isTTF or isCFF2) and keepGlyphNames:
+            postTable.formatType = 2.0
+            postTable.extraNames = []
+            postTable.mapping = {}
+        else:
+            postTable.formatType = 3.0
+
+    def setupMaxp(self):
+        """Create a new `maxp` table. This is called implicitly by FontBuilder
+        itself and is usually not called by client code.
+        """
+        if self.isTTF:
+            defaults = _maxpDefaultsTTF
+        else:
+            defaults = _maxpDefaultsOTF
+        self._initTableWithValues("maxp", defaults, {})
+
+    def setupDummyDSIG(self):
+        """This adds an empty DSIG table to the font to make some MS applications
+        happy. This does not properly sign the font.
+        """
+        values = dict(
+            ulVersion=1,
+            usFlag=0,
+            usNumSigs=0,
+            signatureRecords=[],
+        )
+        self._initTableWithValues("DSIG", {}, values)
+
+    def addOpenTypeFeatures(self, features, filename=None, tables=None):
+        """Add OpenType features to the font from a string containing
+        Feature File syntax.
+
+        The `filename` argument is used in error messages and to determine
+        where to look for "include" files.
+
+        The optional `tables` argument can be a list of OTL tables tags to
+        build, allowing the caller to only build selected OTL tables. See
+        `fontTools.feaLib` for details.
+        """
+        from .feaLib.builder import addOpenTypeFeaturesFromString
+
+        addOpenTypeFeaturesFromString(
+            self.font, features, filename=filename, tables=tables
+        )
+
+    def addFeatureVariations(self, conditionalSubstitutions, featureTag="rvrn"):
+        """Add conditional substitutions to a Variable Font.
+
+        See `fontTools.varLib.featureVars.addFeatureVariations`.
+        """
+        from .varLib import featureVars
+
+        if "fvar" not in self.font:
+            raise KeyError("'fvar' table is missing; can't add FeatureVariations.")
+
+        featureVars.addFeatureVariations(
+            self.font, conditionalSubstitutions, featureTag=featureTag
+        )
+
+    def setupCOLR(
+        self,
+        colorLayers,
+        version=None,
+        varStore=None,
+        varIndexMap=None,
+        clipBoxes=None,
+        allowLayerReuse=True,
+    ):
+        """Build new COLR table using color layers dictionary.
+
+        Cf. `fontTools.colorLib.builder.buildCOLR`.
+        """
+        from fontTools.colorLib.builder import buildCOLR
+
+        glyphMap = self.font.getReverseGlyphMap()
+        self.font["COLR"] = buildCOLR(
+            colorLayers,
+            version=version,
+            glyphMap=glyphMap,
+            varStore=varStore,
+            varIndexMap=varIndexMap,
+            clipBoxes=clipBoxes,
+            allowLayerReuse=allowLayerReuse,
+        )
+
+    def setupCPAL(
+        self,
+        palettes,
+        paletteTypes=None,
+        paletteLabels=None,
+        paletteEntryLabels=None,
+    ):
+        """Build new CPAL table using list of palettes.
+
+        Optionally build CPAL v1 table using paletteTypes, paletteLabels and
+        paletteEntryLabels.
+
+        Cf. `fontTools.colorLib.builder.buildCPAL`.
+        """
+        from fontTools.colorLib.builder import buildCPAL
+
+        self.font["CPAL"] = buildCPAL(
+            palettes,
+            paletteTypes=paletteTypes,
+            paletteLabels=paletteLabels,
+            paletteEntryLabels=paletteEntryLabels,
+            nameTable=self.font.get("name"),
+        )
+
+    def setupStat(self, axes, locations=None, elidedFallbackName=2):
+        """Build a new 'STAT' table.
+
+        See `fontTools.otlLib.builder.buildStatTable` for details about
+        the arguments.
+        """
+        from .otlLib.builder import buildStatTable
+
+        buildStatTable(self.font, axes, locations, elidedFallbackName)
+
+
+def buildCmapSubTable(cmapping, format, platformID, platEncID):
+    subTable = cmap_classes[format](format)
+    subTable.cmap = cmapping
+    subTable.platformID = platformID
+    subTable.platEncID = platEncID
+    subTable.language = 0
+    return subTable
+
+
+def addFvar(font, axes, instances):
+    from .ttLib.tables._f_v_a_r import Axis, NamedInstance
+
+    assert axes
+
+    fvar = newTable("fvar")
+    nameTable = font["name"]
+
+    for axis_def in axes:
+        axis = Axis()
+
+        if isinstance(axis_def, tuple):
+            (
+                axis.axisTag,
+                axis.minValue,
+                axis.defaultValue,
+                axis.maxValue,
+                name,
+            ) = axis_def
+        else:
+            (axis.axisTag, axis.minValue, axis.defaultValue, axis.maxValue, name) = (
+                axis_def.tag,
+                axis_def.minimum,
+                axis_def.default,
+                axis_def.maximum,
+                axis_def.name,
+            )
+
+        if isinstance(name, str):
+            name = dict(en=name)
+
+        axis.axisNameID = nameTable.addMultilingualName(name, ttFont=font)
+        fvar.axes.append(axis)
+
+    for instance in instances:
+        if isinstance(instance, dict):
+            coordinates = instance["location"]
+            name = instance["stylename"]
+            psname = instance.get("postscriptfontname")
+        else:
+            coordinates = instance.location
+            name = instance.localisedStyleName or instance.styleName
+            psname = instance.postScriptFontName
+
+        if isinstance(name, str):
+            name = dict(en=name)
+
+        inst = NamedInstance()
+        inst.subfamilyNameID = nameTable.addMultilingualName(name, ttFont=font)
+        if psname is not None:
+            inst.postscriptNameID = nameTable.addName(psname)
+        inst.coordinates = coordinates
+        fvar.instances.append(inst)
+
+    font["fvar"] = fvar

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/fontTools/help.py

@@ -0,0 +1,35 @@
+import pkgutil
+import sys
+import fontTools
+import importlib
+import os
+from pathlib import Path
+
+
+def main():
+    """Show this help"""
+    path = fontTools.__path__
+    descriptions = {}
+    for pkg in sorted(
+        mod.name
+        for mod in pkgutil.walk_packages([fontTools.__path__[0]], prefix="fontTools.")
+    ):
+        try:
+            imports = __import__(pkg, globals(), locals(), ["main"])
+        except ImportError as e:
+            continue
+        try:
+            description = imports.main.__doc__
+            if description:
+                pkg = pkg.replace("fontTools.", "").replace(".__main__", "")
+                # show the docstring's first line only
+                descriptions[pkg] = description.splitlines()[0]
+        except AttributeError as e:
+            pass
+    for pkg, description in descriptions.items():
+        print("fonttools %-12s %s" % (pkg, description), file=sys.stderr)
+
+
+if __name__ == "__main__":
+    print("fonttools v%s\n" % fontTools.__version__, file=sys.stderr)
+    main()

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/fontTools/tfmLib.py

@@ -0,0 +1,460 @@
+"""Module for reading TFM (TeX Font Metrics) files.
+
+The TFM format is described in the TFtoPL WEB source code, whose typeset form
+can be found on `CTAN <http://mirrors.ctan.org/info/knuth-pdf/texware/tftopl.pdf>`_.
+
+	>>> from fontTools.tfmLib import TFM
+	>>> tfm = TFM("Tests/tfmLib/data/cmr10.tfm")
+	>>>
+	>>> # Accessing an attribute gets you metadata.
+	>>> tfm.checksum
+	1274110073
+	>>> tfm.designsize
+	10.0
+	>>> tfm.codingscheme
+	'TeX text'
+	>>> tfm.family
+	'CMR'
+	>>> tfm.seven_bit_safe_flag
+	False
+	>>> tfm.face
+	234
+	>>> tfm.extraheader
+	{}
+	>>> tfm.fontdimens
+	{'SLANT': 0.0, 'SPACE': 0.33333396911621094, 'STRETCH': 0.16666698455810547, 'SHRINK': 0.11111164093017578, 'XHEIGHT': 0.4305553436279297, 'QUAD': 1.0000028610229492, 'EXTRASPACE': 0.11111164093017578}
+	>>> # Accessing a character gets you its metrics.
+	>>> # “width” is always available, other metrics are available only when
+	>>> # applicable. All values are relative to “designsize”.
+	>>> tfm.chars[ord("g")]
+	{'width': 0.5000019073486328, 'height': 0.4305553436279297, 'depth': 0.1944446563720703, 'italic': 0.013888359069824219}
+	>>> # Kerning and ligature can be accessed as well.
+	>>> tfm.kerning[ord("c")]
+	{104: -0.02777862548828125, 107: -0.02777862548828125}
+	>>> tfm.ligatures[ord("f")]
+	{105: ('LIG', 12), 102: ('LIG', 11), 108: ('LIG', 13)}
+"""
+
+from types import SimpleNamespace
+
+from fontTools.misc.sstruct import calcsize, unpack, unpack2
+
+SIZES_FORMAT = """
+    >
+    lf: h    # length of the entire file, in words
+    lh: h    # length of the header data, in words
+    bc: h    # smallest character code in the font
+    ec: h    # largest character code in the font
+    nw: h    # number of words in the width table
+    nh: h    # number of words in the height table
+    nd: h    # number of words in the depth table
+    ni: h    # number of words in the italic correction table
+    nl: h    # number of words in the ligature/kern table
+    nk: h    # number of words in the kern table
+    ne: h    # number of words in the extensible character table
+    np: h    # number of font parameter words
+"""
+
+SIZES_SIZE = calcsize(SIZES_FORMAT)
+
+FIXED_FORMAT = "12.20F"
+
+HEADER_FORMAT1 = f"""
+    >
+    checksum:            L
+    designsize:          {FIXED_FORMAT}
+"""
+
+HEADER_FORMAT2 = f"""
+    {HEADER_FORMAT1}
+    codingscheme:        40p
+"""
+
+HEADER_FORMAT3 = f"""
+    {HEADER_FORMAT2}
+    family:              20p
+"""
+
+HEADER_FORMAT4 = f"""
+    {HEADER_FORMAT3}
+    seven_bit_safe_flag: ?
+    ignored:             x
+    ignored:             x
+    face:                B
+"""
+
+HEADER_SIZE1 = calcsize(HEADER_FORMAT1)
+HEADER_SIZE2 = calcsize(HEADER_FORMAT2)
+HEADER_SIZE3 = calcsize(HEADER_FORMAT3)
+HEADER_SIZE4 = calcsize(HEADER_FORMAT4)
+
+LIG_KERN_COMMAND = """
+    >
+    skip_byte: B
+    next_char: B
+    op_byte: B
+    remainder: B
+"""
+
+BASE_PARAMS = [
+    "SLANT",
+    "SPACE",
+    "STRETCH",
+    "SHRINK",
+    "XHEIGHT",
+    "QUAD",
+    "EXTRASPACE",
+]
+
+MATHSY_PARAMS = [
+    "NUM1",
+    "NUM2",
+    "NUM3",
+    "DENOM1",
+    "DENOM2",
+    "SUP1",
+    "SUP2",
+    "SUP3",
+    "SUB1",
+    "SUB2",
+    "SUPDROP",
+    "SUBDROP",
+    "DELIM1",
+    "DELIM2",
+    "AXISHEIGHT",
+]
+
+MATHEX_PARAMS = [
+    "DEFAULTRULETHICKNESS",
+    "BIGOPSPACING1",
+    "BIGOPSPACING2",
+    "BIGOPSPACING3",
+    "BIGOPSPACING4",
+    "BIGOPSPACING5",
+]
+
+VANILLA = 0
+MATHSY = 1
+MATHEX = 2
+
+UNREACHABLE = 0
+PASSTHROUGH = 1
+ACCESSABLE = 2
+
+NO_TAG = 0
+LIG_TAG = 1
+LIST_TAG = 2
+EXT_TAG = 3
+
+STOP_FLAG = 128
+KERN_FLAG = 128
+
+
+class TFMException(Exception):
+    def __init__(self, message):
+        super().__init__(message)
+
+
+class TFM:
+    def __init__(self, file):
+        self._read(file)
+
+    def __repr__(self):
+        return (
+            f"<TFM"
+            f" for {self.family}"
+            f" in {self.codingscheme}"
+            f" at {self.designsize:g}pt>"
+        )
+
+    def _read(self, file):
+        if hasattr(file, "read"):
+            data = file.read()
+        else:
+            with open(file, "rb") as fp:
+                data = fp.read()
+
+        self._data = data
+
+        if len(data) < SIZES_SIZE:
+            raise TFMException("Too short input file")
+
+        sizes = SimpleNamespace()
+        unpack2(SIZES_FORMAT, data, sizes)
+
+        # Do some file structure sanity checks.
+        # TeX and TFtoPL do additional functional checks and might even correct
+        # “errors” in the input file, but we instead try to output the file as
+        # it is as long as it is parsable, even if the data make no sense.
+
+        if sizes.lf < 0:
+            raise TFMException("The file claims to have negative or zero length!")
+
+        if len(data) < sizes.lf * 4:
+            raise TFMException("The file has fewer bytes than it claims!")
+
+        for name, length in vars(sizes).items():
+            if length < 0:
+                raise TFMException("The subfile size: '{name}' is negative!")
+
+        if sizes.lh < 2:
+            raise TFMException(f"The header length is only {sizes.lh}!")
+
+        if sizes.bc > sizes.ec + 1 or sizes.ec > 255:
+            raise TFMException(
+                f"The character code range {sizes.bc}..{sizes.ec} is illegal!"
+            )
+
+        if sizes.nw == 0 or sizes.nh == 0 or sizes.nd == 0 or sizes.ni == 0:
+            raise TFMException("Incomplete subfiles for character dimensions!")
+
+        if sizes.ne > 256:
+            raise TFMException(f"There are {ne} extensible recipes!")
+
+        if sizes.lf != (
+            6
+            + sizes.lh
+            + (sizes.ec - sizes.bc + 1)
+            + sizes.nw
+            + sizes.nh
+            + sizes.nd
+            + sizes.ni
+            + sizes.nl
+            + sizes.nk
+            + sizes.ne
+            + sizes.np
+        ):
+            raise TFMException("Subfile sizes don’t add up to the stated total")
+
+        # Subfile offsets, used in the helper function below. These all are
+        # 32-bit word offsets not 8-bit byte offsets.
+        char_base = 6 + sizes.lh - sizes.bc
+        width_base = char_base + sizes.ec + 1
+        height_base = width_base + sizes.nw
+        depth_base = height_base + sizes.nh
+        italic_base = depth_base + sizes.nd
+        lig_kern_base = italic_base + sizes.ni
+        kern_base = lig_kern_base + sizes.nl
+        exten_base = kern_base + sizes.nk
+        param_base = exten_base + sizes.ne
+
+        # Helper functions for accessing individual data. If this looks
+        # nonidiomatic Python, I blame the effect of reading the literate WEB
+        # documentation of TFtoPL.
+        def char_info(c):
+            return 4 * (char_base + c)
+
+        def width_index(c):
+            return data[char_info(c)]
+
+        def noneexistent(c):
+            return c < sizes.bc or c > sizes.ec or width_index(c) == 0
+
+        def height_index(c):
+            return data[char_info(c) + 1] // 16
+
+        def depth_index(c):
+            return data[char_info(c) + 1] % 16
+
+        def italic_index(c):
+            return data[char_info(c) + 2] // 4
+
+        def tag(c):
+            return data[char_info(c) + 2] % 4
+
+        def remainder(c):
+            return data[char_info(c) + 3]
+
+        def width(c):
+            r = 4 * (width_base + width_index(c))
+            return read_fixed(r, "v")["v"]
+
+        def height(c):
+            r = 4 * (height_base + height_index(c))
+            return read_fixed(r, "v")["v"]
+
+        def depth(c):
+            r = 4 * (depth_base + depth_index(c))
+            return read_fixed(r, "v")["v"]
+
+        def italic(c):
+            r = 4 * (italic_base + italic_index(c))
+            return read_fixed(r, "v")["v"]
+
+        def exten(c):
+            return 4 * (exten_base + remainder(c))
+
+        def lig_step(i):
+            return 4 * (lig_kern_base + i)
+
+        def lig_kern_command(i):
+            command = SimpleNamespace()
+            unpack2(LIG_KERN_COMMAND, data[i:], command)
+            return command
+
+        def kern(i):
+            r = 4 * (kern_base + i)
+            return read_fixed(r, "v")["v"]
+
+        def param(i):
+            return 4 * (param_base + i)
+
+        def read_fixed(index, key, obj=None):
+            ret = unpack2(f">;{key}:{FIXED_FORMAT}", data[index:], obj)
+            return ret[0]
+
+        # Set all attributes to empty values regardless of the header size.
+        unpack(HEADER_FORMAT4, [0] * HEADER_SIZE4, self)
+
+        offset = 24
+        length = sizes.lh * 4
+        self.extraheader = {}
+        if length >= HEADER_SIZE4:
+            rest = unpack2(HEADER_FORMAT4, data[offset:], self)[1]
+            if self.face < 18:
+                s = self.face % 2
+                b = self.face // 2
+                self.face = "MBL"[b % 3] + "RI"[s] + "RCE"[b // 3]
+            for i in range(sizes.lh - HEADER_SIZE4 // 4):
+                rest = unpack2(f">;HEADER{i + 18}:l", rest, self.extraheader)[1]
+        elif length >= HEADER_SIZE3:
+            unpack2(HEADER_FORMAT3, data[offset:], self)
+        elif length >= HEADER_SIZE2:
+            unpack2(HEADER_FORMAT2, data[offset:], self)
+        elif length >= HEADER_SIZE1:
+            unpack2(HEADER_FORMAT1, data[offset:], self)
+
+        self.fonttype = VANILLA
+        scheme = self.codingscheme.upper()
+        if scheme.startswith("TEX MATH SY"):
+            self.fonttype = MATHSY
+        elif scheme.startswith("TEX MATH EX"):
+            self.fonttype = MATHEX
+
+        self.fontdimens = {}
+        for i in range(sizes.np):
+            name = f"PARAMETER{i+1}"
+            if i <= 6:
+                name = BASE_PARAMS[i]
+            elif self.fonttype == MATHSY and i <= 21:
+                name = MATHSY_PARAMS[i - 7]
+            elif self.fonttype == MATHEX and i <= 12:
+                name = MATHEX_PARAMS[i - 7]
+            read_fixed(param(i), name, self.fontdimens)
+
+        lig_kern_map = {}
+        self.right_boundary_char = None
+        self.left_boundary_char = None
+        if sizes.nl > 0:
+            cmd = lig_kern_command(lig_step(0))
+            if cmd.skip_byte == 255:
+                self.right_boundary_char = cmd.next_char
+
+            cmd = lig_kern_command(lig_step((sizes.nl - 1)))
+            if cmd.skip_byte == 255:
+                self.left_boundary_char = 256
+                r = 256 * cmd.op_byte + cmd.remainder
+                lig_kern_map[self.left_boundary_char] = r
+
+        self.chars = {}
+        for c in range(sizes.bc, sizes.ec + 1):
+            if width_index(c) > 0:
+                self.chars[c] = info = {}
+                info["width"] = width(c)
+                if height_index(c) > 0:
+                    info["height"] = height(c)
+                if depth_index(c) > 0:
+                    info["depth"] = depth(c)
+                if italic_index(c) > 0:
+                    info["italic"] = italic(c)
+                char_tag = tag(c)
+                if char_tag == NO_TAG:
+                    pass
+                elif char_tag == LIG_TAG:
+                    lig_kern_map[c] = remainder(c)
+                elif char_tag == LIST_TAG:
+                    info["nextlarger"] = remainder(c)
+                elif char_tag == EXT_TAG:
+                    info["varchar"] = varchar = {}
+                    for i in range(4):
+                        part = data[exten(c) + i]
+                        if i == 3 or part > 0:
+                            name = "rep"
+                            if i == 0:
+                                name = "top"
+                            elif i == 1:
+                                name = "mid"
+                            elif i == 2:
+                                name = "bot"
+                            if noneexistent(part):
+                                varchar[name] = c
+                            else:
+                                varchar[name] = part
+
+        self.ligatures = {}
+        self.kerning = {}
+        for c, i in sorted(lig_kern_map.items()):
+            cmd = lig_kern_command(lig_step(i))
+            if cmd.skip_byte > STOP_FLAG:
+                i = 256 * cmd.op_byte + cmd.remainder
+
+            while i < sizes.nl:
+                cmd = lig_kern_command(lig_step(i))
+                if cmd.skip_byte > STOP_FLAG:
+                    pass
+                else:
+                    if cmd.op_byte >= KERN_FLAG:
+                        r = 256 * (cmd.op_byte - KERN_FLAG) + cmd.remainder
+                        self.kerning.setdefault(c, {})[cmd.next_char] = kern(r)
+                    else:
+                        r = cmd.op_byte
+                        if r == 4 or (r > 7 and r != 11):
+                            # Ligature step with nonstandard code, we output
+                            # the code verbatim.
+                            lig = r
+                        else:
+                            lig = ""
+                            if r % 4 > 1:
+                                lig += "/"
+                            lig += "LIG"
+                            if r % 2 != 0:
+                                lig += "/"
+                            while r > 3:
+                                lig += ">"
+                                r -= 4
+                        self.ligatures.setdefault(c, {})[cmd.next_char] = (
+                            lig,
+                            cmd.remainder,
+                        )
+
+                if cmd.skip_byte >= STOP_FLAG:
+                    break
+                i += cmd.skip_byte + 1
+
+
+if __name__ == "__main__":
+    import sys
+
+    tfm = TFM(sys.argv[1])
+    print(
+        "\n".join(
+            x
+            for x in [
+                f"tfm.checksum={tfm.checksum}",
+                f"tfm.designsize={tfm.designsize}",
+                f"tfm.codingscheme={tfm.codingscheme}",
+                f"tfm.fonttype={tfm.fonttype}",
+                f"tfm.family={tfm.family}",
+                f"tfm.seven_bit_safe_flag={tfm.seven_bit_safe_flag}",
+                f"tfm.face={tfm.face}",
+                f"tfm.extraheader={tfm.extraheader}",
+                f"tfm.fontdimens={tfm.fontdimens}",
+                f"tfm.right_boundary_char={tfm.right_boundary_char}",
+                f"tfm.left_boundary_char={tfm.left_boundary_char}",
+                f"tfm.kerning={tfm.kerning}",
+                f"tfm.ligatures={tfm.ligatures}",
+                f"tfm.chars={tfm.chars}",
+            ]
+        )
+    )
+    print(tfm)

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/fontTools/ttx.py

@@ -0,0 +1,420 @@
+"""\
+usage: ttx [options] inputfile1 [... inputfileN]
+
+TTX -- From OpenType To XML And Back
+
+If an input file is a TrueType or OpenType font file, it will be
+decompiled to a TTX file (an XML-based text format).
+If an input file is a TTX file, it will be compiled to whatever 
+format the data is in, a TrueType or OpenType/CFF font file.
+
+Output files are created so they are unique: an existing file is
+never overwritten.
+
+General options
+===============
+
+-h Help            print this message.
+--version          show version and exit.
+-d <outputfolder>  Specify a directory where the output files are
+                   to be created.
+-o <outputfile>    Specify a file to write the output to. A special
+                   value of - would use the standard output.
+-f                 Overwrite existing output file(s), ie. don't append
+                   numbers.
+-v                 Verbose: more messages will be written to stdout
+                   about what is being done.
+-q                 Quiet: No messages will be written to stdout about
+                   what is being done.
+-a                 allow virtual glyphs ID's on compile or decompile.
+
+Dump options
+============
+
+-l           List table info: instead of dumping to a TTX file, list
+             some minimal info about each table.
+-t <table>   Specify a table to dump. Multiple -t options
+             are allowed. When no -t option is specified, all tables
+             will be dumped.
+-x <table>   Specify a table to exclude from the dump. Multiple
+             -x options are allowed. -t and -x are mutually exclusive.
+-s           Split tables: save the TTX data into separate TTX files per
+             table and write one small TTX file that contains references
+             to the individual table dumps. This file can be used as
+             input to ttx, as long as the table files are in the
+             same directory.
+-g           Split glyf table: Save the glyf data into separate TTX files
+             per glyph and write a small TTX for the glyf table which
+             contains references to the individual TTGlyph elements.
+             NOTE: specifying -g implies -s (no need for -s together
+             with -g)
+-i           Do NOT disassemble TT instructions: when this option is
+             given, all TrueType programs (glyph programs, the font
+             program and the pre-program) will be written to the TTX
+             file as hex data instead of assembly. This saves some time
+             and makes the TTX file smaller.
+-z <format>  Specify a bitmap data export option for EBDT:
+             {'raw', 'row', 'bitwise', 'extfile'} or for the CBDT:
+             {'raw', 'extfile'} Each option does one of the following:
+
+             -z raw
+               export the bitmap data as a hex dump
+             -z row
+               export each row as hex data
+             -z bitwise
+               export each row as binary in an ASCII art style
+             -z extfile
+               export the data as external files with XML references
+
+             If no export format is specified 'raw' format is used.
+-e           Don't ignore decompilation errors, but show a full traceback
+             and abort.
+-y <number>  Select font number for TrueType Collection (.ttc/.otc),
+             starting from 0.
+--unicodedata <UnicodeData.txt>
+             Use custom database file to write character names in the
+             comments of the cmap TTX output.
+--newline <value>
+             Control how line endings are written in the XML file. It
+             can be 'LF', 'CR', or 'CRLF'. If not specified, the
+             default platform-specific line endings are used.
+
+Compile options
+===============
+
+-m           Merge with TrueType-input-file: specify a TrueType or
+             OpenType font file to be merged with the TTX file. This
+             option is only valid when at most one TTX file is specified.
+-b           Don't recalc glyph bounding boxes: use the values in the
+             TTX file as-is.
+--recalc-timestamp
+             Set font 'modified' timestamp to current time.
+             By default, the modification time of the TTX file will be
+             used.
+--no-recalc-timestamp
+             Keep the original font 'modified' timestamp.
+--flavor <type>
+             Specify flavor of output font file. May be 'woff' or 'woff2'.
+             Note that WOFF2 requires the Brotli Python extension,
+             available at https://github.com/google/brotli
+--with-zopfli
+             Use Zopfli instead of Zlib to compress WOFF. The Python
+             extension is available at https://pypi.python.org/pypi/zopfli
+"""
+
+
+from fontTools.ttLib import TTFont, TTLibError
+from fontTools.misc.macCreatorType import getMacCreatorAndType
+from fontTools.unicode import setUnicodeData
+from fontTools.misc.textTools import Tag, tostr
+from fontTools.misc.timeTools import timestampSinceEpoch
+from fontTools.misc.loggingTools import Timer
+from fontTools.misc.cliTools import makeOutputFileName
+import os
+import sys
+import getopt
+import re
+import logging
+
+
+log = logging.getLogger("fontTools.ttx")
+
+opentypeheaderRE = re.compile('''sfntVersion=['"]OTTO["']''')
+
+
+class Options(object):
+
+	listTables = False
+	outputDir = None
+	outputFile = None
+	overWrite = False
+	verbose = False
+	quiet = False
+	splitTables = False
+	splitGlyphs = False
+	disassembleInstructions = True
+	mergeFile = None
+	recalcBBoxes = True
+	ignoreDecompileErrors = True
+	bitmapGlyphDataFormat = 'raw'
+	unicodedata = None
+	newlinestr = "\n"
+	recalcTimestamp = None
+	flavor = None
+	useZopfli = False
+
+	def __init__(self, rawOptions, numFiles):
+		self.onlyTables = []
+		self.skipTables = []
+		self.fontNumber = -1
+		for option, value in rawOptions:
+			# general options
+			if option == "-h":
+				print(__doc__)
+				sys.exit(0)
+			elif option == "--version":
+				from fontTools import version
+				print(version)
+				sys.exit(0)
+			elif option == "-d":
+				if not os.path.isdir(value):
+					raise getopt.GetoptError("The -d option value must be an existing directory")
+				self.outputDir = value
+			elif option == "-o":
+				self.outputFile = value
+			elif option == "-f":
+				self.overWrite = True
+			elif option == "-v":
+				self.verbose = True
+			elif option == "-q":
+				self.quiet = True
+			# dump options
+			elif option == "-l":
+				self.listTables = True
+			elif option == "-t":
+				# pad with space if table tag length is less than 4
+				value = value.ljust(4)
+				self.onlyTables.append(value)
+			elif option == "-x":
+				# pad with space if table tag length is less than 4
+				value = value.ljust(4)
+				self.skipTables.append(value)
+			elif option == "-s":
+				self.splitTables = True
+			elif option == "-g":
+				# -g implies (and forces) splitTables
+				self.splitGlyphs = True
+				self.splitTables = True
+			elif option == "-i":
+				self.disassembleInstructions = False
+			elif option == "-z":
+				validOptions = ('raw', 'row', 'bitwise', 'extfile')
+				if value not in validOptions:
+					raise getopt.GetoptError(
+						"-z does not allow %s as a format. Use %s" % (option, validOptions))
+				self.bitmapGlyphDataFormat = value
+			elif option == "-y":
+				self.fontNumber = int(value)
+			# compile options
+			elif option == "-m":
+				self.mergeFile = value
+			elif option == "-b":
+				self.recalcBBoxes = False
+			elif option == "-e":
+				self.ignoreDecompileErrors = False
+			elif option == "--unicodedata":
+				self.unicodedata = value
+			elif option == "--newline":
+				validOptions = ('LF', 'CR', 'CRLF')
+				if value == "LF":
+					self.newlinestr = "\n"
+				elif value == "CR":
+					self.newlinestr = "\r"
+				elif value == "CRLF":
+					self.newlinestr = "\r\n"
+				else:
+					raise getopt.GetoptError(
+						"Invalid choice for --newline: %r (choose from %s)"
+						% (value, ", ".join(map(repr, validOptions))))
+			elif option == "--recalc-timestamp":
+				self.recalcTimestamp = True
+			elif option == "--no-recalc-timestamp":
+				self.recalcTimestamp = False
+			elif option == "--flavor":
+				self.flavor = value
+			elif option == "--with-zopfli":
+				self.useZopfli = True
+		if self.verbose and self.quiet:
+			raise getopt.GetoptError("-q and -v options are mutually exclusive")
+		if self.verbose:
+			self.logLevel = logging.DEBUG
+		elif self.quiet:
+			self.logLevel = logging.WARNING
+		else:
+			self.logLevel = logging.INFO
+		if self.mergeFile and self.flavor:
+			raise getopt.GetoptError("-m and --flavor options are mutually exclusive")
+		if self.onlyTables and self.skipTables:
+			raise getopt.GetoptError("-t and -x options are mutually exclusive")
+		if self.mergeFile and numFiles > 1:
+			raise getopt.GetoptError("Must specify exactly one TTX source file when using -m")
+		if self.flavor != 'woff' and self.useZopfli:
+			raise getopt.GetoptError("--with-zopfli option requires --flavor 'woff'")
+
+
+def ttList(input, output, options):
+	ttf = TTFont(input, fontNumber=options.fontNumber, lazy=True)
+	reader = ttf.reader
+	tags = sorted(reader.keys())
+	print('Listing table info for "%s":' % input)
+	format = "    %4s  %10s  %8s  %8s"
+	print(format % ("tag ", "  checksum", "  length", "  offset"))
+	print(format % ("----", "----------", "--------", "--------"))
+	for tag in tags:
+		entry = reader.tables[tag]
+		if ttf.flavor == "woff2":
+			# WOFF2 doesn't store table checksums, so they must be calculated
+			from fontTools.ttLib.sfnt import calcChecksum
+			data = entry.loadData(reader.transformBuffer)
+			checkSum = calcChecksum(data)
+		else:
+			checkSum = int(entry.checkSum)
+		if checkSum < 0:
+			checkSum = checkSum + 0x100000000
+		checksum = "0x%08X" % checkSum
+		print(format % (tag, checksum, entry.length, entry.offset))
+	print()
+	ttf.close()
+
+
+@Timer(log, 'Done dumping TTX in %(time).3f seconds')
+def ttDump(input, output, options):
+	log.info('Dumping "%s" to "%s"...', input, output)
+	if options.unicodedata:
+		setUnicodeData(options.unicodedata)
+	ttf = TTFont(input, 0,
+			ignoreDecompileErrors=options.ignoreDecompileErrors,
+			fontNumber=options.fontNumber)
+	ttf.saveXML(output,
+			tables=options.onlyTables,
+			skipTables=options.skipTables,
+			splitTables=options.splitTables,
+			splitGlyphs=options.splitGlyphs,
+			disassembleInstructions=options.disassembleInstructions,
+			bitmapGlyphDataFormat=options.bitmapGlyphDataFormat,
+			newlinestr=options.newlinestr)
+	ttf.close()
+
+
+@Timer(log, 'Done compiling TTX in %(time).3f seconds')
+def ttCompile(input, output, options):
+	log.info('Compiling "%s" to "%s"...' % (input, output))
+	if options.useZopfli:
+		from fontTools.ttLib import sfnt
+		sfnt.USE_ZOPFLI = True
+	ttf = TTFont(options.mergeFile, flavor=options.flavor,
+			recalcBBoxes=options.recalcBBoxes,
+			recalcTimestamp=options.recalcTimestamp)
+	ttf.importXML(input)
+
+	if options.recalcTimestamp is None and 'head' in ttf:
+		# use TTX file modification time for head "modified" timestamp
+		mtime = os.path.getmtime(input)
+		ttf['head'].modified = timestampSinceEpoch(mtime)
+
+	ttf.save(output)
+
+
+def guessFileType(fileName):
+	base, ext = os.path.splitext(fileName)
+	try:
+		with open(fileName, "rb") as f:
+			header = f.read(256)
+	except IOError:
+		return None
+
+	if header.startswith(b'\xef\xbb\xbf<?xml'):
+		header = header.lstrip(b'\xef\xbb\xbf')
+	cr, tp = getMacCreatorAndType(fileName)
+	if tp in ("sfnt", "FFIL"):
+		return "TTF"
+	if ext == ".dfont":
+		return "TTF"
+	head = Tag(header[:4])
+	if head == "OTTO":
+		return "OTF"
+	elif head == "ttcf":
+		return "TTC"
+	elif head in ("\0\1\0\0", "true"):
+		return "TTF"
+	elif head == "wOFF":
+		return "WOFF"
+	elif head == "wOF2":
+		return "WOFF2"
+	elif head == "<?xm":
+		# Use 'latin1' because that can't fail.
+		header = tostr(header, 'latin1')
+		if opentypeheaderRE.search(header):
+			return "OTX"
+		else:
+			return "TTX"
+	return None
+
+
+def parseOptions(args):
+	rawOptions, files = getopt.getopt(args, "ld:o:fvqht:x:sgim:z:baey:",
+			['unicodedata=', "recalc-timestamp", "no-recalc-timestamp",
+			 'flavor=', 'version', 'with-zopfli', 'newline='])
+
+	options = Options(rawOptions, len(files))
+	jobs = []
+
+	if not files:
+		raise getopt.GetoptError('Must specify at least one input file')
+
+	for input in files:
+		if not os.path.isfile(input):
+			raise getopt.GetoptError('File not found: "%s"' % input)
+		tp = guessFileType(input)
+		if tp in ("OTF", "TTF", "TTC", "WOFF", "WOFF2"):
+			extension = ".ttx"
+			if options.listTables:
+				action = ttList
+			else:
+				action = ttDump
+		elif tp == "TTX":
+			extension = "."+options.flavor if options.flavor else ".ttf"
+			action = ttCompile
+		elif tp == "OTX":
+			extension = "."+options.flavor if options.flavor else ".otf"
+			action = ttCompile
+		else:
+			raise getopt.GetoptError('Unknown file type: "%s"' % input)
+
+		if options.outputFile:
+			output = options.outputFile
+		else:
+			output = makeOutputFileName(input, options.outputDir, extension, options.overWrite)
+			# 'touch' output file to avoid race condition in choosing file names
+			if action != ttList:
+				open(output, 'a').close()
+		jobs.append((action, input, output))
+	return jobs, options
+
+
+def process(jobs, options):
+	for action, input, output in jobs:
+		action(input, output, options)
+
+
+def main(args=None):
+	"""Convert OpenType fonts to XML and back"""
+	from fontTools import configLogger
+
+	if args is None:
+		args = sys.argv[1:]
+	try:
+		jobs, options = parseOptions(args)
+	except getopt.GetoptError as e:
+		print("%s\nERROR: %s" % (__doc__, e), file=sys.stderr)
+		sys.exit(2)
+
+	configLogger(level=options.logLevel)
+
+	try:
+		process(jobs, options)
+	except KeyboardInterrupt:
+		log.error("(Cancelled.)")
+		sys.exit(1)
+	except SystemExit:
+		raise
+	except TTLibError as e:
+		log.error(e)
+		sys.exit(1)
+	except:
+		log.exception('Unhandled exception has occurred')
+		sys.exit(1)
+
+
+if __name__ == "__main__":
+	sys.exit(main())

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/fontTools/unicode.py

@@ -0,0 +1,47 @@
+def _makeunicodes(f):
+	lines = iter(f.readlines())
+	unicodes = {}
+	for line in lines:
+		if not line: continue
+		num, name = line.split(';')[:2]
+		if name[0] == '<': continue # "<control>", etc.
+		num = int(num, 16)
+		unicodes[num] = name
+	return unicodes
+
+
+class _UnicodeCustom(object):
+
+	def __init__(self, f):
+		if isinstance(f, str):
+			with open(f) as fd:
+				codes = _makeunicodes(fd)
+		else:
+			codes = _makeunicodes(f)
+		self.codes = codes
+
+	def __getitem__(self, charCode):
+		try:
+			return self.codes[charCode]
+		except KeyError:
+			return "????"
+
+class _UnicodeBuiltin(object):
+
+	def __getitem__(self, charCode):
+		try:
+			# use unicodedata backport to python2, if available:
+			# https://github.com/mikekap/unicodedata2
+			import unicodedata2 as unicodedata
+		except ImportError: 
+			import unicodedata
+		try:
+			return unicodedata.name(chr(charCode))
+		except ValueError:
+			return "????"
+
+Unicode = _UnicodeBuiltin()
+
+def setUnicodeData(f):
+	global Unicode
+	Unicode = _UnicodeCustom(f)

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/fonttools-4.34.4.dist-info/INSTALLER

@@ -0,0 +1 @@
+pip

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/fonttools-4.34.4.dist-info/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2017 Just van Rossum
+
+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.

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/fonttools-4.34.4.dist-info/RECORD

@@ -0,0 +1,567 @@
+../../../bin/fonttools,sha256=ShmZ4DZsdGes7QyEyLH64GYmHgNOv7PMCuC_MwwtFEA,235
+../../../bin/pyftmerge,sha256=AW4xwMzLdJa5evF6YTHhzrtoIqY3-gU4c_Ldgoe18Mg,232
+../../../bin/pyftsubset,sha256=VvaYv1kcrQB0EtI6R5HOTjzQFheyP6shiZvXnhCrgyg,233
+../../../bin/ttx,sha256=YxCkDym_jmrKqG0RL3qiOKULO-S3SgqrSYTt-8fy16k,230
+../../../share/man/man1/ttx.1,sha256=cLbm_pOOj1C76T2QXvDxzwDj9gk-GTd5RztvTMsouFw,5377
+fontTools/__init__.py,sha256=97ZMPvXRXGmoaoDQH6DrLuPO8zvAUNhpPQnCzNOupMg,183
+fontTools/__main__.py,sha256=aq5EcFtSp-O7lKJVlIMkkJWdXNkqeEGD1GDF-AGm5os,844
+fontTools/__pycache__/__init__.cpython-38.pyc,,
+fontTools/__pycache__/__main__.cpython-38.pyc,,
+fontTools/__pycache__/afmLib.cpython-38.pyc,,
+fontTools/__pycache__/agl.cpython-38.pyc,,
+fontTools/__pycache__/fontBuilder.cpython-38.pyc,,
+fontTools/__pycache__/help.cpython-38.pyc,,
+fontTools/__pycache__/tfmLib.cpython-38.pyc,,
+fontTools/__pycache__/ttx.cpython-38.pyc,,
+fontTools/__pycache__/unicode.cpython-38.pyc,,
+fontTools/afmLib.py,sha256=LT4vyL-fRVbvkQNfVuChor1zsdOBnsiBOKcOGlDBdwo,11113
+fontTools/agl.py,sha256=GZ5u9dcqIguFiu37GnP3e7B8kaVnPXvIbQsKMQjK-hE,112524
+fontTools/cffLib/__init__.py,sha256=8PWUhdrK94znYJ8GxBNwHgQc9-C6ZTRBo39iEID3fUo,93329
+fontTools/cffLib/__pycache__/__init__.cpython-38.pyc,,
+fontTools/cffLib/__pycache__/specializer.cpython-38.pyc,,
+fontTools/cffLib/__pycache__/width.cpython-38.pyc,,
+fontTools/cffLib/specializer.py,sha256=6JTEnUyVhCd2ppjpc_bEXDAuYbAMngDPpRSFDdvV_ac,24894
+fontTools/cffLib/width.py,sha256=9jhlgdANloe5ZGxdl214o8edRqftuwX6EORUxIVLFOs,5221
+fontTools/colorLib/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+fontTools/colorLib/__pycache__/__init__.cpython-38.pyc,,
+fontTools/colorLib/__pycache__/builder.cpython-38.pyc,,
+fontTools/colorLib/__pycache__/errors.cpython-38.pyc,,
+fontTools/colorLib/__pycache__/geometry.cpython-38.pyc,,
+fontTools/colorLib/__pycache__/table_builder.cpython-38.pyc,,
+fontTools/colorLib/__pycache__/unbuilder.cpython-38.pyc,,
+fontTools/colorLib/builder.py,sha256=Vm91SZJExSXkHZvQkiwFJ0SEUzySHml8LHwBQoUeBmk,22927
+fontTools/colorLib/errors.py,sha256=9vNjxG-ow7oHmCIsxrIkLylABDbuqeYNqLBfDDqMCYI,42
+fontTools/colorLib/geometry.py,sha256=3ScySrR2YDJa7d5K5_xM5Yt1-3NCV-ry8ikYA5VwVbI,5518
+fontTools/colorLib/table_builder.py,sha256=9N_Cqe0GNWJYoekGbf4n-OrJq4A2pLYbUSa30GFv9sM,7485
+fontTools/colorLib/unbuilder.py,sha256=iW-E5I39WsV82K3NgCO4Cjzwm1WqzGrtypHt8epwbHM,2142
+fontTools/config/__init__.py,sha256=8rEgB2-CYrNyzjzmc59gShbflLLi-5vorTwvHcna4Bw,2104
+fontTools/config/__pycache__/__init__.cpython-38.pyc,,
+fontTools/cu2qu/__init__.py,sha256=Cuc7Uglb0nSgaraTxXY5J8bReznH5wApW0uakN7MycY,618
+fontTools/cu2qu/__main__.py,sha256=IWCEMB0jcIxofHb_8NvVLmNBVRK9ZU8TQhN6TNAGrfE,83
+fontTools/cu2qu/__pycache__/__init__.cpython-38.pyc,,
+fontTools/cu2qu/__pycache__/__main__.cpython-38.pyc,,
+fontTools/cu2qu/__pycache__/cli.cpython-38.pyc,,
+fontTools/cu2qu/__pycache__/cu2qu.cpython-38.pyc,,
+fontTools/cu2qu/__pycache__/errors.cpython-38.pyc,,
+fontTools/cu2qu/__pycache__/ufo.cpython-38.pyc,,
+fontTools/cu2qu/cli.py,sha256=LYHVxrT_xKCubcLOkTRn6G633ItazYIg8dQSQAShi3s,5826
+fontTools/cu2qu/cu2qu.py,sha256=kjAxjsIjyez5RuMW7-dzshjhjbsBkG7wUXZ2U2qMsCc,16886
+fontTools/cu2qu/errors.py,sha256=Hem7LksGDthtzVFnzFehxqVy4xwQlahs546v8H6ddNQ,2440
+fontTools/cu2qu/ufo.py,sha256=1sHPa1bWCHyzauUebg41KAMWieOcin6RjTHEAw58PI8,11267
+fontTools/designspaceLib/__init__.py,sha256=1UsZNGN4H1C7HZwiM9Ft_C-qDhM-mo_sj0b01ry2UEo,119952
+fontTools/designspaceLib/__pycache__/__init__.cpython-38.pyc,,
+fontTools/designspaceLib/__pycache__/split.cpython-38.pyc,,
+fontTools/designspaceLib/__pycache__/statNames.cpython-38.pyc,,
+fontTools/designspaceLib/__pycache__/types.cpython-38.pyc,,
+fontTools/designspaceLib/split.py,sha256=wokwYtqTviJGu4tvkA6vjlWp1iMsSS7YK0PxhIdS8MA,17679
+fontTools/designspaceLib/statNames.py,sha256=GxSydNHG4wdDtQSr1q6bTx1JCaEEHe-EvFF2TPGO91s,7958
+fontTools/designspaceLib/types.py,sha256=ofK65qXNADqcpl7zI72Pa5s07-cm7G41iEmLVV44-Es,5320
+fontTools/encodings/MacRoman.py,sha256=43gwuGL4EMBCdTB2pKBmRrGz6DkSVZqyllyxBu-aQi0,2621
+fontTools/encodings/StandardEncoding.py,sha256=7jAuUzticDa5XJyXIpJI9SVXyigHzrhdxjVTEUlROdQ,2650
+fontTools/encodings/__init__.py,sha256=DJBWmoX_Haau7qlgmvWyfbhSzrX2qL636Rns7CG01pk,75
+fontTools/encodings/__pycache__/MacRoman.cpython-38.pyc,,
+fontTools/encodings/__pycache__/StandardEncoding.cpython-38.pyc,,
+fontTools/encodings/__pycache__/__init__.cpython-38.pyc,,
+fontTools/encodings/__pycache__/codecs.cpython-38.pyc,,
+fontTools/encodings/codecs.py,sha256=QvXZC4RjqECsLr11u3IIsEOphxXSLu5_p_J8vxyXDEo,3860
+fontTools/feaLib/__init__.py,sha256=jlIru2ghxvb1HhC5Je2BCXjFJmFQlYKpruorPoz3BvQ,213
+fontTools/feaLib/__main__.py,sha256=Df2PA6LXwna98lSXiL7R4as_ZEdWCIk3egSM5w7GpvM,2240
+fontTools/feaLib/__pycache__/__init__.cpython-38.pyc,,
+fontTools/feaLib/__pycache__/__main__.cpython-38.pyc,,
+fontTools/feaLib/__pycache__/ast.cpython-38.pyc,,
+fontTools/feaLib/__pycache__/builder.cpython-38.pyc,,
+fontTools/feaLib/__pycache__/error.cpython-38.pyc,,
+fontTools/feaLib/__pycache__/lexer.cpython-38.pyc,,
+fontTools/feaLib/__pycache__/location.cpython-38.pyc,,
+fontTools/feaLib/__pycache__/lookupDebugInfo.cpython-38.pyc,,
+fontTools/feaLib/__pycache__/parser.cpython-38.pyc,,
+fontTools/feaLib/__pycache__/variableScalar.cpython-38.pyc,,
+fontTools/feaLib/ast.py,sha256=-GZtHYwkHHCcmxcqyDW8gy2BmO5TVMq6M4uHJZAoLRI,73554
+fontTools/feaLib/builder.py,sha256=B67ln7tsWi9fWhGC100elBgpBZOzDVxVUjUTJ3K9vts,67151
+fontTools/feaLib/error.py,sha256=Tq2dZUlCOyLfjTr3qibsT2g9t-S_JEf6bKgyNX55oCE,643
+fontTools/feaLib/lexer.py,sha256=R4OTEyJMqHjwaefYZ4eMTw0dv8mIuN37L2SeO7tWcg0,11139
+fontTools/feaLib/location.py,sha256=JXzHqGV56EHdcq823AwA5oaK05hf_1ySWpScbo3zGC0,234
+fontTools/feaLib/lookupDebugInfo.py,sha256=sWvfEZiL9M9JPVH7_fZF_rSi7MpwoLagoZCSP2WLKSc,304
+fontTools/feaLib/parser.py,sha256=k_dyBwQ3FWjVYzLvEm0QlPf4KgIiFu-PnVxnWtKO4mE,98216
+fontTools/feaLib/variableScalar.py,sha256=TwsAn55FFVTYTL230Sn9tLP5jugUTwiLjI2ONbVxXuA,3281
+fontTools/fontBuilder.py,sha256=t8LkdDpgRVizbHtEzLt74iX0HvlFK_5X4lie4cxAMuA,31177
+fontTools/help.py,sha256=GCPl3WkgB6daag6N4yocVLPNGeyCdiYxdsUgHd0Yfkg,1027
+fontTools/merge/__init__.py,sha256=cHh35sAeqOjgHLHAh2UVhulH1mag4L_Byf0P1D-5vjs,5756
+fontTools/merge/__main__.py,sha256=vD5-bheoeotbQkRnFQg7nawCUeDKTmR1sqx3BcIYUt0,94
+fontTools/merge/__pycache__/__init__.cpython-38.pyc,,
+fontTools/merge/__pycache__/__main__.cpython-38.pyc,,
+fontTools/merge/__pycache__/base.cpython-38.pyc,,
+fontTools/merge/__pycache__/cmap.cpython-38.pyc,,
+fontTools/merge/__pycache__/layout.cpython-38.pyc,,
+fontTools/merge/__pycache__/options.cpython-38.pyc,,
+fontTools/merge/__pycache__/tables.cpython-38.pyc,,
+fontTools/merge/__pycache__/unicode.cpython-38.pyc,,
+fontTools/merge/__pycache__/util.cpython-38.pyc,,
+fontTools/merge/base.py,sha256=DTCsMkxq_u_OEBERaPvnPnwTVXPW8q1Jz68y9qORr9g,2048
+fontTools/merge/cmap.py,sha256=EdXKoBu93roYInM82ws7JDY5fLZ8Qio6Lpc22lgymso,4655
+fontTools/merge/layout.py,sha256=QTGofQUMoOE-0Zb1Z9YfvXXv5J8DEVzwRAPaLy17k5o,13314
+fontTools/merge/options.py,sha256=UacirHGUBgQFGI8naBCFfL_JwsV0VP-UE_wpYIXjkag,1657
+fontTools/merge/tables.py,sha256=0KWuth9LXwi5dljAicXF0pmdMo6Hz5QncmLoThD3_QM,8568
+fontTools/merge/unicode.py,sha256=K1U1uIc33OseFas_KZJVoHHj32322fzRXadPkIfwofY,3915
+fontTools/merge/util.py,sha256=xvP3P-OppYoTq1hdZR1P8ulB1itjjvCuLyn33nET3Es,2964
+fontTools/misc/__init__.py,sha256=DJBWmoX_Haau7qlgmvWyfbhSzrX2qL636Rns7CG01pk,75
+fontTools/misc/__pycache__/__init__.cpython-38.pyc,,
+fontTools/misc/__pycache__/arrayTools.cpython-38.pyc,,
+fontTools/misc/__pycache__/bezierTools.cpython-38.pyc,,
+fontTools/misc/__pycache__/classifyTools.cpython-38.pyc,,
+fontTools/misc/__pycache__/cliTools.cpython-38.pyc,,
+fontTools/misc/__pycache__/configTools.cpython-38.pyc,,
+fontTools/misc/__pycache__/cython.cpython-38.pyc,,
+fontTools/misc/__pycache__/dictTools.cpython-38.pyc,,
+fontTools/misc/__pycache__/eexec.cpython-38.pyc,,
+fontTools/misc/__pycache__/encodingTools.cpython-38.pyc,,
+fontTools/misc/__pycache__/etree.cpython-38.pyc,,
+fontTools/misc/__pycache__/filenames.cpython-38.pyc,,
+fontTools/misc/__pycache__/fixedTools.cpython-38.pyc,,
+fontTools/misc/__pycache__/intTools.cpython-38.pyc,,
+fontTools/misc/__pycache__/loggingTools.cpython-38.pyc,,
+fontTools/misc/__pycache__/macCreatorType.cpython-38.pyc,,
+fontTools/misc/__pycache__/macRes.cpython-38.pyc,,
+fontTools/misc/__pycache__/psCharStrings.cpython-38.pyc,,
+fontTools/misc/__pycache__/psLib.cpython-38.pyc,,
+fontTools/misc/__pycache__/psOperators.cpython-38.pyc,,
+fontTools/misc/__pycache__/py23.cpython-38.pyc,,
+fontTools/misc/__pycache__/roundTools.cpython-38.pyc,,
+fontTools/misc/__pycache__/sstruct.cpython-38.pyc,,
+fontTools/misc/__pycache__/symfont.cpython-38.pyc,,
+fontTools/misc/__pycache__/testTools.cpython-38.pyc,,
+fontTools/misc/__pycache__/textTools.cpython-38.pyc,,
+fontTools/misc/__pycache__/timeTools.cpython-38.pyc,,
+fontTools/misc/__pycache__/transform.cpython-38.pyc,,
+fontTools/misc/__pycache__/treeTools.cpython-38.pyc,,
+fontTools/misc/__pycache__/vector.cpython-38.pyc,,
+fontTools/misc/__pycache__/xmlReader.cpython-38.pyc,,
+fontTools/misc/__pycache__/xmlWriter.cpython-38.pyc,,
+fontTools/misc/arrayTools.py,sha256=RGm3ikjd5AnxWtmPJvkzPJSS59eprJQ5K7eTrT-pWWw,10722
+fontTools/misc/bezierTools.py,sha256=rJFVm8qBBpp2gMbXjNc8sCsnv0BCCCZ-ZldgdnIKJVI,38272
+fontTools/misc/classifyTools.py,sha256=GzXkEaFtVMqDxoiVJ05sUHQKXcFWHpQk9s7RxL1UMkI,4940
+fontTools/misc/cliTools.py,sha256=3KsqYZc966IdCoqx0DjWge7s5BAZGpXV9EAnE8j9PW8,1665
+fontTools/misc/configTools.py,sha256=X51UOl62wCGDqv9HCdcx-T5SixPrIxYj8Iju0etymYU,11187
+fontTools/misc/cython.py,sha256=gO5qHKZPR-fiCp0ZD-BYvrOpxseB7FLs_r5IRD1-zhs,680
+fontTools/misc/dictTools.py,sha256=L69sNH7DVKEmrLOENGzGv-b7qwH2KUUeX14ftlazIKE,2433
+fontTools/misc/eexec.py,sha256=5HM5Y3RjIp48yUisBV1EJzNqfnua8ksupLyhtDF7mxg,2967
+fontTools/misc/encodingTools.py,sha256=oPyIYCh-UbRnXxiHnquwOFSiE10YmKm1ZApK8pvaO3I,1703
+fontTools/misc/etree.py,sha256=diYgYI9umsIumNIayDkIM3or7Gze7PBQZak_pgPDmi0,17087
+fontTools/misc/filenames.py,sha256=k_zEQKP53gGTesleqTznTvbnz2VRV-XOzH5avtTpJXU,7164
+fontTools/misc/fixedTools.py,sha256=EdCrh1UKr9XOvnqvPdv7X-bMLTQhgpcWBxLP7100AhI,6759
+fontTools/misc/intTools.py,sha256=r_oMJOt6I-y6TvCRB58x2NFqji8rbCQTDS5p-ShK-fs,549
+fontTools/misc/loggingTools.py,sha256=z9VNCzVgD57hYIh6Q6wlGNsaf17Agk9mbedamRK6FP4,17232
+fontTools/misc/macCreatorType.py,sha256=47Di88HRVE7tdkDF1XAgnDEuZAly7RgGTIxa9nwbT5A,1374
+fontTools/misc/macRes.py,sha256=2QviAShnX27C-btE-ljLXmdLuWQIg2h81mQMguaVjFI,7413
+fontTools/misc/plistlib/__init__.py,sha256=qYKb0iEIQjf0nb5JuL_GOiBSBe0Lujx8OQofrjl8LZ4,21103
+fontTools/misc/plistlib/__pycache__/__init__.cpython-38.pyc,,
+fontTools/misc/plistlib/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+fontTools/misc/psCharStrings.py,sha256=nFP_gO739uC3AuMpUd8hxLjuY-s8USvc2LK5VB-PYMw,33952
+fontTools/misc/psLib.py,sha256=MBDR4JgMxMhb28y3uucmuw1_CXt19aQowzfQsmERPoA,9604
+fontTools/misc/psOperators.py,sha256=ozowyXOjddZPmb743upvMcFLP-oeogyv1F3yujOkgoQ,12810
+fontTools/misc/py23.py,sha256=aPVCEUz_deggwLBCeTSsccX6QgJavZqvdVtuhpzrPvA,2238
+fontTools/misc/roundTools.py,sha256=e8p7Tlj03Q63zJ_XBQ238qzN1ck54l-fkSZEUv_6dvo,3035
+fontTools/misc/sstruct.py,sha256=HaQPC2jKvG9bduQ4a87dc4crcoX5N9nErIeXKLr9rHE,6054
+fontTools/misc/symfont.py,sha256=GrsteeKbgYiCZLQAuEy3jbk3h1Nsxq57reM5tzeM6yc,5283
+fontTools/misc/testTools.py,sha256=hf_ls57ndJJfjlQAxEGeaPj3YaXQr5luwPnhlLjRyCA,6922
+fontTools/misc/textTools.py,sha256=m8D1l5-bvw-ymTkOL0EBV5milvb_yBDPPovdVDqZJkY,3093
+fontTools/misc/timeTools.py,sha256=r0Mf4dkmh7FTHQ21zVQfP_JqeNZvYibub5p9GP-GIh4,2041
+fontTools/misc/transform.py,sha256=L9KS64lgYuiKqiC_0RyyFBMhq4kbwP6Bv4_7vVgGSeA,9218
+fontTools/misc/treeTools.py,sha256=tLWkwyDHeZUPVOGNnJeD4Pn7x2bQeZetwJKaEAW2J2M,1269
+fontTools/misc/vector.py,sha256=ds9eoWVhS_W7YQacN0eAY_oWMEuLlA9-cJBMGEJEpbk,3819
+fontTools/misc/xmlReader.py,sha256=RZAtVhzhGqPu1K2HSAgHrPWVtL12qwM17hj6qQGj9rE,4830
+fontTools/misc/xmlWriter.py,sha256=E8CQkA_h_-JGmHZylIwl3bJiyhPc-RCfRL3ExQF86dA,5022
+fontTools/mtiLib/__init__.py,sha256=8Xmkyb4ugMbqtWE1oP5zZUi9y3Ow_gYtvahX0z48Juw,37888
+fontTools/mtiLib/__main__.py,sha256=dKBCSe1_qkBPH6PSVmfXmB_vH-gXh9pIwbFM3iAhmEM,91
+fontTools/mtiLib/__pycache__/__init__.cpython-38.pyc,,
+fontTools/mtiLib/__pycache__/__main__.cpython-38.pyc,,
+fontTools/otlLib/__init__.py,sha256=D2leUW-3gsUTOFcJYGC18edBYjIJ804ut4qitJYWsaQ,45
+fontTools/otlLib/__pycache__/__init__.cpython-38.pyc,,
+fontTools/otlLib/__pycache__/builder.cpython-38.pyc,,
+fontTools/otlLib/__pycache__/error.cpython-38.pyc,,
+fontTools/otlLib/__pycache__/maxContextCalc.cpython-38.pyc,,
+fontTools/otlLib/builder.py,sha256=yGvbz3D483AyxctXPuHDVnbGnFR-nE3h8jaXxtis48Q,109038
+fontTools/otlLib/error.py,sha256=cthuhBuOwZYpkTLi5gFPupUxkXkCHe-L_YgkE7N1wCI,335
+fontTools/otlLib/maxContextCalc.py,sha256=l3PeR9SrhzCTwMRuRzpGxBZJzIWppk1hUqGv6b3--AE,3187
+fontTools/otlLib/optimize/__init__.py,sha256=Yl8wQdvO7SHwvSXsNaR2j4ZQwu2q11rJI1Kf58O6dV0,1531
+fontTools/otlLib/optimize/__main__.py,sha256=GDrfuClFKSoep4tGD-1X_A65JQh2fcbiir14BefprtM,101
+fontTools/otlLib/optimize/__pycache__/__init__.cpython-38.pyc,,
+fontTools/otlLib/optimize/__pycache__/__main__.cpython-38.pyc,,
+fontTools/otlLib/optimize/__pycache__/gpos.cpython-38.pyc,,
+fontTools/otlLib/optimize/gpos.py,sha256=Ccq6-CNrsRXyDM6anrrUtG6F5iDKMe3jML4Q7Euw2g8,18475
+fontTools/pens/__init__.py,sha256=DJBWmoX_Haau7qlgmvWyfbhSzrX2qL636Rns7CG01pk,75
+fontTools/pens/__pycache__/__init__.cpython-38.pyc,,
+fontTools/pens/__pycache__/areaPen.cpython-38.pyc,,
+fontTools/pens/__pycache__/basePen.cpython-38.pyc,,
+fontTools/pens/__pycache__/boundsPen.cpython-38.pyc,,
+fontTools/pens/__pycache__/cocoaPen.cpython-38.pyc,,
+fontTools/pens/__pycache__/cu2quPen.cpython-38.pyc,,
+fontTools/pens/__pycache__/filterPen.cpython-38.pyc,,
+fontTools/pens/__pycache__/freetypePen.cpython-38.pyc,,
+fontTools/pens/__pycache__/hashPointPen.cpython-38.pyc,,
+fontTools/pens/__pycache__/momentsPen.cpython-38.pyc,,
+fontTools/pens/__pycache__/perimeterPen.cpython-38.pyc,,
+fontTools/pens/__pycache__/pointInsidePen.cpython-38.pyc,,
+fontTools/pens/__pycache__/pointPen.cpython-38.pyc,,
+fontTools/pens/__pycache__/qtPen.cpython-38.pyc,,
+fontTools/pens/__pycache__/quartzPen.cpython-38.pyc,,
+fontTools/pens/__pycache__/recordingPen.cpython-38.pyc,,
+fontTools/pens/__pycache__/reportLabPen.cpython-38.pyc,,
+fontTools/pens/__pycache__/reverseContourPen.cpython-38.pyc,,
+fontTools/pens/__pycache__/roundingPen.cpython-38.pyc,,
+fontTools/pens/__pycache__/statisticsPen.cpython-38.pyc,,
+fontTools/pens/__pycache__/svgPathPen.cpython-38.pyc,,
+fontTools/pens/__pycache__/t2CharStringPen.cpython-38.pyc,,
+fontTools/pens/__pycache__/teePen.cpython-38.pyc,,
+fontTools/pens/__pycache__/transformPen.cpython-38.pyc,,
+fontTools/pens/__pycache__/ttGlyphPen.cpython-38.pyc,,
+fontTools/pens/__pycache__/wxPen.cpython-38.pyc,,
+fontTools/pens/areaPen.py,sha256=EiIgKje7tIlA0JmYscMGpeuTj0-6IX1vqWANSOFDCss,1306
+fontTools/pens/basePen.py,sha256=UJOl91xZKSQ5J0DLYDQweLB7WGbZYBGW4DsuMHiKBX0,13225
+fontTools/pens/boundsPen.py,sha256=MpfbOO2NvhcDCqwJ80S020Gy7IyJlOH1owI33c8IQiI,2724
+fontTools/pens/cocoaPen.py,sha256=_CvCJ_Fd-3-6SDcljyCLjSnUo3KKC9IqFPbel9nTmqQ,537
+fontTools/pens/cu2quPen.py,sha256=ofeA-cOvjUyC31ma-ONeYN-_P23gbNJuJofazSQmc9w,10996
+fontTools/pens/filterPen.py,sha256=wycKP3EQTkJirTQSem4mOQFmgD6_AzRfKdwb604IGSw,4732
+fontTools/pens/freetypePen.py,sha256=MsIjlwvd54qQoSe3fqqGm4ZyhrhQi3-9B6X1yv5_KuQ,19813
+fontTools/pens/hashPointPen.py,sha256=meUaKRMNEcw-rrvjSxcg-G4IU1nIsDLiwvpLeB2jISM,2647
+fontTools/pens/momentsPen.py,sha256=xKwzNqDopxUIsVTxqewN0drz3bV_ZCQ-F0b3V1rBjm8,9439
+fontTools/pens/perimeterPen.py,sha256=B9nzzmR-DJBrkMUmsW-VPEDfRXrLEN3lm0BbvS2323A,1892
+fontTools/pens/pointInsidePen.py,sha256=KMxhGgx_w6ieVGcn2P5Y3Juwojmvye__YanO580CuDg,5244
+fontTools/pens/pointPen.py,sha256=C8xNSkRbSLIFjiYLqVkOMLozmbrzHARI4rDVhXqfadM,15245
+fontTools/pens/qtPen.py,sha256=mG64EfzJp0rR6ZkdN2Ks9PZffSiKkHjz1h6Hy2VXIGw,544
+fontTools/pens/quartzPen.py,sha256=UotZzZKyaCAp_Jlnh3Ut11_q5M7-83bxD-A7Xw7Z6Qs,1175
+fontTools/pens/recordingPen.py,sha256=Dql-HGDbhp1XEIONKV3IDFRZ3pLYYnNMGBcSwqEVSkA,4553
+fontTools/pens/reportLabPen.py,sha256=BjjrxQ--mKydz8jwt-XMWHDl_stIBRBA10p3XUBdrx8,1783
+fontTools/pens/reverseContourPen.py,sha256=5PmxS6yrfQsj3Bj4CWRqngyaRARblptNAwBzyyGcGXY,3849
+fontTools/pens/roundingPen.py,sha256=8RRcfds10LRsQGghSMwOr-xJxpmH8Xk423A1VPmiIII,3803
+fontTools/pens/statisticsPen.py,sha256=s6qcFClK4G2tpBQymBjmDZAT2x39jo4hR9dbZix9hAE,3084
+fontTools/pens/svgPathPen.py,sha256=3YIZg77ClWYWd57Bjx3pomazLLDpGg3GM6sARw6gTy0,5401
+fontTools/pens/t2CharStringPen.py,sha256=GUMRvNpXliRaQHJlrmG6gY8YK-qJcj9ZOMp1yVCIfdE,2395
+fontTools/pens/teePen.py,sha256=7mZ32L3NQeqpnccqPJpkm2i4ejhxqhyj8R-84nk3Ewc,1107
+fontTools/pens/transformPen.py,sha256=_Jof5dQDTVPjXKlITlY_GYoaKc3hE5RLIiRSm-argtw,3581
+fontTools/pens/ttGlyphPen.py,sha256=4muXWdKlKMdqBE6sTXEzN-Y9M8ivSOPloExLWeRhvjQ,10133
+fontTools/pens/wxPen.py,sha256=PYcwq9GdxrxoSScmO5hZehPAChFusbzOhtxNZX_IRrM,590
+fontTools/subset/__init__.py,sha256=23RkJgu5m2wW4qOEWmLbIvvCv22eyoNAvG9OyC0tRR0,109805
+fontTools/subset/__main__.py,sha256=OCrmxWb75I39dmEynBjTIveiIOIWLcjv17YAI9XuGWQ,95
+fontTools/subset/__pycache__/__init__.cpython-38.pyc,,
+fontTools/subset/__pycache__/__main__.cpython-38.pyc,,
+fontTools/subset/__pycache__/cff.cpython-38.pyc,,
+fontTools/subset/__pycache__/svg.cpython-38.pyc,,
+fontTools/subset/__pycache__/util.cpython-38.pyc,,
+fontTools/subset/cff.py,sha256=GWfYG1AA16RKCkEK2eiVwnTyEpg6DXTvz7xblOdiqDg,16020
+fontTools/subset/svg.py,sha256=fZWmNk0XxNR7xM1ZBsXC2tsAhFS2hHVayvPTftzcFDw,9226
+fontTools/subset/util.py,sha256=9SXFYb5Ef9Z58uXmYPCQil8B2i3Q7aFB_1fFDFSppdU,754
+fontTools/svgLib/__init__.py,sha256=IGCLwSbU8jLhq6HI2vSdPQgNs6zDUi5774TgX5MCXPY,75
+fontTools/svgLib/__pycache__/__init__.cpython-38.pyc,,
+fontTools/svgLib/path/__init__.py,sha256=PFU73fS7Hk5w22s7cKjSVDVyMeNz3ridC9-w9eYK9Gs,1955
+fontTools/svgLib/path/__pycache__/__init__.cpython-38.pyc,,
+fontTools/svgLib/path/__pycache__/arc.cpython-38.pyc,,
+fontTools/svgLib/path/__pycache__/parser.cpython-38.pyc,,
+fontTools/svgLib/path/__pycache__/shapes.cpython-38.pyc,,
+fontTools/svgLib/path/arc.py,sha256=Kio93A6r7OPbUXaDfdoBqyOIpn5vWpVdYdIjHMQfQSk,5812
+fontTools/svgLib/path/parser.py,sha256=SH-iK3f64u5XUGlqOZQy6EQBU_Hkj6tDWEdsTGe1InM,10702
+fontTools/svgLib/path/shapes.py,sha256=XaOJwy3avxWK4sqDQp4MTZ9x2fla7GLQNP5EFUNc98Q,5331
+fontTools/t1Lib/__init__.py,sha256=pPVn5cTKfQsf9GpWILvoBKFACuQMsdHTWtElZINyvWY,16193
+fontTools/t1Lib/__pycache__/__init__.cpython-38.pyc,,
+fontTools/tfmLib.py,sha256=UMbkM73JXRJVS9t2B-BJc13rSjImaWBuzCoehLwHFhs,14270
+fontTools/ttLib/__init__.py,sha256=Ca_dkbyKS-ygQTLQsWmAtlblPmwCUzRUH1T0zjPvlGE,482
+fontTools/ttLib/__pycache__/__init__.cpython-38.pyc,,
+fontTools/ttLib/__pycache__/macUtils.cpython-38.pyc,,
+fontTools/ttLib/__pycache__/removeOverlaps.cpython-38.pyc,,
+fontTools/ttLib/__pycache__/sfnt.cpython-38.pyc,,
+fontTools/ttLib/__pycache__/standardGlyphOrder.cpython-38.pyc,,
+fontTools/ttLib/__pycache__/ttCollection.cpython-38.pyc,,
+fontTools/ttLib/__pycache__/ttFont.cpython-38.pyc,,
+fontTools/ttLib/__pycache__/woff2.cpython-38.pyc,,
+fontTools/ttLib/macUtils.py,sha256=ozNVoId2eExYEPR4YYrB31snBHHw5NPNvba2pl_nsWU,1540
+fontTools/ttLib/removeOverlaps.py,sha256=jZuClS9U6MynO1E-20gLTvWgocriwqsaLflTyS0Mg_Q,8098
+fontTools/ttLib/sfnt.py,sha256=Rss6d8JEutQFGDWToHH5lLoAQpTF4N77j4Q8zws89Tw,19447
+fontTools/ttLib/standardGlyphOrder.py,sha256=1Dg71QRuhqPtz7yUnknqVngHMLuUmRCkUi9vIZ_VVfA,8302
+fontTools/ttLib/tables/B_A_S_E_.py,sha256=4x2FrRE1TrJ3dzRYtmmy5jLY7PdTKRBJih3u-XBhyYw,85
+fontTools/ttLib/tables/BitmapGlyphMetrics.py,sha256=sTJGi3bhDEVW1aoe0F6EXhcR0baPFp7hOXrd9XPrkfM,1536
+fontTools/ttLib/tables/C_B_D_T_.py,sha256=frhj07AobeNcGMTW-ghx2Vj3b1-85V21ujcT2irSvJY,3033
+fontTools/ttLib/tables/C_B_L_C_.py,sha256=SqMV3Rp5fKI6fI4DH2zOEzy1xh0oY8Bz1R4QuIetjxA,185
+fontTools/ttLib/tables/C_F_F_.py,sha256=sEGy10tZOhHmPKMMWMUQnHFbxjMinw8scYMtVtEgfGs,1259
+fontTools/ttLib/tables/C_F_F__2.py,sha256=sb1Zvn7STQO5JIMRjvt_lMXDQ6Is2AOxy8P8xAY4yO8,426
+fontTools/ttLib/tables/C_O_L_R_.py,sha256=807Nl5UlYmCgzyp5UvmXx7mHDlE2_VG9yQ5_ki3gkKo,4784
+fontTools/ttLib/tables/C_P_A_L_.py,sha256=gpCpjYLaOTnsGZmWUo6lci4rduVxm8IeS8OgZP3dtGI,9473
+fontTools/ttLib/tables/D_S_I_G_.py,sha256=qLs_sF62otfMQn6Pe1v_3s0nERJSHlJt4i_jf0brL10,4572
+fontTools/ttLib/tables/D__e_b_g.py,sha256=2_oy6wxqGWDDmeLkDC3p6yiQAPz8U96oJUnLCup5VDg,433
+fontTools/ttLib/tables/DefaultTable.py,sha256=KRxOrAYMqd0_a-TD4kl3Bd1ehPuSiYzKAr7sqvA8Ma8,1282
+fontTools/ttLib/tables/E_B_D_T_.py,sha256=ZNxyZG9GmrWI3RwCh_vPNjEognneArWt0Y_e3VuCEn0,27177
+fontTools/ttLib/tables/E_B_L_C_.py,sha256=7oMPOw5K_fQXgbSacEYBRV3HD6rsOVp4SNYokX3aqhg,25146
+fontTools/ttLib/tables/F_F_T_M_.py,sha256=Le3rqVHM9cqLExp15L4HVtyBK6aKJJgJ81oUXg9GhZk,1188
+fontTools/ttLib/tables/F__e_a_t.py,sha256=Xk5VBiAnTz3cr7py5pRFoKbLxh_wEk9TxiGxfB9zGd4,4996
+fontTools/ttLib/tables/G_D_E_F_.py,sha256=wJMXPrD9qgtvdm9U0VKwfoSW_rvQX5NBCJ9ullSmYg8,85
+fontTools/ttLib/tables/G_M_A_P_.py,sha256=D4DC-uLIuHVaR0ErYkQB7DVJUdD1xkGRPaZWy40zfFw,3724
+fontTools/ttLib/tables/G_P_K_G_.py,sha256=O4YTuMBB2Lg88KFXt1-XGjtoEY-BB8-1yc6qkfBAAdU,3646
+fontTools/ttLib/tables/G_P_O_S_.py,sha256=G2d4yWSp2NmJQNTMX7lvqCslzkJPowJ46eOb80ZVtKM,85
+fontTools/ttLib/tables/G_S_U_B_.py,sha256=OP6bMn3fdP_p3hErIM2Y4JLdo-fYwWbcs3_MO9G6XCM,85
+fontTools/ttLib/tables/G__l_a_t.py,sha256=Gi2RLP1N4HAiRsZAVGPXrugYx3rpi2WRK6AdSqn1U9g,8400
+fontTools/ttLib/tables/G__l_o_c.py,sha256=DDr_kJlO4J3_ju9TTuPZqZwCeNWbi0Ex0w0PQvtY2xg,2444
+fontTools/ttLib/tables/H_V_A_R_.py,sha256=1SCRvlX1eK1e6-sKnzaa9R0MbAmaCVB8X7pqrCdgdI0,85
+fontTools/ttLib/tables/J_S_T_F_.py,sha256=MQf8KGvJsN_OaGSzZapRvKsCv6kVYt9lLB6P-6vgICc,85
+fontTools/ttLib/tables/L_T_S_H_.py,sha256=kRF-N8ye7OtYRBAiRHbvxV884Q9Ar5W9SGkdUZxWnsY,1613
+fontTools/ttLib/tables/M_A_T_H_.py,sha256=UeJ-Obm9AVVPS00Bfc16gP5P_m8sh3xpQZ0wJF3Bgtk,85
+fontTools/ttLib/tables/M_E_T_A_.py,sha256=5xtxNRi8xk3MOhxm8lQVp78LInmMNo56WrUuuPJa7lI,9362
+fontTools/ttLib/tables/M_V_A_R_.py,sha256=FstEACLz7uacX8yOhT4EFaGuPchjKDijAMzXxrJYCek,85
+fontTools/ttLib/tables/O_S_2f_2.py,sha256=MGVt52dYa291bkUeaSMGLXgmB7dxhRxyyaMzDLilefY,23641
+fontTools/ttLib/tables/S_I_N_G_.py,sha256=E1d6YxtbNjHDS0JEOdbNwzxqlq1oOic4jXXc3qFljsg,2661
+fontTools/ttLib/tables/S_T_A_T_.py,sha256=tPbD_6x4aJACOux8bKe_sFlk0PEat7aiZn8pnXoUGws,88
+fontTools/ttLib/tables/S_V_G_.py,sha256=PplHChKcp9uSVsp5Bg1US0AoHmprxurvwDyU3TcWMIY,6014
+fontTools/ttLib/tables/S__i_l_f.py,sha256=msryU0Hn2mtimgw3B6wYRzCcpRXpMJwAmx3fF9yiT7A,33295
+fontTools/ttLib/tables/S__i_l_l.py,sha256=UF_7a3RuncFH2Lq2MOWp8_7rFaRLxZHSy2xOwU2KYg4,3053
+fontTools/ttLib/tables/T_S_I_B_.py,sha256=4iMSLv0IvU8HijicUZO4hR4NZ4_18d4S6vPGRlkjPsc,82
+fontTools/ttLib/tables/T_S_I_C_.py,sha256=TjDKgGdFEaL4Affo9MTInuVKbYUHMa0pJX18pzgYxT0,88
+fontTools/ttLib/tables/T_S_I_D_.py,sha256=Sl8bSkVK9wmIZjhn8SMirK7jCCLOXhAg5Mk3FijGiXI,82
+fontTools/ttLib/tables/T_S_I_J_.py,sha256=dFnVt_7DvPXe3lri4nuG3NHwXBRMRILK9mO9AaGIvHg,82
+fontTools/ttLib/tables/T_S_I_P_.py,sha256=vDVnjHFAT_1dK9FOocI1vIyrSynSzy2m00iVB6XCMeI,82
+fontTools/ttLib/tables/T_S_I_S_.py,sha256=XXcQeIWaMSWAbSJl6rqJTjreG0A1Bi9YEvewD0YgATI,82
+fontTools/ttLib/tables/T_S_I_V_.py,sha256=oHAWqySjTqSvbY5sRW4mo3v1Y4WhMYs9xdWqz1-yCak,577
+fontTools/ttLib/tables/T_S_I__0.py,sha256=Wan-zOh3hJ1MnDnDogqZfjCuU-tOi34gv6dP2whGrZw,1808
+fontTools/ttLib/tables/T_S_I__1.py,sha256=Zj3HwfsV6GJmeFQ6T8_Cljp4yBR7-5JTiFh733Pm8Q4,5318
+fontTools/ttLib/tables/T_S_I__2.py,sha256=w0PkAzBUKzI9CCnjbffXdD03g14VHgF5ZTLV858NZU4,416
+fontTools/ttLib/tables/T_S_I__3.py,sha256=0vGq0UPNIBItoTSDVMdmvSOXvJgXU7_QaFK9-Qq-PuE,421
+fontTools/ttLib/tables/T_S_I__5.py,sha256=CjLpMBZvGldNuk-0Pykb2m2sz7yhhcUxCOgDxk-jQHg,1288
+fontTools/ttLib/tables/T_T_F_A_.py,sha256=1qUgVPhufFCqVqGc0IZTv7qLFdUwh06SzlegkXSQMdo,77
+fontTools/ttLib/tables/TupleVariation.py,sha256=-r39STlm1E0cLBKMS1qEZtSMCqBZh-ozvDLySxjXooA,24273
+fontTools/ttLib/tables/V_D_M_X_.py,sha256=EPoMRSo9eHRcHyaduO3YMpfznYxf0bf-I20JJ4jRCcw,8187
+fontTools/ttLib/tables/V_O_R_G_.py,sha256=AZdLdd6NFqF4-QcmVv5hUUX_7YAKBesDOKYcu7wvk0w,4730
+fontTools/ttLib/tables/V_V_A_R_.py,sha256=qo17ZU8m2jEpc4fcFOGZ07mRLtkSPXFOWcbFuda-oDA,85
+fontTools/ttLib/tables/__init__.py,sha256=Y2r9RXUSdOd-1OOfLSPvkJ5Ta2JfUUH4wONjPtrvitg,2326
+fontTools/ttLib/tables/__pycache__/B_A_S_E_.cpython-38.pyc,,
+fontTools/ttLib/tables/__pycache__/BitmapGlyphMetrics.cpython-38.pyc,,
+fontTools/ttLib/tables/__pycache__/C_B_D_T_.cpython-38.pyc,,
+fontTools/ttLib/tables/__pycache__/C_B_L_C_.cpython-38.pyc,,
+fontTools/ttLib/tables/__pycache__/C_F_F_.cpython-38.pyc,,
+fontTools/ttLib/tables/__pycache__/C_F_F__2.cpython-38.pyc,,
+fontTools/ttLib/tables/__pycache__/C_O_L_R_.cpython-38.pyc,,
+fontTools/ttLib/tables/__pycache__/C_P_A_L_.cpython-38.pyc,,
+fontTools/ttLib/tables/__pycache__/D_S_I_G_.cpython-38.pyc,,
+fontTools/ttLib/tables/__pycache__/D__e_b_g.cpython-38.pyc,,
+fontTools/ttLib/tables/__pycache__/DefaultTable.cpython-38.pyc,,
+fontTools/ttLib/tables/__pycache__/E_B_D_T_.cpython-38.pyc,,
+fontTools/ttLib/tables/__pycache__/E_B_L_C_.cpython-38.pyc,,
+fontTools/ttLib/tables/__pycache__/F_F_T_M_.cpython-38.pyc,,
+fontTools/ttLib/tables/__pycache__/F__e_a_t.cpython-38.pyc,,
+fontTools/ttLib/tables/__pycache__/G_D_E_F_.cpython-38.pyc,,
+fontTools/ttLib/tables/__pycache__/G_M_A_P_.cpython-38.pyc,,
+fontTools/ttLib/tables/__pycache__/G_P_K_G_.cpython-38.pyc,,
+fontTools/ttLib/tables/__pycache__/G_P_O_S_.cpython-38.pyc,,
+fontTools/ttLib/tables/__pycache__/G_S_U_B_.cpython-38.pyc,,
+fontTools/ttLib/tables/__pycache__/G__l_a_t.cpython-38.pyc,,
+fontTools/ttLib/tables/__pycache__/G__l_o_c.cpython-38.pyc,,
+fontTools/ttLib/tables/__pycache__/H_V_A_R_.cpython-38.pyc,,
+fontTools/ttLib/tables/__pycache__/J_S_T_F_.cpython-38.pyc,,
+fontTools/ttLib/tables/__pycache__/L_T_S_H_.cpython-38.pyc,,
+fontTools/ttLib/tables/__pycache__/M_A_T_H_.cpython-38.pyc,,
+fontTools/ttLib/tables/__pycache__/M_E_T_A_.cpython-38.pyc,,
+fontTools/ttLib/tables/__pycache__/M_V_A_R_.cpython-38.pyc,,
+fontTools/ttLib/tables/__pycache__/O_S_2f_2.cpython-38.pyc,,
+fontTools/ttLib/tables/__pycache__/S_I_N_G_.cpython-38.pyc,,
+fontTools/ttLib/tables/__pycache__/S_T_A_T_.cpython-38.pyc,,
+fontTools/ttLib/tables/__pycache__/S_V_G_.cpython-38.pyc,,
+fontTools/ttLib/tables/__pycache__/S__i_l_f.cpython-38.pyc,,
+fontTools/ttLib/tables/__pycache__/S__i_l_l.cpython-38.pyc,,
+fontTools/ttLib/tables/__pycache__/T_S_I_B_.cpython-38.pyc,,
+fontTools/ttLib/tables/__pycache__/T_S_I_C_.cpython-38.pyc,,
+fontTools/ttLib/tables/__pycache__/T_S_I_D_.cpython-38.pyc,,
+fontTools/ttLib/tables/__pycache__/T_S_I_J_.cpython-38.pyc,,
+fontTools/ttLib/tables/__pycache__/T_S_I_P_.cpython-38.pyc,,
+fontTools/ttLib/tables/__pycache__/T_S_I_S_.cpython-38.pyc,,
+fontTools/ttLib/tables/__pycache__/T_S_I_V_.cpython-38.pyc,,
+fontTools/ttLib/tables/__pycache__/T_S_I__0.cpython-38.pyc,,
+fontTools/ttLib/tables/__pycache__/T_S_I__1.cpython-38.pyc,,
+fontTools/ttLib/tables/__pycache__/T_S_I__2.cpython-38.pyc,,
+fontTools/ttLib/tables/__pycache__/T_S_I__3.cpython-38.pyc,,
+fontTools/ttLib/tables/__pycache__/T_S_I__5.cpython-38.pyc,,
+fontTools/ttLib/tables/__pycache__/T_T_F_A_.cpython-38.pyc,,
+fontTools/ttLib/tables/__pycache__/TupleVariation.cpython-38.pyc,,
+fontTools/ttLib/tables/__pycache__/V_D_M_X_.cpython-38.pyc,,
+fontTools/ttLib/tables/__pycache__/V_O_R_G_.cpython-38.pyc,,
+fontTools/ttLib/tables/__pycache__/V_V_A_R_.cpython-38.pyc,,
+fontTools/ttLib/tables/__pycache__/__init__.cpython-38.pyc,,
+fontTools/ttLib/tables/__pycache__/_a_n_k_r.cpython-38.pyc,,
+fontTools/ttLib/tables/__pycache__/_a_v_a_r.cpython-38.pyc,,
+fontTools/ttLib/tables/__pycache__/_b_s_l_n.cpython-38.pyc,,
+fontTools/ttLib/tables/__pycache__/_c_i_d_g.cpython-38.pyc,,
+fontTools/ttLib/tables/__pycache__/_c_m_a_p.cpython-38.pyc,,
+fontTools/ttLib/tables/__pycache__/_c_v_a_r.cpython-38.pyc,,
+fontTools/ttLib/tables/__pycache__/_c_v_t.cpython-38.pyc,,
+fontTools/ttLib/tables/__pycache__/_f_e_a_t.cpython-38.pyc,,
+fontTools/ttLib/tables/__pycache__/_f_p_g_m.cpython-38.pyc,,
+fontTools/ttLib/tables/__pycache__/_f_v_a_r.cpython-38.pyc,,
+fontTools/ttLib/tables/__pycache__/_g_a_s_p.cpython-38.pyc,,
+fontTools/ttLib/tables/__pycache__/_g_c_i_d.cpython-38.pyc,,
+fontTools/ttLib/tables/__pycache__/_g_l_y_f.cpython-38.pyc,,
+fontTools/ttLib/tables/__pycache__/_g_v_a_r.cpython-38.pyc,,
+fontTools/ttLib/tables/__pycache__/_h_d_m_x.cpython-38.pyc,,
+fontTools/ttLib/tables/__pycache__/_h_e_a_d.cpython-38.pyc,,
+fontTools/ttLib/tables/__pycache__/_h_h_e_a.cpython-38.pyc,,
+fontTools/ttLib/tables/__pycache__/_h_m_t_x.cpython-38.pyc,,
+fontTools/ttLib/tables/__pycache__/_k_e_r_n.cpython-38.pyc,,
+fontTools/ttLib/tables/__pycache__/_l_c_a_r.cpython-38.pyc,,
+fontTools/ttLib/tables/__pycache__/_l_o_c_a.cpython-38.pyc,,
+fontTools/ttLib/tables/__pycache__/_l_t_a_g.cpython-38.pyc,,
+fontTools/ttLib/tables/__pycache__/_m_a_x_p.cpython-38.pyc,,
+fontTools/ttLib/tables/__pycache__/_m_e_t_a.cpython-38.pyc,,
+fontTools/ttLib/tables/__pycache__/_m_o_r_t.cpython-38.pyc,,
+fontTools/ttLib/tables/__pycache__/_m_o_r_x.cpython-38.pyc,,
+fontTools/ttLib/tables/__pycache__/_n_a_m_e.cpython-38.pyc,,
+fontTools/ttLib/tables/__pycache__/_o_p_b_d.cpython-38.pyc,,
+fontTools/ttLib/tables/__pycache__/_p_o_s_t.cpython-38.pyc,,
+fontTools/ttLib/tables/__pycache__/_p_r_e_p.cpython-38.pyc,,
+fontTools/ttLib/tables/__pycache__/_p_r_o_p.cpython-38.pyc,,
+fontTools/ttLib/tables/__pycache__/_s_b_i_x.cpython-38.pyc,,
+fontTools/ttLib/tables/__pycache__/_t_r_a_k.cpython-38.pyc,,
+fontTools/ttLib/tables/__pycache__/_v_h_e_a.cpython-38.pyc,,
+fontTools/ttLib/tables/__pycache__/_v_m_t_x.cpython-38.pyc,,
+fontTools/ttLib/tables/__pycache__/asciiTable.cpython-38.pyc,,
+fontTools/ttLib/tables/__pycache__/grUtils.cpython-38.pyc,,
+fontTools/ttLib/tables/__pycache__/otBase.cpython-38.pyc,,
+fontTools/ttLib/tables/__pycache__/otConverters.cpython-38.pyc,,
+fontTools/ttLib/tables/__pycache__/otData.cpython-38.pyc,,
+fontTools/ttLib/tables/__pycache__/otTables.cpython-38.pyc,,
+fontTools/ttLib/tables/__pycache__/otTraverse.cpython-38.pyc,,
+fontTools/ttLib/tables/__pycache__/sbixGlyph.cpython-38.pyc,,
+fontTools/ttLib/tables/__pycache__/sbixStrike.cpython-38.pyc,,
+fontTools/ttLib/tables/__pycache__/ttProgram.cpython-38.pyc,,
+fontTools/ttLib/tables/_a_n_k_r.py,sha256=ZlT4BJeQODC_zMdFyiokdHS6BvXp2wQgOOAkvtXe6Xw,460
+fontTools/ttLib/tables/_a_v_a_r.py,sha256=LE2gVaA1bcaIKAeBrQoNvjtl3_ubn9M7XGdEyWpgKwA,4534
+fontTools/ttLib/tables/_b_s_l_n.py,sha256=D1tRo8TDAUxeCqVWsTma9u2VxRzxUkCpF84Lv_hy4rU,170
+fontTools/ttLib/tables/_c_i_d_g.py,sha256=OSR64lQMwsmk5X1pHMz7pUdoIdTVeEFfTOZIda90nE4,751
+fontTools/ttLib/tables/_c_m_a_p.py,sha256=opOLsIAToKcJ-PPsud-43uLO-gbRDuW8SwmG5gklf0k,48773
+fontTools/ttLib/tables/_c_v_a_r.py,sha256=tbvcz6Zsdgz_yzbi3ppdLlT5H4pW0A-T2sdKOBuvYXE,3299
+fontTools/ttLib/tables/_c_v_t.py,sha256=hPF8O20-EeQSYEKR-btLvlJYJzZ4iGCYe4MYqdOLFZc,1145
+fontTools/ttLib/tables/_f_e_a_t.py,sha256=onaD-G78aqxUjhR7TEmoi2Ld58cVxA0cwEuduLEZVPA,538
+fontTools/ttLib/tables/_f_p_g_m.py,sha256=4HtL26BMzgeobLd3wLvgwDjmm2eVMzlpUwzDJ8mBM8I,986
+fontTools/ttLib/tables/_f_v_a_r.py,sha256=u5VWsDvK2zHdt6aIOK6GgRR4vRHBqj6bclWVmILKgzk,8258
+fontTools/ttLib/tables/_g_a_s_p.py,sha256=NBhZE7gVVQaJTGm2G7alRclidvxDTUTEXqECemZKhz0,1585
+fontTools/ttLib/tables/_g_c_i_d.py,sha256=4VWq2u6c21ZOQ5_EJ5EwtZXC-zDz6SOPYwDDRZWRczA,170
+fontTools/ttLib/tables/_g_l_y_f.py,sha256=__3y3vXmC1qKO1_9FrsqE9alllLF8RtqRyrabaW8SdY,56607
+fontTools/ttLib/tables/_g_v_a_r.py,sha256=9DTWKB-FuX7PbhAORK1ny9UlAaR14ulyXd-oVmz_H5o,7809
+fontTools/ttLib/tables/_h_d_m_x.py,sha256=ih1-qeztwSksTzq5QQ2LGhL8C96Y7KpUmYvrgsQnGNA,3340
+fontTools/ttLib/tables/_h_e_a_d.py,sha256=loFEWrCQVSu_SPI-pEQLfpZOB7Qrx1NYPqnsF_wmCf4,3965
+fontTools/ttLib/tables/_h_h_e_a.py,sha256=SesDOndy8-Bgte8qE8xMmiAi9ARhqal5Y_ISAiYvWmg,3655
+fontTools/ttLib/tables/_h_m_t_x.py,sha256=5Jf3iZzFGIPf5IppNcsEsJpjarbdiuaax3wKaogBGJo,4618
+fontTools/ttLib/tables/_k_e_r_n.py,sha256=rY2tkN-EEd5tIFCAaJfVLFy0OERPeBqs5_fE4qEIt00,8423
+fontTools/ttLib/tables/_l_c_a_r.py,sha256=SsYzAup_e8Kg6LEC4sXDkwXNBy27-PDV8yOKyaOKj1w,85
+fontTools/ttLib/tables/_l_o_c_a.py,sha256=3t5scKnEhKr6bmNUNdEeyqCZU0ycZg8fNsyl45Mzc9E,1621
+fontTools/ttLib/tables/_l_t_a_g.py,sha256=pTbtCDy8yegXfbgJWXVIzllE0xHMCteDppNkunfdtsI,1921
+fontTools/ttLib/tables/_m_a_x_p.py,sha256=eNwy3vfTQi-UnHgmkTwh6DcUjhHvQWE13-TToTRsLzQ,4191
+fontTools/ttLib/tables/_m_e_t_a.py,sha256=3L-8ahYDxh_XoRuS4WoVR8SeKpq71YUdkVUaT9rO_4I,3618
+fontTools/ttLib/tables/_m_o_r_t.py,sha256=2p7PzPGzdOtFhg-Fxvdh0PO4yRs6_z_WjQegexeZCsw,170
+fontTools/ttLib/tables/_m_o_r_x.py,sha256=UJhBbA3mgVQO1oGmu_2bNXUwQreVSztG85F9k7DpmiQ,170
+fontTools/ttLib/tables/_n_a_m_e.py,sha256=tFetcdXscocYpMXfnNbcr-qTNA1dVuXLyVJUPmICXDI,33507
+fontTools/ttLib/tables/_o_p_b_d.py,sha256=t3eqUkZPyaQbahEmKaqp7brDNbt4MQje2Vq1jBu-fEc,170
+fontTools/ttLib/tables/_p_o_s_t.py,sha256=V0qyOfIIIK5p_qVWrZHq1qOqE33bCEfavujyQRj2OEM,9208
+fontTools/ttLib/tables/_p_r_e_p.py,sha256=oSLIN8AA-o1iQfoyiB8N170gDusGw_NhI9uQP_HW0O8,111
+fontTools/ttLib/tables/_p_r_o_p.py,sha256=3JHFloIJwg9n4dzoe4KLobHc75oJh6DLNe51sakfz8E,170
+fontTools/ttLib/tables/_s_b_i_x.py,sha256=9hOtZT6hek3eNv-lii3j4HuTQz5FkwGnS21kTaQoP2E,3877
+fontTools/ttLib/tables/_t_r_a_k.py,sha256=q7XKRVrnhvnnQpsg7J_Ve5ViHx3aYErKBhMaJ3dUfUM,9321
+fontTools/ttLib/tables/_v_h_e_a.py,sha256=yDEMPJ6oZJD8HCi8OJkdmFV0qUDeyygEY0w1DawRiHw,3384
+fontTools/ttLib/tables/_v_m_t_x.py,sha256=3iOPQroHFa8Z1DPzAeWDTG5yJnpU1IWkULglfVrB8a8,217
+fontTools/ttLib/tables/asciiTable.py,sha256=1QiLVGPVbksDM7A-DR2rbLl8EOyzlbtJcr-GIpFbbUc,560
+fontTools/ttLib/tables/grUtils.py,sha256=SPa8cdnbmSoQ47nVQ9Ohh2g3J-9yOrxtuC2n5sXIgHU,2217
+fontTools/ttLib/tables/otBase.py,sha256=WMmMDwbFhohvzZC-aQBvc6sCG4Zc-LGfuVjnDjdRUqg,42601
+fontTools/ttLib/tables/otConverters.py,sha256=Lp4UXdeN2_1Elynqbo-xI0qduatDKi7zhE3YuaRsquQ,59277
+fontTools/ttLib/tables/otData.py,sha256=ruj26Pli0j04bpKduv890bsMulz3CgLXH4Ma6Sa7fV4,112924
+fontTools/ttLib/tables/otTables.py,sha256=bUJg5P2ECHG5VwyE7five51HnvWZujwCJQnwE_GtoI0,63991
+fontTools/ttLib/tables/otTraverse.py,sha256=OgOaLKMiSRkJGvNaeOn7XT4OAAKs2P5FjgdQb1qEADk,4516
+fontTools/ttLib/tables/sbixGlyph.py,sha256=Y7pP0hJ7n4uVGVP9FniWvfO4erXqkhwBAtN54k-41dc,4426
+fontTools/ttLib/tables/sbixStrike.py,sha256=90-ZDlAQnz5gHkmkLWgy2OBBC2JYyXKdT15gLsrbD3g,5381
+fontTools/ttLib/tables/table_API_readme.txt,sha256=eZlRTLUkLzc_9Ot3pdfhyMb3ahU0_Iipx0vSbzOVGy8,2748
+fontTools/ttLib/tables/ttProgram.py,sha256=_KO3fWAB-qUmdKsHP4YyFkj9VtqtDCm_Y_YIT3I-yQQ,27162
+fontTools/ttLib/ttCollection.py,sha256=VuiiKBbWbs9-ogmRdAJ9iBUEonPzfqXjJxjtx4NJ31o,3423
+fontTools/ttLib/ttFont.py,sha256=izKJ4CQteMABFke6bhx34KmAOX1YclkxGwmC9ihLPak,34475
+fontTools/ttLib/woff2.py,sha256=mz1AC9ftrIYCVZbYeEa1b1B9UrxvkvQYRQGvDS6BxOw,49544
+fontTools/ttx.py,sha256=ux6XHv7XbEL9BuRVNP41ZiGhvC0YvR-riAQwEH9TI3Y,13702
+fontTools/ufoLib/__init__.py,sha256=oDJzK8N0qV7Ktuu-HmpJ3pMKDZ24TqWabFbilm73Za4,79098
+fontTools/ufoLib/__pycache__/__init__.cpython-38.pyc,,
+fontTools/ufoLib/__pycache__/converters.cpython-38.pyc,,
+fontTools/ufoLib/__pycache__/errors.cpython-38.pyc,,
+fontTools/ufoLib/__pycache__/etree.cpython-38.pyc,,
+fontTools/ufoLib/__pycache__/filenames.cpython-38.pyc,,
+fontTools/ufoLib/__pycache__/glifLib.cpython-38.pyc,,
+fontTools/ufoLib/__pycache__/kerning.cpython-38.pyc,,
+fontTools/ufoLib/__pycache__/plistlib.cpython-38.pyc,,
+fontTools/ufoLib/__pycache__/pointPen.cpython-38.pyc,,
+fontTools/ufoLib/__pycache__/utils.cpython-38.pyc,,
+fontTools/ufoLib/__pycache__/validators.cpython-38.pyc,,
+fontTools/ufoLib/converters.py,sha256=bZp27v2VmsyGEq3IzQOB9U3Cv1f5eB1jbZugj5bJWwo,10583
+fontTools/ufoLib/errors.py,sha256=PQFraTNS0BQb0nmpMcDKKpj54xRyi15dbIxoBhxwy70,191
+fontTools/ufoLib/etree.py,sha256=rGcXuMfk4mgn1nBCSMVP6CAuSAN51DrZMw8PYxbgrBA,223
+fontTools/ufoLib/filenames.py,sha256=YPvWyxcH0HnLurK1fOH_WgwAsUi6DeXqSWAUZD080eQ,6888
+fontTools/ufoLib/glifLib.py,sha256=KjwmHmdZ_R9mVKEKzIaghLzLKnUfAcFTQ8ow3jQEkJg,59641
+fontTools/ufoLib/kerning.py,sha256=se4WYX8gTCLyp2VbM8_QT347xyQFdJWHFuzoef-i3CY,2606
+fontTools/ufoLib/plistlib.py,sha256=EYnhCMPmbtnRuutKHLzJTvkYix80mAkpXTEIcdRNUgQ,1498
+fontTools/ufoLib/pointPen.py,sha256=-gZR_E9QabqYbI1IVXCppJjQL5qJwUcBvO4_Bnujbzg,232
+fontTools/ufoLib/utils.py,sha256=E7HahGBiqb2k9bCJP__8eBw9XzjDDwc8Zt_UUwYT5LQ,1892
+fontTools/ufoLib/validators.py,sha256=tqEHhDgtE3IhRpd1uCjBbs8vpBUz0K1D1YYzc2ljAcM,26095
+fontTools/unicode.py,sha256=xI7e7NcvFHK00veR3KTWq-cdNcw61H3zQSxvSIZY2bQ,999
+fontTools/unicodedata/Blocks.py,sha256=UpREe6IH3i9t0nHw6aVsAZvtxTEv9-EPc02lvvjWnTw,43124
+fontTools/unicodedata/OTTags.py,sha256=oUDJC8mDUjvh0ftu5EwmK_hUY52CAEuf1GGRf2d0d8k,1122
+fontTools/unicodedata/ScriptExtensions.py,sha256=4exU01BpiCQ07mFDtQJ4kTUp8wUONKzPbCnmIYUyG_k,26709
+fontTools/unicodedata/Scripts.py,sha256=mJcIGLpVWS2sTxnSJVm2mfkXbEuNBes2wJqZrNyJXbM,124646
+fontTools/unicodedata/__init__.py,sha256=bQHu4Sf5wSdguAOj8S2mAkej1hp7TsiiIx4umP3mS-I,8337
+fontTools/unicodedata/__pycache__/Blocks.cpython-38.pyc,,
+fontTools/unicodedata/__pycache__/OTTags.cpython-38.pyc,,
+fontTools/unicodedata/__pycache__/ScriptExtensions.cpython-38.pyc,,
+fontTools/unicodedata/__pycache__/Scripts.cpython-38.pyc,,
+fontTools/unicodedata/__pycache__/__init__.cpython-38.pyc,,
+fontTools/varLib/__init__.py,sha256=WFidQz7guW4F-tXCxcOPdGybvUTiZ3zP3vMVUN7RShI,37845
+fontTools/varLib/__main__.py,sha256=i2W6IG8FJ3KzOfx5yJ1TC8uQ1dg8fxHE4eywfEQUhgc,92
+fontTools/varLib/__pycache__/__init__.cpython-38.pyc,,
+fontTools/varLib/__pycache__/__main__.cpython-38.pyc,,
+fontTools/varLib/__pycache__/builder.cpython-38.pyc,,
+fontTools/varLib/__pycache__/cff.cpython-38.pyc,,
+fontTools/varLib/__pycache__/errors.cpython-38.pyc,,
+fontTools/varLib/__pycache__/featureVars.cpython-38.pyc,,
+fontTools/varLib/__pycache__/interpolatable.cpython-38.pyc,,
+fontTools/varLib/__pycache__/interpolate_layout.cpython-38.pyc,,
+fontTools/varLib/__pycache__/iup.cpython-38.pyc,,
+fontTools/varLib/__pycache__/merger.cpython-38.pyc,,
+fontTools/varLib/__pycache__/models.cpython-38.pyc,,
+fontTools/varLib/__pycache__/mutator.cpython-38.pyc,,
+fontTools/varLib/__pycache__/mvar.cpython-38.pyc,,
+fontTools/varLib/__pycache__/plot.cpython-38.pyc,,
+fontTools/varLib/__pycache__/stat.cpython-38.pyc,,
+fontTools/varLib/__pycache__/varStore.cpython-38.pyc,,
+fontTools/varLib/builder.py,sha256=ur0GazeGbxmEkNhXkxPoEt-m4IgM6elvWYgKmy10yh8,4307
+fontTools/varLib/cff.py,sha256=5kX6jZzttmQm3hQ-NDgUHj2ATPTjxDBhjzlEeOHQIe0,21433
+fontTools/varLib/errors.py,sha256=z-mk-GeH1GUkOP5y26jWhWagN6Il8PoDdxRzm8-5gW4,6475
+fontTools/varLib/featureVars.py,sha256=AIbMFYr3Qc9DsUkr0CXE53YRV6FM46UzsPEnZBiUkgM,20093
+fontTools/varLib/instancer/__init__.py,sha256=0D8XweLjYicugGYma1QhlyGDqXlsnIaogrzZEw1CsUg,58256
+fontTools/varLib/instancer/__main__.py,sha256=zfULwcP01FhplS1IlcMgNQnLxk5RVfmOuinWjqeid-g,104
+fontTools/varLib/instancer/__pycache__/__init__.cpython-38.pyc,,
+fontTools/varLib/instancer/__pycache__/__main__.cpython-38.pyc,,
+fontTools/varLib/instancer/__pycache__/names.cpython-38.pyc,,
+fontTools/varLib/instancer/names.py,sha256=xV0Bh2ZohY3WEewT2Sgkezhbf3LZ6BpKsk6cuuRrIUY,14413
+fontTools/varLib/interpolatable.py,sha256=Ma5Lj3i25NOdoUD0H_cVSXG-6r2ZRHM10OQCHw5eBUU,15569
+fontTools/varLib/interpolate_layout.py,sha256=6_E0fUu-5471uP6j-X2Ucrf9zmTveay_qg7C4SbnB9w,3311
+fontTools/varLib/iup.py,sha256=33owbarj_pRGYUq3awrwd2_xyJlIXE1qeJ9qrY_8iPg,9181
+fontTools/varLib/merger.py,sha256=tQZSyoFGBmxoUcTQaPCJDBZ4eBJSnm2ulRuXR_PjtG0,49933
+fontTools/varLib/models.py,sha256=2y3Yj-bOllBOy3pb6-aRrShfvIB6kql_Ljz_NMG4Cq4,17329
+fontTools/varLib/mutator.py,sha256=j030AitfHzZg84MWIOwBnJHk_tZ56ho-qruW7RUdBIE,15699
+fontTools/varLib/mvar.py,sha256=_OZpbDH7MiZTeN_RHP2ggjNIP-HxUG2Y5LMk428_q3s,2366
+fontTools/varLib/plot.py,sha256=c8xyDSLjc_0gO_DmS-tlXnqU-Bhedh2GTk4xRavkWTc,4153
+fontTools/varLib/stat.py,sha256=pNtU3Jebm8Gr5umrbF5xGj5yJQciFwSFpfePOcg37xY,4535
+fontTools/varLib/varStore.py,sha256=WIBxcJKuEowfnQXYIBgjZOXj8Mq58W9Yc3Mlq_2_Q-8,17430
+fontTools/voltLib/__init__.py,sha256=ZZ1AsTx1VlDn40Kupce-fM3meOWugy3RZraBW9LG-9M,151
+fontTools/voltLib/__pycache__/__init__.cpython-38.pyc,,
+fontTools/voltLib/__pycache__/ast.cpython-38.pyc,,
+fontTools/voltLib/__pycache__/error.cpython-38.pyc,,
+fontTools/voltLib/__pycache__/lexer.cpython-38.pyc,,
+fontTools/voltLib/__pycache__/parser.cpython-38.pyc,,
+fontTools/voltLib/ast.py,sha256=AYbtVgA4qwraQSDwh7LJgCruxqi0mPw6_1oCDThEn48,13175
+fontTools/voltLib/error.py,sha256=75bGxDBvh4OrpmW4E7pgqkvtgq8ZwetyjRtf7dLT5zQ,397
+fontTools/voltLib/lexer.py,sha256=QjslaIn2YF-u1jNQR4Vi9jn60DbUHkc6c6lmLGvzhkg,3417
+fontTools/voltLib/parser.py,sha256=LXEuSwWzcO1BfJTb6XOJKVwYVV1CQdRRiFZxz2W44zk,25244
+fonttools-4.34.4.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
+fonttools-4.34.4.dist-info/LICENSE,sha256=Z4cgj4P2Wcy8IiOy_elS_6b36KymLxqKK_W8UbsbI4M,1072
+fonttools-4.34.4.dist-info/METADATA,sha256=Is-A-kxp6ihXLT-F8BsfKIJlUQHbWD22xVEFBKJow2I,129218
+fonttools-4.34.4.dist-info/RECORD,,
+fonttools-4.34.4.dist-info/REQUESTED,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+fonttools-4.34.4.dist-info/WHEEL,sha256=G16H4A3IeoQmnOrYV4ueZGKSjhipXx8zc8nu9FGlvMA,92
+fonttools-4.34.4.dist-info/entry_points.txt,sha256=mwtKkpxzi1TdC9N2bHaMWt9cveTLK1X8tg5kvzjC6A4,148
+fonttools-4.34.4.dist-info/top_level.txt,sha256=rRgRylrXzekqWOsrhygzib12pQ7WILf7UGjqEwkIFDM,10

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/fonttools-4.34.4.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
+

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/fonttools-4.34.4.dist-info/entry_points.txt

@@ -0,0 +1,6 @@
+[console_scripts]
+fonttools = fontTools.__main__:main
+pyftmerge = fontTools.merge:main
+pyftsubset = fontTools.subset:main
+ttx = fontTools.ttx:main
+

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/frozenlist/__init__.py

@@ -0,0 +1,96 @@
+import os
+import sys
+import types
+from collections.abc import MutableSequence
+from functools import total_ordering
+from typing import Tuple, Type
+
+__version__ = "1.3.0"
+
+__all__ = ("FrozenList", "PyFrozenList")  # type: Tuple[str, ...]
+
+
+NO_EXTENSIONS = bool(os.environ.get("FROZENLIST_NO_EXTENSIONS"))  # type: bool
+
+
+@total_ordering
+class FrozenList(MutableSequence):
+
+    __slots__ = ("_frozen", "_items")
+
+    if sys.version_info >= (3, 9):
+        __class_getitem__ = classmethod(types.GenericAlias)
+    else:
+
+        @classmethod
+        def __class_getitem__(cls: Type["FrozenList"]) -> Type["FrozenList"]:
+            return cls
+
+    def __init__(self, items=None):
+        self._frozen = False
+        if items is not None:
+            items = list(items)
+        else:
+            items = []
+        self._items = items
+
+    @property
+    def frozen(self):
+        return self._frozen
+
+    def freeze(self):
+        self._frozen = True
+
+    def __getitem__(self, index):
+        return self._items[index]
+
+    def __setitem__(self, index, value):
+        if self._frozen:
+            raise RuntimeError("Cannot modify frozen list.")
+        self._items[index] = value
+
+    def __delitem__(self, index):
+        if self._frozen:
+            raise RuntimeError("Cannot modify frozen list.")
+        del self._items[index]
+
+    def __len__(self):
+        return self._items.__len__()
+
+    def __iter__(self):
+        return self._items.__iter__()
+
+    def __reversed__(self):
+        return self._items.__reversed__()
+
+    def __eq__(self, other):
+        return list(self) == other
+
+    def __le__(self, other):
+        return list(self) <= other
+
+    def insert(self, pos, item):
+        if self._frozen:
+            raise RuntimeError("Cannot modify frozen list.")
+        self._items.insert(pos, item)
+
+    def __repr__(self):
+        return f"<FrozenList(frozen={self._frozen}, {self._items!r})>"
+
+    def __hash__(self):
+        if self._frozen:
+            return hash(tuple(self))
+        else:
+            raise RuntimeError("Cannot hash unfrozen list.")
+
+
+PyFrozenList = FrozenList
+
+
+try:
+    from ._frozenlist import FrozenList as CFrozenList  # type: ignore
+
+    if not NO_EXTENSIONS:  # pragma: no cover
+        FrozenList = CFrozenList  # type: ignore
+except ImportError:  # pragma: no cover
+    pass

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/frozenlist/__init__.pyi

@@ -0,0 +1,47 @@
+from typing import (
+    Generic,
+    Iterable,
+    Iterator,
+    List,
+    MutableSequence,
+    Optional,
+    TypeVar,
+    Union,
+    overload,
+)
+
+_T = TypeVar("_T")
+_Arg = Union[List[_T], Iterable[_T]]
+
+class FrozenList(MutableSequence[_T], Generic[_T]):
+    def __init__(self, items: Optional[_Arg[_T]] = None) -> None: ...
+    @property
+    def frozen(self) -> bool: ...
+    def freeze(self) -> None: ...
+    @overload
+    def __getitem__(self, i: int) -> _T: ...
+    @overload
+    def __getitem__(self, s: slice) -> FrozenList[_T]: ...
+    @overload
+    def __setitem__(self, i: int, o: _T) -> None: ...
+    @overload
+    def __setitem__(self, s: slice, o: Iterable[_T]) -> None: ...
+    @overload
+    def __delitem__(self, i: int) -> None: ...
+    @overload
+    def __delitem__(self, i: slice) -> None: ...
+    def __len__(self) -> int: ...
+    def __iter__(self) -> Iterator[_T]: ...
+    def __reversed__(self) -> Iterator[_T]: ...
+    def __eq__(self, other: object) -> bool: ...
+    def __le__(self, other: FrozenList[_T]) -> bool: ...
+    def __ne__(self, other: object) -> bool: ...
+    def __lt__(self, other: FrozenList[_T]) -> bool: ...
+    def __ge__(self, other: FrozenList[_T]) -> bool: ...
+    def __gt__(self, other: FrozenList[_T]) -> bool: ...
+    def insert(self, pos: int, item: _T) -> None: ...
+    def __repr__(self) -> str: ...
+    def __hash__(self) -> int: ...
+
+# types for C accelerators are the same
+CFrozenList = PyFrozenList = FrozenList