Add files using upload-large-folder tool

lib/python3.13/site-packages/aiohappyeyeballs-2.6.1.dist-info/INSTALLER

@@ -0,0 +1 @@
+uv

lib/python3.13/site-packages/aiohappyeyeballs-2.6.1.dist-info/LICENSE

@@ -0,0 +1,279 @@
+A. HISTORY OF THE SOFTWARE
+==========================
+
+Python was created in the early 1990s by Guido van Rossum at Stichting
+Mathematisch Centrum (CWI, see https://www.cwi.nl) in the Netherlands
+as a successor of a language called ABC.  Guido remains Python's
+principal author, although it includes many contributions from others.
+
+In 1995, Guido continued his work on Python at the Corporation for
+National Research Initiatives (CNRI, see https://www.cnri.reston.va.us)
+in Reston, Virginia where he released several versions of the
+software.
+
+In May 2000, Guido and the Python core development team moved to
+BeOpen.com to form the BeOpen PythonLabs team.  In October of the same
+year, the PythonLabs team moved to Digital Creations, which became
+Zope Corporation.  In 2001, the Python Software Foundation (PSF, see
+https://www.python.org/psf/) was formed, a non-profit organization
+created specifically to own Python-related Intellectual Property.
+Zope Corporation was a sponsoring member of the PSF.
+
+All Python releases are Open Source (see https://opensource.org for
+the Open Source Definition).  Historically, most, but not all, Python
+releases have also been GPL-compatible; the table below summarizes
+the various releases.
+
+    Release         Derived     Year        Owner       GPL-
+                    from                                compatible? (1)
+
+    0.9.0 thru 1.2              1991-1995   CWI         yes
+    1.3 thru 1.5.2  1.2         1995-1999   CNRI        yes
+    1.6             1.5.2       2000        CNRI        no
+    2.0             1.6         2000        BeOpen.com  no
+    1.6.1           1.6         2001        CNRI        yes (2)
+    2.1             2.0+1.6.1   2001        PSF         no
+    2.0.1           2.0+1.6.1   2001        PSF         yes
+    2.1.1           2.1+2.0.1   2001        PSF         yes
+    2.1.2           2.1.1       2002        PSF         yes
+    2.1.3           2.1.2       2002        PSF         yes
+    2.2 and above   2.1.1       2001-now    PSF         yes
+
+Footnotes:
+
+(1) GPL-compatible doesn't mean that we're distributing Python under
+    the GPL.  All Python licenses, unlike the GPL, let you distribute
+    a modified version without making your changes open source.  The
+    GPL-compatible licenses make it possible to combine Python with
+    other software that is released under the GPL; the others don't.
+
+(2) According to Richard Stallman, 1.6.1 is not GPL-compatible,
+    because its license has a choice of law clause.  According to
+    CNRI, however, Stallman's lawyer has told CNRI's lawyer that 1.6.1
+    is "not incompatible" with the GPL.
+
+Thanks to the many outside volunteers who have worked under Guido's
+direction to make these releases possible.
+
+
+B. TERMS AND CONDITIONS FOR ACCESSING OR OTHERWISE USING PYTHON
+===============================================================
+
+Python software and documentation are licensed under the
+Python Software Foundation License Version 2.
+
+Starting with Python 3.8.6, examples, recipes, and other code in
+the documentation are dual licensed under the PSF License Version 2
+and the Zero-Clause BSD license.
+
+Some software incorporated into Python is under different licenses.
+The licenses are listed with code falling under that license.
+
+
+PYTHON SOFTWARE FOUNDATION LICENSE VERSION 2
+--------------------------------------------
+
+1. This LICENSE AGREEMENT is between the Python Software Foundation
+("PSF"), and the Individual or Organization ("Licensee") accessing and
+otherwise using this software ("Python") in source or binary form and
+its associated documentation.
+
+2. Subject to the terms and conditions of this License Agreement, PSF hereby
+grants Licensee a nonexclusive, royalty-free, world-wide license to reproduce,
+analyze, test, perform and/or display publicly, prepare derivative works,
+distribute, and otherwise use Python alone or in any derivative version,
+provided, however, that PSF's License Agreement and PSF's notice of copyright,
+i.e., "Copyright (c) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010,
+2011, 2012, 2013, 2014, 2015, 2016, 2017, 2018, 2019, 2020, 2021, 2022, 2023 Python Software Foundation;
+All Rights Reserved" are retained in Python alone or in any derivative version
+prepared by Licensee.
+
+3. In the event Licensee prepares a derivative work that is based on
+or incorporates Python or any part thereof, and wants to make
+the derivative work available to others as provided herein, then
+Licensee hereby agrees to include in any such work a brief summary of
+the changes made to Python.
+
+4. PSF is making Python available to Licensee on an "AS IS"
+basis.  PSF MAKES NO REPRESENTATIONS OR WARRANTIES, EXPRESS OR
+IMPLIED.  BY WAY OF EXAMPLE, BUT NOT LIMITATION, PSF MAKES NO AND
+DISCLAIMS ANY REPRESENTATION OR WARRANTY OF MERCHANTABILITY OR FITNESS
+FOR ANY PARTICULAR PURPOSE OR THAT THE USE OF PYTHON WILL NOT
+INFRINGE ANY THIRD PARTY RIGHTS.
+
+5. PSF SHALL NOT BE LIABLE TO LICENSEE OR ANY OTHER USERS OF PYTHON
+FOR ANY INCIDENTAL, SPECIAL, OR CONSEQUENTIAL DAMAGES OR LOSS AS
+A RESULT OF MODIFYING, DISTRIBUTING, OR OTHERWISE USING PYTHON,
+OR ANY DERIVATIVE THEREOF, EVEN IF ADVISED OF THE POSSIBILITY THEREOF.
+
+6. This License Agreement will automatically terminate upon a material
+breach of its terms and conditions.
+
+7. Nothing in this License Agreement shall be deemed to create any
+relationship of agency, partnership, or joint venture between PSF and
+Licensee.  This License Agreement does not grant permission to use PSF
+trademarks or trade name in a trademark sense to endorse or promote
+products or services of Licensee, or any third party.
+
+8. By copying, installing or otherwise using Python, Licensee
+agrees to be bound by the terms and conditions of this License
+Agreement.
+
+
+BEOPEN.COM LICENSE AGREEMENT FOR PYTHON 2.0
+-------------------------------------------
+
+BEOPEN PYTHON OPEN SOURCE LICENSE AGREEMENT VERSION 1
+
+1. This LICENSE AGREEMENT is between BeOpen.com ("BeOpen"), having an
+office at 160 Saratoga Avenue, Santa Clara, CA 95051, and the
+Individual or Organization ("Licensee") accessing and otherwise using
+this software in source or binary form and its associated
+documentation ("the Software").
+
+2. Subject to the terms and conditions of this BeOpen Python License
+Agreement, BeOpen hereby grants Licensee a non-exclusive,
+royalty-free, world-wide license to reproduce, analyze, test, perform
+and/or display publicly, prepare derivative works, distribute, and
+otherwise use the Software alone or in any derivative version,
+provided, however, that the BeOpen Python License is retained in the
+Software, alone or in any derivative version prepared by Licensee.
+
+3. BeOpen is making the Software available to Licensee on an "AS IS"
+basis.  BEOPEN MAKES NO REPRESENTATIONS OR WARRANTIES, EXPRESS OR
+IMPLIED.  BY WAY OF EXAMPLE, BUT NOT LIMITATION, BEOPEN MAKES NO AND
+DISCLAIMS ANY REPRESENTATION OR WARRANTY OF MERCHANTABILITY OR FITNESS
+FOR ANY PARTICULAR PURPOSE OR THAT THE USE OF THE SOFTWARE WILL NOT
+INFRINGE ANY THIRD PARTY RIGHTS.
+
+4. BEOPEN SHALL NOT BE LIABLE TO LICENSEE OR ANY OTHER USERS OF THE
+SOFTWARE FOR ANY INCIDENTAL, SPECIAL, OR CONSEQUENTIAL DAMAGES OR LOSS
+AS A RESULT OF USING, MODIFYING OR DISTRIBUTING THE SOFTWARE, OR ANY
+DERIVATIVE THEREOF, EVEN IF ADVISED OF THE POSSIBILITY THEREOF.
+
+5. This License Agreement will automatically terminate upon a material
+breach of its terms and conditions.
+
+6. This License Agreement shall be governed by and interpreted in all
+respects by the law of the State of California, excluding conflict of
+law provisions.  Nothing in this License Agreement shall be deemed to
+create any relationship of agency, partnership, or joint venture
+between BeOpen and Licensee.  This License Agreement does not grant
+permission to use BeOpen trademarks or trade names in a trademark
+sense to endorse or promote products or services of Licensee, or any
+third party.  As an exception, the "BeOpen Python" logos available at
+http://www.pythonlabs.com/logos.html may be used according to the
+permissions granted on that web page.
+
+7. By copying, installing or otherwise using the software, Licensee
+agrees to be bound by the terms and conditions of this License
+Agreement.
+
+
+CNRI LICENSE AGREEMENT FOR PYTHON 1.6.1
+---------------------------------------
+
+1. This LICENSE AGREEMENT is between the Corporation for National
+Research Initiatives, having an office at 1895 Preston White Drive,
+Reston, VA 20191 ("CNRI"), and the Individual or Organization
+("Licensee") accessing and otherwise using Python 1.6.1 software in
+source or binary form and its associated documentation.
+
+2. Subject to the terms and conditions of this License Agreement, CNRI
+hereby grants Licensee a nonexclusive, royalty-free, world-wide
+license to reproduce, analyze, test, perform and/or display publicly,
+prepare derivative works, distribute, and otherwise use Python 1.6.1
+alone or in any derivative version, provided, however, that CNRI's
+License Agreement and CNRI's notice of copyright, i.e., "Copyright (c)
+1995-2001 Corporation for National Research Initiatives; All Rights
+Reserved" are retained in Python 1.6.1 alone or in any derivative
+version prepared by Licensee.  Alternately, in lieu of CNRI's License
+Agreement, Licensee may substitute the following text (omitting the
+quotes): "Python 1.6.1 is made available subject to the terms and
+conditions in CNRI's License Agreement.  This Agreement together with
+Python 1.6.1 may be located on the internet using the following
+unique, persistent identifier (known as a handle): 1895.22/1013.  This
+Agreement may also be obtained from a proxy server on the internet
+using the following URL: http://hdl.handle.net/1895.22/1013".
+
+3. In the event Licensee prepares a derivative work that is based on
+or incorporates Python 1.6.1 or any part thereof, and wants to make
+the derivative work available to others as provided herein, then
+Licensee hereby agrees to include in any such work a brief summary of
+the changes made to Python 1.6.1.
+
+4. CNRI is making Python 1.6.1 available to Licensee on an "AS IS"
+basis.  CNRI MAKES NO REPRESENTATIONS OR WARRANTIES, EXPRESS OR
+IMPLIED.  BY WAY OF EXAMPLE, BUT NOT LIMITATION, CNRI MAKES NO AND
+DISCLAIMS ANY REPRESENTATION OR WARRANTY OF MERCHANTABILITY OR FITNESS
+FOR ANY PARTICULAR PURPOSE OR THAT THE USE OF PYTHON 1.6.1 WILL NOT
+INFRINGE ANY THIRD PARTY RIGHTS.
+
+5. CNRI SHALL NOT BE LIABLE TO LICENSEE OR ANY OTHER USERS OF PYTHON
+1.6.1 FOR ANY INCIDENTAL, SPECIAL, OR CONSEQUENTIAL DAMAGES OR LOSS AS
+A RESULT OF MODIFYING, DISTRIBUTING, OR OTHERWISE USING PYTHON 1.6.1,
+OR ANY DERIVATIVE THEREOF, EVEN IF ADVISED OF THE POSSIBILITY THEREOF.
+
+6. This License Agreement will automatically terminate upon a material
+breach of its terms and conditions.
+
+7. This License Agreement shall be governed by the federal
+intellectual property law of the United States, including without
+limitation the federal copyright law, and, to the extent such
+U.S. federal law does not apply, by the law of the Commonwealth of
+Virginia, excluding Virginia's conflict of law provisions.
+Notwithstanding the foregoing, with regard to derivative works based
+on Python 1.6.1 that incorporate non-separable material that was
+previously distributed under the GNU General Public License (GPL), the
+law of the Commonwealth of Virginia shall govern this License
+Agreement only as to issues arising under or with respect to
+Paragraphs 4, 5, and 7 of this License Agreement.  Nothing in this
+License Agreement shall be deemed to create any relationship of
+agency, partnership, or joint venture between CNRI and Licensee.  This
+License Agreement does not grant permission to use CNRI trademarks or
+trade name in a trademark sense to endorse or promote products or
+services of Licensee, or any third party.
+
+8. By clicking on the "ACCEPT" button where indicated, or by copying,
+installing or otherwise using Python 1.6.1, Licensee agrees to be
+bound by the terms and conditions of this License Agreement.
+
+        ACCEPT
+
+
+CWI LICENSE AGREEMENT FOR PYTHON 0.9.0 THROUGH 1.2
+--------------------------------------------------
+
+Copyright (c) 1991 - 1995, Stichting Mathematisch Centrum Amsterdam,
+The Netherlands.  All rights reserved.
+
+Permission to use, copy, modify, and distribute this software and its
+documentation for any purpose and without fee is hereby granted,
+provided that the above copyright notice appear in all copies and that
+both that copyright notice and this permission notice appear in
+supporting documentation, and that the name of Stichting Mathematisch
+Centrum or CWI not be used in advertising or publicity pertaining to
+distribution of the software without specific, written prior
+permission.
+
+STICHTING MATHEMATISCH CENTRUM DISCLAIMS ALL WARRANTIES WITH REGARD TO
+THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
+FITNESS, IN NO EVENT SHALL STICHTING MATHEMATISCH CENTRUM BE LIABLE
+FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
+OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+ZERO-CLAUSE BSD LICENSE FOR CODE IN THE PYTHON DOCUMENTATION
+----------------------------------------------------------------------
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.

lib/python3.13/site-packages/aiohappyeyeballs-2.6.1.dist-info/METADATA

@@ -0,0 +1,123 @@
+Metadata-Version: 2.3
+Name: aiohappyeyeballs
+Version: 2.6.1
+Summary: Happy Eyeballs for asyncio
+License: PSF-2.0
+Author: J. Nick Koston
+Author-email: nick@koston.org
+Requires-Python: >=3.9
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: Natural Language :: English
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Software Development :: Libraries
+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: License :: OSI Approved :: Python Software Foundation License
+Project-URL: Bug Tracker, https://github.com/aio-libs/aiohappyeyeballs/issues
+Project-URL: Changelog, https://github.com/aio-libs/aiohappyeyeballs/blob/main/CHANGELOG.md
+Project-URL: Documentation, https://aiohappyeyeballs.readthedocs.io
+Project-URL: Repository, https://github.com/aio-libs/aiohappyeyeballs
+Description-Content-Type: text/markdown
+
+# aiohappyeyeballs
+
+<p align="center">
+  <a href="https://github.com/aio-libs/aiohappyeyeballs/actions/workflows/ci.yml?query=branch%3Amain">
+    <img src="https://img.shields.io/github/actions/workflow/status/aio-libs/aiohappyeyeballs/ci-cd.yml?branch=main&label=CI&logo=github&style=flat-square" alt="CI Status" >
+  </a>
+  <a href="https://aiohappyeyeballs.readthedocs.io">
+    <img src="https://img.shields.io/readthedocs/aiohappyeyeballs.svg?logo=read-the-docs&logoColor=fff&style=flat-square" alt="Documentation Status">
+  </a>
+  <a href="https://codecov.io/gh/aio-libs/aiohappyeyeballs">
+    <img src="https://img.shields.io/codecov/c/github/aio-libs/aiohappyeyeballs.svg?logo=codecov&logoColor=fff&style=flat-square" alt="Test coverage percentage">
+  </a>
+</p>
+<p align="center">
+  <a href="https://python-poetry.org/">
+    <img src="https://img.shields.io/badge/packaging-poetry-299bd7?style=flat-square&logo=data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAA4AAAASCAYAAABrXO8xAAAACXBIWXMAAAsTAAALEwEAmpwYAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAJJSURBVHgBfZLPa1NBEMe/s7tNXoxW1KJQKaUHkXhQvHgW6UHQQ09CBS/6V3hKc/AP8CqCrUcpmop3Cx48eDB4yEECjVQrlZb80CRN8t6OM/teagVxYZi38+Yz853dJbzoMV3MM8cJUcLMSUKIE8AzQ2PieZzFxEJOHMOgMQQ+dUgSAckNXhapU/NMhDSWLs1B24A8sO1xrN4NECkcAC9ASkiIJc6k5TRiUDPhnyMMdhKc+Zx19l6SgyeW76BEONY9exVQMzKExGKwwPsCzza7KGSSWRWEQhyEaDXp6ZHEr416ygbiKYOd7TEWvvcQIeusHYMJGhTwF9y7sGnSwaWyFAiyoxzqW0PM/RjghPxF2pWReAowTEXnDh0xgcLs8l2YQmOrj3N7ByiqEoH0cARs4u78WgAVkoEDIDoOi3AkcLOHU60RIg5wC4ZuTC7FaHKQm8Hq1fQuSOBvX/sodmNJSB5geaF5CPIkUeecdMxieoRO5jz9bheL6/tXjrwCyX/UYBUcjCaWHljx1xiX6z9xEjkYAzbGVnB8pvLmyXm9ep+W8CmsSHQQY77Zx1zboxAV0w7ybMhQmfqdmmw3nEp1I0Z+FGO6M8LZdoyZnuzzBdjISicKRnpxzI9fPb+0oYXsNdyi+d3h9bm9MWYHFtPeIZfLwzmFDKy1ai3p+PDls1Llz4yyFpferxjnyjJDSEy9CaCx5m2cJPerq6Xm34eTrZt3PqxYO1XOwDYZrFlH1fWnpU38Y9HRze3lj0vOujZcXKuuXm3jP+s3KbZVra7y2EAAAAAASUVORK5CYII=" alt="Poetry">
+  </a>
+  <a href="https://github.com/astral-sh/ruff">
+    <img src="https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json" alt="Ruff">
+  </a>
+  <a href="https://github.com/pre-commit/pre-commit">
+    <img src="https://img.shields.io/badge/pre--commit-enabled-brightgreen?logo=pre-commit&logoColor=white&style=flat-square" alt="pre-commit">
+  </a>
+</p>
+<p align="center">
+  <a href="https://pypi.org/project/aiohappyeyeballs/">
+    <img src="https://img.shields.io/pypi/v/aiohappyeyeballs.svg?logo=python&logoColor=fff&style=flat-square" alt="PyPI Version">
+  </a>
+  <img src="https://img.shields.io/pypi/pyversions/aiohappyeyeballs.svg?style=flat-square&logo=python&amp;logoColor=fff" alt="Supported Python versions">
+  <img src="https://img.shields.io/pypi/l/aiohappyeyeballs.svg?style=flat-square" alt="License">
+</p>
+
+---
+
+**Documentation**: <a href="https://aiohappyeyeballs.readthedocs.io" target="_blank">https://aiohappyeyeballs.readthedocs.io </a>
+
+**Source Code**: <a href="https://github.com/aio-libs/aiohappyeyeballs" target="_blank">https://github.com/aio-libs/aiohappyeyeballs </a>
+
+---
+
+[Happy Eyeballs](https://en.wikipedia.org/wiki/Happy_Eyeballs)
+([RFC 8305](https://www.rfc-editor.org/rfc/rfc8305.html))
+
+## Use case
+
+This library exists to allow connecting with
+[Happy Eyeballs](https://en.wikipedia.org/wiki/Happy_Eyeballs)
+([RFC 8305](https://www.rfc-editor.org/rfc/rfc8305.html))
+when you
+already have a list of addrinfo and not a DNS name.
+
+The stdlib version of `loop.create_connection()`
+will only work when you pass in an unresolved name which
+is not a good fit when using DNS caching or resolving
+names via another method such as `zeroconf`.
+
+## Installation
+
+Install this via pip (or your favourite package manager):
+
+`pip install aiohappyeyeballs`
+
+## License
+
+[aiohappyeyeballs is licensed under the same terms as cpython itself.](https://github.com/python/cpython/blob/main/LICENSE)
+
+## Example usage
+
+```python
+
+addr_infos = await loop.getaddrinfo("example.org", 80)
+
+socket = await start_connection(addr_infos)
+socket = await start_connection(addr_infos, local_addr_infos=local_addr_infos, happy_eyeballs_delay=0.2)
+
+transport, protocol = await loop.create_connection(
+    MyProtocol, sock=socket, ...)
+
+# Remove the first address for each family from addr_info
+pop_addr_infos_interleave(addr_info, 1)
+
+# Remove all matching address from addr_info
+remove_addr_infos(addr_info, "dead::beef::")
+
+# Convert a local_addr to local_addr_infos
+local_addr_infos = addr_to_addr_infos(("127.0.0.1",0))
+```
+
+## Credits
+
+This package contains code from cpython and is licensed under the same terms as cpython itself.
+
+This package was created with
+[Copier](https://copier.readthedocs.io/) and the
+[browniebroke/pypackage-template](https://github.com/browniebroke/pypackage-template)
+project template.
+

lib/python3.13/site-packages/aiohappyeyeballs-2.6.1.dist-info/RECORD

@@ -0,0 +1,12 @@
+aiohappyeyeballs-2.6.1.dist-info/INSTALLER,sha256=5hhM4Q4mYTT9z6QB6PGpUAW81PGNFrYrdXMj4oM_6ak,2
+aiohappyeyeballs-2.6.1.dist-info/LICENSE,sha256=Oy-B_iHRgcSZxZolbI4ZaEVdZonSaaqFNzv7avQdo78,13936
+aiohappyeyeballs-2.6.1.dist-info/METADATA,sha256=NSXlhJwAfi380eEjAo7BQ4P_TVal9xi0qkyZWibMsVM,5915
+aiohappyeyeballs-2.6.1.dist-info/RECORD,,
+aiohappyeyeballs-2.6.1.dist-info/REQUESTED,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+aiohappyeyeballs-2.6.1.dist-info/WHEEL,sha256=XbeZDeTWKc1w7CSIyre5aMDU_-PohRwTQceYnisIYYY,88
+aiohappyeyeballs/__init__.py,sha256=x7kktHEtaD9quBcWDJPuLeKyjuVAI-Jj14S9B_5hcTs,361
+aiohappyeyeballs/_staggered.py,sha256=edfVowFx-P-ywJjIEF3MdPtEMVODujV6CeMYr65otac,6900
+aiohappyeyeballs/impl.py,sha256=Dlcm2mTJ28ucrGnxkb_fo9CZzLAkOOBizOt7dreBbXE,9681
+aiohappyeyeballs/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+aiohappyeyeballs/types.py,sha256=YZJIAnyoV4Dz0WFtlaf_OyE4EW7Xus1z7aIfNI6tDDQ,425
+aiohappyeyeballs/utils.py,sha256=on9GxIR0LhEfZu8P6Twi9hepX9zDanuZM20MWsb3xlQ,3028

lib/python3.13/site-packages/aiohappyeyeballs-2.6.1.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: poetry-core 2.1.1
+Root-Is-Purelib: true
+Tag: py3-none-any

lib/python3.13/site-packages/annotated_types-0.7.0.dist-info/INSTALLER

@@ -0,0 +1 @@
+uv

lib/python3.13/site-packages/annotated_types-0.7.0.dist-info/METADATA

@@ -0,0 +1,295 @@
+Metadata-Version: 2.3
+Name: annotated-types
+Version: 0.7.0
+Summary: Reusable constraint types to use with typing.Annotated
+Project-URL: Homepage, https://github.com/annotated-types/annotated-types
+Project-URL: Source, https://github.com/annotated-types/annotated-types
+Project-URL: Changelog, https://github.com/annotated-types/annotated-types/releases
+Author-email: Adrian Garcia Badaracco <1755071+adriangb@users.noreply.github.com>, Samuel Colvin <s@muelcolvin.com>, Zac Hatfield-Dodds <zac@zhd.dev>
+License-File: LICENSE
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Environment :: MacOS X
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Information Technology
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Operating System :: Unix
+Classifier: Programming Language :: Python :: 3 :: Only
+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: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Typing :: Typed
+Requires-Python: >=3.8
+Requires-Dist: typing-extensions>=4.0.0; python_version < '3.9'
+Description-Content-Type: text/markdown
+
+# annotated-types
+
+[![CI](https://github.com/annotated-types/annotated-types/workflows/CI/badge.svg?event=push)](https://github.com/annotated-types/annotated-types/actions?query=event%3Apush+branch%3Amain+workflow%3ACI)
+[![pypi](https://img.shields.io/pypi/v/annotated-types.svg)](https://pypi.python.org/pypi/annotated-types)
+[![versions](https://img.shields.io/pypi/pyversions/annotated-types.svg)](https://github.com/annotated-types/annotated-types)
+[![license](https://img.shields.io/github/license/annotated-types/annotated-types.svg)](https://github.com/annotated-types/annotated-types/blob/main/LICENSE)
+
+[PEP-593](https://peps.python.org/pep-0593/) added `typing.Annotated` as a way of
+adding context-specific metadata to existing types, and specifies that
+`Annotated[T, x]` _should_ be treated as `T` by any tool or library without special
+logic for `x`.
+
+This package provides metadata objects which can be used to represent common
+constraints such as upper and lower bounds on scalar values and collection sizes,
+a `Predicate` marker for runtime checks, and
+descriptions of how we intend these metadata to be interpreted. In some cases,
+we also note alternative representations which do not require this package.
+
+## Install
+
+```bash
+pip install annotated-types
+```
+
+## Examples
+
+```python
+from typing import Annotated
+from annotated_types import Gt, Len, Predicate
+
+class MyClass:
+    age: Annotated[int, Gt(18)]                         # Valid: 19, 20, ...
+                                                        # Invalid: 17, 18, "19", 19.0, ...
+    factors: list[Annotated[int, Predicate(is_prime)]]  # Valid: 2, 3, 5, 7, 11, ...
+                                                        # Invalid: 4, 8, -2, 5.0, "prime", ...
+
+    my_list: Annotated[list[int], Len(0, 10)]           # Valid: [], [10, 20, 30, 40, 50]
+                                                        # Invalid: (1, 2), ["abc"], [0] * 20
+```
+
+## Documentation
+
+_While `annotated-types` avoids runtime checks for performance, users should not
+construct invalid combinations such as `MultipleOf("non-numeric")` or `Annotated[int, Len(3)]`.
+Downstream implementors may choose to raise an error, emit a warning, silently ignore
+a metadata item, etc., if the metadata objects described below are used with an
+incompatible type - or for any other reason!_
+
+### Gt, Ge, Lt, Le
+
+Express inclusive and/or exclusive bounds on orderable values - which may be numbers,
+dates, times, strings, sets, etc. Note that the boundary value need not be of the
+same type that was annotated, so long as they can be compared: `Annotated[int, Gt(1.5)]`
+is fine, for example, and implies that the value is an integer x such that `x > 1.5`.
+
+We suggest that implementors may also interpret `functools.partial(operator.le, 1.5)`
+as being equivalent to `Gt(1.5)`, for users who wish to avoid a runtime dependency on
+the `annotated-types` package.
+
+To be explicit, these types have the following meanings:
+
+* `Gt(x)` - value must be "Greater Than" `x` - equivalent to exclusive minimum
+* `Ge(x)` - value must be "Greater than or Equal" to `x` - equivalent to inclusive minimum
+* `Lt(x)` - value must be "Less Than" `x` - equivalent to exclusive maximum
+* `Le(x)` - value must be "Less than or Equal" to `x` - equivalent to inclusive maximum
+
+### Interval
+
+`Interval(gt, ge, lt, le)` allows you to specify an upper and lower bound with a single
+metadata object. `None` attributes should be ignored, and non-`None` attributes
+treated as per the single bounds above.
+
+### MultipleOf
+
+`MultipleOf(multiple_of=x)` might be interpreted in two ways:
+
+1. Python semantics, implying `value % multiple_of == 0`, or
+2. [JSONschema semantics](https://json-schema.org/draft/2020-12/json-schema-validation.html#rfc.section.6.2.1),
+   where `int(value / multiple_of) == value / multiple_of`.
+
+We encourage users to be aware of these two common interpretations and their
+distinct behaviours, especially since very large or non-integer numbers make
+it easy to cause silent data corruption due to floating-point imprecision.
+
+We encourage libraries to carefully document which interpretation they implement.
+
+### MinLen, MaxLen, Len
+
+`Len()` implies that `min_length <= len(value) <= max_length` - lower and upper bounds are inclusive.
+
+As well as `Len()` which can optionally include upper and lower bounds, we also
+provide `MinLen(x)` and `MaxLen(y)` which are equivalent to `Len(min_length=x)`
+and `Len(max_length=y)` respectively.
+
+`Len`, `MinLen`, and `MaxLen` may be used with any type which supports `len(value)`.
+
+Examples of usage:
+
+* `Annotated[list, MaxLen(10)]` (or `Annotated[list, Len(max_length=10))`) - list must have a length of 10 or less
+* `Annotated[str, MaxLen(10)]` - string must have a length of 10 or less
+* `Annotated[list, MinLen(3))` (or `Annotated[list, Len(min_length=3))`) - list must have a length of 3 or more
+* `Annotated[list, Len(4, 6)]` - list must have a length of 4, 5, or 6
+* `Annotated[list, Len(8, 8)]` - list must have a length of exactly 8
+
+#### Changed in v0.4.0
+
+* `min_inclusive` has been renamed to `min_length`, no change in meaning
+* `max_exclusive` has been renamed to `max_length`, upper bound is now **inclusive** instead of **exclusive**
+* The recommendation that slices are interpreted as `Len` has been removed due to ambiguity and different semantic
+  meaning of the upper bound in slices vs. `Len`
+
+See [issue #23](https://github.com/annotated-types/annotated-types/issues/23) for discussion.
+
+### Timezone
+
+`Timezone` can be used with a `datetime` or a `time` to express which timezones
+are allowed. `Annotated[datetime, Timezone(None)]` must be a naive datetime.
+`Timezone[...]` ([literal ellipsis](https://docs.python.org/3/library/constants.html#Ellipsis))
+expresses that any timezone-aware datetime is allowed. You may also pass a specific
+timezone string or [`tzinfo`](https://docs.python.org/3/library/datetime.html#tzinfo-objects)
+object such as `Timezone(timezone.utc)` or `Timezone("Africa/Abidjan")` to express that you only
+allow a specific timezone, though we note that this is often a symptom of fragile design.
+
+#### Changed in v0.x.x
+
+* `Timezone` accepts [`tzinfo`](https://docs.python.org/3/library/datetime.html#tzinfo-objects) objects instead of
+  `timezone`, extending compatibility to [`zoneinfo`](https://docs.python.org/3/library/zoneinfo.html) and third party libraries.
+
+### Unit
+
+`Unit(unit: str)` expresses that the annotated numeric value is the magnitude of
+a quantity with the specified unit. For example, `Annotated[float, Unit("m/s")]`
+would be a float representing a velocity in meters per second.
+
+Please note that `annotated_types` itself makes no attempt to parse or validate
+the unit string in any way. That is left entirely to downstream libraries,
+such as [`pint`](https://pint.readthedocs.io) or
+[`astropy.units`](https://docs.astropy.org/en/stable/units/).
+
+An example of how a library might use this metadata:
+
+```python
+from annotated_types import Unit
+from typing import Annotated, TypeVar, Callable, Any, get_origin, get_args
+
+# given a type annotated with a unit:
+Meters = Annotated[float, Unit("m")]
+
+
+# you can cast the annotation to a specific unit type with any
+# callable that accepts a string and returns the desired type
+T = TypeVar("T")
+def cast_unit(tp: Any, unit_cls: Callable[[str], T]) -> T | None:
+    if get_origin(tp) is Annotated:
+        for arg in get_args(tp):
+            if isinstance(arg, Unit):
+                return unit_cls(arg.unit)
+    return None
+
+
+# using `pint`
+import pint
+pint_unit = cast_unit(Meters, pint.Unit)
+
+
+# using `astropy.units`
+import astropy.units as u
+astropy_unit = cast_unit(Meters, u.Unit)
+```
+
+### Predicate
+
+`Predicate(func: Callable)` expresses that `func(value)` is truthy for valid values.
+Users should prefer the statically inspectable metadata above, but if you need
+the full power and flexibility of arbitrary runtime predicates... here it is.
+
+For some common constraints, we provide generic types:
+
+* `IsLower       = Annotated[T, Predicate(str.islower)]`
+* `IsUpper       = Annotated[T, Predicate(str.isupper)]`
+* `IsDigit       = Annotated[T, Predicate(str.isdigit)]`
+* `IsFinite      = Annotated[T, Predicate(math.isfinite)]`
+* `IsNotFinite   = Annotated[T, Predicate(Not(math.isfinite))]`
+* `IsNan         = Annotated[T, Predicate(math.isnan)]`
+* `IsNotNan      = Annotated[T, Predicate(Not(math.isnan))]`
+* `IsInfinite    = Annotated[T, Predicate(math.isinf)]`
+* `IsNotInfinite = Annotated[T, Predicate(Not(math.isinf))]`
+
+so that you can write e.g. `x: IsFinite[float] = 2.0` instead of the longer
+(but exactly equivalent) `x: Annotated[float, Predicate(math.isfinite)] = 2.0`.
+
+Some libraries might have special logic to handle known or understandable predicates,
+for example by checking for `str.isdigit` and using its presence to both call custom
+logic to enforce digit-only strings, and customise some generated external schema.
+Users are therefore encouraged to avoid indirection like `lambda s: s.lower()`, in
+favor of introspectable methods such as `str.lower` or `re.compile("pattern").search`.
+
+To enable basic negation of commonly used predicates like `math.isnan` without introducing introspection that makes it impossible for implementers to introspect the predicate we provide a `Not` wrapper that simply negates the predicate in an introspectable manner. Several of the predicates listed above are created in this manner.
+
+We do not specify what behaviour should be expected for predicates that raise
+an exception.  For example `Annotated[int, Predicate(str.isdigit)]` might silently
+skip invalid constraints, or statically raise an error; or it might try calling it
+and then propagate or discard the resulting
+`TypeError: descriptor 'isdigit' for 'str' objects doesn't apply to a 'int' object`
+exception.  We encourage libraries to document the behaviour they choose.
+
+### Doc
+
+`doc()` can be used to add documentation information in `Annotated`, for function and method parameters, variables, class attributes, return types, and any place where `Annotated` can be used.
+
+It expects a value that can be statically analyzed, as the main use case is for static analysis, editors, documentation generators, and similar tools.
+
+It returns a `DocInfo` class with a single attribute `documentation` containing the value passed to `doc()`.
+
+This is the early adopter's alternative form of the [`typing-doc` proposal](https://github.com/tiangolo/fastapi/blob/typing-doc/typing_doc.md).
+
+### Integrating downstream types with `GroupedMetadata`
+
+Implementers may choose to provide a convenience wrapper that groups multiple pieces of metadata.
+This can help reduce verbosity and cognitive overhead for users.
+For example, an implementer like Pydantic might provide a `Field` or `Meta` type that accepts keyword arguments and transforms these into low-level metadata:
+
+```python
+from dataclasses import dataclass
+from typing import Iterator
+from annotated_types import GroupedMetadata, Ge
+
+@dataclass
+class Field(GroupedMetadata):
+    ge: int | None = None
+    description: str | None = None
+
+    def __iter__(self) -> Iterator[object]:
+        # Iterating over a GroupedMetadata object should yield annotated-types
+        # constraint metadata objects which describe it as fully as possible,
+        # and may include other unknown objects too.
+        if self.ge is not None:
+            yield Ge(self.ge)
+        if self.description is not None:
+            yield Description(self.description)
+```
+
+Libraries consuming annotated-types constraints should check for `GroupedMetadata` and unpack it by iterating over the object and treating the results as if they had been "unpacked" in the `Annotated` type.  The same logic should be applied to the [PEP 646 `Unpack` type](https://peps.python.org/pep-0646/), so that `Annotated[T, Field(...)]`, `Annotated[T, Unpack[Field(...)]]` and `Annotated[T, *Field(...)]` are all treated consistently.
+
+Libraries consuming annotated-types should also ignore any metadata they do not recongize that came from unpacking a `GroupedMetadata`, just like they ignore unrecognized metadata in `Annotated` itself.
+
+Our own `annotated_types.Interval` class is a `GroupedMetadata` which unpacks itself into `Gt`, `Lt`, etc., so this is not an abstract concern.  Similarly, `annotated_types.Len` is a `GroupedMetadata` which unpacks itself into `MinLen` (optionally) and `MaxLen`.
+
+### Consuming metadata
+
+We intend to not be prescriptive as to _how_ the metadata and constraints are used, but as an example of how one might parse constraints from types annotations see our [implementation in `test_main.py`](https://github.com/annotated-types/annotated-types/blob/f59cf6d1b5255a0fe359b93896759a180bec30ae/tests/test_main.py#L94-L103).
+
+It is up to the implementer to determine how this metadata is used.
+You could use the metadata for runtime type checking, for generating schemas or to generate example data, amongst other use cases.
+
+## Design & History
+
+This package was designed at the PyCon 2022 sprints by the maintainers of Pydantic
+and Hypothesis, with the goal of making it as easy as possible for end-users to
+provide more informative annotations for use by runtime libraries.
+
+It is deliberately minimal, and following PEP-593 allows considerable downstream
+discretion in what (if anything!) they choose to support. Nonetheless, we expect
+that staying simple and covering _only_ the most common use-cases will give users
+and maintainers the best experience we can. If you'd like more constraints for your
+types - follow our lead, by defining them and documenting them downstream!

lib/python3.13/site-packages/annotated_types-0.7.0.dist-info/RECORD

@@ -0,0 +1,9 @@
+annotated_types-0.7.0.dist-info/INSTALLER,sha256=5hhM4Q4mYTT9z6QB6PGpUAW81PGNFrYrdXMj4oM_6ak,2
+annotated_types-0.7.0.dist-info/METADATA,sha256=7ltqxksJJ0wCYFGBNIQCWTlWQGeAH0hRFdnK3CB895E,15046
+annotated_types-0.7.0.dist-info/RECORD,,
+annotated_types-0.7.0.dist-info/REQUESTED,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+annotated_types-0.7.0.dist-info/WHEEL,sha256=zEMcRr9Kr03x1ozGwg5v9NQBKn3kndp6LSoSlVg-jhU,87
+annotated_types-0.7.0.dist-info/licenses/LICENSE,sha256=_hBJiEsaDZNCkB6I4H8ykl0ksxIdmXK2poBfuYJLCV0,1083
+annotated_types/__init__.py,sha256=RynLsRKUEGI0KimXydlD1fZEfEzWwDo0Uon3zOKhG1Q,13819
+annotated_types/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+annotated_types/test_cases.py,sha256=zHFX6EpcMbGJ8FzBYDbO56bPwx_DYIVSKbZM-4B3_lg,6421

lib/python3.13/site-packages/annotated_types-0.7.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.24.2
+Root-Is-Purelib: true
+Tag: py3-none-any

lib/python3.13/site-packages/attrs-25.4.0.dist-info/RECORD

@@ -0,0 +1,37 @@
+attr/__init__.py,sha256=fOYIvt1eGSqQre4uCS3sJWKZ0mwAuC8UD6qba5OS9_U,2057
+attr/__init__.pyi,sha256=IZkzIjvtbRqDWGkDBIF9dd12FgDa379JYq3GHnVOvFQ,11309
+attr/_cmp.py,sha256=3Nn1TjxllUYiX_nJoVnEkXoDk0hM1DYKj5DE7GZe4i0,4117
+attr/_cmp.pyi,sha256=U-_RU_UZOyPUEQzXE6RMYQQcjkZRY25wTH99sN0s7MM,368
+attr/_compat.py,sha256=x0g7iEUOnBVJC72zyFCgb1eKqyxS-7f2LGnNyZ_r95s,2829
+attr/_config.py,sha256=dGq3xR6fgZEF6UBt_L0T-eUHIB4i43kRmH0P28sJVw8,843
+attr/_funcs.py,sha256=Ix5IETTfz5F01F-12MF_CSFomIn2h8b67EVVz2gCtBE,16479
+attr/_make.py,sha256=NRJDGS8syg2h3YNflVNoK2FwR3CpdSZxx8M6lacwljA,104141
+attr/_next_gen.py,sha256=BQtCUlzwg2gWHTYXBQvrEYBnzBUrDvO57u0Py6UCPhc,26274
+attr/_typing_compat.pyi,sha256=XDP54TUn-ZKhD62TOQebmzrwFyomhUCoGRpclb6alRA,469
+attr/_version_info.py,sha256=w4R-FYC3NK_kMkGUWJlYP4cVAlH9HRaC-um3fcjYkHM,2222
+attr/_version_info.pyi,sha256=x_M3L3WuB7r_ULXAWjx959udKQ4HLB8l-hsc1FDGNvk,209
+attr/converters.py,sha256=GlDeOzPeTFgeBBLbj9G57Ez5lAk68uhSALRYJ_exe84,3861
+attr/converters.pyi,sha256=orU2bff-VjQa2kMDyvnMQV73oJT2WRyQuw4ZR1ym1bE,643
+attr/exceptions.py,sha256=HRFq4iybmv7-DcZwyjl6M1euM2YeJVK_hFxuaBGAngI,1977
+attr/exceptions.pyi,sha256=zZq8bCUnKAy9mDtBEw42ZhPhAUIHoTKedDQInJD883M,539
+attr/filters.py,sha256=ZBiKWLp3R0LfCZsq7X11pn9WX8NslS2wXM4jsnLOGc8,1795
+attr/filters.pyi,sha256=3J5BG-dTxltBk1_-RuNRUHrv2qu1v8v4aDNAQ7_mifA,208
+attr/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+attr/setters.py,sha256=5-dcT63GQK35ONEzSgfXCkbB7pPkaR-qv15mm4PVSzQ,1617
+attr/setters.pyi,sha256=NnVkaFU1BB4JB8E4JuXyrzTUgvtMpj8p3wBdJY7uix4,584
+attr/validators.py,sha256=1BnYGTuYvSucGEI4ju-RPNJteVzG0ZlfWpJiWoSFHQ8,21458
+attr/validators.pyi,sha256=ftmW3m4KJ3pQcIXAj-BejT7BY4ZfqrC1G-5W7XvoPds,4082
+attrs-25.4.0.dist-info/INSTALLER,sha256=5hhM4Q4mYTT9z6QB6PGpUAW81PGNFrYrdXMj4oM_6ak,2
+attrs-25.4.0.dist-info/METADATA,sha256=2Rerxj7agcMRxiwdkt6lC2guqHAmkGKCH13nWWK7ZoQ,10473
+attrs-25.4.0.dist-info/RECORD,,
+attrs-25.4.0.dist-info/REQUESTED,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+attrs-25.4.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+attrs-25.4.0.dist-info/licenses/LICENSE,sha256=iCEVyV38KvHutnFPjsbVy8q_Znyv-HKfQkINpj9xTp8,1109
+attrs/__init__.py,sha256=RxaAZNwYiEh-fcvHLZNpQ_DWKni73M_jxEPEftiq1Zc,1183
+attrs/__init__.pyi,sha256=2gV79g9UxJppGSM48hAZJ6h_MHb70dZoJL31ZNJeZYI,9416
+attrs/converters.py,sha256=8kQljrVwfSTRu8INwEk8SI0eGrzmWftsT7rM0EqyohM,76
+attrs/exceptions.py,sha256=ACCCmg19-vDFaDPY9vFl199SPXCQMN_bENs4DALjzms,76
+attrs/filters.py,sha256=VOUMZug9uEU6dUuA0dF1jInUK0PL3fLgP0VBS5d-CDE,73
+attrs/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+attrs/setters.py,sha256=eL1YidYQV3T2h9_SYIZSZR1FAcHGb1TuCTy0E0Lv2SU,73
+attrs/validators.py,sha256=xcy6wD5TtTkdCG1f4XWbocPSO0faBjk5IfVJfP6SUj0,76

lib/python3.13/site-packages/blinker/__init__.py

@@ -0,0 +1,17 @@
+from __future__ import annotations
+
+from .base import ANY
+from .base import default_namespace
+from .base import NamedSignal
+from .base import Namespace
+from .base import Signal
+from .base import signal
+
+__all__ = [
+    "ANY",
+    "default_namespace",
+    "NamedSignal",
+    "Namespace",
+    "Signal",
+    "signal",
+]

lib/python3.13/site-packages/blinker/_utilities.py

@@ -0,0 +1,64 @@
+from __future__ import annotations
+
+import collections.abc as c
+import inspect
+import typing as t
+from weakref import ref
+from weakref import WeakMethod
+
+T = t.TypeVar("T")
+
+
+class Symbol:
+    """A constant symbol, nicer than ``object()``. Repeated calls return the
+    same instance.
+
+    >>> Symbol('foo') is Symbol('foo')
+    True
+    >>> Symbol('foo')
+    foo
+    """
+
+    symbols: t.ClassVar[dict[str, Symbol]] = {}
+
+    def __new__(cls, name: str) -> Symbol:
+        if name in cls.symbols:
+            return cls.symbols[name]
+
+        obj = super().__new__(cls)
+        cls.symbols[name] = obj
+        return obj
+
+    def __init__(self, name: str) -> None:
+        self.name = name
+
+    def __repr__(self) -> str:
+        return self.name
+
+    def __getnewargs__(self) -> tuple[t.Any, ...]:
+        return (self.name,)
+
+
+def make_id(obj: object) -> c.Hashable:
+    """Get a stable identifier for a receiver or sender, to be used as a dict
+    key or in a set.
+    """
+    if inspect.ismethod(obj):
+        # The id of a bound method is not stable, but the id of the unbound
+        # function and instance are.
+        return id(obj.__func__), id(obj.__self__)
+
+    if isinstance(obj, (str, int)):
+        # Instances with the same value always compare equal and have the same
+        # hash, even if the id may change.
+        return obj
+
+    # Assume other types are not hashable but will always be the same instance.
+    return id(obj)
+
+
+def make_ref(obj: T, callback: c.Callable[[ref[T]], None] | None = None) -> ref[T]:
+    if inspect.ismethod(obj):
+        return WeakMethod(obj, callback)  # type: ignore[arg-type, return-value]
+
+    return ref(obj, callback)

lib/python3.13/site-packages/blinker/base.py

@@ -0,0 +1,512 @@
+from __future__ import annotations
+
+import collections.abc as c
+import sys
+import typing as t
+import weakref
+from collections import defaultdict
+from contextlib import contextmanager
+from functools import cached_property
+from inspect import iscoroutinefunction
+
+from ._utilities import make_id
+from ._utilities import make_ref
+from ._utilities import Symbol
+
+F = t.TypeVar("F", bound=c.Callable[..., t.Any])
+
+ANY = Symbol("ANY")
+"""Symbol for "any sender"."""
+
+ANY_ID = 0
+
+
+class Signal:
+    """A notification emitter.
+
+    :param doc: The docstring for the signal.
+    """
+
+    ANY = ANY
+    """An alias for the :data:`~blinker.ANY` sender symbol."""
+
+    set_class: type[set[t.Any]] = set
+    """The set class to use for tracking connected receivers and senders.
+    Python's ``set`` is unordered. If receivers must be dispatched in the order
+    they were connected, an ordered set implementation can be used.
+
+    .. versionadded:: 1.7
+    """
+
+    @cached_property
+    def receiver_connected(self) -> Signal:
+        """Emitted at the end of each :meth:`connect` call.
+
+        The signal sender is the signal instance, and the :meth:`connect`
+        arguments are passed through: ``receiver``, ``sender``, and ``weak``.
+
+        .. versionadded:: 1.2
+        """
+        return Signal(doc="Emitted after a receiver connects.")
+
+    @cached_property
+    def receiver_disconnected(self) -> Signal:
+        """Emitted at the end of each :meth:`disconnect` call.
+
+        The sender is the signal instance, and the :meth:`disconnect` arguments
+        are passed through: ``receiver`` and ``sender``.
+
+        This signal is emitted **only** when :meth:`disconnect` is called
+        explicitly. This signal cannot be emitted by an automatic disconnect
+        when a weakly referenced receiver or sender goes out of scope, as the
+        instance is no longer be available to be used as the sender for this
+        signal.
+
+        An alternative approach is available by subscribing to
+        :attr:`receiver_connected` and setting up a custom weakref cleanup
+        callback on weak receivers and senders.
+
+        .. versionadded:: 1.2
+        """
+        return Signal(doc="Emitted after a receiver disconnects.")
+
+    def __init__(self, doc: str | None = None) -> None:
+        if doc:
+            self.__doc__ = doc
+
+        self.receivers: dict[
+            t.Any, weakref.ref[c.Callable[..., t.Any]] | c.Callable[..., t.Any]
+        ] = {}
+        """The map of connected receivers. Useful to quickly check if any
+        receivers are connected to the signal: ``if s.receivers:``. The
+        structure and data is not part of the public API, but checking its
+        boolean value is.
+        """
+
+        self.is_muted: bool = False
+        self._by_receiver: dict[t.Any, set[t.Any]] = defaultdict(self.set_class)
+        self._by_sender: dict[t.Any, set[t.Any]] = defaultdict(self.set_class)
+        self._weak_senders: dict[t.Any, weakref.ref[t.Any]] = {}
+
+    def connect(self, receiver: F, sender: t.Any = ANY, weak: bool = True) -> F:
+        """Connect ``receiver`` to be called when the signal is sent by
+        ``sender``.
+
+        :param receiver: The callable to call when :meth:`send` is called with
+            the given ``sender``, passing ``sender`` as a positional argument
+            along with any extra keyword arguments.
+        :param sender: Any object or :data:`ANY`. ``receiver`` will only be
+            called when :meth:`send` is called with this sender. If ``ANY``, the
+            receiver will be called for any sender. A receiver may be connected
+            to multiple senders by calling :meth:`connect` multiple times.
+        :param weak: Track the receiver with a :mod:`weakref`. The receiver will
+            be automatically disconnected when it is garbage collected. When
+            connecting a receiver defined within a function, set to ``False``,
+            otherwise it will be disconnected when the function scope ends.
+        """
+        receiver_id = make_id(receiver)
+        sender_id = ANY_ID if sender is ANY else make_id(sender)
+
+        if weak:
+            self.receivers[receiver_id] = make_ref(
+                receiver, self._make_cleanup_receiver(receiver_id)
+            )
+        else:
+            self.receivers[receiver_id] = receiver
+
+        self._by_sender[sender_id].add(receiver_id)
+        self._by_receiver[receiver_id].add(sender_id)
+
+        if sender is not ANY and sender_id not in self._weak_senders:
+            # store a cleanup for weakref-able senders
+            try:
+                self._weak_senders[sender_id] = make_ref(
+                    sender, self._make_cleanup_sender(sender_id)
+                )
+            except TypeError:
+                pass
+
+        if "receiver_connected" in self.__dict__ and self.receiver_connected.receivers:
+            try:
+                self.receiver_connected.send(
+                    self, receiver=receiver, sender=sender, weak=weak
+                )
+            except TypeError:
+                # TODO no explanation or test for this
+                self.disconnect(receiver, sender)
+                raise
+
+        return receiver
+
+    def connect_via(self, sender: t.Any, weak: bool = False) -> c.Callable[[F], F]:
+        """Connect the decorated function to be called when the signal is sent
+        by ``sender``.
+
+        The decorated function will be called when :meth:`send` is called with
+        the given ``sender``, passing ``sender`` as a positional argument along
+        with any extra keyword arguments.
+
+        :param sender: Any object or :data:`ANY`. ``receiver`` will only be
+            called when :meth:`send` is called with this sender. If ``ANY``, the
+            receiver will be called for any sender. A receiver may be connected
+            to multiple senders by calling :meth:`connect` multiple times.
+        :param weak: Track the receiver with a :mod:`weakref`. The receiver will
+            be automatically disconnected when it is garbage collected. When
+            connecting a receiver defined within a function, set to ``False``,
+            otherwise it will be disconnected when the function scope ends.=
+
+        .. versionadded:: 1.1
+        """
+
+        def decorator(fn: F) -> F:
+            self.connect(fn, sender, weak)
+            return fn
+
+        return decorator
+
+    @contextmanager
+    def connected_to(
+        self, receiver: c.Callable[..., t.Any], sender: t.Any = ANY
+    ) -> c.Generator[None, None, None]:
+        """A context manager that temporarily connects ``receiver`` to the
+        signal while a ``with`` block executes. When the block exits, the
+        receiver is disconnected. Useful for tests.
+
+        :param receiver: The callable to call when :meth:`send` is called with
+            the given ``sender``, passing ``sender`` as a positional argument
+            along with any extra keyword arguments.
+        :param sender: Any object or :data:`ANY`. ``receiver`` will only be
+            called when :meth:`send` is called with this sender. If ``ANY``, the
+            receiver will be called for any sender.
+
+        .. versionadded:: 1.1
+        """
+        self.connect(receiver, sender=sender, weak=False)
+
+        try:
+            yield None
+        finally:
+            self.disconnect(receiver)
+
+    @contextmanager
+    def muted(self) -> c.Generator[None, None, None]:
+        """A context manager that temporarily disables the signal. No receivers
+        will be called if the signal is sent, until the ``with`` block exits.
+        Useful for tests.
+        """
+        self.is_muted = True
+
+        try:
+            yield None
+        finally:
+            self.is_muted = False
+
+    def send(
+        self,
+        sender: t.Any | None = None,
+        /,
+        *,
+        _async_wrapper: c.Callable[
+            [c.Callable[..., c.Coroutine[t.Any, t.Any, t.Any]]], c.Callable[..., t.Any]
+        ]
+        | None = None,
+        **kwargs: t.Any,
+    ) -> list[tuple[c.Callable[..., t.Any], t.Any]]:
+        """Call all receivers that are connected to the given ``sender``
+        or :data:`ANY`. Each receiver is called with ``sender`` as a positional
+        argument along with any extra keyword arguments. Return a list of
+        ``(receiver, return value)`` tuples.
+
+        The order receivers are called is undefined, but can be influenced by
+        setting :attr:`set_class`.
+
+        If a receiver raises an exception, that exception will propagate up.
+        This makes debugging straightforward, with an assumption that correctly
+        implemented receivers will not raise.
+
+        :param sender: Call receivers connected to this sender, in addition to
+            those connected to :data:`ANY`.
+        :param _async_wrapper: Will be called on any receivers that are async
+            coroutines to turn them into sync callables. For example, could run
+            the receiver with an event loop.
+        :param kwargs: Extra keyword arguments to pass to each receiver.
+
+        .. versionchanged:: 1.7
+            Added the ``_async_wrapper`` argument.
+        """
+        if self.is_muted:
+            return []
+
+        results = []
+
+        for receiver in self.receivers_for(sender):
+            if iscoroutinefunction(receiver):
+                if _async_wrapper is None:
+                    raise RuntimeError("Cannot send to a coroutine function.")
+
+                result = _async_wrapper(receiver)(sender, **kwargs)
+            else:
+                result = receiver(sender, **kwargs)
+
+            results.append((receiver, result))
+
+        return results
+
+    async def send_async(
+        self,
+        sender: t.Any | None = None,
+        /,
+        *,
+        _sync_wrapper: c.Callable[
+            [c.Callable[..., t.Any]], c.Callable[..., c.Coroutine[t.Any, t.Any, t.Any]]
+        ]
+        | None = None,
+        **kwargs: t.Any,
+    ) -> list[tuple[c.Callable[..., t.Any], t.Any]]:
+        """Await all receivers that are connected to the given ``sender``
+        or :data:`ANY`. Each receiver is called with ``sender`` as a positional
+        argument along with any extra keyword arguments. Return a list of
+        ``(receiver, return value)`` tuples.
+
+        The order receivers are called is undefined, but can be influenced by
+        setting :attr:`set_class`.
+
+        If a receiver raises an exception, that exception will propagate up.
+        This makes debugging straightforward, with an assumption that correctly
+        implemented receivers will not raise.
+
+        :param sender: Call receivers connected to this sender, in addition to
+            those connected to :data:`ANY`.
+        :param _sync_wrapper: Will be called on any receivers that are sync
+            callables to turn them into async coroutines. For example,
+            could call the receiver in a thread.
+        :param kwargs: Extra keyword arguments to pass to each receiver.
+
+        .. versionadded:: 1.7
+        """
+        if self.is_muted:
+            return []
+
+        results = []
+
+        for receiver in self.receivers_for(sender):
+            if not iscoroutinefunction(receiver):
+                if _sync_wrapper is None:
+                    raise RuntimeError("Cannot send to a non-coroutine function.")
+
+                result = await _sync_wrapper(receiver)(sender, **kwargs)
+            else:
+                result = await receiver(sender, **kwargs)
+
+            results.append((receiver, result))
+
+        return results
+
+    def has_receivers_for(self, sender: t.Any) -> bool:
+        """Check if there is at least one receiver that will be called with the
+        given ``sender``. A receiver connected to :data:`ANY` will always be
+        called, regardless of sender. Does not check if weakly referenced
+        receivers are still live. See :meth:`receivers_for` for a stronger
+        search.
+
+        :param sender: Check for receivers connected to this sender, in addition
+            to those connected to :data:`ANY`.
+        """
+        if not self.receivers:
+            return False
+
+        if self._by_sender[ANY_ID]:
+            return True
+
+        if sender is ANY:
+            return False
+
+        return make_id(sender) in self._by_sender
+
+    def receivers_for(
+        self, sender: t.Any
+    ) -> c.Generator[c.Callable[..., t.Any], None, None]:
+        """Yield each receiver to be called for ``sender``, in addition to those
+        to be called for :data:`ANY`. Weakly referenced receivers that are not
+        live will be disconnected and skipped.
+
+        :param sender: Yield receivers connected to this sender, in addition
+            to those connected to :data:`ANY`.
+        """
+        # TODO: test receivers_for(ANY)
+        if not self.receivers:
+            return
+
+        sender_id = make_id(sender)
+
+        if sender_id in self._by_sender:
+            ids = self._by_sender[ANY_ID] | self._by_sender[sender_id]
+        else:
+            ids = self._by_sender[ANY_ID].copy()
+
+        for receiver_id in ids:
+            receiver = self.receivers.get(receiver_id)
+
+            if receiver is None:
+                continue
+
+            if isinstance(receiver, weakref.ref):
+                strong = receiver()
+
+                if strong is None:
+                    self._disconnect(receiver_id, ANY_ID)
+                    continue
+
+                yield strong
+            else:
+                yield receiver
+
+    def disconnect(self, receiver: c.Callable[..., t.Any], sender: t.Any = ANY) -> None:
+        """Disconnect ``receiver`` from being called when the signal is sent by
+        ``sender``.
+
+        :param receiver: A connected receiver callable.
+        :param sender: Disconnect from only this sender. By default, disconnect
+            from all senders.
+        """
+        sender_id: c.Hashable
+
+        if sender is ANY:
+            sender_id = ANY_ID
+        else:
+            sender_id = make_id(sender)
+
+        receiver_id = make_id(receiver)
+        self._disconnect(receiver_id, sender_id)
+
+        if (
+            "receiver_disconnected" in self.__dict__
+            and self.receiver_disconnected.receivers
+        ):
+            self.receiver_disconnected.send(self, receiver=receiver, sender=sender)
+
+    def _disconnect(self, receiver_id: c.Hashable, sender_id: c.Hashable) -> None:
+        if sender_id == ANY_ID:
+            if self._by_receiver.pop(receiver_id, None) is not None:
+                for bucket in self._by_sender.values():
+                    bucket.discard(receiver_id)
+
+            self.receivers.pop(receiver_id, None)
+        else:
+            self._by_sender[sender_id].discard(receiver_id)
+            self._by_receiver[receiver_id].discard(sender_id)
+
+    def _make_cleanup_receiver(
+        self, receiver_id: c.Hashable
+    ) -> c.Callable[[weakref.ref[c.Callable[..., t.Any]]], None]:
+        """Create a callback function to disconnect a weakly referenced
+        receiver when it is garbage collected.
+        """
+
+        def cleanup(ref: weakref.ref[c.Callable[..., t.Any]]) -> None:
+            # If the interpreter is shutting down, disconnecting can result in a
+            # weird ignored exception. Don't call it in that case.
+            if not sys.is_finalizing():
+                self._disconnect(receiver_id, ANY_ID)
+
+        return cleanup
+
+    def _make_cleanup_sender(
+        self, sender_id: c.Hashable
+    ) -> c.Callable[[weakref.ref[t.Any]], None]:
+        """Create a callback function to disconnect all receivers for a weakly
+        referenced sender when it is garbage collected.
+        """
+        assert sender_id != ANY_ID
+
+        def cleanup(ref: weakref.ref[t.Any]) -> None:
+            self._weak_senders.pop(sender_id, None)
+
+            for receiver_id in self._by_sender.pop(sender_id, ()):
+                self._by_receiver[receiver_id].discard(sender_id)
+
+        return cleanup
+
+    def _cleanup_bookkeeping(self) -> None:
+        """Prune unused sender/receiver bookkeeping. Not threadsafe.
+
+        Connecting & disconnecting leaves behind a small amount of bookkeeping
+        data. Typical workloads using Blinker, for example in most web apps,
+        Flask, CLI scripts, etc., are not adversely affected by this
+        bookkeeping.
+
+        With a long-running process performing dynamic signal routing with high
+        volume, e.g. connecting to function closures, senders are all unique
+        object instances. Doing all of this over and over may cause memory usage
+        to grow due to extraneous bookkeeping. (An empty ``set`` for each stale
+        sender/receiver pair.)
+
+        This method will prune that bookkeeping away, with the caveat that such
+        pruning is not threadsafe. The risk is that cleanup of a fully
+        disconnected receiver/sender pair occurs while another thread is
+        connecting that same pair. If you are in the highly dynamic, unique
+        receiver/sender situation that has lead you to this method, that failure
+        mode is perhaps not a big deal for you.
+        """
+        for mapping in (self._by_sender, self._by_receiver):
+            for ident, bucket in list(mapping.items()):
+                if not bucket:
+                    mapping.pop(ident, None)
+
+    def _clear_state(self) -> None:
+        """Disconnect all receivers and senders. Useful for tests."""
+        self._weak_senders.clear()
+        self.receivers.clear()
+        self._by_sender.clear()
+        self._by_receiver.clear()
+
+
+class NamedSignal(Signal):
+    """A named generic notification emitter. The name is not used by the signal
+    itself, but matches the key in the :class:`Namespace` that it belongs to.
+
+    :param name: The name of the signal within the namespace.
+    :param doc: The docstring for the signal.
+    """
+
+    def __init__(self, name: str, doc: str | None = None) -> None:
+        super().__init__(doc)
+
+        #: The name of this signal.
+        self.name: str = name
+
+    def __repr__(self) -> str:
+        base = super().__repr__()
+        return f"{base[:-1]}; {self.name!r}>"  # noqa: E702
+
+
+class Namespace(dict[str, NamedSignal]):
+    """A dict mapping names to signals."""
+
+    def signal(self, name: str, doc: str | None = None) -> NamedSignal:
+        """Return the :class:`NamedSignal` for the given ``name``, creating it
+        if required. Repeated calls with the same name return the same signal.
+
+        :param name: The name of the signal.
+        :param doc: The docstring of the signal.
+        """
+        if name not in self:
+            self[name] = NamedSignal(name, doc)
+
+        return self[name]
+
+
+class _PNamespaceSignal(t.Protocol):
+    def __call__(self, name: str, doc: str | None = None) -> NamedSignal: ...
+
+
+default_namespace: Namespace = Namespace()
+"""A default :class:`Namespace` for creating named signals. :func:`signal`
+creates a :class:`NamedSignal` in this namespace.
+"""
+
+signal: _PNamespaceSignal = default_namespace.signal
+"""Return a :class:`NamedSignal` in :data:`default_namespace` with the given
+``name``, creating it if required. Repeated calls with the same name return the
+same signal.
+"""

lib/python3.13/site-packages/cachetools/__init__.py

@@ -0,0 +1,718 @@
+"""Extensible memoizing collections and decorators."""
+
+__all__ = (
+    "Cache",
+    "FIFOCache",
+    "LFUCache",
+    "LRUCache",
+    "RRCache",
+    "TLRUCache",
+    "TTLCache",
+    "cached",
+    "cachedmethod",
+)
+
+__version__ = "6.2.2"
+
+import collections
+import collections.abc
+import functools
+import heapq
+import random
+import time
+
+from . import keys
+
+
+class _DefaultSize:
+    __slots__ = ()
+
+    def __getitem__(self, _key):
+        return 1
+
+    def __setitem__(self, _key, _value):
+        pass
+
+    def pop(self, _key):
+        return 1
+
+
+class Cache(collections.abc.MutableMapping):
+    """Mutable mapping to serve as a simple cache or cache base class."""
+
+    __marker = object()
+
+    __size = _DefaultSize()
+
+    def __init__(self, maxsize, getsizeof=None):
+        if getsizeof:
+            self.getsizeof = getsizeof
+        if self.getsizeof is not Cache.getsizeof:
+            self.__size = dict()
+        self.__data = dict()
+        self.__currsize = 0
+        self.__maxsize = maxsize
+
+    def __repr__(self):
+        return "%s(%s, maxsize=%r, currsize=%r)" % (
+            type(self).__name__,
+            repr(self.__data),
+            self.__maxsize,
+            self.__currsize,
+        )
+
+    def __getitem__(self, key):
+        try:
+            return self.__data[key]
+        except KeyError:
+            return self.__missing__(key)
+
+    def __setitem__(self, key, value):
+        maxsize = self.__maxsize
+        size = self.getsizeof(value)
+        if size > maxsize:
+            raise ValueError("value too large")
+        if key not in self.__data or self.__size[key] < size:
+            while self.__currsize + size > maxsize:
+                self.popitem()
+        if key in self.__data:
+            diffsize = size - self.__size[key]
+        else:
+            diffsize = size
+        self.__data[key] = value
+        self.__size[key] = size
+        self.__currsize += diffsize
+
+    def __delitem__(self, key):
+        size = self.__size.pop(key)
+        del self.__data[key]
+        self.__currsize -= size
+
+    def __contains__(self, key):
+        return key in self.__data
+
+    def __missing__(self, key):
+        raise KeyError(key)
+
+    def __iter__(self):
+        return iter(self.__data)
+
+    def __len__(self):
+        return len(self.__data)
+
+    # Note that we cannot simply inherit get(), pop() and setdefault()
+    # from MutableMapping, since these rely on __getitem__ throwing a
+    # KeyError on cache miss.  This is not the case if __missing__ is
+    # implemented for a Cache subclass, so we have to roll our own,
+    # somewhat less elegant versions.
+
+    def get(self, key, default=None):
+        if key in self:
+            return self[key]
+        else:
+            return default
+
+    def pop(self, key, default=__marker):
+        if key in self:
+            value = self[key]
+            del self[key]
+        elif default is self.__marker:
+            raise KeyError(key)
+        else:
+            value = default
+        return value
+
+    def setdefault(self, key, default=None):
+        if key in self:
+            value = self[key]
+        else:
+            self[key] = value = default
+        return value
+
+    @property
+    def maxsize(self):
+        """The maximum size of the cache."""
+        return self.__maxsize
+
+    @property
+    def currsize(self):
+        """The current size of the cache."""
+        return self.__currsize
+
+    @staticmethod
+    def getsizeof(value):
+        """Return the size of a cache element's value."""
+        return 1
+
+
+class FIFOCache(Cache):
+    """First In First Out (FIFO) cache implementation."""
+
+    def __init__(self, maxsize, getsizeof=None):
+        Cache.__init__(self, maxsize, getsizeof)
+        self.__order = collections.OrderedDict()
+
+    def __setitem__(self, key, value, cache_setitem=Cache.__setitem__):
+        cache_setitem(self, key, value)
+        try:
+            self.__order.move_to_end(key)
+        except KeyError:
+            self.__order[key] = None
+
+    def __delitem__(self, key, cache_delitem=Cache.__delitem__):
+        cache_delitem(self, key)
+        del self.__order[key]
+
+    def popitem(self):
+        """Remove and return the `(key, value)` pair first inserted."""
+        try:
+            key = next(iter(self.__order))
+        except StopIteration:
+            raise KeyError("%s is empty" % type(self).__name__) from None
+        else:
+            return (key, self.pop(key))
+
+
+class LFUCache(Cache):
+    """Least Frequently Used (LFU) cache implementation."""
+
+    class _Link:
+        __slots__ = ("count", "keys", "next", "prev")
+
+        def __init__(self, count):
+            self.count = count
+            self.keys = set()
+
+        def unlink(self):
+            next = self.next
+            prev = self.prev
+            prev.next = next
+            next.prev = prev
+
+    def __init__(self, maxsize, getsizeof=None):
+        Cache.__init__(self, maxsize, getsizeof)
+        self.__root = root = LFUCache._Link(0)  # sentinel
+        root.prev = root.next = root
+        self.__links = {}
+
+    def __getitem__(self, key, cache_getitem=Cache.__getitem__):
+        value = cache_getitem(self, key)
+        if key in self:  # __missing__ may not store item
+            self.__touch(key)
+        return value
+
+    def __setitem__(self, key, value, cache_setitem=Cache.__setitem__):
+        cache_setitem(self, key, value)
+        if key in self.__links:
+            return self.__touch(key)
+        root = self.__root
+        link = root.next
+        if link.count != 1:
+            link = LFUCache._Link(1)
+            link.next = root.next
+            root.next = link.next.prev = link
+            link.prev = root
+        link.keys.add(key)
+        self.__links[key] = link
+
+    def __delitem__(self, key, cache_delitem=Cache.__delitem__):
+        cache_delitem(self, key)
+        link = self.__links.pop(key)
+        link.keys.remove(key)
+        if not link.keys:
+            link.unlink()
+
+    def popitem(self):
+        """Remove and return the `(key, value)` pair least frequently used."""
+        root = self.__root
+        curr = root.next
+        if curr is root:
+            raise KeyError("%s is empty" % type(self).__name__) from None
+        key = next(iter(curr.keys))  # remove an arbitrary element
+        return (key, self.pop(key))
+
+    def __touch(self, key):
+        """Increment use count"""
+        link = self.__links[key]
+        curr = link.next
+        if curr.count != link.count + 1:
+            if len(link.keys) == 1:
+                link.count += 1
+                return
+            curr = LFUCache._Link(link.count + 1)
+            curr.next = link.next
+            link.next = curr.next.prev = curr
+            curr.prev = link
+        curr.keys.add(key)
+        link.keys.remove(key)
+        if not link.keys:
+            link.unlink()
+        self.__links[key] = curr
+
+
+class LRUCache(Cache):
+    """Least Recently Used (LRU) cache implementation."""
+
+    def __init__(self, maxsize, getsizeof=None):
+        Cache.__init__(self, maxsize, getsizeof)
+        self.__order = collections.OrderedDict()
+
+    def __getitem__(self, key, cache_getitem=Cache.__getitem__):
+        value = cache_getitem(self, key)
+        if key in self:  # __missing__ may not store item
+            self.__touch(key)
+        return value
+
+    def __setitem__(self, key, value, cache_setitem=Cache.__setitem__):
+        cache_setitem(self, key, value)
+        self.__touch(key)
+
+    def __delitem__(self, key, cache_delitem=Cache.__delitem__):
+        cache_delitem(self, key)
+        del self.__order[key]
+
+    def popitem(self):
+        """Remove and return the `(key, value)` pair least recently used."""
+        try:
+            key = next(iter(self.__order))
+        except StopIteration:
+            raise KeyError("%s is empty" % type(self).__name__) from None
+        else:
+            return (key, self.pop(key))
+
+    def __touch(self, key):
+        """Mark as recently used"""
+        try:
+            self.__order.move_to_end(key)
+        except KeyError:
+            self.__order[key] = None
+
+
+class RRCache(Cache):
+    """Random Replacement (RR) cache implementation."""
+
+    def __init__(self, maxsize, choice=random.choice, getsizeof=None):
+        Cache.__init__(self, maxsize, getsizeof)
+        self.__choice = choice
+        self.__index = {}
+        self.__keys = []
+
+    @property
+    def choice(self):
+        """The `choice` function used by the cache."""
+        return self.__choice
+
+    def __setitem__(self, key, value, cache_setitem=Cache.__setitem__):
+        cache_setitem(self, key, value)
+        if key not in self.__index:
+            self.__index[key] = len(self.__keys)
+            self.__keys.append(key)
+
+    def __delitem__(self, key, cache_delitem=Cache.__delitem__):
+        cache_delitem(self, key)
+        index = self.__index.pop(key)
+        if index != len(self.__keys) - 1:
+            last = self.__keys[-1]
+            self.__keys[index] = last
+            self.__index[last] = index
+        self.__keys.pop()
+
+    def popitem(self):
+        """Remove and return a random `(key, value)` pair."""
+        try:
+            key = self.__choice(self.__keys)
+        except IndexError:
+            raise KeyError("%s is empty" % type(self).__name__) from None
+        else:
+            return (key, self.pop(key))
+
+
+class _TimedCache(Cache):
+    """Base class for time aware cache implementations."""
+
+    class _Timer:
+        def __init__(self, timer):
+            self.__timer = timer
+            self.__nesting = 0
+
+        def __call__(self):
+            if self.__nesting == 0:
+                return self.__timer()
+            else:
+                return self.__time
+
+        def __enter__(self):
+            if self.__nesting == 0:
+                self.__time = time = self.__timer()
+            else:
+                time = self.__time
+            self.__nesting += 1
+            return time
+
+        def __exit__(self, *exc):
+            self.__nesting -= 1
+
+        def __reduce__(self):
+            return _TimedCache._Timer, (self.__timer,)
+
+        def __getattr__(self, name):
+            return getattr(self.__timer, name)
+
+    def __init__(self, maxsize, timer=time.monotonic, getsizeof=None):
+        Cache.__init__(self, maxsize, getsizeof)
+        self.__timer = _TimedCache._Timer(timer)
+
+    def __repr__(self, cache_repr=Cache.__repr__):
+        with self.__timer as time:
+            self.expire(time)
+            return cache_repr(self)
+
+    def __len__(self, cache_len=Cache.__len__):
+        with self.__timer as time:
+            self.expire(time)
+            return cache_len(self)
+
+    @property
+    def currsize(self):
+        with self.__timer as time:
+            self.expire(time)
+            return super().currsize
+
+    @property
+    def timer(self):
+        """The timer function used by the cache."""
+        return self.__timer
+
+    def clear(self):
+        with self.__timer as time:
+            self.expire(time)
+            Cache.clear(self)
+
+    def get(self, *args, **kwargs):
+        with self.__timer:
+            return Cache.get(self, *args, **kwargs)
+
+    def pop(self, *args, **kwargs):
+        with self.__timer:
+            return Cache.pop(self, *args, **kwargs)
+
+    def setdefault(self, *args, **kwargs):
+        with self.__timer:
+            return Cache.setdefault(self, *args, **kwargs)
+
+
+class TTLCache(_TimedCache):
+    """LRU Cache implementation with per-item time-to-live (TTL) value."""
+
+    class _Link:
+        __slots__ = ("key", "expires", "next", "prev")
+
+        def __init__(self, key=None, expires=None):
+            self.key = key
+            self.expires = expires
+
+        def __reduce__(self):
+            return TTLCache._Link, (self.key, self.expires)
+
+        def unlink(self):
+            next = self.next
+            prev = self.prev
+            prev.next = next
+            next.prev = prev
+
+    def __init__(self, maxsize, ttl, timer=time.monotonic, getsizeof=None):
+        _TimedCache.__init__(self, maxsize, timer, getsizeof)
+        self.__root = root = TTLCache._Link()
+        root.prev = root.next = root
+        self.__links = collections.OrderedDict()
+        self.__ttl = ttl
+
+    def __contains__(self, key):
+        try:
+            link = self.__links[key]  # no reordering
+        except KeyError:
+            return False
+        else:
+            return self.timer() < link.expires
+
+    def __getitem__(self, key, cache_getitem=Cache.__getitem__):
+        try:
+            link = self.__getlink(key)
+        except KeyError:
+            expired = False
+        else:
+            expired = not (self.timer() < link.expires)
+        if expired:
+            return self.__missing__(key)
+        else:
+            return cache_getitem(self, key)
+
+    def __setitem__(self, key, value, cache_setitem=Cache.__setitem__):
+        with self.timer as time:
+            self.expire(time)
+            cache_setitem(self, key, value)
+        try:
+            link = self.__getlink(key)
+        except KeyError:
+            self.__links[key] = link = TTLCache._Link(key)
+        else:
+            link.unlink()
+        link.expires = time + self.__ttl
+        link.next = root = self.__root
+        link.prev = prev = root.prev
+        prev.next = root.prev = link
+
+    def __delitem__(self, key, cache_delitem=Cache.__delitem__):
+        cache_delitem(self, key)
+        link = self.__links.pop(key)
+        link.unlink()
+        if not (self.timer() < link.expires):
+            raise KeyError(key)
+
+    def __iter__(self):
+        root = self.__root
+        curr = root.next
+        while curr is not root:
+            # "freeze" time for iterator access
+            with self.timer as time:
+                if time < curr.expires:
+                    yield curr.key
+            curr = curr.next
+
+    def __setstate__(self, state):
+        self.__dict__.update(state)
+        root = self.__root
+        root.prev = root.next = root
+        for link in sorted(self.__links.values(), key=lambda obj: obj.expires):
+            link.next = root
+            link.prev = prev = root.prev
+            prev.next = root.prev = link
+        self.expire(self.timer())
+
+    @property
+    def ttl(self):
+        """The time-to-live value of the cache's items."""
+        return self.__ttl
+
+    def expire(self, time=None):
+        """Remove expired items from the cache and return an iterable of the
+        expired `(key, value)` pairs.
+
+        """
+        if time is None:
+            time = self.timer()
+        root = self.__root
+        curr = root.next
+        links = self.__links
+        expired = []
+        cache_delitem = Cache.__delitem__
+        cache_getitem = Cache.__getitem__
+        while curr is not root and not (time < curr.expires):
+            expired.append((curr.key, cache_getitem(self, curr.key)))
+            cache_delitem(self, curr.key)
+            del links[curr.key]
+            next = curr.next
+            curr.unlink()
+            curr = next
+        return expired
+
+    def popitem(self):
+        """Remove and return the `(key, value)` pair least recently used that
+        has not already expired.
+
+        """
+        with self.timer as time:
+            self.expire(time)
+            try:
+                key = next(iter(self.__links))
+            except StopIteration:
+                raise KeyError("%s is empty" % type(self).__name__) from None
+            else:
+                return (key, self.pop(key))
+
+    def __getlink(self, key):
+        value = self.__links[key]
+        self.__links.move_to_end(key)
+        return value
+
+
+class TLRUCache(_TimedCache):
+    """Time aware Least Recently Used (TLRU) cache implementation."""
+
+    @functools.total_ordering
+    class _Item:
+        __slots__ = ("key", "expires", "removed")
+
+        def __init__(self, key=None, expires=None):
+            self.key = key
+            self.expires = expires
+            self.removed = False
+
+        def __lt__(self, other):
+            return self.expires < other.expires
+
+    def __init__(self, maxsize, ttu, timer=time.monotonic, getsizeof=None):
+        _TimedCache.__init__(self, maxsize, timer, getsizeof)
+        self.__items = collections.OrderedDict()
+        self.__order = []
+        self.__ttu = ttu
+
+    def __contains__(self, key):
+        try:
+            item = self.__items[key]  # no reordering
+        except KeyError:
+            return False
+        else:
+            return self.timer() < item.expires
+
+    def __getitem__(self, key, cache_getitem=Cache.__getitem__):
+        try:
+            item = self.__getitem(key)
+        except KeyError:
+            expired = False
+        else:
+            expired = not (self.timer() < item.expires)
+        if expired:
+            return self.__missing__(key)
+        else:
+            return cache_getitem(self, key)
+
+    def __setitem__(self, key, value, cache_setitem=Cache.__setitem__):
+        with self.timer as time:
+            expires = self.__ttu(key, value, time)
+            if not (time < expires):
+                return  # skip expired items
+            self.expire(time)
+            cache_setitem(self, key, value)
+        # removing an existing item would break the heap structure, so
+        # only mark it as removed for now
+        try:
+            self.__getitem(key).removed = True
+        except KeyError:
+            pass
+        self.__items[key] = item = TLRUCache._Item(key, expires)
+        heapq.heappush(self.__order, item)
+
+    def __delitem__(self, key, cache_delitem=Cache.__delitem__):
+        with self.timer as time:
+            # no self.expire() for performance reasons, e.g. self.clear() [#67]
+            cache_delitem(self, key)
+        item = self.__items.pop(key)
+        item.removed = True
+        if not (time < item.expires):
+            raise KeyError(key)
+
+    def __iter__(self):
+        for curr in self.__order:
+            # "freeze" time for iterator access
+            with self.timer as time:
+                if time < curr.expires and not curr.removed:
+                    yield curr.key
+
+    @property
+    def ttu(self):
+        """The local time-to-use function used by the cache."""
+        return self.__ttu
+
+    def expire(self, time=None):
+        """Remove expired items from the cache and return an iterable of the
+        expired `(key, value)` pairs.
+
+        """
+        if time is None:
+            time = self.timer()
+        items = self.__items
+        order = self.__order
+        # clean up the heap if too many items are marked as removed
+        if len(order) > len(items) * 2:
+            self.__order = order = [item for item in order if not item.removed]
+            heapq.heapify(order)
+        expired = []
+        cache_delitem = Cache.__delitem__
+        cache_getitem = Cache.__getitem__
+        while order and (order[0].removed or not (time < order[0].expires)):
+            item = heapq.heappop(order)
+            if not item.removed:
+                expired.append((item.key, cache_getitem(self, item.key)))
+                cache_delitem(self, item.key)
+                del items[item.key]
+        return expired
+
+    def popitem(self):
+        """Remove and return the `(key, value)` pair least recently used that
+        has not already expired.
+
+        """
+        with self.timer as time:
+            self.expire(time)
+            try:
+                key = next(iter(self.__items))
+            except StopIteration:
+                raise KeyError("%s is empty" % type(self).__name__) from None
+            else:
+                return (key, self.pop(key))
+
+    def __getitem(self, key):
+        value = self.__items[key]
+        self.__items.move_to_end(key)
+        return value
+
+
+_CacheInfo = collections.namedtuple(
+    "CacheInfo", ["hits", "misses", "maxsize", "currsize"]
+)
+
+
+def cached(cache, key=keys.hashkey, lock=None, condition=None, info=False):
+    """Decorator to wrap a function with a memoizing callable that saves
+    results in a cache.
+
+    """
+    from ._cached import _wrapper
+
+    if isinstance(condition, bool):
+        from warnings import warn
+
+        warn(
+            "passing `info` as positional parameter is deprecated",
+            DeprecationWarning,
+            stacklevel=2,
+        )
+        info = condition
+        condition = None
+
+    def decorator(func):
+        if info:
+            if isinstance(cache, Cache):
+
+                def make_info(hits, misses):
+                    return _CacheInfo(hits, misses, cache.maxsize, cache.currsize)
+
+            elif isinstance(cache, collections.abc.Mapping):
+
+                def make_info(hits, misses):
+                    return _CacheInfo(hits, misses, None, len(cache))
+
+            else:
+
+                def make_info(hits, misses):
+                    return _CacheInfo(hits, misses, 0, 0)
+
+            return _wrapper(func, cache, key, lock, condition, info=make_info)
+        else:
+            return _wrapper(func, cache, key, lock, condition)
+
+    return decorator
+
+
+def cachedmethod(cache, key=keys.methodkey, lock=None, condition=None):
+    """Decorator to wrap a class or instance method with a memoizing
+    callable that saves results in a cache.
+
+    """
+    from ._cachedmethod import _wrapper
+
+    def decorator(method):
+        return _wrapper(method, cache, key, lock, condition)
+
+    return decorator

lib/python3.13/site-packages/cachetools/_cached.py

@@ -0,0 +1,247 @@
+"""Function decorator helpers."""
+
+import functools
+
+
+def _condition_info(func, cache, key, lock, cond, info):
+    hits = misses = 0
+    pending = set()
+
+    def wrapper(*args, **kwargs):
+        nonlocal hits, misses
+        k = key(*args, **kwargs)
+        with lock:
+            cond.wait_for(lambda: k not in pending)
+            try:
+                result = cache[k]
+                hits += 1
+                return result
+            except KeyError:
+                pending.add(k)
+                misses += 1
+        try:
+            v = func(*args, **kwargs)
+            with lock:
+                try:
+                    cache[k] = v
+                except ValueError:
+                    pass  # value too large
+                return v
+        finally:
+            with lock:
+                pending.remove(k)
+                cond.notify_all()
+
+    def cache_clear():
+        nonlocal hits, misses
+        with lock:
+            cache.clear()
+            hits = misses = 0
+
+    def cache_info():
+        with lock:
+            return info(hits, misses)
+
+    wrapper.cache_clear = cache_clear
+    wrapper.cache_info = cache_info
+    return wrapper
+
+
+def _locked_info(func, cache, key, lock, info):
+    hits = misses = 0
+
+    def wrapper(*args, **kwargs):
+        nonlocal hits, misses
+        k = key(*args, **kwargs)
+        with lock:
+            try:
+                result = cache[k]
+                hits += 1
+                return result
+            except KeyError:
+                misses += 1
+        v = func(*args, **kwargs)
+        with lock:
+            try:
+                # In case of a race condition, i.e. if another thread
+                # stored a value for this key while we were calling
+                # func(), prefer the cached value.
+                return cache.setdefault(k, v)
+            except ValueError:
+                return v  # value too large
+
+    def cache_clear():
+        nonlocal hits, misses
+        with lock:
+            cache.clear()
+            hits = misses = 0
+
+    def cache_info():
+        with lock:
+            return info(hits, misses)
+
+    wrapper.cache_clear = cache_clear
+    wrapper.cache_info = cache_info
+    return wrapper
+
+
+def _unlocked_info(func, cache, key, info):
+    hits = misses = 0
+
+    def wrapper(*args, **kwargs):
+        nonlocal hits, misses
+        k = key(*args, **kwargs)
+        try:
+            result = cache[k]
+            hits += 1
+            return result
+        except KeyError:
+            misses += 1
+        v = func(*args, **kwargs)
+        try:
+            cache[k] = v
+        except ValueError:
+            pass  # value too large
+        return v
+
+    def cache_clear():
+        nonlocal hits, misses
+        cache.clear()
+        hits = misses = 0
+
+    wrapper.cache_clear = cache_clear
+    wrapper.cache_info = lambda: info(hits, misses)
+    return wrapper
+
+
+def _uncached_info(func, info):
+    misses = 0
+
+    def wrapper(*args, **kwargs):
+        nonlocal misses
+        misses += 1
+        return func(*args, **kwargs)
+
+    def cache_clear():
+        nonlocal misses
+        misses = 0
+
+    wrapper.cache_clear = cache_clear
+    wrapper.cache_info = lambda: info(0, misses)
+    return wrapper
+
+
+def _condition(func, cache, key, lock, cond):
+    pending = set()
+
+    def wrapper(*args, **kwargs):
+        k = key(*args, **kwargs)
+        with lock:
+            cond.wait_for(lambda: k not in pending)
+            try:
+                result = cache[k]
+                return result
+            except KeyError:
+                pending.add(k)
+        try:
+            v = func(*args, **kwargs)
+            with lock:
+                try:
+                    cache[k] = v
+                except ValueError:
+                    pass  # value too large
+                return v
+        finally:
+            with lock:
+                pending.remove(k)
+                cond.notify_all()
+
+    def cache_clear():
+        with lock:
+            cache.clear()
+
+    wrapper.cache_clear = cache_clear
+    return wrapper
+
+
+def _locked(func, cache, key, lock):
+    def wrapper(*args, **kwargs):
+        k = key(*args, **kwargs)
+        with lock:
+            try:
+                return cache[k]
+            except KeyError:
+                pass  # key not found
+        v = func(*args, **kwargs)
+        with lock:
+            try:
+                # possible race condition: see above
+                return cache.setdefault(k, v)
+            except ValueError:
+                return v  # value too large
+
+    def cache_clear():
+        with lock:
+            cache.clear()
+
+    wrapper.cache_clear = cache_clear
+    return wrapper
+
+
+def _unlocked(func, cache, key):
+    def wrapper(*args, **kwargs):
+        k = key(*args, **kwargs)
+        try:
+            return cache[k]
+        except KeyError:
+            pass  # key not found
+        v = func(*args, **kwargs)
+        try:
+            cache[k] = v
+        except ValueError:
+            pass  # value too large
+        return v
+
+    wrapper.cache_clear = lambda: cache.clear()
+    return wrapper
+
+
+def _uncached(func):
+    def wrapper(*args, **kwargs):
+        return func(*args, **kwargs)
+
+    wrapper.cache_clear = lambda: None
+    return wrapper
+
+
+def _wrapper(func, cache, key, lock=None, cond=None, info=None):
+    if info is not None:
+        if cache is None:
+            wrapper = _uncached_info(func, info)
+        elif cond is not None and lock is not None:
+            wrapper = _condition_info(func, cache, key, lock, cond, info)
+        elif cond is not None:
+            wrapper = _condition_info(func, cache, key, cond, cond, info)
+        elif lock is not None:
+            wrapper = _locked_info(func, cache, key, lock, info)
+        else:
+            wrapper = _unlocked_info(func, cache, key, info)
+    else:
+        if cache is None:
+            wrapper = _uncached(func)
+        elif cond is not None and lock is not None:
+            wrapper = _condition(func, cache, key, lock, cond)
+        elif cond is not None:
+            wrapper = _condition(func, cache, key, cond, cond)
+        elif lock is not None:
+            wrapper = _locked(func, cache, key, lock)
+        else:
+            wrapper = _unlocked(func, cache, key)
+        wrapper.cache_info = None
+
+    wrapper.cache = cache
+    wrapper.cache_key = key
+    wrapper.cache_lock = lock if lock is not None else cond
+    wrapper.cache_condition = cond
+
+    return functools.update_wrapper(wrapper, func)

lib/python3.13/site-packages/cachetools/_cachedmethod.py

@@ -0,0 +1,128 @@
+"""Method decorator helpers."""
+
+import functools
+import weakref
+
+
+def warn_cache_none():
+    from warnings import warn
+
+    warn(
+        "returning `None` from `cache(self)` is deprecated",
+        DeprecationWarning,
+        stacklevel=3,
+    )
+
+
+def _condition(method, cache, key, lock, cond):
+    pending = weakref.WeakKeyDictionary()
+
+    def wrapper(self, *args, **kwargs):
+        c = cache(self)
+        if c is None:
+            warn_cache_none()
+            return method(self, *args, **kwargs)
+        k = key(self, *args, **kwargs)
+        with lock(self):
+            p = pending.setdefault(self, set())
+            cond(self).wait_for(lambda: k not in p)
+            try:
+                return c[k]
+            except KeyError:
+                p.add(k)
+        try:
+            v = method(self, *args, **kwargs)
+            with lock(self):
+                try:
+                    c[k] = v
+                except ValueError:
+                    pass  # value too large
+                return v
+        finally:
+            with lock(self):
+                pending[self].remove(k)
+                cond(self).notify_all()
+
+    def cache_clear(self):
+        c = cache(self)
+        if c is not None:
+            with lock(self):
+                c.clear()
+
+    wrapper.cache_clear = cache_clear
+    return wrapper
+
+
+def _locked(method, cache, key, lock):
+    def wrapper(self, *args, **kwargs):
+        c = cache(self)
+        if c is None:
+            warn_cache_none()
+            return method(self, *args, **kwargs)
+        k = key(self, *args, **kwargs)
+        with lock(self):
+            try:
+                return c[k]
+            except KeyError:
+                pass  # key not found
+        v = method(self, *args, **kwargs)
+        # in case of a race, prefer the item already in the cache
+        with lock(self):
+            try:
+                return c.setdefault(k, v)
+            except ValueError:
+                return v  # value too large
+
+    def cache_clear(self):
+        c = cache(self)
+        if c is not None:
+            with lock(self):
+                c.clear()
+
+    wrapper.cache_clear = cache_clear
+    return wrapper
+
+
+def _unlocked(method, cache, key):
+    def wrapper(self, *args, **kwargs):
+        c = cache(self)
+        if c is None:
+            warn_cache_none()
+            return method(self, *args, **kwargs)
+        k = key(self, *args, **kwargs)
+        try:
+            return c[k]
+        except KeyError:
+            pass  # key not found
+        v = method(self, *args, **kwargs)
+        try:
+            c[k] = v
+        except ValueError:
+            pass  # value too large
+        return v
+
+    def cache_clear(self):
+        c = cache(self)
+        if c is not None:
+            c.clear()
+
+    wrapper.cache_clear = cache_clear
+    return wrapper
+
+
+def _wrapper(method, cache, key, lock=None, cond=None):
+    if cond is not None and lock is not None:
+        wrapper = _condition(method, cache, key, lock, cond)
+    elif cond is not None:
+        wrapper = _condition(method, cache, key, cond, cond)
+    elif lock is not None:
+        wrapper = _locked(method, cache, key, lock)
+    else:
+        wrapper = _unlocked(method, cache, key)
+
+    wrapper.cache = cache
+    wrapper.cache_key = key
+    wrapper.cache_lock = lock if lock is not None else cond
+    wrapper.cache_condition = cond
+
+    return functools.update_wrapper(wrapper, method)

lib/python3.13/site-packages/cachetools/func.py

@@ -0,0 +1,102 @@
+"""`functools.lru_cache` compatible memoizing function decorators."""
+
+__all__ = ("fifo_cache", "lfu_cache", "lru_cache", "rr_cache", "ttl_cache")
+
+import functools
+import math
+import random
+import time
+from threading import Condition
+
+from . import FIFOCache, LFUCache, LRUCache, RRCache, TTLCache
+from . import cached
+from . import keys
+
+
+class _UnboundTTLCache(TTLCache):
+    def __init__(self, ttl, timer):
+        TTLCache.__init__(self, math.inf, ttl, timer)
+
+    @property
+    def maxsize(self):
+        return None
+
+
+def _cache(cache, maxsize, typed):
+    def decorator(func):
+        key = keys.typedkey if typed else keys.hashkey
+        wrapper = cached(cache=cache, key=key, condition=Condition(), info=True)(func)
+        wrapper.cache_parameters = lambda: {"maxsize": maxsize, "typed": typed}
+        return wrapper
+
+    return decorator
+
+
+def fifo_cache(maxsize=128, typed=False):
+    """Decorator to wrap a function with a memoizing callable that saves
+    up to `maxsize` results based on a First In First Out (FIFO)
+    algorithm.
+
+    """
+    if maxsize is None:
+        return _cache({}, None, typed)
+    elif callable(maxsize):
+        return _cache(FIFOCache(128), 128, typed)(maxsize)
+    else:
+        return _cache(FIFOCache(maxsize), maxsize, typed)
+
+
+def lfu_cache(maxsize=128, typed=False):
+    """Decorator to wrap a function with a memoizing callable that saves
+    up to `maxsize` results based on a Least Frequently Used (LFU)
+    algorithm.
+
+    """
+    if maxsize is None:
+        return _cache({}, None, typed)
+    elif callable(maxsize):
+        return _cache(LFUCache(128), 128, typed)(maxsize)
+    else:
+        return _cache(LFUCache(maxsize), maxsize, typed)
+
+
+def lru_cache(maxsize=128, typed=False):
+    """Decorator to wrap a function with a memoizing callable that saves
+    up to `maxsize` results based on a Least Recently Used (LRU)
+    algorithm.
+
+    """
+    if maxsize is None:
+        return _cache({}, None, typed)
+    elif callable(maxsize):
+        return _cache(LRUCache(128), 128, typed)(maxsize)
+    else:
+        return _cache(LRUCache(maxsize), maxsize, typed)
+
+
+def rr_cache(maxsize=128, choice=random.choice, typed=False):
+    """Decorator to wrap a function with a memoizing callable that saves
+    up to `maxsize` results based on a Random Replacement (RR)
+    algorithm.
+
+    """
+    if maxsize is None:
+        return _cache({}, None, typed)
+    elif callable(maxsize):
+        return _cache(RRCache(128, choice), 128, typed)(maxsize)
+    else:
+        return _cache(RRCache(maxsize, choice), maxsize, typed)
+
+
+def ttl_cache(maxsize=128, ttl=600, timer=time.monotonic, typed=False):
+    """Decorator to wrap a function with a memoizing callable that saves
+    up to `maxsize` results based on a Least Recently Used (LRU)
+    algorithm with a per-item time-to-live (TTL) value.
+
+    """
+    if maxsize is None:
+        return _cache(_UnboundTTLCache(ttl, timer), None, typed)
+    elif callable(maxsize):
+        return _cache(TTLCache(128, ttl, timer), 128, typed)(maxsize)
+    else:
+        return _cache(TTLCache(maxsize, ttl, timer), maxsize, typed)

lib/python3.13/site-packages/cachetools/keys.py

@@ -0,0 +1,62 @@
+"""Key functions for memoizing decorators."""
+
+__all__ = ("hashkey", "methodkey", "typedkey", "typedmethodkey")
+
+
+class _HashedTuple(tuple):
+    """A tuple that ensures that hash() will be called no more than once
+    per element, since cache decorators will hash the key multiple
+    times on a cache miss.  See also _HashedSeq in the standard
+    library functools implementation.
+
+    """
+
+    __hashvalue = None
+
+    def __hash__(self, hash=tuple.__hash__):
+        hashvalue = self.__hashvalue
+        if hashvalue is None:
+            self.__hashvalue = hashvalue = hash(self)
+        return hashvalue
+
+    def __add__(self, other, add=tuple.__add__):
+        return _HashedTuple(add(self, other))
+
+    def __radd__(self, other, add=tuple.__add__):
+        return _HashedTuple(add(other, self))
+
+    def __getstate__(self):
+        return {}
+
+
+# A sentinel for separating args from kwargs.  Using the class itself
+# ensures uniqueness and preserves identity when pickling/unpickling.
+_kwmark = (_HashedTuple,)
+
+
+def hashkey(*args, **kwargs):
+    """Return a cache key for the specified hashable arguments."""
+
+    if kwargs:
+        return _HashedTuple(args + sum(sorted(kwargs.items()), _kwmark))
+    else:
+        return _HashedTuple(args)
+
+
+def methodkey(self, *args, **kwargs):
+    """Return a cache key for use with cached methods."""
+    return hashkey(*args, **kwargs)
+
+
+def typedkey(*args, **kwargs):
+    """Return a typed cache key for the specified hashable arguments."""
+
+    key = hashkey(*args, **kwargs)
+    key += tuple(type(v) for v in args)
+    key += tuple(type(v) for _, v in sorted(kwargs.items()))
+    return key
+
+
+def typedmethodkey(self, *args, **kwargs):
+    """Return a typed cache key for use with cached methods."""
+    return typedkey(*args, **kwargs)

lib/python3.13/site-packages/cuda_pathfinder-1.3.2.dist-info/INSTALLER

@@ -0,0 +1 @@
+uv

lib/python3.13/site-packages/cuda_pathfinder-1.3.2.dist-info/METADATA

@@ -0,0 +1,47 @@
+Metadata-Version: 2.4
+Name: cuda-pathfinder
+Version: 1.3.2
+Summary: Pathfinder for CUDA components
+Author-email: NVIDIA Corporation <cuda-python-conduct@nvidia.com>
+License-Expression: Apache-2.0
+Project-URL: Repository, https://github.com/NVIDIA/cuda-python
+Project-URL: Documentation, https://nvidia.github.io/cuda-python/
+Requires-Python: >=3.9
+Description-Content-Type: text/x-rst
+License-File: LICENSE
+Dynamic: license-file
+
+.. SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+.. SPDX-License-Identifier: Apache-2.0
+
+*******************************************************
+cuda-pathfinder: Utilities for locating CUDA components
+*******************************************************
+
+.. image:: https://img.shields.io/badge/NVIDIA-black?logo=nvidia
+   :target: https://www.nvidia.com/
+   :alt: NVIDIA
+
+`cuda.pathfinder <https://nvidia.github.io/cuda-python/cuda-pathfinder/>`_
+aims to be a one-stop solution for locating CUDA components. Currently
+it supports locating and loading dynamic libraries (``.so``, ``.dll``), and
+locating CTK header directories. Support for other artifacts is in progress.
+
+* `Documentation <https://nvidia.github.io/cuda-python/cuda-pathfinder/>`_
+* `Releases <https://nvidia.github.io/cuda-python/cuda-pathfinder/latest/release.html>`_
+* `Repository <https://github.com/NVIDIA/cuda-python/tree/main/cuda_pathfinder/>`_
+* `Issue tracker <https://github.com/NVIDIA/cuda-python/issues/>`_ (select component ``cuda.pathfinder``)
+
+``cuda.pathfinder`` is under active development. Feedback and suggestions are welcome.
+
+
+Installation
+============
+
+.. code-block:: bash
+
+   pip install cuda-pathfinder
+
+``cuda-pathfinder`` is `CUDA Toolkit (CTK) <https://developer.nvidia.com/cuda-toolkit>`_
+version-agnostic. It follows the general CUDA Toolkit support policy: the
+two most recent major versions are supported simultaneously.

lib/python3.13/site-packages/cuda_pathfinder-1.3.2.dist-info/RECORD

@@ -0,0 +1,22 @@
+cuda/pathfinder/__init__.py,sha256=0wYh03rQ052PLO_Tx29ns78ZvujcFB3w4lP5vqKBEQo,1446
+cuda/pathfinder/_dynamic_libs/find_nvidia_dynamic_lib.py,sha256=OZiFguL6h1wWYgChXn2Q_o1qey2NabAC_8JDvBqE-oE,7700
+cuda/pathfinder/_dynamic_libs/load_dl_common.py,sha256=GNxt26-3sIEVszIDhbASUgG5eSYeQ27wA8w09eRGVIQ,698
+cuda/pathfinder/_dynamic_libs/load_dl_linux.py,sha256=cn6ohzxVewAQm7YjiWHRom2VkpdTt90hP1v8Xxtkdsk,8035
+cuda/pathfinder/_dynamic_libs/load_dl_windows.py,sha256=neDkJyIjlxRQdyfwPqAoFd-TfHc_KF196q-iLCkBftw,6114
+cuda/pathfinder/_dynamic_libs/load_nvidia_dynamic_lib.py,sha256=g4BIea4FsWgrNT3BvnFcQRorzQEJkolwE3hFi1w-LZw,4971
+cuda/pathfinder/_dynamic_libs/supported_nvidia_libs.py,sha256=ZtgK9JXYm8hN0lZsVFTAQUI4DyiG0sfcrLTx5ohDe98,15446
+cuda/pathfinder/_headers/find_nvidia_headers.py,sha256=6ff20zQgESXPAWBitwQqhqql08dCjbKULfXZb1cApgc,5511
+cuda/pathfinder/_headers/supported_nvidia_headers.py,sha256=_XK_PWvXniXj465Uopm3Kx0NrxD2dFbh9mSnUyn1C0s,3290
+cuda/pathfinder/_utils/env_vars.py,sha256=wMPynYwhzs2Omf3zDRcedqaxFlMJFsM0r1gkwNIqC4w,1787
+cuda/pathfinder/_utils/find_site_packages_dll.py,sha256=rZV7ylufarBmqdDk9BW1vEvuz-wYj10mISJCXzPrGU0,1002
+cuda/pathfinder/_utils/find_site_packages_so.py,sha256=pSWtfnJiToQddFBC5hzaYQK_YBZwTQ8oMQLV3_p9A_E,1498
+cuda/pathfinder/_utils/find_sub_dirs.py,sha256=2PwRkBcJpARP8r-p0iNpeZmijCJnSHudfzRSuKp0qr0,1883
+cuda/pathfinder/_utils/platform_aware.py,sha256=oOCqy_VyNdEdISVM2ilde8Kl6rOeElItvsAnw0WD9b8,463
+cuda/pathfinder/_version.py,sha256=F68ShSCFLZTYqos0Vv_q6vWAzK3RZJcQ1SaxpVqFwNM,160
+cuda_pathfinder-1.3.2.dist-info/INSTALLER,sha256=5hhM4Q4mYTT9z6QB6PGpUAW81PGNFrYrdXMj4oM_6ak,2
+cuda_pathfinder-1.3.2.dist-info/METADATA,sha256=poxeLLs7bHM7_lIrMY9lLgn96XwtgFOyRVarSphdoWo,1905
+cuda_pathfinder-1.3.2.dist-info/RECORD,,
+cuda_pathfinder-1.3.2.dist-info/REQUESTED,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+cuda_pathfinder-1.3.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+cuda_pathfinder-1.3.2.dist-info/licenses/LICENSE,sha256=DVQuDIgE45qn836wDaWnYhSdxoLXgpRRKH4RuTjpRZQ,10174
+cuda_pathfinder-1.3.2.dist-info/top_level.txt,sha256=U5vpnvwNpaJF8bl4KnoUluMDTRt0J972FipwXjgNQ3A,5

lib/python3.13/site-packages/cuda_pathfinder-1.3.2.dist-info/WHEEL

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

lib/python3.13/site-packages/cuda_pathfinder-1.3.2.dist-info/top_level.txt

@@ -0,0 +1 @@
+cuda

lib/python3.13/site-packages/cycler-0.12.1.dist-info/LICENSE

@@ -0,0 +1,27 @@
+Copyright (c) 2015, matplotlib project
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+* Redistributions of source code must retain the above copyright notice, this
+  list of conditions and the following disclaimer.
+
+* Redistributions in binary form must reproduce the above copyright notice,
+  this list of conditions and the following disclaimer in the documentation
+  and/or other materials provided with the distribution.
+
+* Neither the name of the matplotlib project nor the names of its
+  contributors may be used to endorse or promote products derived from
+  this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

lib/python3.13/site-packages/cycler-0.12.1.dist-info/METADATA

@@ -0,0 +1,78 @@
+Metadata-Version: 2.1
+Name: cycler
+Version: 0.12.1
+Summary: Composable style cycles
+Author-email: Thomas A Caswell <matplotlib-users@python.org>
+License: Copyright (c) 2015, matplotlib project
+        All rights reserved.
+        
+        Redistribution and use in source and binary forms, with or without
+        modification, are permitted provided that the following conditions are met:
+        
+        * Redistributions of source code must retain the above copyright notice, this
+          list of conditions and the following disclaimer.
+        
+        * Redistributions in binary form must reproduce the above copyright notice,
+          this list of conditions and the following disclaimer in the documentation
+          and/or other materials provided with the distribution.
+        
+        * Neither the name of the matplotlib project nor the names of its
+          contributors may be used to endorse or promote products derived from
+          this software without specific prior written permission.
+        
+        THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+        AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+        IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+        DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+        FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+        DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+        SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+        CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+        OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+        OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+Project-URL: homepage, https://matplotlib.org/cycler/
+Project-URL: repository, https://github.com/matplotlib/cycler
+Keywords: cycle kwargs
+Classifier: License :: OSI Approved :: BSD License
+Classifier: Development Status :: 4 - Beta
+Classifier: Programming Language :: Python :: 3
+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: Programming Language :: Python :: 3 :: Only
+Requires-Python: >=3.8
+Description-Content-Type: text/x-rst
+License-File: LICENSE
+Provides-Extra: docs
+Requires-Dist: ipython ; extra == 'docs'
+Requires-Dist: matplotlib ; extra == 'docs'
+Requires-Dist: numpydoc ; extra == 'docs'
+Requires-Dist: sphinx ; extra == 'docs'
+Provides-Extra: tests
+Requires-Dist: pytest ; extra == 'tests'
+Requires-Dist: pytest-cov ; extra == 'tests'
+Requires-Dist: pytest-xdist ; extra == 'tests'
+
+|PyPi|_ |Conda|_ |Supported Python versions|_ |GitHub Actions|_ |Codecov|_
+
+.. |PyPi| image:: https://img.shields.io/pypi/v/cycler.svg?style=flat
+.. _PyPi: https://pypi.python.org/pypi/cycler
+
+.. |Conda| image:: https://img.shields.io/conda/v/conda-forge/cycler
+.. _Conda:  https://anaconda.org/conda-forge/cycler
+
+.. |Supported Python versions| image:: https://img.shields.io/pypi/pyversions/cycler.svg
+.. _Supported Python versions: https://pypi.python.org/pypi/cycler
+
+.. |GitHub Actions| image:: https://github.com/matplotlib/cycler/actions/workflows/tests.yml/badge.svg
+.. _GitHub Actions: https://github.com/matplotlib/cycler/actions
+
+.. |Codecov| image:: https://codecov.io/github/matplotlib/cycler/badge.svg?branch=main&service=github
+.. _Codecov: https://codecov.io/github/matplotlib/cycler?branch=main
+
+cycler: composable cycles
+=========================
+
+Docs: https://matplotlib.org/cycler/

lib/python3.13/site-packages/cycler-0.12.1.dist-info/RECORD

@@ -0,0 +1,9 @@
+cycler-0.12.1.dist-info/INSTALLER,sha256=5hhM4Q4mYTT9z6QB6PGpUAW81PGNFrYrdXMj4oM_6ak,2
+cycler-0.12.1.dist-info/LICENSE,sha256=8SGBQ9dm2j_qZvEzlrfxXfRqgzA_Kb-Wum6Y601C9Ag,1497
+cycler-0.12.1.dist-info/METADATA,sha256=IyieGbdvHgE5Qidpbmryts0c556JcxIJv5GVFIsY7TY,3779
+cycler-0.12.1.dist-info/RECORD,,
+cycler-0.12.1.dist-info/REQUESTED,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+cycler-0.12.1.dist-info/WHEEL,sha256=yQN5g4mg4AybRjkgi-9yy4iQEFibGQmlz78Pik5Or-A,92
+cycler-0.12.1.dist-info/top_level.txt,sha256=D8BVVDdAAelLb2FOEz7lDpc6-AL21ylKPrMhtG6yzyE,7
+cycler/__init__.py,sha256=1JdRgv5Zzxo-W1ev7B_LWquysWP6LZH6CHk_COtIaXE,16709
+cycler/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0

lib/python3.13/site-packages/cycler-0.12.1.dist-info/WHEEL

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

lib/python3.13/site-packages/datasets-4.4.1.dist-info/AUTHORS

@@ -0,0 +1,8 @@
+# This is the list of HuggingFace Datasets authors for copyright purposes.
+#
+# This does not necessarily list everyone who has contributed code, since in
+# some cases, their employer may be the copyright holder.  To see the full list
+# of contributors, see the revision history in source control.
+
+Google Inc.
+HuggingFace Inc.

lib/python3.13/site-packages/datasets-4.4.1.dist-info/INSTALLER

@@ -0,0 +1 @@
+uv

lib/python3.13/site-packages/datasets-4.4.1.dist-info/LICENSE

@@ -0,0 +1,202 @@
+
+                                 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.

lib/python3.13/site-packages/datasets-4.4.1.dist-info/METADATA

@@ -0,0 +1,375 @@
+Metadata-Version: 2.2
+Name: datasets
+Version: 4.4.1
+Summary: HuggingFace community-driven open-source library of datasets
+Home-page: https://github.com/huggingface/datasets
+Download-URL: https://github.com/huggingface/datasets/tags
+Author: HuggingFace Inc.
+Author-email: thomas@huggingface.co
+License: Apache 2.0
+Keywords: datasets machine learning datasets
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Education
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Operating System :: OS Independent
+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: Programming Language :: Python :: 3.14
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.9.0
+Description-Content-Type: text/markdown
+License-File: LICENSE
+License-File: AUTHORS
+Requires-Dist: filelock
+Requires-Dist: numpy>=1.17
+Requires-Dist: pyarrow>=21.0.0
+Requires-Dist: dill<0.4.1,>=0.3.0
+Requires-Dist: pandas
+Requires-Dist: requests>=2.32.2
+Requires-Dist: httpx<1.0.0
+Requires-Dist: tqdm>=4.66.3
+Requires-Dist: xxhash
+Requires-Dist: multiprocess<0.70.19
+Requires-Dist: fsspec[http]<=2025.10.0,>=2023.1.0
+Requires-Dist: huggingface-hub<2.0,>=0.25.0
+Requires-Dist: packaging
+Requires-Dist: pyyaml>=5.1
+Provides-Extra: audio
+Requires-Dist: torchcodec>=0.6.0; extra == "audio"
+Requires-Dist: torch>=2.8.0; extra == "audio"
+Provides-Extra: vision
+Requires-Dist: Pillow>=9.4.0; extra == "vision"
+Provides-Extra: tensorflow
+Requires-Dist: tensorflow>=2.6.0; extra == "tensorflow"
+Provides-Extra: tensorflow-gpu
+Requires-Dist: tensorflow>=2.6.0; extra == "tensorflow-gpu"
+Provides-Extra: torch
+Requires-Dist: torch; extra == "torch"
+Provides-Extra: jax
+Requires-Dist: jax>=0.3.14; extra == "jax"
+Requires-Dist: jaxlib>=0.3.14; extra == "jax"
+Provides-Extra: streaming
+Provides-Extra: dev
+Requires-Dist: numba>=0.56.4; python_version < "3.14" and extra == "dev"
+Requires-Dist: absl-py; extra == "dev"
+Requires-Dist: decorator; extra == "dev"
+Requires-Dist: joblib<1.3.0; extra == "dev"
+Requires-Dist: joblibspark; python_version < "3.14" and extra == "dev"
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: pytest-datadir; extra == "dev"
+Requires-Dist: pytest-xdist; extra == "dev"
+Requires-Dist: aiohttp; extra == "dev"
+Requires-Dist: elasticsearch<8.0.0,>=7.17.12; extra == "dev"
+Requires-Dist: faiss-cpu>=1.8.0.post1; extra == "dev"
+Requires-Dist: h5py; extra == "dev"
+Requires-Dist: jax>=0.3.14; sys_platform != "win32" and extra == "dev"
+Requires-Dist: jaxlib>=0.3.14; sys_platform != "win32" and extra == "dev"
+Requires-Dist: lz4; python_version < "3.14" and extra == "dev"
+Requires-Dist: moto[server]; extra == "dev"
+Requires-Dist: pyspark>=3.4; extra == "dev"
+Requires-Dist: py7zr; extra == "dev"
+Requires-Dist: rarfile>=4.0; extra == "dev"
+Requires-Dist: sqlalchemy; extra == "dev"
+Requires-Dist: protobuf<4.0.0; extra == "dev"
+Requires-Dist: tensorflow>=2.6.0; (python_version < "3.10" and sys_platform != "win32") and extra == "dev"
+Requires-Dist: tensorflow>=2.16.0; (python_version >= "3.10" and sys_platform != "win32" and python_version < "3.14") and extra == "dev"
+Requires-Dist: tiktoken; extra == "dev"
+Requires-Dist: torch>=2.8.0; extra == "dev"
+Requires-Dist: torchdata; extra == "dev"
+Requires-Dist: transformers>=4.42.0; extra == "dev"
+Requires-Dist: zstandard; extra == "dev"
+Requires-Dist: polars[timezone]>=0.20.0; extra == "dev"
+Requires-Dist: Pillow>=9.4.0; extra == "dev"
+Requires-Dist: torchcodec>=0.7.0; python_version < "3.14" and extra == "dev"
+Requires-Dist: nibabel>=5.3.1; extra == "dev"
+Requires-Dist: ruff>=0.3.0; extra == "dev"
+Requires-Dist: transformers; extra == "dev"
+Requires-Dist: torch; extra == "dev"
+Requires-Dist: tensorflow>=2.6.0; extra == "dev"
+Provides-Extra: tests
+Requires-Dist: numba>=0.56.4; python_version < "3.14" and extra == "tests"
+Requires-Dist: absl-py; extra == "tests"
+Requires-Dist: decorator; extra == "tests"
+Requires-Dist: joblib<1.3.0; extra == "tests"
+Requires-Dist: joblibspark; python_version < "3.14" and extra == "tests"
+Requires-Dist: pytest; extra == "tests"
+Requires-Dist: pytest-datadir; extra == "tests"
+Requires-Dist: pytest-xdist; extra == "tests"
+Requires-Dist: aiohttp; extra == "tests"
+Requires-Dist: elasticsearch<8.0.0,>=7.17.12; extra == "tests"
+Requires-Dist: faiss-cpu>=1.8.0.post1; extra == "tests"
+Requires-Dist: h5py; extra == "tests"
+Requires-Dist: jax>=0.3.14; sys_platform != "win32" and extra == "tests"
+Requires-Dist: jaxlib>=0.3.14; sys_platform != "win32" and extra == "tests"
+Requires-Dist: lz4; python_version < "3.14" and extra == "tests"
+Requires-Dist: moto[server]; extra == "tests"
+Requires-Dist: pyspark>=3.4; extra == "tests"
+Requires-Dist: py7zr; extra == "tests"
+Requires-Dist: rarfile>=4.0; extra == "tests"
+Requires-Dist: sqlalchemy; extra == "tests"
+Requires-Dist: protobuf<4.0.0; extra == "tests"
+Requires-Dist: tensorflow>=2.6.0; (python_version < "3.10" and sys_platform != "win32") and extra == "tests"
+Requires-Dist: tensorflow>=2.16.0; (python_version >= "3.10" and sys_platform != "win32" and python_version < "3.14") and extra == "tests"
+Requires-Dist: tiktoken; extra == "tests"
+Requires-Dist: torch>=2.8.0; extra == "tests"
+Requires-Dist: torchdata; extra == "tests"
+Requires-Dist: transformers>=4.42.0; extra == "tests"
+Requires-Dist: zstandard; extra == "tests"
+Requires-Dist: polars[timezone]>=0.20.0; extra == "tests"
+Requires-Dist: Pillow>=9.4.0; extra == "tests"
+Requires-Dist: torchcodec>=0.7.0; python_version < "3.14" and extra == "tests"
+Requires-Dist: nibabel>=5.3.1; extra == "tests"
+Provides-Extra: tests-numpy2
+Requires-Dist: numba>=0.56.4; python_version < "3.14" and extra == "tests-numpy2"
+Requires-Dist: absl-py; extra == "tests-numpy2"
+Requires-Dist: decorator; extra == "tests-numpy2"
+Requires-Dist: joblib<1.3.0; extra == "tests-numpy2"
+Requires-Dist: joblibspark; python_version < "3.14" and extra == "tests-numpy2"
+Requires-Dist: pytest; extra == "tests-numpy2"
+Requires-Dist: pytest-datadir; extra == "tests-numpy2"
+Requires-Dist: pytest-xdist; extra == "tests-numpy2"
+Requires-Dist: aiohttp; extra == "tests-numpy2"
+Requires-Dist: elasticsearch<8.0.0,>=7.17.12; extra == "tests-numpy2"
+Requires-Dist: h5py; extra == "tests-numpy2"
+Requires-Dist: jax>=0.3.14; sys_platform != "win32" and extra == "tests-numpy2"
+Requires-Dist: jaxlib>=0.3.14; sys_platform != "win32" and extra == "tests-numpy2"
+Requires-Dist: lz4; python_version < "3.14" and extra == "tests-numpy2"
+Requires-Dist: moto[server]; extra == "tests-numpy2"
+Requires-Dist: pyspark>=3.4; extra == "tests-numpy2"
+Requires-Dist: py7zr; extra == "tests-numpy2"
+Requires-Dist: rarfile>=4.0; extra == "tests-numpy2"
+Requires-Dist: sqlalchemy; extra == "tests-numpy2"
+Requires-Dist: protobuf<4.0.0; extra == "tests-numpy2"
+Requires-Dist: tiktoken; extra == "tests-numpy2"
+Requires-Dist: torch>=2.8.0; extra == "tests-numpy2"
+Requires-Dist: torchdata; extra == "tests-numpy2"
+Requires-Dist: transformers>=4.42.0; extra == "tests-numpy2"
+Requires-Dist: zstandard; extra == "tests-numpy2"
+Requires-Dist: polars[timezone]>=0.20.0; extra == "tests-numpy2"
+Requires-Dist: Pillow>=9.4.0; extra == "tests-numpy2"
+Requires-Dist: torchcodec>=0.7.0; python_version < "3.14" and extra == "tests-numpy2"
+Requires-Dist: nibabel>=5.3.1; extra == "tests-numpy2"
+Provides-Extra: quality
+Requires-Dist: ruff>=0.3.0; extra == "quality"
+Provides-Extra: benchmarks
+Requires-Dist: tensorflow==2.12.0; extra == "benchmarks"
+Requires-Dist: torch==2.0.1; extra == "benchmarks"
+Requires-Dist: transformers==4.30.1; extra == "benchmarks"
+Provides-Extra: docs
+Requires-Dist: transformers; extra == "docs"
+Requires-Dist: torch; extra == "docs"
+Requires-Dist: tensorflow>=2.6.0; extra == "docs"
+Provides-Extra: pdfs
+Requires-Dist: pdfplumber>=0.11.4; extra == "pdfs"
+Provides-Extra: nibabel
+Requires-Dist: nibabel>=5.3.2; extra == "nibabel"
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: download-url
+Dynamic: home-page
+Dynamic: keywords
+Dynamic: license
+Dynamic: provides-extra
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+<p align="center">
+  <picture>
+    <source media="(prefers-color-scheme: dark)" srcset="https://huggingface.co/datasets/huggingface/documentation-images/raw/main/datasets-logo-dark.svg">
+    <source media="(prefers-color-scheme: light)" srcset="https://huggingface.co/datasets/huggingface/documentation-images/raw/main/datasets-logo-light.svg">
+    <img alt="Hugging Face Datasets Library" src="https://huggingface.co/datasets/huggingface/documentation-images/raw/main/datasets-logo-light.svg" width="352" height="59" style="max-width: 100%;">
+  </picture>
+  <br/>
+  <br/>
+</p>
+
+<p align="center">
+    <a href="https://github.com/huggingface/datasets/actions/workflows/ci.yml?query=branch%3Amain"><img alt="Build" src="https://github.com/huggingface/datasets/actions/workflows/ci.yml/badge.svg?branch=main"></a>
+    <a href="https://github.com/huggingface/datasets/blob/main/LICENSE"><img alt="GitHub" src="https://img.shields.io/github/license/huggingface/datasets.svg?color=blue"></a>
+    <a href="https://huggingface.co/docs/datasets/index.html"><img alt="Documentation" src="https://img.shields.io/website/http/huggingface.co/docs/datasets/index.html.svg?down_color=red&down_message=offline&up_message=online"></a>
+    <a href="https://github.com/huggingface/datasets/releases"><img alt="GitHub release" src="https://img.shields.io/github/release/huggingface/datasets.svg"></a>
+    <a href="https://huggingface.co/datasets/"><img alt="Number of datasets" src="https://img.shields.io/endpoint?url=https://huggingface.co/api/shields/datasets&color=brightgreen"></a>
+    <a href="CODE_OF_CONDUCT.md"><img alt="Contributor Covenant" src="https://img.shields.io/badge/Contributor%20Covenant-2.0-4baaaa.svg"></a>
+    <a href="https://zenodo.org/badge/latestdoi/250213286"><img src="https://zenodo.org/badge/250213286.svg" alt="DOI"></a>
+</p>
+
+🤗 Datasets is a lightweight library providing **two** main features:
+
+- **one-line dataloaders for many public datasets**: one-liners to download and pre-process any of the ![number of datasets](https://img.shields.io/endpoint?url=https://huggingface.co/api/shields/datasets&color=brightgreen) major public datasets (image datasets, audio datasets, text datasets in 467 languages and dialects, etc.) provided on the [HuggingFace Datasets Hub](https://huggingface.co/datasets). With a simple command like `squad_dataset = load_dataset("rajpurkar/squad")`, get any of these datasets ready to use in a dataloader for training/evaluating a ML model (Numpy/Pandas/PyTorch/TensorFlow/JAX),
+- **efficient data pre-processing**: simple, fast and reproducible data pre-processing for the public datasets as well as your own local datasets in CSV, JSON, text, PNG, JPEG, WAV, MP3, Parquet, HDF5, etc. With simple commands like `processed_dataset = dataset.map(process_example)`, efficiently prepare the dataset for inspection and ML model evaluation and training.
+
+[🎓 **Documentation**](https://huggingface.co/docs/datasets/) [🔎 **Find a dataset in the Hub**](https://huggingface.co/datasets) [🌟 **Share a dataset on the Hub**](https://huggingface.co/docs/datasets/share)
+
+<h3 align="center">
+    <a href="https://hf.co/course"><img src="https://raw.githubusercontent.com/huggingface/datasets/main/docs/source/imgs/course_banner.png"></a>
+</h3>
+
+🤗 Datasets is designed to let the community easily add and share new datasets.
+
+🤗 Datasets has many additional interesting features:
+
+- Thrive on large datasets: 🤗 Datasets naturally frees the user from RAM memory limitation, all datasets are memory-mapped using an efficient zero-serialization cost backend (Apache Arrow).
+- Smart caching: never wait for your data to process several times.
+- Lightweight and fast with a transparent and pythonic API (multi-processing/caching/memory-mapping).
+- Built-in interoperability with NumPy, PyTorch, TensorFlow 2, JAX, Pandas, Polars and more.
+- Native support for audio, image and video data.
+- Enable streaming mode to save disk space and start iterating over the dataset immediately.
+
+🤗 Datasets originated from a fork of the awesome [TensorFlow Datasets](https://github.com/tensorflow/datasets) and the HuggingFace team want to deeply thank the TensorFlow Datasets team for building this amazing library.
+
+# Installation
+
+## With pip
+
+🤗 Datasets can be installed from PyPi and has to be installed in a virtual environment (venv or conda for instance)
+
+```bash
+pip install datasets
+```
+
+## With conda
+
+🤗 Datasets can be installed using conda as follows:
+
+```bash
+conda install -c huggingface -c conda-forge datasets
+```
+
+Follow the installation pages of TensorFlow and PyTorch to see how to install them with conda.
+
+For more details on installation, check the installation page in the documentation: https://huggingface.co/docs/datasets/installation
+
+## Installation to use with Machine Learning & Data frameworks frameworks
+
+If you plan to use 🤗 Datasets with PyTorch (2.0+), TensorFlow (2.6+) or JAX (3.14+) you should also install PyTorch, TensorFlow or JAX.
+🤗 Datasets is also well integrated with data frameworks like PyArrow, Pandas, Polars and Spark, which should be installed separately.
+
+For more details on using the library with these frameworks, check the quick start page in the documentation: https://huggingface.co/docs/datasets/quickstart
+
+# Usage
+
+🤗 Datasets is made to be very simple to use - the API is centered around a single function, `datasets.load_dataset(dataset_name, **kwargs)`, that instantiates a dataset.
+
+This library can be used for text/image/audio/etc. datasets. Here is an example to load a text dataset:
+
+Here is a quick example:
+
+```python
+from datasets import load_dataset
+
+# Print all the available datasets
+from huggingface_hub import list_datasets
+print([dataset.id for dataset in list_datasets()])
+
+# Load a dataset and print the first example in the training set
+squad_dataset = load_dataset('rajpurkar/squad')
+print(squad_dataset['train'][0])
+
+# Process the dataset - add a column with the length of the context texts
+dataset_with_length = squad_dataset.map(lambda x: {"length": len(x["context"])})
+
+# Process the dataset - tokenize the context texts (using a tokenizer from the 🤗 Transformers library)
+from transformers import AutoTokenizer
+tokenizer = AutoTokenizer.from_pretrained('bert-base-cased')
+
+tokenized_dataset = squad_dataset.map(lambda x: tokenizer(x['context']), batched=True)
+```
+
+If your dataset is bigger than your disk or if you don't want to wait to download the data, you can use streaming:
+
+```python
+# If you want to use the dataset immediately and efficiently stream the data as you iterate over the dataset
+image_dataset = load_dataset('timm/imagenet-1k-wds', streaming=True)
+for example in image_dataset["train"]:
+    break
+```
+
+For more details on using the library, check the quick start page in the documentation: https://huggingface.co/docs/datasets/quickstart and the specific pages on:
+
+- Loading a dataset: https://huggingface.co/docs/datasets/loading
+- What's in a Dataset: https://huggingface.co/docs/datasets/access
+- Processing data with 🤗 Datasets: https://huggingface.co/docs/datasets/process
+    - Processing audio data: https://huggingface.co/docs/datasets/audio_process
+    - Processing image data: https://huggingface.co/docs/datasets/image_process
+    - Processing text data: https://huggingface.co/docs/datasets/nlp_process
+- Streaming a dataset: https://huggingface.co/docs/datasets/stream
+- etc.
+
+# Add a new dataset to the Hub
+
+We have a very detailed step-by-step guide to add a new dataset to the ![number of datasets](https://img.shields.io/endpoint?url=https://huggingface.co/api/shields/datasets&color=brightgreen) datasets already provided on the [HuggingFace Datasets Hub](https://huggingface.co/datasets).
+
+You can find:
+- [how to upload a dataset to the Hub using your web browser or Python](https://huggingface.co/docs/datasets/upload_dataset) and also
+- [how to upload it using Git](https://huggingface.co/docs/datasets/share).
+
+# Disclaimers
+
+You can use 🤗 Datasets to load datasets based on versioned git repositories maintained by the dataset authors. For reproducibility reasons, we ask users to pin the `revision` of the repositories they use.
+
+If you're a dataset owner and wish to update any part of it (description, citation, license, etc.), or do not want your dataset to be included in the Hugging Face Hub, please get in touch by opening a discussion or a pull request in the Community tab of the dataset page. Thanks for your contribution to the ML community!
+
+## BibTeX
+
+If you want to cite our 🤗 Datasets library, you can use our [paper](https://arxiv.org/abs/2109.02846):
+
+```bibtex
+@inproceedings{lhoest-etal-2021-datasets,
+    title = "Datasets: A Community Library for Natural Language Processing",
+    author = "Lhoest, Quentin  and
+      Villanova del Moral, Albert  and
+      Jernite, Yacine  and
+      Thakur, Abhishek  and
+      von Platen, Patrick  and
+      Patil, Suraj  and
+      Chaumond, Julien  and
+      Drame, Mariama  and
+      Plu, Julien  and
+      Tunstall, Lewis  and
+      Davison, Joe  and
+      {\v{S}}a{\v{s}}ko, Mario  and
+      Chhablani, Gunjan  and
+      Malik, Bhavitvya  and
+      Brandeis, Simon  and
+      Le Scao, Teven  and
+      Sanh, Victor  and
+      Xu, Canwen  and
+      Patry, Nicolas  and
+      McMillan-Major, Angelina  and
+      Schmid, Philipp  and
+      Gugger, Sylvain  and
+      Delangue, Cl{\'e}ment  and
+      Matussi{\`e}re, Th{\'e}o  and
+      Debut, Lysandre  and
+      Bekman, Stas  and
+      Cistac, Pierric  and
+      Goehringer, Thibault  and
+      Mustar, Victor  and
+      Lagunas, Fran{\c{c}}ois  and
+      Rush, Alexander  and
+      Wolf, Thomas",
+    booktitle = "Proceedings of the 2021 Conference on Empirical Methods in Natural Language Processing: System Demonstrations",
+    month = nov,
+    year = "2021",
+    address = "Online and Punta Cana, Dominican Republic",
+    publisher = "Association for Computational Linguistics",
+    url = "https://aclanthology.org/2021.emnlp-demo.21",
+    pages = "175--184",
+    abstract = "The scale, variety, and quantity of publicly-available NLP datasets has grown rapidly as researchers propose new tasks, larger models, and novel benchmarks. Datasets is a community library for contemporary NLP designed to support this ecosystem. Datasets aims to standardize end-user interfaces, versioning, and documentation, while providing a lightweight front-end that behaves similarly for small datasets as for internet-scale corpora. The design of the library incorporates a distributed, community-driven approach to adding datasets and documenting usage. After a year of development, the library now includes more than 650 unique datasets, has more than 250 contributors, and has helped support a variety of novel cross-dataset research projects and shared tasks. The library is available at https://github.com/huggingface/datasets.",
+    eprint={2109.02846},
+    archivePrefix={arXiv},
+    primaryClass={cs.CL},
+}
+```
+
+If you need to cite a specific version of our 🤗 Datasets library for reproducibility, you can use the corresponding version Zenodo DOI from this [list](https://zenodo.org/search?q=conceptrecid:%224817768%22&sort=-version&all_versions=True).

lib/python3.13/site-packages/datasets-4.4.1.dist-info/RECORD

@@ -0,0 +1,140 @@
+../../../bin/datasets-cli,sha256=fPSBmke1bkm9nO1ckm0Z4Lr0DvLglPXHg3hWDZpJvwA,347
+datasets-4.4.1.dist-info/AUTHORS,sha256=L0FBY23tCNHLmvsOKAbumHn8WZZIK98sH53JYxhAchU,327
+datasets-4.4.1.dist-info/INSTALLER,sha256=5hhM4Q4mYTT9z6QB6PGpUAW81PGNFrYrdXMj4oM_6ak,2
+datasets-4.4.1.dist-info/LICENSE,sha256=z8d0m5b2O9McPEK1xHG_dWgUBT6EfBDz6wA0F7xSPTA,11358
+datasets-4.4.1.dist-info/METADATA,sha256=RUEdOKdx7SFIYVBiCtIVbyHyeXZ6vxaKjYL08llFZaw,19764
+datasets-4.4.1.dist-info/RECORD,,
+datasets-4.4.1.dist-info/REQUESTED,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+datasets-4.4.1.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+datasets-4.4.1.dist-info/entry_points.txt,sha256=iM-h4A7OQCrZqr3L2mwiyMtPeFj8w4HAHzmI45y3tg0,69
+datasets-4.4.1.dist-info/top_level.txt,sha256=9A857YvCQm_Dg3UjeKkWPz9sDBos0t3zN2pf5krTemQ,9
+datasets/__init__.py,sha256=uQHgHsFq7zM2-XawTxvpiLFh7USPy8cRDgR2DlnVT4M,1630
+datasets/arrow_dataset.py,sha256=WW5Auw2jgj-Zy4rZalRCgOsevASc7fqYeVfKNLemNgI,316758
+datasets/arrow_reader.py,sha256=byEDpH_SwzjbnVqW0pXjBaE1NoXFE4Cmwoz7zTB_IvA,25131
+datasets/arrow_writer.py,sha256=5f0mgbIbvFYBKAP3knoFaIQTk6WD-gDp84d2mPwjs1w,34913
+datasets/builder.py,sha256=s_mYd7dVd9Fm5xcwNEOWbvXUKpJrDeoryOqDivXsN_8,87822
+datasets/combine.py,sha256=HurdKaOMz8bQMNkmXxBkBgVALA8EpNQUAqR7iVkLnQk,11213
+datasets/commands/__init__.py,sha256=rujbQtxJbwHhF9WQqp2DD9tfVTghDMJdl0v6H551Pcs,312
+datasets/commands/datasets_cli.py,sha256=CRy2H60h2sxJDpfa4LZ4dxipdGIZlTL47pEXLV6tfwQ,1175
+datasets/commands/delete_from_hub.py,sha256=o0wdolb1r1Jnl6F0KdqKn3u0l8VR2od6KzbRoqrSNPM,1396
+datasets/commands/env.py,sha256=8qg-hpXSXXsHvtYFvJkn5rn9IncqPsjjx3nR8no4a2I,1239
+datasets/commands/test.py,sha256=LEcbsx_zEl15679i2BPXFuvfdPsFGOogVR0rjBkf3_k,7820
+datasets/config.py,sha256=fNBmbPUt0xiJf3VRF9WzgZtUfC4YWALNUHb8gnQDF-w,10408
+datasets/data_files.py,sha256=vDMrILEt5OgoMyTW_m0XlwJum0DSlnewuxwzRzbHAFI,32163
+datasets/dataset_dict.py,sha256=J8LQHfUlkU53Nn_pGxPjCrLHks8xWcIyRuTMLfC-qj0,135158
+datasets/distributed.py,sha256=pulXFluRCmo69KeDqblPz32avS6LCHTGycS77XgI2mY,1562
+datasets/download/__init__.py,sha256=lbFOtITDaR7PHrhzJ8VfRnpaOT6NYozSxUcLv_GVfTg,281
+datasets/download/download_config.py,sha256=ODHFej2H-JIqFllklUFkiF4ILJ62l8clAGk13b8Ru3U,3796
+datasets/download/download_manager.py,sha256=44VSuSzIMJoZ-bDa3uF494jio5JmZFMeGAPzuXYRA7Q,12762
+datasets/download/streaming_download_manager.py,sha256=qvcoVsXnAGNi2lzKRktck_DJrIx1fQ7xedm881s0IQw,7537
+datasets/exceptions.py,sha256=B93GwElhEvlhHPU9GBSY8if27jhRwu875-gL6B2CL6c,4185
+datasets/features/__init__.py,sha256=cjbWpEW5nzjLYtCsTbICeVtthvAlrikobbeEJ_X85Mc,585
+datasets/features/_torchcodec.py,sha256=Ws7JMYlUlPa7NHh1ZgxWQNrJV0c14kfYYCdrLjCkmjA,627
+datasets/features/audio.py,sha256=led2AAsM9P7mZtEIKmzNwtFYdIBD35-wOowRTrgnOu4,14647
+datasets/features/features.py,sha256=aYDYzFi1f0QH_nYmbBc_CXUvTFUYs0ie51jglEfnTGQ,94039
+datasets/features/image.py,sha256=Hgy5DL-IgX0sHl_n9sNWphrwJJQA9z-ULNw4Uu9OOuk,16940
+datasets/features/nifti.py,sha256=XByqtyA1CNC7UTgDlIgGrg7cRflnvgZhkr9o5LQUSEs,9768
+datasets/features/pdf.py,sha256=3gWOD9kDsICWuKU1rSGQnS_l1T6cNfira5hLDI7GfKw,11141
+datasets/features/translation.py,sha256=aIJfNMXTTQLamEk4L8mfTDDdyzscZUnhSPAor8RjE_8,4490
+datasets/features/video.py,sha256=FgUOjqQT27ZD2-z13j6i6PEDkW__p8bePfMoYZb1hQ0,14053
+datasets/filesystems/__init__.py,sha256=jBDUQosQqEFIXUDLZwRWaTgNomwL6Fq2qiYPvvxuae0,1523
+datasets/filesystems/compression.py,sha256=J16G_P0F9SxVfsLy9XLesyQJgvp4kpaO9MAihokEUvY,4528
+datasets/fingerprint.py,sha256=rPZzuQA9O3xe9pqxR13H1dgOGg7mbWVTiOoBYPDgfgs,20330
+datasets/formatting/__init__.py,sha256=-pM10fSzw4MVj_L3NFWEv2sUyBh4mbnvCkfXgfS6WII,5412
+datasets/formatting/formatting.py,sha256=8zMv7dfTyyEDvzNjKDzT7Eb2_fn2n6OknfGmYK_0-MM,26626
+datasets/formatting/jax_formatter.py,sha256=uwckTeHc5DMt8CuqieBzSrfWQuhqaW3X076HaPxxKoY,7412
+datasets/formatting/np_formatter.py,sha256=gmp76JnzjCaIZTvcZUzsGp-vvIjFMqXEUArMU-JisCw,5102
+datasets/formatting/polars_formatter.py,sha256=oTm4l30SgGha-Oku42C0dA91Y8f2oifF9aWvi3QITDk,4744
+datasets/formatting/tf_formatter.py,sha256=_wnRRFH1Q5uzCK8mG8qAfdAVybGGuljbGUe46hmMTrU,5236
+datasets/formatting/torch_formatter.py,sha256=0VnHF8jC7KNjr7Ww9NHEnZDqeKKODiZBs8e6eMOzLDA,11623
+datasets/hub.py,sha256=6qnJVVTdEIShaUGlHrRjFJwvnJiNQuzsU01C8ID-8lA,4822
+datasets/info.py,sha256=AdNB1CcWOag6SfoR0IM7-grZbIYNPG_N1msl5ccJnq8,19642
+datasets/inspect.py,sha256=nC0X--w_RXZflkhhr729MJoP_4i929ith9QwfoaDF4M,15647
+datasets/io/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+datasets/io/abc.py,sha256=LwDMXYs6YkhZuz1JiMK4PDIqgNjv7I8xH3UMUELW2ys,1672
+datasets/io/csv.py,sha256=v4zaWehHb9U3njbdhy7wQnb8qO_c_58XOUC9JgBBVwI,5265
+datasets/io/generator.py,sha256=GLagjjxYSlfxWVHK5KZdEW6V3izo9KkQQkf03qpjkfs,2165
+datasets/io/json.py,sha256=vQZT9vhTbKX5Nyob4zQZR1NXWCft7bT5_6_8DD4XZyo,6697
+datasets/io/parquet.py,sha256=foFbhZzJr8VJH2Mctxz0xHR72BTOMyQcTJDPryw5qng,5388
+datasets/io/spark.py,sha256=VUIODLHgIbiK0CI0UvthQ_gUO0MQDtHUozvw7Dfs8FI,1797
+datasets/io/sql.py,sha256=4Zjw7peVEhhzoDtz2VTCFPqt2Tpy4zMB7T7ajb2GVTY,4234
+datasets/io/text.py,sha256=bebEzXBSGC40_Gy94j9ZTJ7Hg0IfrV_4pnIUEhQZVig,1975
+datasets/iterable_dataset.py,sha256=g-EcofKnrIfq94AR_F8LS3SI4FpivzJ2GLE514_nZ4U,211812
+datasets/keyhash.py,sha256=4bqtuEHHlof2BBJIydN2s6N7--wJg54DXgsgzbtbNzA,3896
+datasets/load.py,sha256=zarzIfFh0UXAw69z0qov4QWGfOicNNLugiHvWtxaIYg,66949
+datasets/naming.py,sha256=aqQqYG4QR8YoxJJMAUyVv_oQyudm4WAApsEHvcozpNg,3001
+datasets/packaged_modules/__init__.py,sha256=GRDBfCfxpVsJ_4WHVE4aC9t5Ws8Uo_t1FEhs5qqsclM,5822
+datasets/packaged_modules/arrow/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+datasets/packaged_modules/arrow/arrow.py,sha256=lkadNXfBbJMQNDw-tK4B4Y1KJR5G-J6aAn9I9jHiLWY,3494
+datasets/packaged_modules/audiofolder/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+datasets/packaged_modules/audiofolder/audiofolder.py,sha256=N4mOZypp8oTI-9FBSeEFE-oQ23U6ZmqPlFcqbUkviA8,1744
+datasets/packaged_modules/cache/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+datasets/packaged_modules/cache/cache.py,sha256=sjQDBHJUeLU1U9PUK179BHfn8dHNA2RoudCWeIAv8p8,8196
+datasets/packaged_modules/csv/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+datasets/packaged_modules/csv/csv.py,sha256=4LShCsr9o4YY0C-n4V37L01u2_2qithYrswSp1WMsRU,8568
+datasets/packaged_modules/folder_based_builder/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+datasets/packaged_modules/folder_based_builder/folder_based_builder.py,sha256=ryTimqZbh9_reC9sjR0Hl6Ww6AbJy9RrX1ijB-qPnGU,21509
+datasets/packaged_modules/generator/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+datasets/packaged_modules/generator/generator.py,sha256=Oke-26QOyDRkGfmIARqSXDqOJW0sIDjboYCwWSHsbdQ,1002
+datasets/packaged_modules/hdf5/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+datasets/packaged_modules/hdf5/hdf5.py,sha256=QqzKr53qsD9XwqCGjrpWcRBnnwmpmtI-efaRV0DPSMY,12761
+datasets/packaged_modules/imagefolder/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+datasets/packaged_modules/imagefolder/imagefolder.py,sha256=UpMVe8TUyayzHsVSfKN5wiXcc94QdamMvxauI4oFdw4,1956
+datasets/packaged_modules/json/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+datasets/packaged_modules/json/json.py,sha256=xGcVS6AlQTTsjqyVC5bF_yKj012eqNnzudOYTXx2Ixw,9466
+datasets/packaged_modules/niftifolder/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+datasets/packaged_modules/niftifolder/niftifolder.py,sha256=b57h90uCGJ4GWelGbAvSonSi8TnEM2t-tdCEFIa_c6k,586
+datasets/packaged_modules/pandas/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+datasets/packaged_modules/pandas/pandas.py,sha256=eR0B5iGOHZ1owzezYmlvx5U_rWblmlpCt_PdC5Ax59E,2547
+datasets/packaged_modules/parquet/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+datasets/packaged_modules/parquet/parquet.py,sha256=gjLURvIpfIEuWUB-9z0Ago9yPdGRyJSOTD9W25X6OqA,9015
+datasets/packaged_modules/pdffolder/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+datasets/packaged_modules/pdffolder/pdffolder.py,sha256=bPYBh9-XOr2C-gg_Fl8h-UKhsVQ7VXjBL2FfW8abiGU,565
+datasets/packaged_modules/spark/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+datasets/packaged_modules/spark/spark.py,sha256=UKu4mRB3k0EFb-Ij83eXpzr7VjCYn_TohQconF8Npag,14689
+datasets/packaged_modules/sql/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+datasets/packaged_modules/sql/sql.py,sha256=0WWm-Xfputk2_QRCVrbKDbZAqZNHxOGdUwfX__4F5E0,4495
+datasets/packaged_modules/text/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+datasets/packaged_modules/text/text.py,sha256=VOJVHkmy4Vm53nspW7QboCkPxd1S0M0uEzun5v8rzUE,5516
+datasets/packaged_modules/videofolder/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+datasets/packaged_modules/videofolder/videofolder.py,sha256=HLTMldDZ3WfK8OAbI2wssBuNCP6ucRBpNLpCoJVDL10,807
+datasets/packaged_modules/webdataset/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+datasets/packaged_modules/webdataset/_tenbin.py,sha256=oovYsgR2R3eXSn1xSCLG3oTly1szKDP4UOiRp4ORdIk,8533
+datasets/packaged_modules/webdataset/webdataset.py,sha256=CNoJjGkQvC457cg6N-eeao0myKMiRzi-x087XZzoeBE,10464
+datasets/packaged_modules/xml/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+datasets/packaged_modules/xml/xml.py,sha256=av0HcLQnKl5d1yM0jfBqVhw9EbzqmO_RsHDfa5pkvx4,2822
+datasets/parallel/__init__.py,sha256=wiRFK4x67ez2vvmjwM2Sb9R1yFdf38laSarU9y0Bido,76
+datasets/parallel/parallel.py,sha256=E-oOQ6zwKrkLFPwZ-3EOcr_aANJDhE-d6QTq7Mp7WvA,4738
+datasets/search.py,sha256=PxveDc1hy2Yux7Gtvat1_Qe_0D6aIKQBWI5KbV0gS6I,35592
+datasets/splits.py,sha256=zZO9vPnbfzfxXQG8LSAQkajXV7TGB2kEwOWrQxPFQbI,23430
+datasets/streaming.py,sha256=7MIamZ2NmReUmJ_2pxgdSopIf7Oh5nFFAbb7WHLuW7E,5772
+datasets/table.py,sha256=8EpNo6Q6HMp2kkKITHUobwaZIJTfXZ4o4e47fzHXij0,93972
+datasets/utils/__init__.py,sha256=PuZtB9YTbRyvdwubnsx-JGdHuMA7p0I0Rmh0E_uxYF0,999
+datasets/utils/_dataset_viewer.py,sha256=SrE1N18S5yCoCx0rAhwaHNDVS9uhxjspA84iNT4TFRw,4397
+datasets/utils/_dill.py,sha256=fPBTvK8yif0Yoxdp-a6vssExfLm7-3usD-xA3ai-N_g,17550
+datasets/utils/_filelock.py,sha256=iXW3bxsIr5JWNemhKtF_-q_0ysajkUTItzMm8LY9LBY,2355
+datasets/utils/deprecation_utils.py,sha256=hTHwlzRs92NfNVudH71LMpW70sjbsP5amebrIgi3A-U,3452
+datasets/utils/doc_utils.py,sha256=HoSm0TFaQaCYGfDgNhpBJ4Xc2WQZuOD6dTxLd9D87fs,407
+datasets/utils/experimental.py,sha256=JgOjaEY3RWZ--3u0-ry82gLCDUpudfBfl-hWZ46SyS4,1097
+datasets/utils/extract.py,sha256=kKMAujtg5FOK91MBXyWl6FFHZStEPn8WkOE7Jmo2Iq4,13021
+datasets/utils/file_utils.py,sha256=DcNkvq-UtK6UvxAOeRDFA3XI-isx6KIKaUMxI7QDKNA,55060
+datasets/utils/filelock.py,sha256=H6C5dQGFCzVKyeDRRY8fZ4YGTEvvNd-MTjpL_sWYb5k,352
+datasets/utils/hub.py,sha256=V2JGolL5VjFT0YiEhI0sxJED_9tGdvma7lH22d64S9I,130
+datasets/utils/info_utils.py,sha256=gAzubjnQbE0YTzB3hf3Cipmx5wCBtOje3fPwjYdzVBE,4330
+datasets/utils/logging.py,sha256=c2g1gl3IV4C7A2-ky0yfrHZuYi4P41HRTdS3XCmdMew,5381
+datasets/utils/metadata.py,sha256=Hrmn8xUoEzwpJKG3Y6tfJt5t7nW1OCxNjfLTlEaxsrI,9367
+datasets/utils/patching.py,sha256=iTeb7XG4faLJKNylq55EcZyCndUXU_XBDvOOkuDz_sc,4955
+datasets/utils/py_utils.py,sha256=v-nq7bKydxCDPiDiaRq1ssEF3pkRTpQn4NV4BxmO-2s,23375
+datasets/utils/resources/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+datasets/utils/resources/creators.json,sha256=XtIpMZefgBOdTevRrQTkFiufbgCbp_iyxseyphYQkn0,257
+datasets/utils/resources/languages.json,sha256=Z0rQNPsfje8zMi8KdvvwxF4APwwqcskJFUvhNiLAgPM,199138
+datasets/utils/resources/multilingualities.json,sha256=02Uc8RtRzfl13l98Y_alZm5HuMYwPzL78B0S5a1X-8c,205
+datasets/utils/resources/readme_structure.yaml,sha256=hNf9msoBZw5jfakQrDb0Af8T325TXdcaHsAO2MUcZvY,3877
+datasets/utils/resources/size_categories.json,sha256=_5nAP7z8R6t7_GfER81QudFO6Y1tqYu4AWrr4Aot8S8,171
+datasets/utils/sharding.py,sha256=VBQ4bRJQijMNDQTgFb1_ddlQ28wAcA0aQp4e-1jFIAk,4215
+datasets/utils/stratify.py,sha256=-MVaLmijYhGyKDpnZS9A8SiHekaIyVm84HVyIIQOmfg,4085
+datasets/utils/tf_utils.py,sha256=T3OysLGbkO7y-J-o9OVGyn9l-l-A3ruj-24JM_UULm8,24448
+datasets/utils/tqdm.py,sha256=44F0g2fBpJwShh1l88PP7Z8kBihFWA_Yee4sjiQSxes,4303
+datasets/utils/track.py,sha256=M81CGLn3MyJzHm98CQkbF3_1DG7evQsw-V52_Bp2paI,1838
+datasets/utils/typing.py,sha256=G11ytWmwjqVia2IdziRDIWvQ4mLJee-sKzgJfHqU16E,205
+datasets/utils/version.py,sha256=Z82cHpjTbQVJyWgnwSU8DsW2G0y-sSbSoOVeQrAds9k,3281

lib/python3.13/site-packages/datasets-4.4.1.dist-info/WHEEL

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

lib/python3.13/site-packages/datasets-4.4.1.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+datasets-cli = datasets.commands.datasets_cli:main

lib/python3.13/site-packages/datasets-4.4.1.dist-info/top_level.txt

@@ -0,0 +1 @@
+datasets

lib/python3.13/site-packages/fastrlock-0.8.3.dist-info/INSTALLER

@@ -0,0 +1 @@
+uv

lib/python3.13/site-packages/fastrlock-0.8.3.dist-info/LICENSE

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

lib/python3.13/site-packages/fastrlock-0.8.3.dist-info/METADATA

@@ -0,0 +1,226 @@
+Metadata-Version: 2.1
+Name: fastrlock
+Version: 0.8.3
+Summary: Fast, re-entrant optimistic lock implemented in Cython
+Home-page: https://github.com/scoder/fastrlock
+Author: Stefan Behnel
+Author-email: stefan_ml@behnel.de
+License: MIT style
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Information Technology
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Cython
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Software Development
+License-File: LICENSE
+
+FastRLock
+---------
+
+This is a C-level implementation of a fast, re-entrant, optimistic lock for CPython.
+It is a drop-in replacement for
+`threading.RLock <https://docs.python.org/3/library/threading.html#threading.RLock>`_.
+FastRLock is implemented in `Cython <https://cython.org>`_ and also provides a C-API
+for direct use from Cython code via ``from fastrlock cimport rlock`` or
+``from cython.cimports.fastrlock import rlock``.
+
+Under normal conditions, it is about 10x faster than ``threading.RLock`` in Python 2.7
+because it avoids all locking unless two or more threads try to acquire it at the
+same time.  Under congestion, it is still about 10% faster than RLock due to being
+implemented in Cython.
+
+This is mostly equivalent to the revised RLock implementation in Python 3.2,
+but still faster due to being implemented in Cython.  However, in Python 3.4 and
+later, the ``threading.RLock`` implementation in the stdlib tends to be as fast
+or even faster than the lock provided by this package, when called through the
+Python API.  ``FastRLock`` is still faster also on these systems when called
+through its Cython API from other Cython modules.
+
+It was initially published as a code recipe here:
+https://code.activestate.com/recipes/577336-fast-re-entrant-optimistic-lock-implemented-in-cyt/
+
+FastRLock has been used and tested in `Lupa <https://github.com/scoder/lupa>`_ for several years.
+
+
+How does it work?
+-----------------
+
+The FastRLock implementation optimises for the non-congested case.  It works by
+exploiting the availability of the GIL.  Since it knows that it holds the GIL when
+the acquire()/release() methods are called, it can safely check the lock for being
+held by other threads and just count any re-entries as long as it is always the
+same thread that acquires it.  This is a lot faster than actually acquiring the
+underlying lock.
+
+When a second thread wants to acquire the lock as well, it first checks the lock
+count and finds out that the lock is already owned.  If the underlying lock is also
+held by another thread already, it then just frees the GIL and asks for acquiring
+the lock, just like RLock does.  If the underlying lock is not held, however, it
+acquires it immediately and basically hands over the ownership by telling the
+current owner to free it when it's done.  Then, it falls back to the normal
+non-owner behaviour that asks for the lock and will eventually acquire it when it
+gets released.  This makes sure that the real lock is only acquired when at least
+two threads want it.
+
+All of these operations are basically atomic because any thread that modifies the
+lock state always holds the GIL.  Note that the implementation must not call any
+Python code while handling the lock, as calling into Python may lead to a context
+switch which hands over the GIL to another thread and thus breaks atomicity.
+Therefore, the code misuses Cython's 'nogil' annotation to make sure that no Python
+code slips in accidentally.
+
+
+How fast is it?
+---------------
+
+Here are some timings for the following scenarios:
+
+1) five acquire-release cycles ('lock_unlock')
+2) five acquire calls followed by five release calls (nested locking, 'reentrant_lock_unlock')
+3) a mixed and partly nested sequence of acquire and release calls ('mixed_lock_unlock')
+4) five acquire-release cycles that do not block ('lock_unlock_nonblocking')
+
+All four are benchmarked for the single threaded case and the multi threaded case
+with 10 threads.  I also tested it with 20 threads only to see that it then takes
+about twice the time for both versions.  Note also that the congested case is
+substantially slower for both locks and the benchmark includes the thread
+creation time, so I only looped 1000x here to get useful
+timings instead of 100000x for the single threaded case.
+
+The results here are mixed.  Depending on the optimisation of the CPython
+installation, it can be faster, about the same speed, or somewhat slower.
+In any case, the direct Cython interface is always faster than going through
+the Python API, because it avoids the Python call overhead and executes
+a C call instead.
+
+::
+
+    Testing RLock (3.10.1)
+
+    sequential (x100000):
+    lock_unlock              :    138.36 msec
+    reentrant_lock_unlock    :     95.35 msec
+    mixed_lock_unlock        :    102.05 msec
+    lock_unlock_nonblocking  :    131.44 msec
+    context_manager          :    616.83 msec
+
+    threaded 10T (x1000):
+    lock_unlock              :   1386.60 msec
+    reentrant_lock_unlock    :   1207.75 msec
+    mixed_lock_unlock        :   1319.62 msec
+    lock_unlock_nonblocking  :   1325.07 msec
+    context_manager          :   1357.93 msec
+
+    Testing FastRLock (0.8.1)
+
+    sequential (x100000):
+    lock_unlock              :     77.47 msec
+    reentrant_lock_unlock    :     64.14 msec
+    mixed_lock_unlock        :     73.51 msec
+    lock_unlock_nonblocking  :     70.31 msec
+    context_manager          :    393.34 msec
+
+    threaded 10T (x1000):
+    lock_unlock              :   1214.13 msec
+    reentrant_lock_unlock    :   1171.75 msec
+    mixed_lock_unlock        :   1184.33 msec
+    lock_unlock_nonblocking  :   1207.42 msec
+    context_manager          :   1232.20 msec
+
+    Testing Cython interface of FastRLock (0.8.1)
+
+    sequential (x100000):
+    lock_unlock              :     18.70 msec
+    reentrant_lock_unlock    :     15.88 msec
+    mixed_lock_unlock        :     14.96 msec
+    lock_unlock_nonblocking  :     13.47 msec
+
+    threaded 10T (x1000):
+    lock_unlock              :   1236.21 msec
+    reentrant_lock_unlock    :   1245.77 msec
+    mixed_lock_unlock        :   1194.25 msec
+    lock_unlock_nonblocking  :   1206.96 msec
+
+
+===================
+fastrlock changelog
+===================
+
+0.8.3 (2024-12-17)
+==================
+
+* Rebuilt with Cython 3.0.11 to add Python 3.13 support.
+
+
+0.8.2 (2023-08-27)
+==================
+
+* Rebuilt with Cython 3.0.2 to add Python 3.12 support.
+
+
+0.8.1 (2022-11-02)
+==================
+
+* Rebuilt with Cython 3.0.0a11 to add Python 3.11 support.
+
+
+0.8 (2021-10-22)
+================
+
+* Rebuilt with Cython 3.0.0a9 to improve the performance in recent
+  Python 3.x versions.
+
+
+0.7 (2021-10-21)
+================
+
+* Adapted for unsigned thread IDs, as used by Py3.7+.
+  (original patch by Guilherme Dantas)
+
+* Build with Cython 0.29.24 to support Py3.10 and later.
+
+
+0.6 (2021-03-21)
+================
+
+* Rebuild with Cython 0.29.22 to support Py3.9 and later.
+
+
+0.5 (2020-06-05)
+================
+
+* Rebuild with Cython 0.29.20 to support Py3.8 and later.
+
+
+0.4 (2018-08-24)
+================
+
+* Rebuild with Cython 0.28.5.
+
+* Linux wheels are faster through profile guided optimisation.
+
+* Add missing file to sdist.
+  (patch by Mark Harfouche, Github issue #5)
+
+
+0.3 (2017-08-10)
+================
+
+* improve cimport support of C-API
+  (patch by Naotoshi Seo, Github issue #3)
+
+* provide ``fastrlock.__version__``
+
+
+0.2 (2017-08-09)
+================
+
+* add missing readme file to sdist
+
+
+0.1 (2017-06-04)
+================
+
+* initial release

lib/python3.13/site-packages/fastrlock-0.8.3.dist-info/RECORD

@@ -0,0 +1,13 @@
+fastrlock-0.8.3.dist-info/INSTALLER,sha256=5hhM4Q4mYTT9z6QB6PGpUAW81PGNFrYrdXMj4oM_6ak,2
+fastrlock-0.8.3.dist-info/LICENSE,sha256=edWWCQqdGaUaEXXL0SQGCy8j1Pa-vqeYIkHSMRdRljA,1063
+fastrlock-0.8.3.dist-info/METADATA,sha256=CSkdXG1Tg_Nn1ar1AXfaqMPqOzGI3Er9xl1ed3brFQo,7664
+fastrlock-0.8.3.dist-info/RECORD,,
+fastrlock-0.8.3.dist-info/REQUESTED,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+fastrlock-0.8.3.dist-info/WHEEL,sha256=DhVnjUrgFTXtsoVOoKWdzDrhNCSUWwR0S5N1r3Zukh4,186
+fastrlock-0.8.3.dist-info/top_level.txt,sha256=QMLNNCjoisR1NTxtzPxl2Zyih9n6sFxd8VCUQzIJHOA,10
+fastrlock/__init__.pxd,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+fastrlock/__init__.py,sha256=lYDBBV0R1dtMBmWKorNXKhEma8Fo0OswJJW6zCSGmtU,169
+fastrlock/_lock.pxi,sha256=tPIg2qyMZbCZDEXQsp_tb_Em2J0podo3iU3-XEBdnTQ,2608
+fastrlock/rlock.cpython-313-x86_64-linux-gnu.so,sha256=gff9iX1lYMZf6lyvs5WwBdTKD3JFTHcFxdYaxQOqmf4,118912
+fastrlock/rlock.pxd,sha256=slrtTC9yStpzsL9FUgoyU69D_YsJAe036GEfH6Z9a0c,313
+fastrlock/rlock.pyx,sha256=YZfaVup-Tkqb42IcNlunf4Vtt2vXVQfZPG4l9BmQlAY,3599

lib/python3.13/site-packages/fastrlock-0.8.3.dist-info/WHEEL

@@ -0,0 +1,7 @@
+Wheel-Version: 1.0
+Generator: setuptools (75.6.0)
+Root-Is-Purelib: false
+Tag: cp313-cp313-manylinux_2_5_x86_64
+Tag: cp313-cp313-manylinux1_x86_64
+Tag: cp313-cp313-manylinux_2_28_x86_64
+

lib/python3.13/site-packages/fastrlock-0.8.3.dist-info/top_level.txt

@@ -0,0 +1 @@
+fastrlock

lib/python3.13/site-packages/flashinfer_python-0.4.1.dist-info/INSTALLER

@@ -0,0 +1 @@
+uv

lib/python3.13/site-packages/flashinfer_python-0.4.1.dist-info/METADATA

@@ -0,0 +1,243 @@
+Metadata-Version: 2.4
+Name: flashinfer-python
+Version: 0.4.1
+Summary: FlashInfer: Kernel Library for LLM Serving
+Author: FlashInfer team
+License-Expression: Apache-2.0
+Project-URL: Homepage, https://github.com/flashinfer-ai/flashinfer
+Requires-Python: <4.0,>=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+License-File: licenses/LICENSE.cutlass.txt
+License-File: licenses/LICENSE.flashattention3.txt
+License-File: licenses/LICENSE.fmt.txt
+License-File: licenses/LICENSE.spdlog.txt
+Requires-Dist: apache-tvm-ffi==0.1.0b15
+Requires-Dist: click
+Requires-Dist: einops
+Requires-Dist: ninja
+Requires-Dist: numpy
+Requires-Dist: nvidia-cudnn-frontend>=1.13.0
+Requires-Dist: nvidia-cutlass-dsl>=4.2.1
+Requires-Dist: nvidia-ml-py
+Requires-Dist: packaging>=24.2
+Requires-Dist: requests
+Requires-Dist: tabulate
+Requires-Dist: torch
+Requires-Dist: tqdm
+Dynamic: license-file
+
+<p align="center">
+  <picture>
+    <source media="(prefers-color-scheme: dark)" srcset="https://github.com/flashinfer-ai/web-data/blob/main/logo/FlashInfer-black-background.png?raw=true">
+    <img alt="FlashInfer" src="https://github.com/flashinfer-ai/web-data/blob/main/logo/FlashInfer-white-background.png?raw=true" width=55%>
+  </picture>
+</p>
+<h1 align="center">
+Kernel Library for LLM Serving
+</h1>
+
+<p align="center">
+| <a href="https://flashinfer.ai"><b>Blog</b></a> | <a href="https://docs.flashinfer.ai"><b>Documentation</b></a> | <a href="https://join.slack.com/t/flashinfer/shared_invite/zt-379wct3hc-D5jR~1ZKQcU00WHsXhgvtA"><b>Slack</b></a> |  <a href="https://github.com/orgs/flashinfer-ai/discussions"><b>Discussion Forum</b></a> |
+</p>
+
+[![Build Status](https://ci.tlcpack.ai/job/flashinfer-ci/job/main/badge/icon)](https://ci.tlcpack.ai/job/flashinfer-ci/job/main/)
+[![Documentation](https://github.com/flashinfer-ai/flashinfer/actions/workflows/build-doc.yml/badge.svg)](https://github.com/flashinfer-ai/flashinfer/actions/workflows/build-doc.yml)
+
+
+FlashInfer is a library and kernel generator for Large Language Models that provides high-performance implementation of LLM GPU kernels such as FlashAttention, SparseAttention, PageAttention, Sampling, and more. FlashInfer focuses on LLM serving and inference, and delivers state-of-the-art performance across diverse scenarios.
+
+Check our [v0.2 release blog](https://flashinfer.ai/2024/12/16/flashinfer-v02-release.html) for new features!
+
+The core features of FlashInfer include:
+1. **Efficient Sparse/Dense Attention Kernels**: Efficient single/batch attention for sparse(paged)/dense KV-storage on CUDA Cores and Tensor Cores (both FA2 & FA3) templates. The vector-sparse attention can achieve 90% of the bandwidth of dense kernels with same problem size.
+2. **Load-Balanced Scheduling**: FlashInfer decouples `plan`/`run` stage of attention computation where we schedule the computation of variable-length inputs in `plan` stage to alleviate load-imbalance issue.
+3. **Memory Efficiency**: FlashInfer offers [Cascade Attention](https://docs.flashinfer.ai/api/cascade.html#flashinfer.cascade.MultiLevelCascadeAttentionWrapper) for hierarchical KV-Cache, and implements Head-Query fusion for accelerating Grouped-Query Attention, and efficient kernels for low-precision attention and fused-RoPE attention for compressed KV-Cache.
+4. **Customizable Attention**: Bring your own attention variants through JIT-compilation.
+5. **CUDAGraph and torch.compile Compatibility**: FlashInfer kernels can be captured by CUDAGraphs and torch.compile for low-latency inference.
+6. **Efficient LLM-specific Operators**: High-Performance [fused kernel for Top-P, Top-K/Min-P sampling](https://docs.flashinfer.ai/api/sampling.html) without the need to sorting.
+
+FlashInfer supports PyTorch, TVM and C++ (header-only) APIs, and can be easily integrated into existing projects.
+
+## News
+- [Mar 10, 2025] [Blog Post](https://flashinfer.ai/2025/03/10/sampling.html) Sorting-Free GPU Kernels for LLM Sampling, which explains the design of sampling kernels in FlashInfer.
+- [Mar 1, 2025] Checkout flashinfer's [intra-kernel profiler](https://github.com/flashinfer-ai/flashinfer/tree/main/profiler) for visualizing the timeline of each threadblock in GPU kernels.
+- [Dec 16, 2024] [Blog Post](https://flashinfer.ai/2024/12/16/flashinfer-v02-release.html) FlashInfer 0.2 - Efficient and Customizable Kernels for LLM Inference Serving
+- [Sept 2024] We've launched a [Slack](https://join.slack.com/t/flashinfer/shared_invite/zt-2r93kj2aq-wZnC2n_Z2~mf73N5qnVGGA) workspace for Flashinfer users and developers. Join us for timely support, discussions, updates and knowledge sharing!
+- [Jan 31, 2024] [Blog Post](https://flashinfer.ai/2024/01/08/cascade-inference.html) Cascade Inference: Memory-Efficient Shared Prefix Batch Decoding
+- [Jan 31, 2024] [Blog Post](https://flashinfer.ai/2024/01/03/introduce-flashinfer.html) Accelerating Self-Attentions for LLM Serving with FlashInfer
+
+## Getting Started
+
+Using our PyTorch API is the easiest way to get started:
+
+### Install from PyPI
+
+FlashInfer is available as a Python package for Linux. Install the core package with:
+
+```bash
+pip install flashinfer-python
+```
+
+**Package Options:**
+- **flashinfer-python**: Core package that compiles/downloads kernels on first use
+- **flashinfer-cubin**: Pre-compiled kernel binaries for all supported GPU architectures
+- **flashinfer-jit-cache**: Pre-built kernel cache for specific CUDA versions
+
+**For faster initialization and offline usage**, install the optional packages to have most kernels pre-compiled:
+```bash
+pip install flashinfer-python flashinfer-cubin
+# JIT cache package (replace cu129 with your CUDA version: cu128, cu129, or cu130)
+pip install flashinfer-jit-cache --index-url https://flashinfer.ai/whl/cu129
+```
+
+This eliminates compilation and downloading overhead at runtime.
+
+### Install from Source
+
+Build the core package from source:
+
+```bash
+git clone https://github.com/flashinfer-ai/flashinfer.git --recursive
+cd flashinfer
+python -m pip install -v .
+```
+
+**For development**, install in editable mode:
+```bash
+python -m pip install --no-build-isolation -e . -v
+```
+
+**Build optional packages:**
+
+`flashinfer-cubin`:
+```bash
+cd flashinfer-cubin
+python -m build --no-isolation --wheel
+python -m pip install dist/*.whl
+```
+
+`flashinfer-jit-cache` (customize `FLASHINFER_CUDA_ARCH_LIST` for your target GPUs):
+```bash
+export FLASHINFER_CUDA_ARCH_LIST="7.5 8.0 8.9 10.0a 10.3a 12.0a"
+cd flashinfer-jit-cache
+python -m build --no-isolation --wheel
+python -m pip install dist/*.whl
+```
+
+For more details, see the [Install from Source documentation](https://docs.flashinfer.ai/installation.html#install-from-source).
+
+### Install Nightly Build
+
+Nightly builds are available for testing the latest features:
+
+```bash
+# Core and cubin packages
+pip install -U --pre flashinfer-python --index-url https://flashinfer.ai/whl/nightly/ --no-deps # Install the nightly package from custom index, without installing dependencies
+pip install flashinfer-python  # Install flashinfer-python's dependencies from PyPI
+pip install -U --pre flashinfer-cubin --index-url https://flashinfer.ai/whl/nightly/
+# JIT cache package (replace cu129 with your CUDA version: cu128, cu129, or cu130)
+pip install -U --pre flashinfer-jit-cache --index-url https://flashinfer.ai/whl/nightly/cu129
+```
+
+### Verify Installation
+
+After installation, verify that FlashInfer is correctly installed and configured:
+
+```bash
+flashinfer show-config
+```
+
+This command displays:
+- FlashInfer version and installed packages (flashinfer-python, flashinfer-cubin, flashinfer-jit-cache)
+- PyTorch and CUDA version information
+- Environment variables and artifact paths
+- Downloaded cubin status and module compilation status
+
+### Trying it out
+
+Below is a minimal example of using FlashInfer's single-request decode/append/prefill attention kernels:
+
+```python
+import torch
+import flashinfer
+
+kv_len = 2048
+num_kv_heads = 32
+head_dim = 128
+
+k = torch.randn(kv_len, num_kv_heads, head_dim).half().to(0)
+v = torch.randn(kv_len, num_kv_heads, head_dim).half().to(0)
+
+# decode attention
+
+num_qo_heads = 32
+q = torch.randn(num_qo_heads, head_dim).half().to(0)
+
+o = flashinfer.single_decode_with_kv_cache(q, k, v) # decode attention without RoPE on-the-fly
+o_rope_on_the_fly = flashinfer.single_decode_with_kv_cache(q, k, v, pos_encoding_mode="ROPE_LLAMA") # decode with LLaMA style RoPE on-the-fly
+
+# append attention
+append_qo_len = 128
+q = torch.randn(append_qo_len, num_qo_heads, head_dim).half().to(0) # append attention, the last 128 tokens in the KV-Cache are the new tokens
+o = flashinfer.single_prefill_with_kv_cache(q, k, v, causal=True) # append attention without RoPE on-the-fly, apply causal mask
+o_rope_on_the_fly = flashinfer.single_prefill_with_kv_cache(q, k, v, causal=True, pos_encoding_mode="ROPE_LLAMA") # append attention with LLaMA style RoPE on-the-fly, apply causal mask
+
+# prefill attention
+qo_len = 2048
+q = torch.randn(qo_len, num_qo_heads, head_dim).half().to(0) # prefill attention
+o = flashinfer.single_prefill_with_kv_cache(q, k, v, causal=False) # prefill attention without RoPE on-the-fly, do not apply causal mask
+```
+
+Check out [documentation](https://docs.flashinfer.ai/) for usage of batch decode/append/prefill kernels and shared-prefix cascading kernels.
+
+## Custom Attention Variants
+
+Starting from FlashInfer v0.2, users can customize their own attention variants with additional parameters. For more details, refer to our [JIT examples](https://github.com/flashinfer-ai/flashinfer/blob/main/tests/utils/test_jit_example.py).
+
+## GPU Support
+
+FlashInfer currently provides support for NVIDIA SM architectures 75 and higher and beta support for 103, 110, 120, and 121.
+
+## Adoption
+
+We are thrilled to share that FlashInfer is being adopted by many cutting-edge projects, including but not limited to:
+- [MLC-LLM](https://github.com/mlc-ai/mlc-llm)
+- [Punica](https://github.com/punica-ai/punica)
+- [SGLang](https://github.com/sgl-project/sglang)
+- [ScaleLLM](https://github.com/vectorch-ai/ScaleLLM)
+- [vLLM](https://github.com/vllm-project/vllm)
+- [TGI](https://github.com/huggingface/text-generation-inference)
+- [lorax](https://github.com/predibase/lorax)
+- [TensorRT-LLM](https://github.com/NVIDIA/TensorRT-LLM)
+- [LightLLM](https://github.com/ModelTC/lightllm)
+
+## Acknowledgement
+
+FlashInfer is inspired by [FlashAttention 1&2](https://github.com/dao-AILab/flash-attention/), [vLLM](https://github.com/vllm-project/vllm), [stream-K](https://arxiv.org/abs/2301.03598), [cutlass](https://github.com/nvidia/cutlass) and [AITemplate](https://github.com/facebookincubator/AITemplate) projects.
+
+## Citation
+
+If you find FlashInfer helpful in your project or research, please consider citing our [paper](https://arxiv.org/abs/2501.01005):
+
+```bibtex
+@article{ye2025flashinfer,
+    title = {FlashInfer: Efficient and Customizable Attention Engine for LLM Inference Serving},
+    author = {
+      Ye, Zihao and
+      Chen, Lequn and
+      Lai, Ruihang and
+      Lin, Wuwei and
+      Zhang, Yineng and
+      Wang, Stephanie and
+      Chen, Tianqi and
+      Kasikci, Baris and
+      Grover, Vinod and
+      Krishnamurthy, Arvind and
+      Ceze, Luis
+    },
+    journal = {arXiv preprint arXiv:2501.01005},
+    year = {2025},
+    url = {https://arxiv.org/abs/2501.01005}
+}
+```