Add files using upload-large-folder tool

.gitattributes

@@ -109,3 +109,9 @@ tuning-competition-baseline/.venv/lib/python3.11/site-packages/torch/_inductor/_
 .venv/lib/python3.11/site-packages/pillow.libs/libopenjp2-05423b53.so filter=lfs diff=lfs merge=lfs -text
 .venv/lib/python3.11/site-packages/pillow.libs/libxcb-b8a56d01.so.1.1.0 filter=lfs diff=lfs merge=lfs -text
 .venv/lib/python3.11/site-packages/vllm/worker/__pycache__/hpu_model_runner.cpython-311.pyc filter=lfs diff=lfs merge=lfs -text
+.venv/lib/python3.11/site-packages/torchvision.libs/libwebp.4a54d2c8.so.4 filter=lfs diff=lfs merge=lfs -text
+.venv/lib/python3.11/site-packages/torchvision.libs/libnvjpeg.02b6d700.so.12 filter=lfs diff=lfs merge=lfs -text
+.venv/lib/python3.11/site-packages/torchvision.libs/libcudart.41118559.so.12 filter=lfs diff=lfs merge=lfs -text
+.venv/lib/python3.11/site-packages/pycparser/__pycache__/yacctab.cpython-311.pyc filter=lfs diff=lfs merge=lfs -text
+.venv/lib/python3.11/site-packages/torchvision.libs/libz.5f199d92.so.1 filter=lfs diff=lfs merge=lfs -text
+.venv/lib/python3.11/site-packages/torchvision.libs/libjpeg.ceea7512.so.62 filter=lfs diff=lfs merge=lfs -text

.venv/lib/python3.11/site-packages/airportsdata-20241001.dist-info/INSTALLER

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

.venv/lib/python3.11/site-packages/airportsdata-20241001.dist-info/LICENSE

@@ -0,0 +1,24 @@
+The MIT License (MIT)
+
+Copyright (c) 2020- Mike Borsetti <mike@borsetti.com>
+
+This project includes data from https://github.com/mwgg/Airports Copyright
+(c) 2014 mwgg
+
+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.

.venv/lib/python3.11/site-packages/airportsdata-20241001.dist-info/METADATA

@@ -0,0 +1,194 @@
+Metadata-Version: 2.1
+Name: airportsdata
+Version: 20241001
+Summary: Extensive database of location and timezone data for nearly every airport and landing strip in the world.
+Author-email: Mike Borsetti <mike+airportsdata@borsetti.com>
+Maintainer-email: Mike Borsetti <mike+airportsdata@borsetti.com>
+License: The MIT License (MIT)
+        
+        Copyright (c) 2020- Mike Borsetti <mike@borsetti.com>
+        
+        This project includes data from https://github.com/mwgg/Airports Copyright
+        (c) 2014 mwgg
+        
+        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.
+        
+Project-URL: Documentation, https://github.com/mborsetti/airportsdata/blob/main/README.rst
+Project-URL: Repository, https://github.com/mborsetti/airportsdata/
+Project-URL: Database (csv), https://github.com/mborsetti/airportsdata/blob/main/airportsdata/airports.csv
+Project-URL: Changelog, https://github.com/mborsetti/airportsdata/blob/main/CHANGELOG.rst
+Project-URL: Issues, https://github.com/mborsetti/airportsdata/issues
+Project-URL: CI, https://github.com/mborsetti/airportsdata/actions
+Keywords: airports,aerodromes,ICAO,IATA
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Database
+Classifier: Intended Audience :: Developers
+Classifier: Typing :: Typed
+Requires-Python: >=3.9
+Description-Content-Type: text/x-rst
+License-File: LICENSE
+
+========================
+airportsdata |downloads|
+========================
+
+.. |ICAO| replace:: 28,237
+
+.. |IATA| replace:: 7,876
+
+.. |LID| replace:: 12,604
+
+.. |pyversion| image:: https://img.shields.io/pypi/v/airportsdata.svg
+    :target: https://pypi.org/project/airportsdata/
+    :alt: pypi version
+.. |support| image:: https://img.shields.io/pypi/pyversions/airportsdata.svg
+    :target: https://pypi.org/project/airportsdata/
+    :alt: supported Python version
+.. |pypi_version| image:: https://img.shields.io/pypi/v/airportsdata.svg?label=
+    :target: https://pypi.org/project/airportsdata/
+    :alt: PyPI version
+.. |format| image:: https://img.shields.io/pypi/format/airportsdata.svg
+    :target: https://pypi.org/project/airportsdata/
+    :alt: Kit format
+.. |downloads| image:: https://static.pepy.tech/badge/airportsdata
+    :target: https://www.pepy.tech/project/airportsdata
+    :alt: PyPI downloads
+.. |license| image:: https://img.shields.io/pypi/l/airportsdata.svg
+    :target: https://pypi.org/project/airportsdata/
+    :alt: license
+.. |issues| image:: https://img.shields.io/github/issues-raw/mborsetti/airportsdata
+    :target: https://github.com/mborsetti/airportsdata/issues
+    :alt: issues
+.. |CI| image:: https://github.com/mborsetti/airportsdata/actions/workflows/ci-cd.yaml/badge.svg?event=push
+    :target: https://github.com/mborsetti/airportsdata/actions
+    :alt: CI testing status
+.. |coveralls| image:: https://coveralls.io/repos/github/mborsetti/airportsdata/badge.svg?branch=main
+    :target: https://coveralls.io/github/mborsetti/airportsdata?branch=main
+    :alt: code coverage by Coveralls
+.. |status| image:: https://img.shields.io/pypi/status/airportsdata.svg
+    :target: https://pypi.org/project/airportsdata/
+    :alt: Package stability
+.. |security| image:: https://img.shields.io/badge/security-bandit-yellow.svg
+    :target: https://github.com/PyCQA/bandit
+    :alt: Security Status
+
+Extensive database of location and timezone data for nearly every operational airport and landing strip in the world,
+with |ICAO| entries.
+
+Each entry consists of the following data:
+
+* ``icao``: ICAO 4-letter Location Indicator (Doc 7910) or (if none) an internal Pseudo-ICAO Identifier [#]_ (|ICAO|
+  entries);
+* ``iata``: IATA 3-letter Location Code (|IATA| entries) or an empty string [#]_;
+* ``name``: Official name (diacritized latin script);
+* ``city``: City (diacritized latin script), ideally using the local language;
+* ``subd``: Subdivision (e.g. state, province, region, etc.), ideally using the local-language or English names of
+  `ISO 3166-2 <https://en.wikipedia.org/wiki/ISO_3166-2#Current_codes>`__;
+* ``country``: `ISO 3166-1 <https://en.wikipedia.org/wiki/ISO_3166-1#Current_codes>`__ alpha-2 country code
+  (plus ``XK`` for Kosovo);
+* ``elevation``: MSL elevation of the highest point of the landing area, in feet (warning: it is often wrong);
+* ``lat``: Latitude (decimal) of the `airport reference point
+  <https://en.wikipedia.org/wiki/Airport_reference_point>`__ (max 5 decimal digits);
+* ``lon``: Longitude (decimal) of the `airport reference point
+  <https://en.wikipedia.org/wiki/Airport_reference_point>`__ (max 5 decimal digits);
+* ``tz``: Timezone expressed as a `tz database name <https://en.wikipedia.org/wiki/List_of_tz_database_time_zones>`__
+  (IANA-compliant);
+* ``lid``: U.S. FAA Location Identifier (|LID| entries), or an empty string.
+
+.. [#] See `here <https://github.com/mborsetti/airportsdata/blob/main/README_identifiers.rst>`__ for an explanation on
+   how the Pseudo-ICAO Identifier is generated for airports and seaplane bases without an ICAO 4-letter Location
+   Indicator.
+
+.. [#] IATA Multi Airport Cities are not not airports and therfore not included, but we provide a database and a Python
+   function that returns the above data for all the airports of a IATA MAC. Please see documentation `here
+   <https://github.com/mborsetti/airportsdata/blob/main/README_IATA.rst>`__.
+
+Best efforts are placed to review all contributions for accuracy, but accuracy cannot be guaranteed nor should be
+expected by users.
+
+Important notes:
+
+* Timezone was originally sourced from `TimeZoneDB <https://timezonedb.com>`__;
+* No historical data (closed airports are removed).
+
+Please report any issues you may find `here
+<https://github.com/mborsetti/airportsdata/blob/main/CONTRIBUTING.rst>`__.
+
+This project is a fork of https://github.com/mwgg/Airports. All new data submitted in this fork have been validated
+against national `Aeronautical Information Publications (AIP) or equivalent
+<https://github.com/mborsetti/airportsdata/blob/main/README_AIP.rst>`__ (or
+ARINC database) and `IATA <https://www.iata.org/en/publications/directories/code-search/>`__ before publishing.
+
+Raw data
+========
+
+A CSV (comma separated values) file, with headers and encoded in UTF-8, is downloadable from GitHub `here
+<https://github.com/mborsetti/airportsdata/raw/main/airportsdata/airports.csv>`__.
+
+Python
+======
+|pyversion| |support| |format| |status| |security| |CI| |coveralls| |issues|
+
+Install from `PyPi <https://pypi.org/project/airportsdata/>`__  using pip:
+
+.. code-block:: bash
+
+  pip install -U airportsdata
+
+Once installed, to load the data into a dict:
+
+.. code-block:: python
+
+   import airportsdata
+   airports = airportsdata.load()  # key is the ICAO identifier (the default)
+   print(airports['KJFK'])
+
+or
+
+.. code-block:: python
+
+   import airportsdata
+   airports = airportsdata.load('IATA')  # key is the IATA location code
+   print(airports['JFK'])
+
+or
+
+.. code-block:: python
+
+   import airportsdata
+   airports = airportsdata.load('LID')  # key is the FAA LID
+   print(airports['01AA'])
+
+Older Python versions are supported for 3 years after being obsoleted by a new major release (i.e. about 4 years
+since their original release).
+
+License |license|
+=================
+
+Released under the `MIT License <https://opensource.org/licenses/MIT>`__ (see license `here
+<https://github.com/mborsetti/airportsdata/blob/main/LICENSE>`__).

.venv/lib/python3.11/site-packages/airportsdata-20241001.dist-info/RECORD

@@ -0,0 +1,11 @@
+airportsdata-20241001.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
+airportsdata-20241001.dist-info/LICENSE,sha256=Gra_Nl4fahiDq2oveX52GyIQgbUqMyc9hsFX_VYhBr4,1191
+airportsdata-20241001.dist-info/METADATA,sha256=xZmo6PVCkbbv3Shhg0Oqocc0ZuC-XY1QDDPRO8q6dhw,8918
+airportsdata-20241001.dist-info/RECORD,,
+airportsdata-20241001.dist-info/WHEEL,sha256=GV9aMThwP_4oNCtvEC2ec3qUYutgWeAzklro_0m4WJQ,91
+airportsdata-20241001.dist-info/top_level.txt,sha256=pwno2lCh8ojWgA5MI3oKaEO0U96yNrH106dZIvhEbgE,13
+airportsdata/__init__.py,sha256=fUFo8sBUvVeZiWXRmWZ3Udxi5TSoM4WZIvv_KngF3Cc,5261
+airportsdata/__pycache__/__init__.cpython-311.pyc,,
+airportsdata/airports.csv,sha256=koANA3k5geIpWLnSzKML0CUOGKSCxkpAx9R8Chiuoio,3040844
+airportsdata/iata_macs.csv,sha256=jgeMECojIRDZ5e6JcTYQF0NRzGOCdJK9YCf-nB0u3Iw,4061
+airportsdata/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0

.venv/lib/python3.11/site-packages/airportsdata-20241001.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (75.1.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

.venv/lib/python3.11/site-packages/airportsdata-20241001.dist-info/top_level.txt

@@ -0,0 +1 @@
+airportsdata

.venv/lib/python3.11/site-packages/google_auth-2.38.0.dist-info/INSTALLER

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

.venv/lib/python3.11/site-packages/google_auth-2.38.0.dist-info/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

.venv/lib/python3.11/site-packages/google_auth-2.38.0.dist-info/METADATA

@@ -0,0 +1,138 @@
+Metadata-Version: 2.1
+Name: google-auth
+Version: 2.38.0
+Summary: Google Authentication Library
+Home-page: https://github.com/googleapis/google-auth-library-python
+Author: Google Cloud Platform
+Author-email: googleapis-packages@google.com
+License: Apache 2.0
+Keywords: google auth oauth client
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Operating System :: POSIX
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Operating System :: MacOS :: MacOS X
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Internet :: WWW/HTTP
+Requires-Python: >=3.7
+License-File: LICENSE
+Requires-Dist: cachetools<6.0,>=2.0.0
+Requires-Dist: pyasn1-modules>=0.2.1
+Requires-Dist: rsa<5,>=3.1.4
+Provides-Extra: aiohttp
+Requires-Dist: aiohttp<4.0.0.dev0,>=3.6.2; extra == "aiohttp"
+Requires-Dist: requests<3.0.0.dev0,>=2.20.0; extra == "aiohttp"
+Provides-Extra: enterprise_cert
+Requires-Dist: cryptography; extra == "enterprise-cert"
+Requires-Dist: pyopenssl; extra == "enterprise-cert"
+Provides-Extra: pyjwt
+Requires-Dist: pyjwt>=2.0; extra == "pyjwt"
+Requires-Dist: cryptography>=38.0.3; extra == "pyjwt"
+Provides-Extra: pyopenssl
+Requires-Dist: pyopenssl>=20.0.0; extra == "pyopenssl"
+Requires-Dist: cryptography>=38.0.3; extra == "pyopenssl"
+Provides-Extra: reauth
+Requires-Dist: pyu2f>=0.1.5; extra == "reauth"
+Provides-Extra: requests
+Requires-Dist: requests<3.0.0.dev0,>=2.20.0; extra == "requests"
+
+Google Auth Python Library
+==========================
+
+|pypi|
+
+This library simplifies using Google's various server-to-server authentication
+mechanisms to access Google APIs.
+
+.. |pypi| image:: https://img.shields.io/pypi/v/google-auth.svg
+   :target: https://pypi.python.org/pypi/google-auth
+
+Installing
+----------
+
+You can install using `pip`_::
+
+    $ pip install google-auth
+
+.. _pip: https://pip.pypa.io/en/stable/
+
+For more information on setting up your Python development environment, please refer to `Python Development Environment Setup Guide`_ for Google Cloud Platform.
+
+.. _`Python Development Environment Setup Guide`: https://cloud.google.com/python/docs/setup
+
+Extras
+------
+
+google-auth has few extras that you can install. For example::
+
+    $ pip install google-auth[pyopenssl]
+
+Note that the extras pyopenssl and enterprise_cert should not be used together because they use conflicting versions of `cryptography`_.
+
+.. _`cryptography`: https://cryptography.io/en/latest/
+
+Supported Python Versions
+^^^^^^^^^^^^^^^^^^^^^^^^^
+Python >= 3.7
+
+**NOTE**:
+Python 3.7 was marked as `unsupported`_ by the python community in June 2023.
+We recommend that all developers upgrade to Python 3.8 and newer as soon as
+they can. Support for Python 3.7 will be removed from this library after
+January 1 2024. Previous releases that support Python 3.7 will continue to be available
+for download, but releases after January 1 2024 will only target Python 3.8 and
+newer.
+
+.. _unsupported: https://devguide.python.org/versions/#unsupported-versions
+
+Unsupported Python Versions
+^^^^^^^^^^^^^^^^^^^^^^^^^^^
+- Python == 2.7:  The last version of this library with support for Python 2.7
+  was `google.auth == 1.34.0`.
+
+- Python 3.5:   The last version of this library with support for Python 3.5
+  was `google.auth == 1.23.0`.
+
+- Python 3.6:   The last version of this library with support for Python 3.6
+  was `google.auth == 2.22.0`.
+
+Documentation
+-------------
+
+Google Auth Python Library has usage and reference documentation at https://googleapis.dev/python/google-auth/latest/index.html.
+
+Current Maintainers
+-------------------
+- googleapis-auth@google.com
+
+Authors
+-------
+
+- `@theacodes <https://github.com/theacodes>`_ (Thea Flowers)
+- `@dhermes <https://github.com/dhermes>`_ (Danny Hermes)
+- `@lukesneeringer <https://github.com/lukesneeringer>`_ (Luke Sneeringer)
+- `@busunkim96 <https://github.com/busunkim96>`_ (Bu Sun Kim)
+
+Contributing
+------------
+
+Contributions to this library are always welcome and highly encouraged.
+
+See `CONTRIBUTING.rst`_ for more information on how to get started.
+
+.. _CONTRIBUTING.rst: https://github.com/googleapis/google-auth-library-python/blob/main/CONTRIBUTING.rst
+
+License
+-------
+
+Apache 2.0 - See `the LICENSE`_ for more information.
+
+.. _the LICENSE: https://github.com/googleapis/google-auth-library-python/blob/main/LICENSE

.venv/lib/python3.11/site-packages/google_auth-2.38.0.dist-info/RECORD

@@ -0,0 +1,150 @@
+google/auth/__init__.py,sha256=wg5MWwRk8nfJFMmUMU2gLirrPdGe9NMwqLkdSwdFwE8,1639
+google/auth/__pycache__/__init__.cpython-311.pyc,,
+google/auth/__pycache__/_cloud_sdk.cpython-311.pyc,,
+google/auth/__pycache__/_credentials_async.cpython-311.pyc,,
+google/auth/__pycache__/_credentials_base.cpython-311.pyc,,
+google/auth/__pycache__/_default.cpython-311.pyc,,
+google/auth/__pycache__/_default_async.cpython-311.pyc,,
+google/auth/__pycache__/_exponential_backoff.cpython-311.pyc,,
+google/auth/__pycache__/_helpers.cpython-311.pyc,,
+google/auth/__pycache__/_jwt_async.cpython-311.pyc,,
+google/auth/__pycache__/_oauth2client.cpython-311.pyc,,
+google/auth/__pycache__/_refresh_worker.cpython-311.pyc,,
+google/auth/__pycache__/_service_account_info.cpython-311.pyc,,
+google/auth/__pycache__/api_key.cpython-311.pyc,,
+google/auth/__pycache__/app_engine.cpython-311.pyc,,
+google/auth/__pycache__/aws.cpython-311.pyc,,
+google/auth/__pycache__/credentials.cpython-311.pyc,,
+google/auth/__pycache__/downscoped.cpython-311.pyc,,
+google/auth/__pycache__/environment_vars.cpython-311.pyc,,
+google/auth/__pycache__/exceptions.cpython-311.pyc,,
+google/auth/__pycache__/external_account.cpython-311.pyc,,
+google/auth/__pycache__/external_account_authorized_user.cpython-311.pyc,,
+google/auth/__pycache__/iam.cpython-311.pyc,,
+google/auth/__pycache__/identity_pool.cpython-311.pyc,,
+google/auth/__pycache__/impersonated_credentials.cpython-311.pyc,,
+google/auth/__pycache__/jwt.cpython-311.pyc,,
+google/auth/__pycache__/metrics.cpython-311.pyc,,
+google/auth/__pycache__/pluggable.cpython-311.pyc,,
+google/auth/__pycache__/version.cpython-311.pyc,,
+google/auth/_cloud_sdk.py,sha256=u7tbE3KdHBCzZK8ka47xG3CHHtF0DhFDjmPSgz8lwXg,5212
+google/auth/_credentials_async.py,sha256=bHB28wMULOIEMmYqKEOU06A4co7uIXPcnfVC_TaA6KY,6802
+google/auth/_credentials_base.py,sha256=KxdCZyoFyvrfWhJbNnuYkpUhxs0bmbxYvcH8-xp5hUs,2692
+google/auth/_default.py,sha256=xNeiYdYKhEYuAGap1ATDG9GrMUAfFO1_Sow-CenvBoE,30312
+google/auth/_default_async.py,sha256=r4bFozWfioQa4lIEC-psuRsLiVhnJbuW-uQ0daj7s3Q,11575
+google/auth/_exponential_backoff.py,sha256=qxA9ek80rBkoARx0Egl2b1MlYU0D-pQNVqgCmUh-lgU,5372
+google/auth/_helpers.py,sha256=7Zm-uwaZWyFb3fE2JQA-sJUTSBvltTgZkNkMGc7raRo,8236
+google/auth/_jwt_async.py,sha256=5mGab5CkdnBMkQkS4mtNkwFkktp1jBw6G1sYQk8bYKY,5972
+google/auth/_oauth2client.py,sha256=hPxcl_8q6Oxr0hOHPUWaWObxI85Pv-0q6kZhRUrT5oY,5855
+google/auth/_refresh_worker.py,sha256=7apJkFsD9oL1yz1K7O8v-YN3f3TdNBiJdd7_Wmq6zpE,3375
+google/auth/_service_account_info.py,sha256=KGruc_OxS7O7_EADD4JEIjjz_-5Xa1_rlgk1t0p1nvk,2816
+google/auth/aio/__init__.py,sha256=e3ToAxXNHhqJLBgW8B66650xdqrTCZDLcwP2p5DhCPM,869
+google/auth/aio/__pycache__/__init__.cpython-311.pyc,,
+google/auth/aio/__pycache__/credentials.cpython-311.pyc,,
+google/auth/aio/credentials.py,sha256=lXY0_SJ9c36Mzp47fN4a8JT5HfNzFQtIIwsZEwzoDR4,5273
+google/auth/aio/transport/__init__.py,sha256=8dQWHpube1IeWw02q6AvMRTM5V_2iN4y3UMLenbmUUQ,4692
+google/auth/aio/transport/__pycache__/__init__.cpython-311.pyc,,
+google/auth/aio/transport/__pycache__/aiohttp.cpython-311.pyc,,
+google/auth/aio/transport/__pycache__/sessions.cpython-311.pyc,,
+google/auth/aio/transport/aiohttp.py,sha256=u-tFrcYh2P06P4pKY2o56e7nuN-dXPMZhi3q6Q7YDGQ,6729
+google/auth/aio/transport/sessions.py,sha256=RcRHfkeo_ppEY1o8ts8aJqw76y54I8D0P8QT7yFq4aI,10388
+google/auth/api_key.py,sha256=PeieTYceHJIFCo0zQo1EA9NEDL_Ie6S78qmD-6Ig17s,2583
+google/auth/app_engine.py,sha256=LuEaoWM1UwcIUJ6OrLza0tTpqJBXbtzZ3XjN0C-6Wvk,6121
+google/auth/aws.py,sha256=2V5NLhboorkPLLwnA87VuyH9imruake6qhyHKV_rVYM,34568
+google/auth/compute_engine/__init__.py,sha256=BqeTka-oyHFATkys3SGKRlOyWQ8mVV0vVaP2hOwV4Qw,910
+google/auth/compute_engine/__pycache__/__init__.cpython-311.pyc,,
+google/auth/compute_engine/__pycache__/_metadata.cpython-311.pyc,,
+google/auth/compute_engine/__pycache__/credentials.cpython-311.pyc,,
+google/auth/compute_engine/_metadata.py,sha256=nmsegMDH_mLKrdNQcX75y3_szSyoeHo682Bj-uWV_o0,12686
+google/auth/compute_engine/credentials.py,sha256=CxuxQkA-df1wSiTmk9ddXRRI8f8OgiaEvl_bvOt-J3A,19025
+google/auth/credentials.py,sha256=l0g0iATMCpJnJXU5aE6YD850yBnZpshdYyDrYzhmE40,18700
+google/auth/crypt/__init__.py,sha256=xxBMOPuzD-XOxPvzkleLa2oj4u-9FSjnFmUN3PBk00s,3324
+google/auth/crypt/__pycache__/__init__.cpython-311.pyc,,
+google/auth/crypt/__pycache__/_cryptography_rsa.cpython-311.pyc,,
+google/auth/crypt/__pycache__/_helpers.cpython-311.pyc,,
+google/auth/crypt/__pycache__/_python_rsa.cpython-311.pyc,,
+google/auth/crypt/__pycache__/base.cpython-311.pyc,,
+google/auth/crypt/__pycache__/es256.cpython-311.pyc,,
+google/auth/crypt/__pycache__/rsa.cpython-311.pyc,,
+google/auth/crypt/_cryptography_rsa.py,sha256=o2QTRkfDRLtEBiq-fbpbTWypvxaxUDwzlx2NpXG9o0w,5158
+google/auth/crypt/_helpers.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+google/auth/crypt/_python_rsa.py,sha256=L0kgvPXVdEGhajzxLRIgdk2T9rY0nlThrSlSz8Hc8XY,6123
+google/auth/crypt/base.py,sha256=3CJrnQsppR6h-WnTRqSrt1hPEQVkHcwNIVJ_B5M00hY,4190
+google/auth/crypt/es256.py,sha256=hXyeia3g6_TZf-UYdZVzFKgbPrLlgSuR1mMvYKSYqbg,6251
+google/auth/crypt/rsa.py,sha256=QI17aKQsX3gdbJkBef-zsm-X_YBjBollCaoA65Am-WI,1109
+google/auth/downscoped.py,sha256=KmmC8lbBWUFUsIYt1VpcbTXs3yYJYXteH19qdZQgobA,21793
+google/auth/environment_vars.py,sha256=ML9aFh5gwRStBDjn8BQSQHyWsA-OcMn-RB5FRMM8qOw,3297
+google/auth/exceptions.py,sha256=8oEeB_1UirJIyBoglQRpCFjCOcxcTaLr6EpBrrxjeEs,3193
+google/auth/external_account.py,sha256=v-Qln5KsbXYlO2xPlIxeGMBY5iA4Atj2cP-KgbF2CpY,25977
+google/auth/external_account_authorized_user.py,sha256=-garTidaTqA8XNOPdBxJl6tfx-ub_-dr7WPVKEI2eAs,13987
+google/auth/iam.py,sha256=DQcJ127yejPqQa20jwzrGfiWffiWioAYkxZI4cQAUm8,4674
+google/auth/identity_pool.py,sha256=zroaND7aE1nMNs53Pf-84OpybRmG2MT4nLAfPQtz_t8,18734
+google/auth/impersonated_credentials.py,sha256=Jiet31lLn5hqZv2uw114dF-e1lwH_v506E7QCaHwTgM,21900
+google/auth/jwt.py,sha256=1m_arp5x-4I5UTDaK9y50PSlKnUhnSKFyJW95k3-7cQ,31096
+google/auth/metrics.py,sha256=wx3m95QQCF885wYvPL4T01CHOdCBN5JvFCtbOakd98Q,5614
+google/auth/pluggable.py,sha256=peGQ4izmkZ3Fna7fjhBhQVXjtDBcHK12uEAteMyJ8s0,17322
+google/auth/py.typed,sha256=l05_LTgi3oy-einKBrw66s6aavgzG2o-SekKPOY3ayM,74
+google/auth/transport/__init__.py,sha256=Bc9Tx4qozvP1g1USD8pvk7NEVE6hgXrpO-FH2WQFkkU,3621
+google/auth/transport/__pycache__/__init__.cpython-311.pyc,,
+google/auth/transport/__pycache__/_aiohttp_requests.cpython-311.pyc,,
+google/auth/transport/__pycache__/_custom_tls_signer.cpython-311.pyc,,
+google/auth/transport/__pycache__/_http_client.cpython-311.pyc,,
+google/auth/transport/__pycache__/_mtls_helper.cpython-311.pyc,,
+google/auth/transport/__pycache__/_requests_base.cpython-311.pyc,,
+google/auth/transport/__pycache__/grpc.cpython-311.pyc,,
+google/auth/transport/__pycache__/mtls.cpython-311.pyc,,
+google/auth/transport/__pycache__/requests.cpython-311.pyc,,
+google/auth/transport/__pycache__/urllib3.cpython-311.pyc,,
+google/auth/transport/_aiohttp_requests.py,sha256=nPi885vxrNoXi5h9Mw3nHj5jYUH8aZ_9QQN0V4dDLAY,14609
+google/auth/transport/_custom_tls_signer.py,sha256=ilLlKFNognkvOWcnlYAWmUIUo9YhSrTSAKLa05zQ8Do,9989
+google/auth/transport/_http_client.py,sha256=j7Amhmg-ipWztX3W5zOs2kJUFFuGCs0PhI7ZMAvle50,3706
+google/auth/transport/_mtls_helper.py,sha256=rhJ-QDEWeoiLGguwtMjruy6ObR89oqwtZ382sW1g3uM,14739
+google/auth/transport/_requests_base.py,sha256=4y0tTMR_hPGeAmBSyCU6_moh99ZxJZ4CF79E2s-t7TA,1657
+google/auth/transport/grpc.py,sha256=o6wDBMWKlTybwsE8CUdEcoEA2t_vdjRvQTGU9vcJPcc,13931
+google/auth/transport/mtls.py,sha256=C1Ox7fB0DSEdNkIJ7q5ofrQ-_I_cj1JOJ8o5_Zzgb24,3968
+google/auth/transport/requests.py,sha256=Bd-K1jvqkseiob-iho2CtYWYVj3ZbmXU8b0VHWA2aJ0,22351
+google/auth/transport/urllib3.py,sha256=cQITCEXvu375iIP749bG5p96Sf2EVBsq63EbKRYkhTA,16049
+google/auth/version.py,sha256=bLKSlZBveRs2P3ZXlbHinmywhxK6d-gRl3FcW8l_eZE,598
+google/oauth2/__init__.py,sha256=IdFKxhIzlqNIalPgeB2P5hP6KkoxcpNk61hp7P2B85w,1196
+google/oauth2/__pycache__/__init__.cpython-311.pyc,,
+google/oauth2/__pycache__/_client.cpython-311.pyc,,
+google/oauth2/__pycache__/_client_async.cpython-311.pyc,,
+google/oauth2/__pycache__/_credentials_async.cpython-311.pyc,,
+google/oauth2/__pycache__/_id_token_async.cpython-311.pyc,,
+google/oauth2/__pycache__/_reauth_async.cpython-311.pyc,,
+google/oauth2/__pycache__/_service_account_async.cpython-311.pyc,,
+google/oauth2/__pycache__/challenges.cpython-311.pyc,,
+google/oauth2/__pycache__/credentials.cpython-311.pyc,,
+google/oauth2/__pycache__/gdch_credentials.cpython-311.pyc,,
+google/oauth2/__pycache__/id_token.cpython-311.pyc,,
+google/oauth2/__pycache__/reauth.cpython-311.pyc,,
+google/oauth2/__pycache__/service_account.cpython-311.pyc,,
+google/oauth2/__pycache__/sts.cpython-311.pyc,,
+google/oauth2/__pycache__/utils.cpython-311.pyc,,
+google/oauth2/__pycache__/webauthn_handler.cpython-311.pyc,,
+google/oauth2/__pycache__/webauthn_handler_factory.cpython-311.pyc,,
+google/oauth2/__pycache__/webauthn_types.cpython-311.pyc,,
+google/oauth2/_client.py,sha256=XOtqZf3J9U5zW9x5v6zPSKeF_YlRNdYlqfzOZPepxdc,17338
+google/oauth2/_client_async.py,sha256=gBB74HOw_UVT6i-84T4N_39YnyajYwP5Ih1Kmtsjeu8,10129
+google/oauth2/_credentials_async.py,sha256=hUrucQkcYuYlyCdHMci8tzaVncnjQlFc2sAfNu5Dt8k,4474
+google/oauth2/_id_token_async.py,sha256=o_DViJoWMGlL3zwTbW2unGDBfY569D_VMB4l7bx-Qpw,10115
+google/oauth2/_reauth_async.py,sha256=C6k3f4T0aoVWItl8shYjOl5ngaoTJw3zKVhqHAeBXU0,11696
+google/oauth2/_service_account_async.py,sha256=5-HBGWoHhbWpCRbd34YiopQepEsEf8gSiuMlSm5hN84,5131
+google/oauth2/challenges.py,sha256=__yS2EcWXlgdLLP4inbk0QjJuyXnztpT9r2DCuXvieI,10404
+google/oauth2/credentials.py,sha256=AqPdW8ymp1EnmiTgwyLdRxjaj2kISjHPw4Yh0JZUleI,24913
+google/oauth2/gdch_credentials.py,sha256=CY6iPnPuc2OCIe1Zujwg1Mu9QSl1iGJqGOy6TkUleHw,9007
+google/oauth2/id_token.py,sha256=tuSXv7rLo6Fqw33_fXud8xiX66K6zM0ox091BsfwcTI,12933
+google/oauth2/py.typed,sha256=I0muXRRdbdpJoZ_VyheisiTTYcmjTAitQpNvuuh6fMw,76
+google/oauth2/reauth.py,sha256=p9ybxvFyaSMM85jL2veKMM-DVb4TtrDVPNqsLeDPmyk,12845
+google/oauth2/service_account.py,sha256=PyKtS9QfflVfIgdyRju1I1VFr8V3A57IGzxUSAYGmgA,32232
+google/oauth2/sts.py,sha256=GjpFEvByl3EzyGt2v1kev6rvP7_uSQ3eTlpBK9vUhSc,6699
+google/oauth2/utils.py,sha256=4crAdpKbDtobpQfXJc3uF6Zm6F3IzffvRSo-9h_515w,6315
+google/oauth2/webauthn_handler.py,sha256=6hYiSDIFXlLwghsYf13ceDiOWdLYn6Dh7-YwSqTbLaA,2743
+google/oauth2/webauthn_handler_factory.py,sha256=soE5cokZ3pLNbBo1HC6F1N-N-I-ir-DGlD0trGPCpBs,429
+google/oauth2/webauthn_types.py,sha256=kaDu4Gouk07CEkP08PZ26XAeVHyGP-SGWbDGnH1l2IE,5386
+google_auth-2.38.0.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
+google_auth-2.38.0.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+google_auth-2.38.0.dist-info/METADATA,sha256=7R3Ery802jdDQ0WO_3fmiuQiZBXhMlp4Vllq6JPYnTg,4775
+google_auth-2.38.0.dist-info/RECORD,,
+google_auth-2.38.0.dist-info/WHEEL,sha256=OpXWERl2xLPRHTvd2ZXo_iluPEQd8uSbYkJ53NAER_Y,109
+google_auth-2.38.0.dist-info/top_level.txt,sha256=BWmDiI8eoKfseZ5-MI2AW66GLJLNH4Lz23AXXTrIlyQ,23

.venv/lib/python3.11/site-packages/google_auth-2.38.0.dist-info/WHEEL

@@ -0,0 +1,6 @@
+Wheel-Version: 1.0
+Generator: setuptools (75.3.0)
+Root-Is-Purelib: true
+Tag: py2-none-any
+Tag: py3-none-any
+

.venv/lib/python3.11/site-packages/google_auth-2.38.0.dist-info/top_level.txt

@@ -0,0 +1,3 @@
+google
+scripts
+testing

.venv/lib/python3.11/site-packages/h11-0.14.0.dist-info/INSTALLER

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

.venv/lib/python3.11/site-packages/h11-0.14.0.dist-info/LICENSE.txt

@@ -0,0 +1,22 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 Nathaniel J. Smith <njs@pobox.com> and other contributors
+
+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.

.venv/lib/python3.11/site-packages/h11-0.14.0.dist-info/METADATA

@@ -0,0 +1,193 @@
+Metadata-Version: 2.1
+Name: h11
+Version: 0.14.0
+Summary: A pure-Python, bring-your-own-I/O implementation of HTTP/1.1
+Home-page: https://github.com/python-hyper/h11
+Author: Nathaniel J. Smith
+Author-email: njs@pobox.com
+License: MIT
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Programming Language :: Python :: Implementation :: PyPy
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+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: Topic :: Internet :: WWW/HTTP
+Classifier: Topic :: System :: Networking
+Requires-Python: >=3.7
+License-File: LICENSE.txt
+Requires-Dist: typing-extensions ; python_version < "3.8"
+
+h11
+===
+
+.. image:: https://travis-ci.org/python-hyper/h11.svg?branch=master
+   :target: https://travis-ci.org/python-hyper/h11
+   :alt: Automated test status
+
+.. image:: https://codecov.io/gh/python-hyper/h11/branch/master/graph/badge.svg
+   :target: https://codecov.io/gh/python-hyper/h11
+   :alt: Test coverage
+
+.. image:: https://readthedocs.org/projects/h11/badge/?version=latest
+   :target: http://h11.readthedocs.io/en/latest/?badge=latest
+   :alt: Documentation Status
+
+This is a little HTTP/1.1 library written from scratch in Python,
+heavily inspired by `hyper-h2 <https://hyper-h2.readthedocs.io/>`_.
+
+It's a "bring-your-own-I/O" library; h11 contains no IO code
+whatsoever. This means you can hook h11 up to your favorite network
+API, and that could be anything you want: synchronous, threaded,
+asynchronous, or your own implementation of `RFC 6214
+<https://tools.ietf.org/html/rfc6214>`_ -- h11 won't judge you.
+(Compare this to the current state of the art, where every time a `new
+network API <https://trio.readthedocs.io/>`_ comes along then someone
+gets to start over reimplementing the entire HTTP protocol from
+scratch.) Cory Benfield made an `excellent blog post describing the
+benefits of this approach
+<https://lukasa.co.uk/2015/10/The_New_Hyper/>`_, or if you like video
+then here's his `PyCon 2016 talk on the same theme
+<https://www.youtube.com/watch?v=7cC3_jGwl_U>`_.
+
+This also means that h11 is not immediately useful out of the box:
+it's a toolkit for building programs that speak HTTP, not something
+that could directly replace ``requests`` or ``twisted.web`` or
+whatever. But h11 makes it much easier to implement something like
+``requests`` or ``twisted.web``.
+
+At a high level, working with h11 goes like this:
+
+1) First, create an ``h11.Connection`` object to track the state of a
+   single HTTP/1.1 connection.
+
+2) When you read data off the network, pass it to
+   ``conn.receive_data(...)``; you'll get back a list of objects
+   representing high-level HTTP "events".
+
+3) When you want to send a high-level HTTP event, create the
+   corresponding "event" object and pass it to ``conn.send(...)``;
+   this will give you back some bytes that you can then push out
+   through the network.
+
+For example, a client might instantiate and then send a
+``h11.Request`` object, then zero or more ``h11.Data`` objects for the
+request body (e.g., if this is a POST), and then a
+``h11.EndOfMessage`` to indicate the end of the message. Then the
+server would then send back a ``h11.Response``, some ``h11.Data``, and
+its own ``h11.EndOfMessage``. If either side violates the protocol,
+you'll get a ``h11.ProtocolError`` exception.
+
+h11 is suitable for implementing both servers and clients, and has a
+pleasantly symmetric API: the events you send as a client are exactly
+the ones that you receive as a server and vice-versa.
+
+`Here's an example of a tiny HTTP client
+<https://github.com/python-hyper/h11/blob/master/examples/basic-client.py>`_
+
+It also has `a fine manual <https://h11.readthedocs.io/>`_.
+
+FAQ
+---
+
+*Whyyyyy?*
+
+I wanted to play with HTTP in `Curio
+<https://curio.readthedocs.io/en/latest/tutorial.html>`__ and `Trio
+<https://trio.readthedocs.io>`__, which at the time didn't have any
+HTTP libraries. So I thought, no big deal, Python has, like, a dozen
+different implementations of HTTP, surely I can find one that's
+reusable. I didn't find one, but I did find Cory's call-to-arms
+blog-post. So I figured, well, fine, if I have to implement HTTP from
+scratch, at least I can make sure no-one *else* has to ever again.
+
+*Should I use it?*
+
+Maybe. You should be aware that it's a very young project. But, it's
+feature complete and has an exhaustive test-suite and complete docs,
+so the next step is for people to try using it and see how it goes
+:-). If you do then please let us know -- if nothing else we'll want
+to talk to you before making any incompatible changes!
+
+*What are the features/limitations?*
+
+Roughly speaking, it's trying to be a robust, complete, and non-hacky
+implementation of the first "chapter" of the HTTP/1.1 spec: `RFC 7230:
+HTTP/1.1 Message Syntax and Routing
+<https://tools.ietf.org/html/rfc7230>`_. That is, it mostly focuses on
+implementing HTTP at the level of taking bytes on and off the wire,
+and the headers related to that, and tries to be anal about spec
+conformance. It doesn't know about higher-level concerns like URL
+routing, conditional GETs, cross-origin cookie policies, or content
+negotiation. But it does know how to take care of framing,
+cross-version differences in keep-alive handling, and the "obsolete
+line folding" rule, so you can focus your energies on the hard /
+interesting parts for your application, and it tries to support the
+full specification in the sense that any useful HTTP/1.1 conformant
+application should be able to use h11.
+
+It's pure Python, and has no dependencies outside of the standard
+library.
+
+It has a test suite with 100.0% coverage for both statements and
+branches.
+
+Currently it supports Python 3 (testing on 3.7-3.10) and PyPy 3.
+The last Python 2-compatible version was h11 0.11.x.
+(Originally it had a Cython wrapper for `http-parser
+<https://github.com/nodejs/http-parser>`_ and a beautiful nested state
+machine implemented with ``yield from`` to postprocess the output. But
+I had to take these out -- the new *parser* needs fewer lines-of-code
+than the old *parser wrapper*, is written in pure Python, uses no
+exotic language syntax, and has more features. It's sad, really; that
+old state machine was really slick. I just need a few sentences here
+to mourn that.)
+
+I don't know how fast it is. I haven't benchmarked or profiled it yet,
+so it's probably got a few pointless hot spots, and I've been trying
+to err on the side of simplicity and robustness instead of
+micro-optimization. But at the architectural level I tried hard to
+avoid fundamentally bad decisions, e.g., I believe that all the
+parsing algorithms remain linear-time even in the face of pathological
+input like slowloris, and there are no byte-by-byte loops. (I also
+believe that it maintains bounded memory usage in the face of
+arbitrary/pathological input.)
+
+The whole library is ~800 lines-of-code. You can read and understand
+the whole thing in less than an hour. Most of the energy invested in
+this so far has been spent on trying to keep things simple by
+minimizing special-cases and ad hoc state manipulation; even though it
+is now quite small and simple, I'm still annoyed that I haven't
+figured out how to make it even smaller and simpler. (Unfortunately,
+HTTP does not lend itself to simplicity.)
+
+The API is ~feature complete and I don't expect the general outlines
+to change much, but you can't judge an API's ergonomics until you
+actually document and use it, so I'd expect some changes in the
+details.
+
+*How do I try it?*
+
+.. code-block:: sh
+
+  $ pip install h11
+  $ git clone git@github.com:python-hyper/h11
+  $ cd h11/examples
+  $ python basic-client.py
+
+and go from there.
+
+*License?*
+
+MIT
+
+*Code of conduct?*
+
+Contributors are requested to follow our `code of conduct
+<https://github.com/python-hyper/h11/blob/master/CODE_OF_CONDUCT.md>`_ in
+all project spaces.

.venv/lib/python3.11/site-packages/h11-0.14.0.dist-info/RECORD

@@ -0,0 +1,52 @@
+h11-0.14.0.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
+h11-0.14.0.dist-info/LICENSE.txt,sha256=N9tbuFkm2yikJ6JYZ_ELEjIAOuob5pzLhRE4rbjm82E,1124
+h11-0.14.0.dist-info/METADATA,sha256=B7pZ0m7WBXNs17vl6hUH9bJTL9s37DaGvY31w7jNxSg,8175
+h11-0.14.0.dist-info/RECORD,,
+h11-0.14.0.dist-info/WHEEL,sha256=ewwEueio1C2XeHTvT17n8dZUJgOvyCWCt0WVNLClP9o,92
+h11-0.14.0.dist-info/top_level.txt,sha256=F7dC4jl3zeh8TGHEPaWJrMbeuoWbS379Gwdi-Yvdcis,4
+h11/__init__.py,sha256=iO1KzkSO42yZ6ffg-VMgbx_ZVTWGUY00nRYEWn-s3kY,1507
+h11/__pycache__/__init__.cpython-311.pyc,,
+h11/__pycache__/_abnf.cpython-311.pyc,,
+h11/__pycache__/_connection.cpython-311.pyc,,
+h11/__pycache__/_events.cpython-311.pyc,,
+h11/__pycache__/_headers.cpython-311.pyc,,
+h11/__pycache__/_readers.cpython-311.pyc,,
+h11/__pycache__/_receivebuffer.cpython-311.pyc,,
+h11/__pycache__/_state.cpython-311.pyc,,
+h11/__pycache__/_util.cpython-311.pyc,,
+h11/__pycache__/_version.cpython-311.pyc,,
+h11/__pycache__/_writers.cpython-311.pyc,,
+h11/_abnf.py,sha256=ybixr0xsupnkA6GFAyMubuXF6Tc1lb_hF890NgCsfNc,4815
+h11/_connection.py,sha256=eS2sorMD0zKLCFiB9lW9W9F_Nzny2tjHa4e6s1ujr1c,26539
+h11/_events.py,sha256=LEfuvg1AbhHaVRwxCd0I-pFn9-ezUOaoL8o2Kvy1PBA,11816
+h11/_headers.py,sha256=RqB8cd8CN0blYPzcLe5qeCh-phv6D1U_CHj4hs67lgQ,10230
+h11/_readers.py,sha256=EbSed0jzwVUiD1nOPAeUcVE4Flf3wXkxfb8c06-OTBM,8383
+h11/_receivebuffer.py,sha256=xrspsdsNgWFxRfQcTXxR8RrdjRXXTK0Io5cQYWpJ1Ws,5252
+h11/_state.py,sha256=k1VL6SDbaPkSrZ-49ewCXDpuiUS69_46YhbWjuV1qEY,13300
+h11/_util.py,sha256=LWkkjXyJaFlAy6Lt39w73UStklFT5ovcvo0TkY7RYuk,4888
+h11/_version.py,sha256=LVyTdiZRzIIEv79UyOgbM5iUrJUllEzlCWaJEYBY1zc,686
+h11/_writers.py,sha256=oFKm6PtjeHfbj4RLX7VB7KDc1gIY53gXG3_HR9ltmTA,5081
+h11/py.typed,sha256=sow9soTwP9T_gEAQSVh7Gb8855h04Nwmhs2We-JRgZM,7
+h11/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+h11/tests/__pycache__/__init__.cpython-311.pyc,,
+h11/tests/__pycache__/helpers.cpython-311.pyc,,
+h11/tests/__pycache__/test_against_stdlib_http.cpython-311.pyc,,
+h11/tests/__pycache__/test_connection.cpython-311.pyc,,
+h11/tests/__pycache__/test_events.cpython-311.pyc,,
+h11/tests/__pycache__/test_headers.cpython-311.pyc,,
+h11/tests/__pycache__/test_helpers.cpython-311.pyc,,
+h11/tests/__pycache__/test_io.cpython-311.pyc,,
+h11/tests/__pycache__/test_receivebuffer.cpython-311.pyc,,
+h11/tests/__pycache__/test_state.cpython-311.pyc,,
+h11/tests/__pycache__/test_util.cpython-311.pyc,,
+h11/tests/data/test-file,sha256=ZJ03Rqs98oJw29OHzJg7LlMzyGQaRAY0r3AqBeM2wVU,65
+h11/tests/helpers.py,sha256=a1EVG_p7xU4wRsa3tMPTRxuaKCmretok9sxXWvqfmQA,3355
+h11/tests/test_against_stdlib_http.py,sha256=cojCHgHXFQ8gWhNlEEwl3trmOpN-5uDukRoHnElqo3A,3995
+h11/tests/test_connection.py,sha256=ZbPLDPclKvjgjAhgk-WlCPBaf17c4XUIV2tpaW08jOI,38720
+h11/tests/test_events.py,sha256=LPVLbcV-NvPNK9fW3rraR6Bdpz1hAlsWubMtNaJ5gHg,4657
+h11/tests/test_headers.py,sha256=qd8T1Zenuz5GbD6wklSJ5G8VS7trrYgMV0jT-SMvqg8,5612
+h11/tests/test_helpers.py,sha256=kAo0CEM4LGqmyyP2ZFmhsyq3UFJqoFfAbzu3hbWreRM,794
+h11/tests/test_io.py,sha256=uCZVnjarkRBkudfC1ij-KSCQ71XWJhnkgkgWWkKgYPQ,16386
+h11/tests/test_receivebuffer.py,sha256=3jGbeJM36Akqg_pAhPb7XzIn2NS6RhPg-Ryg8Eu6ytk,3454
+h11/tests/test_state.py,sha256=rqll9WqFsJPE0zSrtCn9LH659mPKsDeXZ-DwXwleuBQ,8928
+h11/tests/test_util.py,sha256=VO5L4nSFe4pgtSwKuv6u_6l0H7UeizF5WKuHTWreg70,2970

.venv/lib/python3.11/site-packages/h11-0.14.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: bdist_wheel (0.37.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

.venv/lib/python3.11/site-packages/h11-0.14.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+h11

.venv/lib/python3.11/site-packages/msgspec/__init__.py

@@ -0,0 +1,35 @@
+from ._core import (
+    DecodeError,
+    EncodeError,
+    Field as _Field,
+    Meta,
+    MsgspecError,
+    Raw,
+    Struct,
+    UnsetType,
+    UNSET,
+    NODEFAULT,
+    ValidationError,
+    defstruct,
+    convert,
+    to_builtins,
+)
+
+
+def field(*, default=NODEFAULT, default_factory=NODEFAULT, name=None):
+    return _Field(default=default, default_factory=default_factory, name=name)
+
+
+field.__doc__ = _Field.__doc__
+
+
+from . import msgpack
+from . import json
+from . import yaml
+from . import toml
+from . import inspect
+from . import structs
+from ._version import get_versions
+
+__version__ = get_versions()["version"]
+del get_versions

.venv/lib/python3.11/site-packages/msgspec/__init__.pyi

@@ -0,0 +1,185 @@
+import enum
+from typing import (
+    Any,
+    Callable,
+    ClassVar,
+    Dict,
+    Final,
+    Iterable,
+    Literal,
+    Mapping,
+    Optional,
+    Tuple,
+    Type,
+    TypeVar,
+    Union,
+    overload,
+)
+
+from typing_extensions import dataclass_transform, Buffer
+
+from . import inspect, json, msgpack, structs, toml, yaml
+
+T = TypeVar("T")
+
+class UnsetType(enum.Enum):
+    UNSET = "UNSET"
+
+UNSET = UnsetType.UNSET
+
+class _NoDefault(enum.Enum):
+    NODEFAULT = "NODEFAULT"
+
+NODEFAULT = _NoDefault.NODEFAULT
+
+@overload
+def field(*, default: T, name: Optional[str] = None) -> T: ...
+@overload
+def field(*, default_factory: Callable[[], T], name: Optional[str] = None) -> T: ...
+@overload
+def field(*, name: Optional[str] = None) -> Any: ...
+@dataclass_transform(field_specifiers=(field,))
+class Struct:
+    __struct_fields__: ClassVar[Tuple[str, ...]]
+    __struct_config__: ClassVar[structs.StructConfig]
+    __match_args__: ClassVar[Tuple[str, ...]]
+    # A default __init__ so that Structs with unknown field types (say
+    # constructed by `defstruct`) won't error on every call to `__init__`
+    def __init__(self, *args: Any, **kwargs: Any) -> None: ...
+    def __init_subclass__(
+        cls,
+        tag: Union[None, bool, str, int, Callable[[str], Union[str, int]]] = None,
+        tag_field: Union[None, str] = None,
+        rename: Union[
+            None,
+            Literal["lower", "upper", "camel", "pascal", "kebab"],
+            Callable[[str], Optional[str]],
+            Mapping[str, str],
+        ] = None,
+        omit_defaults: bool = False,
+        forbid_unknown_fields: bool = False,
+        frozen: bool = False,
+        eq: bool = True,
+        order: bool = False,
+        kw_only: bool = False,
+        repr_omit_defaults: bool = False,
+        array_like: bool = False,
+        gc: bool = True,
+        weakref: bool = False,
+        dict: bool = False,
+        cache_hash: bool = False,
+    ) -> None: ...
+    def __rich_repr__(
+        self,
+    ) -> Iterable[Union[Any, Tuple[Any], Tuple[str, Any], Tuple[str, Any, Any]]]: ...
+
+def defstruct(
+    name: str,
+    fields: Iterable[Union[str, Tuple[str, type], Tuple[str, type, Any]]],
+    *,
+    bases: Optional[Tuple[Type[Struct], ...]] = None,
+    module: Optional[str] = None,
+    namespace: Optional[Dict[str, Any]] = None,
+    tag: Union[None, bool, str, int, Callable[[str], Union[str, int]]] = None,
+    tag_field: Union[None, str] = None,
+    rename: Union[
+        None,
+        Literal["lower", "upper", "camel", "pascal", "kebab"],
+        Callable[[str], Optional[str]],
+        Mapping[str, str],
+    ] = None,
+    omit_defaults: bool = False,
+    forbid_unknown_fields: bool = False,
+    frozen: bool = False,
+    eq: bool = True,
+    order: bool = False,
+    kw_only: bool = False,
+    repr_omit_defaults: bool = False,
+    array_like: bool = False,
+    gc: bool = True,
+    weakref: bool = False,
+    dict: bool = False,
+    cache_hash: bool = False,
+) -> Type[Struct]: ...
+
+# Lie and say `Raw` is a subclass of `bytes`, so mypy will accept it in most
+# places where an object that implements the buffer protocol is valid
+class Raw(bytes):
+    @overload
+    def __new__(cls) -> "Raw": ...
+    @overload
+    def __new__(cls, msg: Union[Buffer, str]) -> "Raw": ...
+    def copy(self) -> "Raw": ...
+
+class Meta:
+    def __init__(
+        self,
+        *,
+        gt: Union[int, float, None] = None,
+        ge: Union[int, float, None] = None,
+        lt: Union[int, float, None] = None,
+        le: Union[int, float, None] = None,
+        multiple_of: Union[int, float, None] = None,
+        pattern: Union[str, None] = None,
+        min_length: Union[int, None] = None,
+        max_length: Union[int, None] = None,
+        tz: Union[bool, None] = None,
+        title: Union[str, None] = None,
+        description: Union[str, None] = None,
+        examples: Union[list, None] = None,
+        extra_json_schema: Union[dict, None] = None,
+        extra: Union[dict, None] = None,
+    ): ...
+    gt: Final[Union[int, float, None]]
+    ge: Final[Union[int, float, None]]
+    lt: Final[Union[int, float, None]]
+    le: Final[Union[int, float, None]]
+    multiple_of: Final[Union[int, float, None]]
+    pattern: Final[Union[str, None]]
+    min_length: Final[Union[int, None]]
+    max_length: Final[Union[int, None]]
+    tz: Final[Union[int, None]]
+    title: Final[Union[str, None]]
+    description: Final[Union[str, None]]
+    examples: Final[Union[list, None]]
+    extra_json_schema: Final[Union[dict, None]]
+    extra: Final[Union[dict, None]]
+    def __rich_repr__(self) -> Iterable[Tuple[str, Any]]: ...
+
+def to_builtins(
+    obj: Any,
+    *,
+    str_keys: bool = False,
+    builtin_types: Union[Iterable[type], None] = None,
+    enc_hook: Optional[Callable[[Any], Any]] = None,
+    order: Literal[None, "deterministic", "sorted"] = None,
+) -> Any: ...
+@overload
+def convert(
+    obj: Any,
+    type: Type[T],
+    *,
+    strict: bool = True,
+    from_attributes: bool = False,
+    dec_hook: Optional[Callable[[type, Any], Any]] = None,
+    builtin_types: Union[Iterable[type], None] = None,
+    str_keys: bool = False,
+) -> T: ...
+@overload
+def convert(
+    obj: Any,
+    type: Any,
+    *,
+    strict: bool = True,
+    from_attributes: bool = False,
+    dec_hook: Optional[Callable[[type, Any], Any]] = None,
+    builtin_types: Union[Iterable[type], None] = None,
+    str_keys: bool = False,
+) -> Any: ...
+
+class MsgspecError(Exception): ...
+class EncodeError(MsgspecError): ...
+class DecodeError(MsgspecError): ...
+class ValidationError(DecodeError): ...
+
+__version__: str

.venv/lib/python3.11/site-packages/msgspec/_json_schema.py

@@ -0,0 +1,439 @@
+from __future__ import annotations
+
+import re
+import textwrap
+from collections.abc import Iterable
+from typing import Any, Optional, Callable
+
+from . import inspect as mi, to_builtins
+
+__all__ = ("schema", "schema_components")
+
+
+def schema(
+    type: Any, *, schema_hook: Optional[Callable[[type], dict[str, Any]]] = None
+) -> dict[str, Any]:
+    """Generate a JSON Schema for a given type.
+
+    Any schemas for (potentially) shared components are extracted and stored in
+    a top-level ``"$defs"`` field.
+
+    If you want to generate schemas for multiple types, or to have more control
+    over the generated schema you may want to use ``schema_components`` instead.
+
+    Parameters
+    ----------
+    type : type
+        The type to generate the schema for.
+    schema_hook : callable, optional
+        An optional callback to use for generating JSON schemas of custom
+        types. Will be called with the custom type, and should return a dict
+        representation of the JSON schema for that type.
+
+    Returns
+    -------
+    schema : dict
+        The generated JSON Schema.
+
+    See Also
+    --------
+    schema_components
+    """
+    (out,), components = schema_components((type,), schema_hook=schema_hook)
+    if components:
+        out["$defs"] = components
+    return out
+
+
+def schema_components(
+    types: Iterable[Any],
+    *,
+    schema_hook: Optional[Callable[[type], dict[str, Any]]] = None,
+    ref_template: str = "#/$defs/{name}",
+) -> tuple[tuple[dict[str, Any], ...], dict[str, Any]]:
+    """Generate JSON Schemas for one or more types.
+
+    Any schemas for (potentially) shared components are extracted and returned
+    in a separate ``components`` dict.
+
+    Parameters
+    ----------
+    types : Iterable[type]
+        An iterable of one or more types to generate schemas for.
+    schema_hook : callable, optional
+        An optional callback to use for generating JSON schemas of custom
+        types. Will be called with the custom type, and should return a dict
+        representation of the JSON schema for that type.
+    ref_template : str, optional
+        A template to use when generating ``"$ref"`` fields. This template is
+        formatted with the type name as ``template.format(name=name)``. This
+        can be useful if you intend to store the ``components`` mapping
+        somewhere other than a top-level ``"$defs"`` field. For example, you
+        might use ``ref_template="#/components/{name}"`` if generating an
+        OpenAPI schema.
+
+    Returns
+    -------
+    schemas : tuple[dict]
+        A tuple of JSON Schemas, one for each type in ``types``.
+    components : dict
+        A mapping of name to schema for any shared components used by
+        ``schemas``.
+
+    See Also
+    --------
+    schema
+    """
+    type_infos = mi.multi_type_info(types)
+
+    component_types = _collect_component_types(type_infos)
+
+    name_map = _build_name_map(component_types)
+
+    gen = _SchemaGenerator(name_map, schema_hook, ref_template)
+
+    schemas = tuple(gen.to_schema(t) for t in type_infos)
+
+    components = {
+        name_map[cls]: gen.to_schema(t, False) for cls, t in component_types.items()
+    }
+    return schemas, components
+
+
+def _collect_component_types(type_infos: Iterable[mi.Type]) -> dict[Any, mi.Type]:
+    """Find all types in the type tree that are "nameable" and worthy of being
+    extracted out into a shared top-level components mapping.
+
+    Currently this looks for Struct, Dataclass, NamedTuple, TypedDict, and Enum
+    types.
+    """
+    components = {}
+
+    def collect(t):
+        if isinstance(
+            t, (mi.StructType, mi.TypedDictType, mi.DataclassType, mi.NamedTupleType)
+        ):
+            if t.cls not in components:
+                components[t.cls] = t
+                for f in t.fields:
+                    collect(f.type)
+        elif isinstance(t, mi.EnumType):
+            components[t.cls] = t
+        elif isinstance(t, mi.Metadata):
+            collect(t.type)
+        elif isinstance(t, mi.CollectionType):
+            collect(t.item_type)
+        elif isinstance(t, mi.TupleType):
+            for st in t.item_types:
+                collect(st)
+        elif isinstance(t, mi.DictType):
+            collect(t.key_type)
+            collect(t.value_type)
+        elif isinstance(t, mi.UnionType):
+            for st in t.types:
+                collect(st)
+
+    for t in type_infos:
+        collect(t)
+
+    return components
+
+
+def _type_repr(obj):
+    return obj.__name__ if isinstance(obj, type) else repr(obj)
+
+
+def _get_class_name(cls: Any) -> str:
+    if hasattr(cls, "__origin__"):
+        name = cls.__origin__.__name__
+        args = ", ".join(_type_repr(a) for a in cls.__args__)
+        return f"{name}[{args}]"
+    return cls.__name__
+
+
+def _get_doc(t: mi.Type) -> str:
+    assert hasattr(t, "cls")
+    cls = getattr(t.cls, "__origin__", t.cls)
+    doc = getattr(cls, "__doc__", "")
+    if not doc:
+        return ""
+    doc = textwrap.dedent(doc).strip("\r\n")
+    if isinstance(t, mi.EnumType):
+        if doc == "An enumeration.":
+            return ""
+    elif isinstance(t, (mi.NamedTupleType, mi.DataclassType)):
+        if doc.startswith(f"{cls.__name__}(") and doc.endswith(")"):
+            return ""
+    return doc
+
+
+def _build_name_map(component_types: dict[Any, mi.Type]) -> dict[Any, str]:
+    """A mapping from nameable subcomponents to a generated name.
+
+    The generated name is usually a normalized version of the class name. In
+    the case of conflicts, the name will be expanded to also include the full
+    import path.
+    """
+
+    def normalize(name):
+        return re.sub(r"[^a-zA-Z0-9.\-_]", "_", name)
+
+    def fullname(cls):
+        return normalize(f"{cls.__module__}.{cls.__qualname__}")
+
+    conflicts = set()
+    names: dict[str, Any] = {}
+
+    for cls in component_types:
+        name = normalize(_get_class_name(cls))
+        if name in names:
+            old = names.pop(name)
+            conflicts.add(name)
+            names[fullname(old)] = old
+        if name in conflicts:
+            names[fullname(cls)] = cls
+        else:
+            names[name] = cls
+    return {v: k for k, v in names.items()}
+
+
+class _SchemaGenerator:
+    def __init__(
+        self,
+        name_map: dict[Any, str],
+        schema_hook: Optional[Callable[[type], dict[str, Any]]] = None,
+        ref_template: str = "#/$defs/{name}",
+    ):
+        self.name_map = name_map
+        self.schema_hook = schema_hook
+        self.ref_template = ref_template
+
+    def to_schema(self, t: mi.Type, check_ref: bool = True) -> dict[str, Any]:
+        """Converts a Type to a json-schema."""
+        schema: dict[str, Any] = {}
+
+        while isinstance(t, mi.Metadata):
+            schema = mi._merge_json(schema, t.extra_json_schema)
+            t = t.type
+
+        if check_ref and hasattr(t, "cls"):
+            if name := self.name_map.get(t.cls):
+                schema["$ref"] = self.ref_template.format(name=name)
+                return schema
+
+        if isinstance(t, (mi.AnyType, mi.RawType)):
+            pass
+        elif isinstance(t, mi.NoneType):
+            schema["type"] = "null"
+        elif isinstance(t, mi.BoolType):
+            schema["type"] = "boolean"
+        elif isinstance(t, (mi.IntType, mi.FloatType)):
+            schema["type"] = "integer" if isinstance(t, mi.IntType) else "number"
+            if t.ge is not None:
+                schema["minimum"] = t.ge
+            if t.gt is not None:
+                schema["exclusiveMinimum"] = t.gt
+            if t.le is not None:
+                schema["maximum"] = t.le
+            if t.lt is not None:
+                schema["exclusiveMaximum"] = t.lt
+            if t.multiple_of is not None:
+                schema["multipleOf"] = t.multiple_of
+        elif isinstance(t, mi.StrType):
+            schema["type"] = "string"
+            if t.max_length is not None:
+                schema["maxLength"] = t.max_length
+            if t.min_length is not None:
+                schema["minLength"] = t.min_length
+            if t.pattern is not None:
+                schema["pattern"] = t.pattern
+        elif isinstance(t, (mi.BytesType, mi.ByteArrayType, mi.MemoryViewType)):
+            schema["type"] = "string"
+            schema["contentEncoding"] = "base64"
+            if t.max_length is not None:
+                schema["maxLength"] = 4 * ((t.max_length + 2) // 3)
+            if t.min_length is not None:
+                schema["minLength"] = 4 * ((t.min_length + 2) // 3)
+        elif isinstance(t, mi.DateTimeType):
+            schema["type"] = "string"
+            if t.tz is True:
+                schema["format"] = "date-time"
+        elif isinstance(t, mi.TimeType):
+            schema["type"] = "string"
+            if t.tz is True:
+                schema["format"] = "time"
+            elif t.tz is False:
+                schema["format"] = "partial-time"
+        elif isinstance(t, mi.DateType):
+            schema["type"] = "string"
+            schema["format"] = "date"
+        elif isinstance(t, mi.TimeDeltaType):
+            schema["type"] = "string"
+            schema["format"] = "duration"
+        elif isinstance(t, mi.UUIDType):
+            schema["type"] = "string"
+            schema["format"] = "uuid"
+        elif isinstance(t, mi.DecimalType):
+            schema["type"] = "string"
+            schema["format"] = "decimal"
+        elif isinstance(t, mi.CollectionType):
+            schema["type"] = "array"
+            if not isinstance(t.item_type, mi.AnyType):
+                schema["items"] = self.to_schema(t.item_type)
+            if t.max_length is not None:
+                schema["maxItems"] = t.max_length
+            if t.min_length is not None:
+                schema["minItems"] = t.min_length
+        elif isinstance(t, mi.TupleType):
+            schema["type"] = "array"
+            schema["minItems"] = schema["maxItems"] = len(t.item_types)
+            if t.item_types:
+                schema["prefixItems"] = [self.to_schema(i) for i in t.item_types]
+                schema["items"] = False
+        elif isinstance(t, mi.DictType):
+            schema["type"] = "object"
+            # If there are restrictions on the keys, specify them as propertyNames
+            if isinstance(key_type := t.key_type, mi.StrType):
+                property_names: dict[str, Any] = {}
+                if key_type.min_length is not None:
+                    property_names["minLength"] = key_type.min_length
+                if key_type.max_length is not None:
+                    property_names["maxLength"] = key_type.max_length
+                if key_type.pattern is not None:
+                    property_names["pattern"] = key_type.pattern
+                if property_names:
+                    schema["propertyNames"] = property_names
+            if not isinstance(t.value_type, mi.AnyType):
+                schema["additionalProperties"] = self.to_schema(t.value_type)
+            if t.max_length is not None:
+                schema["maxProperties"] = t.max_length
+            if t.min_length is not None:
+                schema["minProperties"] = t.min_length
+        elif isinstance(t, mi.UnionType):
+            structs = {}
+            other = []
+            tag_field = None
+            for subtype in t.types:
+                real_type = subtype
+                while isinstance(real_type, mi.Metadata):
+                    real_type = real_type.type
+                if isinstance(real_type, mi.StructType) and not real_type.array_like:
+                    tag_field = real_type.tag_field
+                    structs[real_type.tag] = real_type
+                else:
+                    other.append(subtype)
+
+            options = [self.to_schema(a) for a in other]
+
+            if len(structs) >= 2:
+                mapping = {
+                    k: self.ref_template.format(name=self.name_map[v.cls])
+                    for k, v in structs.items()
+                }
+                struct_schema = {
+                    "anyOf": [self.to_schema(v) for v in structs.values()],
+                    "discriminator": {"propertyName": tag_field, "mapping": mapping},
+                }
+                if options:
+                    options.append(struct_schema)
+                    schema["anyOf"] = options
+                else:
+                    schema.update(struct_schema)
+            elif len(structs) == 1:
+                _, subtype = structs.popitem()
+                options.append(self.to_schema(subtype))
+                schema["anyOf"] = options
+            else:
+                schema["anyOf"] = options
+        elif isinstance(t, mi.LiteralType):
+            schema["enum"] = sorted(t.values)
+        elif isinstance(t, mi.EnumType):
+            schema.setdefault("title", t.cls.__name__)
+            if doc := _get_doc(t):
+                schema.setdefault("description", doc)
+            schema["enum"] = sorted(e.value for e in t.cls)
+        elif isinstance(t, mi.StructType):
+            schema.setdefault("title", _get_class_name(t.cls))
+            if doc := _get_doc(t):
+                schema.setdefault("description", doc)
+            required = []
+            names = []
+            fields = []
+
+            if t.tag_field is not None:
+                required.append(t.tag_field)
+                names.append(t.tag_field)
+                fields.append({"enum": [t.tag]})
+
+            for field in t.fields:
+                field_schema = self.to_schema(field.type)
+                if field.required:
+                    required.append(field.encode_name)
+                elif field.default is not mi.NODEFAULT:
+                    field_schema["default"] = to_builtins(field.default, str_keys=True)
+                elif field.default_factory in (list, dict, set, bytearray):
+                    field_schema["default"] = field.default_factory()
+                names.append(field.encode_name)
+                fields.append(field_schema)
+
+            if t.array_like:
+                n_trailing_defaults = 0
+                for n_trailing_defaults, f in enumerate(reversed(t.fields)):
+                    if f.required:
+                        break
+                schema["type"] = "array"
+                schema["prefixItems"] = fields
+                schema["minItems"] = len(fields) - n_trailing_defaults
+                if t.forbid_unknown_fields:
+                    schema["maxItems"] = len(fields)
+            else:
+                schema["type"] = "object"
+                schema["properties"] = dict(zip(names, fields))
+                schema["required"] = required
+                if t.forbid_unknown_fields:
+                    schema["additionalProperties"] = False
+        elif isinstance(t, (mi.TypedDictType, mi.DataclassType, mi.NamedTupleType)):
+            schema.setdefault("title", _get_class_name(t.cls))
+            if doc := _get_doc(t):
+                schema.setdefault("description", doc)
+            names = []
+            fields = []
+            required = []
+            for field in t.fields:
+                field_schema = self.to_schema(field.type)
+                if field.required:
+                    required.append(field.encode_name)
+                elif field.default is not mi.NODEFAULT:
+                    field_schema["default"] = to_builtins(field.default, str_keys=True)
+                names.append(field.encode_name)
+                fields.append(field_schema)
+            if isinstance(t, mi.NamedTupleType):
+                schema["type"] = "array"
+                schema["prefixItems"] = fields
+                schema["minItems"] = len(required)
+                schema["maxItems"] = len(fields)
+            else:
+                schema["type"] = "object"
+                schema["properties"] = dict(zip(names, fields))
+                schema["required"] = required
+        elif isinstance(t, mi.ExtType):
+            raise TypeError("json-schema doesn't support msgpack Ext types")
+        elif isinstance(t, mi.CustomType):
+            if self.schema_hook:
+                try:
+                    schema = mi._merge_json(self.schema_hook(t.cls), schema)
+                except NotImplementedError:
+                    pass
+            if not schema:
+                raise TypeError(
+                    "Generating JSON schema for custom types requires either:\n"
+                    "- specifying a `schema_hook`\n"
+                    "- annotating the type with `Meta(extra_json_schema=...)`\n"
+                    "\n"
+                    f"type {t.cls!r} is not supported"
+                )
+        else:
+            # This should be unreachable
+            raise TypeError(f"json-schema doesn't support type {t!r}")
+
+        return schema

.venv/lib/python3.11/site-packages/msgspec/_utils.py

@@ -0,0 +1,319 @@
+# type: ignore
+import collections
+import sys
+import typing
+
+from typing import _AnnotatedAlias  # noqa: F401
+
+try:
+    from typing_extensions import get_type_hints as _get_type_hints
+except Exception:
+    from typing import get_type_hints as _get_type_hints
+
+try:
+    from typing_extensions import NotRequired, Required
+except Exception:
+    try:
+        from typing import NotRequired, Required
+    except Exception:
+        Required = NotRequired = None
+
+
+def get_type_hints(obj):
+    return _get_type_hints(obj, include_extras=True)
+
+
+# The `is_class` argument was new in 3.11, but was backported to 3.9 and 3.10.
+# It's _likely_ to be available for 3.9/3.10, but may not be. Easiest way to
+# check is to try it and see. This check can be removed when we drop support
+# for Python 3.10.
+try:
+    typing.ForwardRef("Foo", is_class=True)
+except TypeError:
+
+    def _forward_ref(value):
+        return typing.ForwardRef(value, is_argument=False)
+
+else:
+
+    def _forward_ref(value):
+        return typing.ForwardRef(value, is_argument=False, is_class=True)
+
+
+# Python 3.13 adds a new mandatory type_params kwarg to _eval_type
+if sys.version_info >= (3, 13):
+
+    def _eval_type(t, globalns, localns):
+        return typing._eval_type(t, globalns, localns, ())
+elif sys.version_info < (3, 10):
+
+    def _eval_type(t, globalns, localns):
+        try:
+            return typing._eval_type(t, globalns, localns)
+        except TypeError as e:
+            try:
+                from eval_type_backport import eval_type_backport
+            except ImportError:
+                raise TypeError(
+                    f"Unable to evaluate type annotation {t.__forward_arg__!r}. If you are making use "
+                    "of the new typing syntax (unions using `|` since Python 3.10 or builtins subscripting "
+                    "since Python 3.9), you should either replace the use of new syntax with the existing "
+                    "`typing` constructs or install the `eval_type_backport` package."
+                ) from e
+
+            return eval_type_backport(
+                t,
+                globalns,
+                localns,
+                try_default=False,
+            )
+else:
+    _eval_type = typing._eval_type
+
+
+def _apply_params(obj, mapping):
+    if isinstance(obj, typing.TypeVar):
+        return mapping.get(obj, obj)
+
+    try:
+        parameters = tuple(obj.__parameters__)
+    except Exception:
+        # Not parameterized or __parameters__ is invalid, ignore
+        return obj
+
+    if not parameters:
+        # Not parametrized
+        return obj
+
+    # Parametrized
+    args = tuple(mapping.get(p, p) for p in parameters)
+    return obj[args]
+
+
+def _get_class_mro_and_typevar_mappings(obj):
+    mapping = {}
+
+    if isinstance(obj, type):
+        cls = obj
+    else:
+        cls = obj.__origin__
+
+    def inner(c, scope):
+        if isinstance(c, type):
+            cls = c
+            new_scope = {}
+        else:
+            cls = getattr(c, "__origin__", None)
+            if cls in (None, object, typing.Generic) or cls in mapping:
+                return
+            params = cls.__parameters__
+            args = tuple(_apply_params(a, scope) for a in c.__args__)
+            assert len(params) == len(args)
+            mapping[cls] = new_scope = dict(zip(params, args))
+
+        if issubclass(cls, typing.Generic):
+            bases = getattr(cls, "__orig_bases__", cls.__bases__)
+            for b in bases:
+                inner(b, new_scope)
+
+    inner(obj, {})
+    return cls.__mro__, mapping
+
+
+def get_class_annotations(obj):
+    """Get the annotations for a class.
+
+    This is similar to ``typing.get_type_hints``, except:
+
+    - We maintain it
+    - It leaves extras like ``Annotated``/``ClassVar`` alone
+    - It resolves any parametrized generics in the class mro. The returned
+      mapping may still include ``TypeVar`` values, but those should be treated
+      as their unparametrized variants (i.e. equal to ``Any`` for the common case).
+
+    Note that this function doesn't check that Generic types are being used
+    properly - invalid uses of `Generic` may slip through without complaint.
+
+    The assumption here is that the user is making use of a static analysis
+    tool like ``mypy``/``pyright`` already, which would catch misuse of these
+    APIs.
+    """
+    hints = {}
+    mro, typevar_mappings = _get_class_mro_and_typevar_mappings(obj)
+
+    for cls in mro:
+        if cls in (typing.Generic, object):
+            continue
+
+        mapping = typevar_mappings.get(cls)
+        cls_locals = dict(vars(cls))
+        cls_globals = getattr(sys.modules.get(cls.__module__, None), "__dict__", {})
+
+        ann = cls.__dict__.get("__annotations__", {})
+        for name, value in ann.items():
+            if name in hints:
+                continue
+            if value is None:
+                value = type(None)
+            elif isinstance(value, str):
+                value = _forward_ref(value)
+            value = _eval_type(value, cls_locals, cls_globals)
+            if mapping is not None:
+                value = _apply_params(value, mapping)
+            hints[name] = value
+    return hints
+
+
+# A mapping from a type annotation (or annotation __origin__) to the concrete
+# python type that msgspec will use when decoding. THIS IS PRIVATE FOR A
+# REASON. DON'T MUCK WITH THIS.
+_CONCRETE_TYPES = {
+    list: list,
+    tuple: tuple,
+    set: set,
+    frozenset: frozenset,
+    dict: dict,
+    typing.List: list,
+    typing.Tuple: tuple,
+    typing.Set: set,
+    typing.FrozenSet: frozenset,
+    typing.Dict: dict,
+    typing.Collection: list,
+    typing.MutableSequence: list,
+    typing.Sequence: list,
+    typing.MutableMapping: dict,
+    typing.Mapping: dict,
+    typing.MutableSet: set,
+    typing.AbstractSet: set,
+    collections.abc.Collection: list,
+    collections.abc.MutableSequence: list,
+    collections.abc.Sequence: list,
+    collections.abc.MutableSet: set,
+    collections.abc.Set: set,
+    collections.abc.MutableMapping: dict,
+    collections.abc.Mapping: dict,
+}
+
+
+def get_typeddict_info(obj):
+    if isinstance(obj, type):
+        cls = obj
+    else:
+        cls = obj.__origin__
+
+    raw_hints = get_class_annotations(obj)
+
+    if hasattr(cls, "__required_keys__"):
+        required = set(cls.__required_keys__)
+    elif cls.__total__:
+        required = set(raw_hints)
+    else:
+        required = set()
+
+    # Both `typing.TypedDict` and `typing_extensions.TypedDict` have a bug
+    # where `Required`/`NotRequired` aren't properly detected at runtime when
+    # `__future__.annotations` is enabled, meaning the `__required_keys__`
+    # isn't correct. This code block works around this issue by amending the
+    # set of required keys as needed, while also stripping off any
+    # `Required`/`NotRequired` wrappers.
+    hints = {}
+    for k, v in raw_hints.items():
+        origin = getattr(v, "__origin__", False)
+        if origin is Required:
+            required.add(k)
+            hints[k] = v.__args__[0]
+        elif origin is NotRequired:
+            required.discard(k)
+            hints[k] = v.__args__[0]
+        else:
+            hints[k] = v
+    return hints, required
+
+
+def get_dataclass_info(obj):
+    if isinstance(obj, type):
+        cls = obj
+    else:
+        cls = obj.__origin__
+    hints = get_class_annotations(obj)
+    required = []
+    optional = []
+    defaults = []
+
+    if hasattr(cls, "__dataclass_fields__"):
+        from dataclasses import _FIELD, _FIELD_INITVAR, MISSING
+
+        for field in cls.__dataclass_fields__.values():
+            if field._field_type is not _FIELD:
+                if field._field_type is _FIELD_INITVAR:
+                    raise TypeError(
+                        "dataclasses with `InitVar` fields are not supported"
+                    )
+                continue
+            name = field.name
+            typ = hints[name]
+            if field.default is not MISSING:
+                defaults.append(field.default)
+                optional.append((name, typ, False))
+            elif field.default_factory is not MISSING:
+                defaults.append(field.default_factory)
+                optional.append((name, typ, True))
+            else:
+                required.append((name, typ, False))
+
+        required.extend(optional)
+
+        pre_init = None
+        post_init = getattr(cls, "__post_init__", None)
+    else:
+        from attrs import NOTHING, Factory
+
+        fields_with_validators = []
+
+        for field in cls.__attrs_attrs__:
+            name = field.name
+            typ = hints[name]
+            default = field.default
+            if default is not NOTHING:
+                if isinstance(default, Factory):
+                    if default.takes_self:
+                        raise NotImplementedError(
+                            "Support for default factories with `takes_self=True` "
+                            "is not implemented. File a GitHub issue if you need "
+                            "this feature!"
+                        )
+                    defaults.append(default.factory)
+                    optional.append((name, typ, True))
+                else:
+                    defaults.append(default)
+                    optional.append((name, typ, False))
+            else:
+                required.append((name, typ, False))
+
+            if field.validator is not None:
+                fields_with_validators.append(field)
+
+        required.extend(optional)
+
+        pre_init = getattr(cls, "__attrs_pre_init__", None)
+        post_init = getattr(cls, "__attrs_post_init__", None)
+
+        if fields_with_validators:
+            post_init = _wrap_attrs_validators(fields_with_validators, post_init)
+
+    return cls, tuple(required), tuple(defaults), pre_init, post_init
+
+
+def _wrap_attrs_validators(fields, post_init):
+    def inner(obj):
+        for field in fields:
+            field.validator(obj, field, getattr(obj, field.name))
+        if post_init is not None:
+            post_init(obj)
+
+    return inner
+
+
+def rebuild(cls, kwargs):
+    """Used to unpickle Structs with keyword-only fields"""
+    return cls(**kwargs)

.venv/lib/python3.11/site-packages/msgspec/_version.py

@@ -0,0 +1,21 @@
+
+# This file was generated by 'versioneer.py' (0.19) from
+# revision-control system data, or from the parent directory name of an
+# unpacked source archive. Distribution tarballs contain a pre-generated copy
+# of this file.
+
+import json
+
+version_json = '''
+{
+ "date": "2024-12-27T11:06:58-0600",
+ "dirty": false,
+ "error": null,
+ "full-revisionid": "dd965dce22e5278d4935bea923441ecde31b5325",
+ "version": "0.19.0"
+}
+'''  # END VERSION_JSON
+
+
+def get_versions():
+    return json.loads(version_json)

.venv/lib/python3.11/site-packages/msgspec/inspect.py

@@ -0,0 +1,1005 @@
+from __future__ import annotations
+
+import datetime
+import decimal
+import enum
+import uuid
+from collections.abc import Iterable
+from typing import (
+    Any,
+    Final,
+    Literal,
+    Tuple,
+    Type as typing_Type,
+    TypeVar,
+    Union,
+)
+
+try:
+    from types import UnionType as _types_UnionType  # type: ignore
+except Exception:
+    _types_UnionType = type("UnionType", (), {})  # type: ignore
+
+try:
+    from typing import TypeAliasType as _TypeAliasType  # type: ignore
+except Exception:
+    _TypeAliasType = type("TypeAliasType", (), {})  # type: ignore
+
+import msgspec
+from msgspec import NODEFAULT, UNSET, UnsetType as _UnsetType
+
+from ._core import (  # type: ignore
+    Factory as _Factory,
+    to_builtins as _to_builtins,
+)
+from ._utils import (  # type: ignore
+    _CONCRETE_TYPES,
+    _AnnotatedAlias,
+    get_class_annotations as _get_class_annotations,
+    get_dataclass_info as _get_dataclass_info,
+    get_typeddict_info as _get_typeddict_info,
+)
+
+__all__ = (
+    "type_info",
+    "multi_type_info",
+    "Type",
+    "Metadata",
+    "AnyType",
+    "NoneType",
+    "BoolType",
+    "IntType",
+    "FloatType",
+    "StrType",
+    "BytesType",
+    "ByteArrayType",
+    "MemoryViewType",
+    "DateTimeType",
+    "TimeType",
+    "DateType",
+    "TimeDeltaType",
+    "UUIDType",
+    "DecimalType",
+    "ExtType",
+    "RawType",
+    "EnumType",
+    "LiteralType",
+    "CustomType",
+    "UnionType",
+    "CollectionType",
+    "ListType",
+    "SetType",
+    "FrozenSetType",
+    "VarTupleType",
+    "TupleType",
+    "DictType",
+    "Field",
+    "TypedDictType",
+    "NamedTupleType",
+    "DataclassType",
+    "StructType",
+)
+
+
+def __dir__():
+    return __all__
+
+
+class Type(msgspec.Struct):
+    """The base Type."""
+
+
+class Metadata(Type):
+    """A type wrapping a subtype with additional metadata.
+
+    Parameters
+    ----------
+    type: Type
+        The subtype.
+    extra_json_schema: dict, optional
+        A dict of extra fields to set for the subtype when generating a
+        json-schema.
+    extra: dict, optional
+        A dict of extra user-defined metadata attached to the subtype.
+    """
+
+    type: Type
+    extra_json_schema: Union[dict, None] = None
+    extra: Union[dict, None] = None
+
+
+class AnyType(Type):
+    """A type corresponding to `typing.Any`."""
+
+
+class NoneType(Type):
+    """A type corresponding to `None`."""
+
+
+class BoolType(Type):
+    """A type corresponding to `bool`."""
+
+
+class IntType(Type):
+    """A type corresponding to `int`.
+
+    Parameters
+    ----------
+    gt: int, optional
+        If set, an instance of this type must be greater than ``gt``.
+    ge: int, optional
+        If set, an instance of this type must be greater than or equal to ``ge``.
+    lt: int, optional
+        If set, an instance of this type must be less than to ``lt``.
+    le: int, optional
+        If set, an instance of this type must be less than or equal to ``le``.
+    multiple_of: int, optional
+        If set, an instance of this type must be a multiple of ``multiple_of``.
+    """
+
+    gt: Union[int, None] = None
+    ge: Union[int, None] = None
+    lt: Union[int, None] = None
+    le: Union[int, None] = None
+    multiple_of: Union[int, None] = None
+
+
+class FloatType(Type):
+    """A type corresponding to `float`.
+
+    Parameters
+    ----------
+    gt: float, optional
+        If set, an instance of this type must be greater than ``gt``.
+    ge: float, optional
+        If set, an instance of this type must be greater than or equal to ``ge``.
+    lt: float, optional
+        If set, an instance of this type must be less than to ``lt``.
+    le: float, optional
+        If set, an instance of this type must be less than or equal to ``le``.
+    multiple_of: float, optional
+        If set, an instance of this type must be a multiple of ``multiple_of``.
+    """
+
+    gt: Union[float, None] = None
+    ge: Union[float, None] = None
+    lt: Union[float, None] = None
+    le: Union[float, None] = None
+    multiple_of: Union[float, None] = None
+
+
+class StrType(Type):
+    """A type corresponding to `str`.
+
+    Parameters
+    ----------
+    min_length: int, optional
+        If set, an instance of this type must have length greater than or equal
+        to ``min_length``.
+    max_length: int, optional
+        If set, an instance of this type must have length less than or equal
+        to ``max_length``.
+    pattern: str, optional
+        If set, an instance of this type must match against this regex pattern.
+        Note that the pattern is treated as **unanchored**.
+    """
+
+    min_length: Union[int, None] = None
+    max_length: Union[int, None] = None
+    pattern: Union[str, None] = None
+
+
+class BytesType(Type):
+    """A type corresponding to `bytes`.
+
+    Parameters
+    ----------
+    min_length: int, optional
+        If set, an instance of this type must have length greater than or equal
+        to ``min_length``.
+    max_length: int, optional
+        If set, an instance of this type must have length less than or equal
+        to ``max_length``.
+    """
+
+    min_length: Union[int, None] = None
+    max_length: Union[int, None] = None
+
+
+class ByteArrayType(Type):
+    """A type corresponding to `bytearray`.
+
+    Parameters
+    ----------
+    min_length: int, optional
+        If set, an instance of this type must have length greater than or equal
+        to ``min_length``.
+    max_length: int, optional
+        If set, an instance of this type must have length less than or equal
+        to ``max_length``.
+    """
+
+    min_length: Union[int, None] = None
+    max_length: Union[int, None] = None
+
+
+class MemoryViewType(Type):
+    """A type corresponding to `memoryview`.
+
+    Parameters
+    ----------
+    min_length: int, optional
+        If set, an instance of this type must have length greater than or equal
+        to ``min_length``.
+    max_length: int, optional
+        If set, an instance of this type must have length less than or equal
+        to ``max_length``.
+    """
+
+    min_length: Union[int, None] = None
+    max_length: Union[int, None] = None
+
+
+class DateTimeType(Type):
+    """A type corresponding to `datetime.datetime`.
+
+    Parameters
+    ----------
+    tz: bool
+        The timezone-requirements for an instance of this type. ``True``
+        indicates a timezone-aware value is required, ``False`` indicates a
+        timezone-aware value is required. The default is ``None``, which
+        accepts either timezone-aware or timezone-naive values.
+    """
+
+    tz: Union[bool, None] = None
+
+
+class TimeType(Type):
+    """A type corresponding to `datetime.time`.
+
+    Parameters
+    ----------
+    tz: bool
+        The timezone-requirements for an instance of this type. ``True``
+        indicates a timezone-aware value is required, ``False`` indicates a
+        timezone-aware value is required. The default is ``None``, which
+        accepts either timezone-aware or timezone-naive values.
+    """
+
+    tz: Union[bool, None] = None
+
+
+class DateType(Type):
+    """A type corresponding to `datetime.date`."""
+
+
+class TimeDeltaType(Type):
+    """A type corresponding to `datetime.timedelta`."""
+
+
+class UUIDType(Type):
+    """A type corresponding to `uuid.UUID`."""
+
+
+class DecimalType(Type):
+    """A type corresponding to `decimal.Decimal`."""
+
+
+class ExtType(Type):
+    """A type corresponding to `msgspec.msgpack.Ext`."""
+
+
+class RawType(Type):
+    """A type corresponding to `msgspec.Raw`."""
+
+
+class EnumType(Type):
+    """A type corresponding to an `enum.Enum` type.
+
+    Parameters
+    ----------
+    cls: type
+        The corresponding `enum.Enum` type.
+    """
+
+    cls: typing_Type[enum.Enum]
+
+
+class LiteralType(Type):
+    """A type corresponding to a `typing.Literal` type.
+
+    Parameters
+    ----------
+    values: tuple
+        A tuple of possible values for this literal instance. Only `str` or
+        `int` literals are supported.
+    """
+
+    values: Union[Tuple[str, ...], Tuple[int, ...]]
+
+
+class CustomType(Type):
+    """A custom type.
+
+    Parameters
+    ----------
+    cls: type
+        The corresponding custom type.
+    """
+
+    cls: type
+
+
+class UnionType(Type):
+    """A union type.
+
+    Parameters
+    ----------
+    types: Tuple[Type, ...]
+        A tuple of possible types for this union.
+    """
+
+    types: Tuple[Type, ...]
+
+    @property
+    def includes_none(self) -> bool:
+        """A helper for checking whether ``None`` is included in this union."""
+        return any(isinstance(t, NoneType) for t in self.types)
+
+
+class CollectionType(Type):
+    """A collection type.
+
+    This is the base type shared by collection types like `ListType`,
+    `SetType`, etc.
+
+    Parameters
+    ----------
+    item_type: Type
+        The item type.
+    min_length: int, optional
+        If set, an instance of this type must have length greater than or equal
+        to ``min_length``.
+    max_length: int, optional
+        If set, an instance of this type must have length less than or equal
+        to ``max_length``.
+    """
+
+    item_type: Type
+    min_length: Union[int, None] = None
+    max_length: Union[int, None] = None
+
+
+class ListType(CollectionType):
+    """A type corresponding to a `list`.
+
+    Parameters
+    ----------
+    item_type: Type
+        The item type.
+    min_length: int, optional
+        If set, an instance of this type must have length greater than or equal
+        to ``min_length``.
+    max_length: int, optional
+        If set, an instance of this type must have length less than or equal
+        to ``max_length``.
+    """
+
+
+class VarTupleType(CollectionType):
+    """A type corresponding to a variadic `tuple`.
+
+    Parameters
+    ----------
+    item_type: Type
+        The item type.
+    min_length: int, optional
+        If set, an instance of this type must have length greater than or equal
+        to ``min_length``.
+    max_length: int, optional
+        If set, an instance of this type must have length less than or equal
+        to ``max_length``.
+    """
+
+
+class SetType(CollectionType):
+    """A type corresponding to a `set`.
+
+    Parameters
+    ----------
+    item_type: Type
+        The item type.
+    min_length: int, optional
+        If set, an instance of this type must have length greater than or equal
+        to ``min_length``.
+    max_length: int, optional
+        If set, an instance of this type must have length less than or equal
+        to ``max_length``.
+    """
+
+
+class FrozenSetType(CollectionType):
+    """A type corresponding to a `frozenset`.
+
+    Parameters
+    ----------
+    item_type: Type
+        The item type.
+    min_length: int, optional
+        If set, an instance of this type must have length greater than or equal
+        to ``min_length``.
+    max_length: int, optional
+        If set, an instance of this type must have length less than or equal
+        to ``max_length``.
+    """
+
+
+class TupleType(Type):
+    """A type corresponding to `tuple`.
+
+    Parameters
+    ----------
+    item_types: Tuple[Type, ...]
+        A tuple of types for each element in the tuple.
+    """
+
+    item_types: Tuple[Type, ...]
+
+
+class DictType(Type):
+    """A type corresponding to `dict`.
+
+    Parameters
+    ----------
+    key_type: Type
+        The key type.
+    value_type: Type
+        The value type.
+    min_length: int, optional
+        If set, an instance of this type must have length greater than or equal
+        to ``min_length``.
+    max_length: int, optional
+        If set, an instance of this type must have length less than or equal
+        to ``max_length``.
+    """
+
+    key_type: Type
+    value_type: Type
+    min_length: Union[int, None] = None
+    max_length: Union[int, None] = None
+
+
+class Field(msgspec.Struct):
+    """A record describing a field in an object-like type.
+
+    Parameters
+    ----------
+    name: str
+        The field name as seen by Python code (e.g. ``field_one``).
+    encode_name: str
+        The name used when encoding/decoding the field. This may differ if
+        the field is renamed (e.g. ``fieldOne``).
+    type: Type
+        The field type.
+    required: bool, optional
+        Whether the field is required. Note that if `required` is False doesn't
+        necessarily mean that `default` or `default_factory` will be set -
+        optional fields may exist with no default value.
+    default: Any, optional
+        A default value for the field. Will be `NODEFAULT` if no default value
+        is set.
+    default_factory: Any, optional
+        A callable that creates a default value for the field. Will be
+        `NODEFAULT` if no ``default_factory`` is set.
+    """
+
+    name: str
+    encode_name: str
+    type: Type
+    required: bool = True
+    default: Any = msgspec.field(default_factory=lambda: NODEFAULT)
+    default_factory: Any = msgspec.field(default_factory=lambda: NODEFAULT)
+
+
+class TypedDictType(Type):
+    """A type corresponding to a `typing.TypedDict` type.
+
+    Parameters
+    ----------
+    cls: type
+        The corresponding TypedDict type.
+    fields: Tuple[Field, ...]
+        A tuple of fields in the TypedDict.
+    """
+
+    cls: type
+    fields: Tuple[Field, ...]
+
+
+class NamedTupleType(Type):
+    """A type corresponding to a `typing.NamedTuple` type.
+
+    Parameters
+    ----------
+    cls: type
+        The corresponding NamedTuple type.
+    fields: Tuple[Field, ...]
+        A tuple of fields in the NamedTuple.
+    """
+
+    cls: type
+    fields: Tuple[Field, ...]
+
+
+class DataclassType(Type):
+    """A type corresponding to a `dataclasses` or `attrs` type.
+
+    Parameters
+    ----------
+    cls: type
+        The corresponding dataclass type.
+    fields: Tuple[Field, ...]
+        A tuple of fields in the dataclass.
+    """
+
+    cls: type
+    fields: Tuple[Field, ...]
+
+
+class StructType(Type):
+    """A type corresponding to a `msgspec.Struct` type.
+
+    Parameters
+    ----------
+    cls: type
+        The corresponding Struct type.
+    fields: Tuple[Field, ...]
+        A tuple of fields in the Struct.
+    tag_field: str or None, optional
+        If set, the field name used for the tag in a tagged union.
+    tag: str, int, or None, optional
+        If set, the value used for the tag in a tagged union.
+    array_like: bool, optional
+        Whether the struct is encoded as an array rather than an object.
+    forbid_unknown_fields: bool, optional
+        If ``False`` (the default) unknown fields are ignored when decoding. If
+        ``True`` any unknown fields will result in an error.
+    """
+
+    cls: typing_Type[msgspec.Struct]
+    fields: Tuple[Field, ...]
+    tag_field: Union[str, None] = None
+    tag: Union[str, int, None] = None
+    array_like: bool = False
+    forbid_unknown_fields: bool = False
+
+
+def multi_type_info(types: Iterable[Any]) -> tuple[Type, ...]:
+    """Get information about multiple msgspec-compatible types.
+
+    Parameters
+    ----------
+    types: an iterable of types
+        The types to get info about.
+
+    Returns
+    -------
+    tuple[Type, ...]
+
+    Examples
+    --------
+    >>> msgspec.inspect.multi_type_info([int, float, list[str]])  # doctest: +NORMALIZE_WHITESPACE
+    (IntType(gt=None, ge=None, lt=None, le=None, multiple_of=None),
+     FloatType(gt=None, ge=None, lt=None, le=None, multiple_of=None),
+     ListType(item_type=StrType(min_length=None, max_length=None, pattern=None),
+              min_length=None, max_length=None))
+    """
+    return _Translator(types).run()
+
+
+def type_info(type: Any) -> Type:
+    """Get information about a msgspec-compatible type.
+
+    Note that if you need to inspect multiple types it's more efficient to call
+    `multi_type_info` once with a sequence of types than calling `type_info`
+    multiple times.
+
+    Parameters
+    ----------
+    type: type
+        The type to get info about.
+
+    Returns
+    -------
+    Type
+
+    Examples
+    --------
+    >>> msgspec.inspect.type_info(bool)
+    BoolType()
+
+    >>> msgspec.inspect.type_info(int)
+    IntType(gt=None, ge=None, lt=None, le=None, multiple_of=None)
+
+    >>> msgspec.inspect.type_info(list[int])  # doctest: +NORMALIZE_WHITESPACE
+    ListType(item_type=IntType(gt=None, ge=None, lt=None, le=None, multiple_of=None),
+             min_length=None, max_length=None)
+    """
+    return multi_type_info([type])[0]
+
+
+# Implementation details
+def _origin_args_metadata(t):
+    # Strip wrappers (Annotated, NewType, Final) until we hit a concrete type
+    metadata = []
+    while True:
+        try:
+            origin = _CONCRETE_TYPES.get(t)
+        except TypeError:
+            # t is not hashable
+            origin = None
+
+        if origin is not None:
+            args = None
+            break
+
+        origin = getattr(t, "__origin__", None)
+        if origin is not None:
+            if type(t) is _AnnotatedAlias:
+                metadata.extend(m for m in t.__metadata__ if type(m) is msgspec.Meta)
+                t = origin
+            elif origin == Final:
+                t = t.__args__[0]
+            elif type(origin) is _TypeAliasType:
+                t = origin.__value__[t.__args__]
+            else:
+                args = getattr(t, "__args__", None)
+                origin = _CONCRETE_TYPES.get(origin, origin)
+                break
+        else:
+            supertype = getattr(t, "__supertype__", None)
+            if supertype is not None:
+                t = supertype
+            elif type(t) is _TypeAliasType:
+                t = t.__value__
+            else:
+                origin = t
+                args = None
+                break
+
+    if type(origin) is _types_UnionType:
+        args = origin.__args__
+        origin = Union
+    return origin, args, tuple(metadata)
+
+
+def _is_struct(t):
+    return type(t) is type(msgspec.Struct)
+
+
+def _is_enum(t):
+    return type(t) is enum.EnumMeta
+
+
+def _is_dataclass(t):
+    return hasattr(t, "__dataclass_fields__")
+
+
+def _is_attrs(t):
+    return hasattr(t, "__attrs_attrs__")
+
+
+def _is_typeddict(t):
+    try:
+        return issubclass(t, dict) and hasattr(t, "__total__")
+    except TypeError:
+        return False
+
+
+def _is_namedtuple(t):
+    try:
+        return issubclass(t, tuple) and hasattr(t, "_fields")
+    except TypeError:
+        return False
+
+
+def _merge_json(a, b):
+    if b:
+        a = a.copy()
+        for key, b_val in b.items():
+            if key in a:
+                a_val = a[key]
+                if isinstance(a_val, dict) and isinstance(b_val, dict):
+                    a[key] = _merge_json(a_val, b_val)
+                elif isinstance(a_val, (list, tuple)) and isinstance(
+                    b_val, (list, tuple)
+                ):
+                    a[key] = list(a_val) + list(b_val)
+                else:
+                    a[key] = b_val
+            else:
+                a[key] = b_val
+    return a
+
+
+class _Translator:
+    def __init__(self, types):
+        self.types = tuple(types)
+        self.type_hints = {}
+        self.cache = {}
+
+    def _get_class_annotations(self, t):
+        """A cached version of `get_class_annotations`"""
+        try:
+            return self.type_hints[t]
+        except KeyError:
+            out = self.type_hints[t] = _get_class_annotations(t)
+            return out
+
+    def run(self):
+        # First construct a decoder to validate the types are valid
+        from ._core import MsgpackDecoder
+
+        MsgpackDecoder(Tuple[self.types])
+        return tuple(self.translate(t) for t in self.types)
+
+    def translate(self, typ):
+        t, args, metadata = _origin_args_metadata(typ)
+
+        # Extract and merge components of any `Meta` annotations
+        constrs = {}
+        extra_json_schema = {}
+        extra = {}
+        for meta in metadata:
+            for attr in (
+                "ge",
+                "gt",
+                "le",
+                "lt",
+                "multiple_of",
+                "pattern",
+                "min_length",
+                "max_length",
+                "tz",
+            ):
+                if (val := getattr(meta, attr)) is not None:
+                    constrs[attr] = val
+            for attr in ("title", "description", "examples"):
+                if (val := getattr(meta, attr)) is not None:
+                    extra_json_schema[attr] = val
+            if meta.extra_json_schema is not None:
+                extra_json_schema = _merge_json(
+                    extra_json_schema,
+                    _to_builtins(meta.extra_json_schema, str_keys=True),
+                )
+            if meta.extra is not None:
+                extra.update(meta.extra)
+
+        out = self._translate_inner(t, args, **constrs)
+        if extra_json_schema or extra:
+            # If extra metadata is present, wrap the output type in a Metadata
+            # wrapper object
+            return Metadata(
+                out, extra_json_schema=extra_json_schema or None, extra=extra or None
+            )
+        return out
+
+    def _translate_inner(
+        self,
+        t,
+        args,
+        ge=None,
+        gt=None,
+        le=None,
+        lt=None,
+        multiple_of=None,
+        pattern=None,
+        min_length=None,
+        max_length=None,
+        tz=None,
+    ):
+        if t is Any:
+            return AnyType()
+        elif isinstance(t, TypeVar):
+            if t.__bound__ is not None:
+                return self.translate(t.__bound__)
+            return AnyType()
+        elif t is None or t is type(None):
+            return NoneType()
+        elif t is bool:
+            return BoolType()
+        elif t is int:
+            return IntType(ge=ge, gt=gt, le=le, lt=lt, multiple_of=multiple_of)
+        elif t is float:
+            return FloatType(ge=ge, gt=gt, le=le, lt=lt, multiple_of=multiple_of)
+        elif t is str:
+            return StrType(
+                min_length=min_length, max_length=max_length, pattern=pattern
+            )
+        elif t is bytes:
+            return BytesType(min_length=min_length, max_length=max_length)
+        elif t is bytearray:
+            return ByteArrayType(min_length=min_length, max_length=max_length)
+        elif t is memoryview:
+            return MemoryViewType(min_length=min_length, max_length=max_length)
+        elif t is datetime.datetime:
+            return DateTimeType(tz=tz)
+        elif t is datetime.time:
+            return TimeType(tz=tz)
+        elif t is datetime.date:
+            return DateType()
+        elif t is datetime.timedelta:
+            return TimeDeltaType()
+        elif t is uuid.UUID:
+            return UUIDType()
+        elif t is decimal.Decimal:
+            return DecimalType()
+        elif t is msgspec.Raw:
+            return RawType()
+        elif t is msgspec.msgpack.Ext:
+            return ExtType()
+        elif t is list:
+            return ListType(
+                self.translate(args[0]) if args else AnyType(),
+                min_length=min_length,
+                max_length=max_length,
+            )
+        elif t is set:
+            return SetType(
+                self.translate(args[0]) if args else AnyType(),
+                min_length=min_length,
+                max_length=max_length,
+            )
+        elif t is frozenset:
+            return FrozenSetType(
+                self.translate(args[0]) if args else AnyType(),
+                min_length=min_length,
+                max_length=max_length,
+            )
+        elif t is tuple:
+            # Handle an annoying compatibility issue:
+            # - Tuple[()] has args == ((),)
+            # - tuple[()] has args == ()
+            if args == ((),):
+                args = ()
+            if args is None:
+                return VarTupleType(
+                    AnyType(), min_length=min_length, max_length=max_length
+                )
+            elif len(args) == 2 and args[-1] is ...:
+                return VarTupleType(
+                    self.translate(args[0]),
+                    min_length=min_length,
+                    max_length=max_length,
+                )
+            else:
+                return TupleType(tuple(self.translate(a) for a in args))
+        elif t is dict:
+            return DictType(
+                self.translate(args[0]) if args else AnyType(),
+                self.translate(args[1]) if args else AnyType(),
+                min_length=min_length,
+                max_length=max_length,
+            )
+        elif t is Union:
+            args = tuple(self.translate(a) for a in args if a is not _UnsetType)
+            return args[0] if len(args) == 1 else UnionType(args)
+        elif t is Literal:
+            return LiteralType(tuple(sorted(args)))
+        elif _is_enum(t):
+            return EnumType(t)
+        elif _is_struct(t):
+            cls = t[args] if args else t
+            if cls in self.cache:
+                return self.cache[cls]
+            config = t.__struct_config__
+            self.cache[cls] = out = StructType(
+                cls,
+                (),
+                tag_field=config.tag_field,
+                tag=config.tag,
+                array_like=config.array_like,
+                forbid_unknown_fields=config.forbid_unknown_fields,
+            )
+
+            hints = self._get_class_annotations(cls)
+            npos = len(t.__struct_fields__) - len(t.__struct_defaults__)
+            fields = []
+            for name, encode_name, default_obj in zip(
+                t.__struct_fields__,
+                t.__struct_encode_fields__,
+                (NODEFAULT,) * npos + t.__struct_defaults__,
+            ):
+                if default_obj is NODEFAULT:
+                    required = True
+                    default = default_factory = NODEFAULT
+                elif isinstance(default_obj, _Factory):
+                    required = False
+                    default = NODEFAULT
+                    default_factory = default_obj.factory
+                else:
+                    required = False
+                    default = NODEFAULT if default_obj is UNSET else default_obj
+                    default_factory = NODEFAULT
+
+                field = Field(
+                    name=name,
+                    encode_name=encode_name,
+                    type=self.translate(hints[name]),
+                    required=required,
+                    default=default,
+                    default_factory=default_factory,
+                )
+                fields.append(field)
+
+            out.fields = tuple(fields)
+            return out
+        elif _is_typeddict(t):
+            cls = t[args] if args else t
+            if cls in self.cache:
+                return self.cache[cls]
+            self.cache[cls] = out = TypedDictType(cls, ())
+            hints, required = _get_typeddict_info(cls)
+            out.fields = tuple(
+                Field(
+                    name=name,
+                    encode_name=name,
+                    type=self.translate(field_type),
+                    required=name in required,
+                )
+                for name, field_type in sorted(hints.items())
+            )
+            return out
+        elif _is_dataclass(t) or _is_attrs(t):
+            cls = t[args] if args else t
+            if cls in self.cache:
+                return self.cache[cls]
+            self.cache[cls] = out = DataclassType(cls, ())
+            _, info, defaults, _, _ = _get_dataclass_info(cls)
+            defaults = ((NODEFAULT,) * (len(info) - len(defaults))) + defaults
+            fields = []
+            for (name, typ, is_factory), default_obj in zip(info, defaults):
+                if default_obj is NODEFAULT:
+                    required = True
+                    default = default_factory = NODEFAULT
+                elif is_factory:
+                    required = False
+                    default = NODEFAULT
+                    default_factory = default_obj
+                else:
+                    required = False
+                    default = NODEFAULT if default_obj is UNSET else default_obj
+                    default_factory = NODEFAULT
+
+                fields.append(
+                    Field(
+                        name=name,
+                        encode_name=name,
+                        type=self.translate(typ),
+                        required=required,
+                        default=default,
+                        default_factory=default_factory,
+                    )
+                )
+            out.fields = tuple(fields)
+            return out
+        elif _is_namedtuple(t):
+            cls = t[args] if args else t
+            if cls in self.cache:
+                return self.cache[cls]
+            self.cache[cls] = out = NamedTupleType(cls, ())
+            hints = self._get_class_annotations(cls)
+            out.fields = tuple(
+                Field(
+                    name=name,
+                    encode_name=name,
+                    type=self.translate(hints.get(name, Any)),
+                    required=name not in t._field_defaults,
+                    default=t._field_defaults.get(name, NODEFAULT),
+                )
+                for name in t._fields
+            )
+            return out
+        else:
+            return CustomType(t)

.venv/lib/python3.11/site-packages/msgspec/json.py

@@ -0,0 +1,8 @@
+from ._core import (
+    JSONDecoder as Decoder,
+    JSONEncoder as Encoder,
+    json_decode as decode,
+    json_encode as encode,
+    json_format as format,
+)
+from ._json_schema import schema, schema_components

.venv/lib/python3.11/site-packages/msgspec/json.pyi

@@ -0,0 +1,118 @@
+from collections.abc import Iterable
+from typing import (
+    Any,
+    Callable,
+    Dict,
+    Generic,
+    Iterable,
+    Literal,
+    Optional,
+    Tuple,
+    Type,
+    TypeVar,
+    Union,
+    overload,
+)
+
+from typing_extensions import Buffer
+
+T = TypeVar("T")
+
+enc_hook_sig = Optional[Callable[[Any], Any]]
+dec_hook_sig = Optional[Callable[[type, Any], Any]]
+float_hook_sig = Optional[Callable[[str], Any]]
+schema_hook_sig = Optional[Callable[[type], dict[str, Any]]]
+
+class Encoder:
+    enc_hook: enc_hook_sig
+    decimal_format: Literal["string", "number"]
+    uuid_format: Literal["canonical", "hex"]
+    order: Literal[None, "deterministic", "sorted"]
+
+    def __init__(
+        self,
+        *,
+        enc_hook: enc_hook_sig = None,
+        decimal_format: Literal["string", "number"] = "string",
+        uuid_format: Literal["canonical", "hex"] = "canonical",
+        order: Literal[None, "deterministic", "sorted"] = None,
+    ): ...
+    def encode(self, obj: Any, /) -> bytes: ...
+    def encode_lines(self, items: Iterable, /) -> bytes: ...
+    def encode_into(
+        self, obj: Any, buffer: bytearray, offset: Optional[int] = 0, /
+    ) -> None: ...
+
+class Decoder(Generic[T]):
+    type: Type[T]
+    strict: bool
+    dec_hook: dec_hook_sig
+    float_hook: float_hook_sig
+
+    @overload
+    def __init__(
+        self: Decoder[Any],
+        *,
+        strict: bool = True,
+        dec_hook: dec_hook_sig = None,
+        float_hook: float_hook_sig = None,
+    ) -> None: ...
+    @overload
+    def __init__(
+        self: Decoder[T],
+        type: Type[T] = ...,
+        *,
+        strict: bool = True,
+        dec_hook: dec_hook_sig = None,
+        float_hook: float_hook_sig = None,
+    ) -> None: ...
+    @overload
+    def __init__(
+        self: Decoder[Any],
+        type: Any = ...,
+        *,
+        strict: bool = True,
+        dec_hook: dec_hook_sig = None,
+        float_hook: float_hook_sig = None,
+    ) -> None: ...
+    def decode(self, buf: Union[Buffer, str], /) -> T: ...
+    def decode_lines(self, buf: Union[Buffer, str], /) -> list[T]: ...
+
+@overload
+def decode(
+    buf: Union[Buffer, str],
+    /,
+    *,
+    strict: bool = True,
+    dec_hook: dec_hook_sig = None,
+) -> Any: ...
+@overload
+def decode(
+    buf: Union[Buffer, str],
+    /,
+    *,
+    type: Type[T] = ...,
+    strict: bool = True,
+    dec_hook: dec_hook_sig = None,
+) -> T: ...
+@overload
+def decode(
+    buf: Union[Buffer, str],
+    /,
+    *,
+    type: Any = ...,
+    strict: bool = True,
+    dec_hook: dec_hook_sig = None,
+) -> Any: ...
+def encode(obj: Any, /, *, enc_hook: enc_hook_sig = None, order: Literal[None, "deterministic", "sorted"] = None) -> bytes: ...
+def schema(type: Any, *, schema_hook: schema_hook_sig = None) -> Dict[str, Any]: ...
+def schema_components(
+    types: Iterable[Any],
+    *,
+    schema_hook: schema_hook_sig = None,
+    ref_template: str = "#/$defs/{name}"
+) -> Tuple[Tuple[Dict[str, Any], ...], Dict[str, Any]]: ...
+@overload
+def format(buf: str, /, *, indent: int = 2) -> str: ...
+@overload
+def format(buf: Buffer, /, *, indent: int = 2) -> bytes: ...

.venv/lib/python3.11/site-packages/msgspec/msgpack.py

@@ -0,0 +1,7 @@
+from ._core import (
+    Ext,
+    MsgpackDecoder as Decoder,
+    MsgpackEncoder as Encoder,
+    msgpack_decode as decode,
+    msgpack_encode as encode,
+)

.venv/lib/python3.11/site-packages/msgspec/msgpack.pyi

@@ -0,0 +1,109 @@
+from typing import (
+    Any,
+    Callable,
+    Generic,
+    Literal,
+    Optional,
+    Type,
+    TypeVar,
+    Union,
+    overload,
+)
+
+from typing_extensions import Buffer
+
+
+T = TypeVar("T")
+
+enc_hook_sig = Optional[Callable[[Any], Any]]
+ext_hook_sig = Optional[Callable[[int, memoryview], Any]]
+dec_hook_sig = Optional[Callable[[type, Any], Any]]
+
+class Ext:
+    code: int
+    data: Union[bytes, bytearray, memoryview]
+    def __init__(
+        self, code: int, data: Union[bytes, bytearray, memoryview]
+    ) -> None: ...
+
+class Decoder(Generic[T]):
+    type: Type[T]
+    strict: bool
+    dec_hook: dec_hook_sig
+    ext_hook: ext_hook_sig
+    @overload
+    def __init__(
+        self: Decoder[Any],
+        *,
+        strict: bool = True,
+        dec_hook: dec_hook_sig = None,
+        ext_hook: ext_hook_sig = None,
+    ) -> None: ...
+    @overload
+    def __init__(
+        self: Decoder[T],
+        type: Type[T] = ...,
+        *,
+        strict: bool = True,
+        dec_hook: dec_hook_sig = None,
+        ext_hook: ext_hook_sig = None,
+    ) -> None: ...
+    @overload
+    def __init__(
+        self: Decoder[Any],
+        type: Any = ...,
+        *,
+        strict: bool = True,
+        dec_hook: dec_hook_sig = None,
+        ext_hook: ext_hook_sig = None,
+    ) -> None: ...
+    def decode(self, buf: Buffer, /) -> T: ...
+
+class Encoder:
+    enc_hook: enc_hook_sig
+    decimal_format: Literal["string", "number"]
+    uuid_format: Literal["canonical", "hex", "bytes"]
+    order: Literal[None, "deterministic", "sorted"]
+    def __init__(
+        self,
+        *,
+        enc_hook: enc_hook_sig = None,
+        decimal_format: Literal["string", "number"] = "string",
+        uuid_format: Literal["canonical", "hex", "bytes"] = "canonical",
+        order: Literal[None, "deterministic", "sorted"] = None,
+    ): ...
+    def encode(self, obj: Any, /) -> bytes: ...
+    def encode_into(
+        self, obj: Any, buffer: bytearray, offset: Optional[int] = 0, /
+    ) -> None: ...
+
+@overload
+def decode(
+    buf: Buffer,
+    /,
+    *,
+    strict: bool = True,
+    dec_hook: dec_hook_sig = None,
+    ext_hook: ext_hook_sig = None,
+) -> Any: ...
+@overload
+def decode(
+    buf: Buffer,
+    /,
+    *,
+    type: Type[T] = ...,
+    strict: bool = True,
+    dec_hook: dec_hook_sig = None,
+    ext_hook: ext_hook_sig = None,
+) -> T: ...
+@overload
+def decode(
+    buf: Buffer,
+    /,
+    *,
+    type: Any = ...,
+    strict: bool = True,
+    dec_hook: dec_hook_sig = None,
+    ext_hook: ext_hook_sig = None,
+) -> Any: ...
+def encode(obj: Any, /, *, enc_hook: enc_hook_sig = None, order: Literal[None, "deterministic", "sorted"] = None) -> bytes: ...

.venv/lib/python3.11/site-packages/msgspec/structs.py

@@ -0,0 +1,106 @@
+from __future__ import annotations
+
+from typing import Any
+
+from . import NODEFAULT, Struct, field
+from ._core import (  # noqa
+    Factory as _Factory,
+    StructConfig,
+    asdict,
+    astuple,
+    replace,
+    force_setattr,
+)
+from ._utils import get_class_annotations as _get_class_annotations
+
+__all__ = (
+    "FieldInfo",
+    "StructConfig",
+    "asdict",
+    "astuple",
+    "fields",
+    "force_setattr",
+    "replace",
+)
+
+
+def __dir__():
+    return __all__
+
+
+class FieldInfo(Struct):
+    """A record describing a field in a struct type.
+
+    Parameters
+    ----------
+    name: str
+        The field name as seen by Python code (e.g. ``field_one``).
+    encode_name: str
+        The name used when encoding/decoding the field. This may differ if
+        the field is renamed (e.g. ``fieldOne``).
+    type: Any
+        The full field type annotation.
+    default: Any, optional
+        A default value for the field. Will be `NODEFAULT` if no default value
+        is set.
+    default_factory: Any, optional
+        A callable that creates a default value for the field. Will be
+        `NODEFAULT` if no ``default_factory`` is set.
+    """
+
+    name: str
+    encode_name: str
+    type: Any
+    default: Any = field(default_factory=lambda: NODEFAULT)
+    default_factory: Any = field(default_factory=lambda: NODEFAULT)
+
+    @property
+    def required(self) -> bool:
+        """A helper for checking whether a field is required"""
+        return self.default is NODEFAULT and self.default_factory is NODEFAULT
+
+
+def fields(type_or_instance: Struct | type[Struct]) -> tuple[FieldInfo]:
+    """Get information about the fields in a Struct.
+
+    Parameters
+    ----------
+    type_or_instance:
+        A struct type or instance.
+
+    Returns
+    -------
+    tuple[FieldInfo]
+    """
+    if isinstance(type_or_instance, Struct):
+        annotated_cls = cls = type(type_or_instance)
+    else:
+        annotated_cls = type_or_instance
+        cls = getattr(type_or_instance, "__origin__", type_or_instance)
+        if not (isinstance(cls, type) and issubclass(cls, Struct)):
+            raise TypeError("Must be called with a struct type or instance")
+
+    hints = _get_class_annotations(annotated_cls)
+    npos = len(cls.__struct_fields__) - len(cls.__struct_defaults__)
+    fields = []
+    for name, encode_name, default_obj in zip(
+        cls.__struct_fields__,
+        cls.__struct_encode_fields__,
+        (NODEFAULT,) * npos + cls.__struct_defaults__,
+    ):
+        default = default_factory = NODEFAULT
+        if isinstance(default_obj, _Factory):
+            default_factory = default_obj.factory
+        elif default_obj is not NODEFAULT:
+            default = default_obj
+
+        field = FieldInfo(
+            name=name,
+            encode_name=encode_name,
+            type=hints[name],
+            default=default,
+            default_factory=default_factory,
+        )
+        fields.append(field)
+
+    return tuple(fields)

.venv/lib/python3.11/site-packages/msgspec/structs.pyi

@@ -0,0 +1,37 @@
+from typing import Any, TypeVar, Union
+
+from . import NODEFAULT, Struct
+
+S = TypeVar("S", bound=Struct)
+
+def replace(struct: S, /, **changes: Any) -> S: ...
+def asdict(struct: Struct) -> dict[str, Any]: ...
+def astuple(struct: Struct) -> tuple[Any, ...]: ...
+def force_setattr(struct: Struct, name: str, value: Any) -> None: ...
+
+class StructConfig:
+    frozen: bool
+    eq: bool
+    order: bool
+    array_like: bool
+    gc: bool
+    repr_omit_defaults: bool
+    omit_defaults: bool
+    forbid_unknown_fields: bool
+    weakref: bool
+    dict: bool
+    cache_hash: bool
+    tag: Union[str, int, None]
+    tag_field: Union[str, None]
+
+class FieldInfo(Struct):
+    name: str
+    encode_name: str
+    type: Any
+    default: Any = NODEFAULT
+    default_factory: Any = NODEFAULT
+
+    @property
+    def required(self) -> bool: ...
+
+def fields(type_or_instance: Struct | type[Struct]) -> tuple[FieldInfo]: ...