Add files using upload-large-folder tool

lib/python3.13/site-packages/astor-0.8.1.dist-info/AUTHORS

@@ -0,0 +1,19 @@
+Original author of astor/codegen.py:
+* Armin Ronacher <armin.ronacher@active-4.com>
+
+And with some modifications based on Armin's code:
+* Paul Dubs <paul.dubs@gmail.com>
+
+* Berker Peksag <berker.peksag@gmail.com>
+* Patrick Maupin <pmaupin@gmail.com>
+* Abhishek L <abhishek.lekshmanan@gmail.com>
+* Bob Tolbert <bob@eyesopen.com>
+* Whyzgeek <whyzgeek@gmail.com>
+* Zack M. Davis <code@zackmdavis.net>
+* Ryan Gonzalez <rymg19@gmail.com>
+* Lenny Truong <leonardtruong@protonmail.com>
+* Radomír Bosák <radomir.bosak@gmail.com>
+* Kodi Arfer <git@arfer.net>
+* Felix Yan <felixonmars@archlinux.org>
+* Chris Rink <chrisrink10@gmail.com>
+* Batuhan Taskaya <batuhanosmantaskaya@gmail.com>

lib/python3.13/site-packages/astor-0.8.1.dist-info/INSTALLER

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

lib/python3.13/site-packages/astor-0.8.1.dist-info/LICENSE

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

lib/python3.13/site-packages/astor-0.8.1.dist-info/METADATA

@@ -0,0 +1,98 @@
+Metadata-Version: 2.1
+Name: astor
+Version: 0.8.1
+Summary: Read/rewrite/write Python ASTs
+Home-page: https://github.com/berkerpeksag/astor
+Author: Patrick Maupin
+Author-email: pmaupin@gmail.com
+License: BSD-3-Clause
+Keywords: ast,codegen,PEP 8
+Platform: Independent
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: BSD License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 2
+Classifier: Programming Language :: Python :: 2.7
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.4
+Classifier: Programming Language :: Python :: 3.5
+Classifier: Programming Language :: Python :: 3.6
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: Implementation
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Programming Language :: Python :: Implementation :: PyPy
+Classifier: Topic :: Software Development :: Code Generators
+Classifier: Topic :: Software Development :: Compilers
+Requires-Python: !=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,>=2.7
+
+=============================
+astor -- AST observe/rewrite
+=============================
+
+:PyPI: https://pypi.org/project/astor/
+:Documentation: https://astor.readthedocs.io
+:Source: https://github.com/berkerpeksag/astor
+:License: 3-clause BSD
+:Build status:
+    .. image:: https://secure.travis-ci.org/berkerpeksag/astor.svg
+        :alt: Travis CI
+        :target: https://travis-ci.org/berkerpeksag/astor/
+
+astor is designed to allow easy manipulation of Python source via the AST.
+
+There are some other similar libraries, but astor focuses on the following areas:
+
+- Round-trip an AST back to Python [1]_:
+
+  - Modified AST doesn't need linenumbers, ctx, etc. or otherwise
+    be directly compileable for the round-trip to work.
+  - Easy to read generated code as, well, code
+  - Can round-trip two different source trees to compare for functional
+    differences, using the astor.rtrip tool (for example, after PEP8 edits).
+
+- Dump pretty-printing of AST
+
+  - Harder to read than round-tripped code, but more accurate to figure out what
+    is going on.
+
+  - Easier to read than dump from built-in AST module
+
+- Non-recursive treewalk
+
+  - Sometimes you want a recursive treewalk (and astor supports that, starting
+    at any node on the tree), but sometimes you don't need to do that.  astor
+    doesn't require you to explicitly visit sub-nodes unless you want to:
+
+  - You can add code that executes before a node's children are visited, and/or
+  - You can add code that executes after a node's children are visited, and/or
+  - You can add code that executes and keeps the node's children from being
+    visited (and optionally visit them yourself via a recursive call)
+
+  - Write functions to access the tree based on object names and/or attribute names
+  - Enjoy easy access to parent node(s) for tree rewriting
+
+.. [1]
+    The decompilation back to Python is based on code originally written
+    by Armin Ronacher.  Armin's code was well-structured, but failed on
+    some obscure corner cases of the Python language (and even more corner
+    cases when the AST changed on different versions of Python), and its
+    output arguably had cosmetic issues -- for example, it produced
+    parentheses even in some cases where they were not needed, to
+    avoid having to reason about precedence.
+
+    Other derivatives of Armin's code are floating around, and typically
+    have fixes for a few corner cases that happened to be noticed by the
+    maintainers, but most of them have not been tested as thoroughly as
+    astor.  One exception may be the version of codegen
+    `maintained at github by CensoredUsername`__.  This has been tested
+    to work properly on Python 2.7 using astor's test suite, and, as it
+    is a single source file, it may be easier to drop into some applications
+    that do not require astor's other features or Python 3.x compatibility.
+
+__ https://github.com/CensoredUsername/codegen
+
+

lib/python3.13/site-packages/astor-0.8.1.dist-info/RECORD

@@ -0,0 +1,20 @@
+astor-0.8.1.dist-info/AUTHORS,sha256=dy5MQIMINxY79YbaRR19C_CNAgHe3tcuvESs7ypxKQc,679
+astor-0.8.1.dist-info/INSTALLER,sha256=5hhM4Q4mYTT9z6QB6PGpUAW81PGNFrYrdXMj4oM_6ak,2
+astor-0.8.1.dist-info/LICENSE,sha256=zkHq_C78AY2cfJahx3lmgkbHfbEaE544ifNH9GSmG50,1554
+astor-0.8.1.dist-info/METADATA,sha256=0nH_-dzD0tPZUB4Hs5o-OOEuId9lteVELQPI5hG0oKo,4235
+astor-0.8.1.dist-info/RECORD,,
+astor-0.8.1.dist-info/REQUESTED,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+astor-0.8.1.dist-info/WHEEL,sha256=8zNYZbwQSXoB9IfXOjPfeNwvAsALAjffgk27FqvCWbo,110
+astor-0.8.1.dist-info/top_level.txt,sha256=M5xfrbiL9-EIlOb1h2T8s6gFbV3b9AbwgI0ARzaRyaY,6
+astor-0.8.1.dist-info/zip-safe,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
+astor/VERSION,sha256=qvZyHcN8QLQjOsz8CB8ld2_zvR0qS51c6nYNHCz4ZmU,6
+astor/__init__.py,sha256=C9rmH4v9K7pkIk3eDuVRhqO5wULt3B42copNJsEw8rw,2291
+astor/code_gen.py,sha256=0KAimfyV8pIPXQx6s_NyPSXRhAxMLWXbCPEQuCTpxac,32032
+astor/codegen.py,sha256=lTqdJWMK4EAJ1wxDw2XR-MLyHJmvbV1_Q5QLj9naE_g,204
+astor/file_util.py,sha256=BETsKYg8UiKoZNswRkirzPSZWgku41dRzZC7T5X3_F4,3268
+astor/node_util.py,sha256=WEWMUMSfHtLwgx54nMkc2APLV573iOPhqPag4gIbhVQ,6542
+astor/op_util.py,sha256=GGcgYqa3DFOAaoSt7TTu46VUhe1J13dO14-SQTRXRYI,3191
+astor/rtrip.py,sha256=AlvQvsUuUZ8zxvRFpWF_Fsv4-NksPB23rvVkTrkvef8,6741
+astor/source_repr.py,sha256=1lj4jakkrcGDRoo-BIRZDszQ8gukdeLR_fmvGqBrP-U,7373
+astor/string_repr.py,sha256=YeC_DVeIJdPElqjgzzhPFheQsz_QjMEW_SLODFvEsIA,2917
+astor/tree_walk.py,sha256=fJaw54GgTg4NTRJLVRl2XSnfFOG9GdjOUlI6ZChLOb8,6020

lib/python3.13/site-packages/astor-0.8.1.dist-info/WHEEL

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

lib/python3.13/site-packages/astor-0.8.1.dist-info/top_level.txt

@@ -0,0 +1 @@
+astor

lib/python3.13/site-packages/astor-0.8.1.dist-info/zip-safe

@@ -0,0 +1 @@
+

lib/python3.13/site-packages/cbor2-5.7.1.dist-info/INSTALLER

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

lib/python3.13/site-packages/cbor2-5.7.1.dist-info/METADATA

@@ -0,0 +1,148 @@
+Metadata-Version: 2.4
+Name: cbor2
+Version: 5.7.1
+Summary: CBOR (de)serializer with extensive tag support
+Author-email: Alex Grönholm <alex.gronholm@nextday.fi>
+License-Expression: MIT
+Project-URL: Changelog, https://cbor2.readthedocs.io/en/latest/versionhistory.html
+Project-URL: Documentation, https://cbor2.readthedocs.org/en/latest/
+Project-URL: Source Code, https://github.com/agronholm/cbor2
+Project-URL: Issue Tracker, https://github.com/agronholm/cbor2/issues
+Keywords: serialization,cbor
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: Typing :: Typed
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Requires-Python: >=3.9
+Description-Content-Type: text/x-rst
+License-File: LICENSE.txt
+Dynamic: license-file
+
+.. image:: https://github.com/agronholm/cbor2/actions/workflows/test.yml/badge.svg
+  :target: https://github.com/agronholm/cbor2/actions/workflows/test.yml
+  :alt: Testing Status
+.. image:: https://github.com/agronholm/cbor2/actions/workflows/publish.yml/badge.svg
+  :target: https://github.com/agronholm/cbor2/actions/workflows/publish.yml
+  :alt: Publish Status
+.. image:: https://coveralls.io/repos/github/agronholm/cbor2/badge.svg?branch=master
+  :target: https://coveralls.io/github/agronholm/cbor2?branch=master
+  :alt: Code Coverage
+.. image:: https://readthedocs.org/projects/cbor2/badge/?version=latest
+  :target: https://cbor2.readthedocs.io/en/latest/?badge=latest
+  :alt: Documentation Status
+
+About
+=====
+
+This library provides encoding and decoding for the Concise Binary Object Representation (CBOR)
+(`RFC 8949`_) serialization format. The specification is fully compatible with the original RFC 7049.
+`Read the docs <https://cbor2.readthedocs.io/>`_ to learn more.
+
+It is implemented in pure python with an optional C backend.
+
+On PyPy, cbor2 runs with almost identical performance to the C backend.
+
+.. _RFC 8949: https://www.rfc-editor.org/rfc/rfc8949.html
+
+Features
+--------
+
+* Simple api like ``json`` or ``pickle`` modules.
+* Support many `CBOR tags`_ with `stdlib objects`_.
+* Generic tag decoding.
+* `Shared value`_ references including cyclic references.
+* `String references`_ compact encoding with repeated strings replaced with indices.
+* Optional C module backend tested on big- and little-endian architectures.
+* Extensible `tagged value handling`_ using ``tag_hook`` and ``object_hook`` on decode and ``default`` on encode.
+* Command-line diagnostic tool, converting CBOR file or stream to JSON ``python -m cbor2.tool``
+  (This is a lossy conversion, for diagnostics only)
+* Thorough test suite.
+
+.. _CBOR tags: https://www.iana.org/assignments/cbor-tags/cbor-tags.xhtml
+.. _stdlib objects: https://cbor2.readthedocs.io/en/latest/usage.html#tag-support
+.. _Shared value: http://cbor.schmorp.de/value-sharing
+.. _String references: http://cbor.schmorp.de/stringref
+.. _tagged value handling: https://cbor2.readthedocs.io/en/latest/customizing.html#using-the-cbor-tags-for-custom-types
+
+Installation
+============
+
+::
+
+    pip install cbor2
+
+Requirements
+------------
+
+* Python >= 3.9 (or `PyPy3`_ 3.9+)
+* C-extension: Any C compiler that can build Python extensions.
+  Any modern libc with the exception of Glibc<2.9
+
+.. _PyPy3: https://www.pypy.org/
+
+Building the C-Extension
+------------------------
+
+To force building of the optional C-extension, set OS env ``CBOR2_BUILD_C_EXTENSION=1``.
+To disable building of the optional C-extension, set OS env ``CBOR2_BUILD_C_EXTENSION=0``.
+If this environment variable is unset, setup.py will default to auto detecting a compatible C library and
+attempt to compile the extension.
+
+
+Usage
+=====
+
+`Basic Usage <https://cbor2.readthedocs.io/en/latest/usage.html#basic-usage>`_
+
+Command-line Usage
+==================
+
+The provided command line tool (``cbor2``) converts CBOR data in raw binary or base64
+encoding into a representation that allows printing as JSON. This is a lossy
+transformation as each datatype is converted into something that can be represented as a
+JSON value.
+
+The tool can alternatively be invoked with ``python -m cbor2.tool``.
+
+Usage::
+
+    # Pass hexadecimal through xxd.
+    $ echo a16568656c6c6f65776f726c64 | xxd -r -ps | cbor2 --pretty
+    {
+        "hello": "world"
+    }
+    # Decode Base64 directly
+    $ echo ggEC | python -m cbor2.tool --decode
+    [1, 2]
+    # Read from a file encoded in Base64
+    $ python -m cbor2.tool -d tests/examples.cbor.b64
+    {...}
+
+It can be used in a pipeline with json processing tools like `jq`_ to allow syntax
+coloring, field extraction and more.
+
+CBOR data items concatenated into a sequence can be decoded also::
+
+    $ echo ggECggMEggUG | cbor2 -d --sequence
+    [1, 2]
+    [3, 4]
+    [5, 6]
+
+Multiple files can also be sent to a single output file::
+
+    $ cbor2 -o all_files.json file1.cbor file2.cbor ... fileN.cbor
+
+.. _jq: https://stedolan.github.io/jq/
+
+Security
+========
+
+This library has not been tested against malicious input. In theory it should be
+as safe as JSON, since unlike ``pickle`` the decoder does not execute any code.

lib/python3.13/site-packages/cbor2-5.7.1.dist-info/RECORD

@@ -0,0 +1,19 @@
+../../../bin/cbor2,sha256=mBxgdAJTwSbgkqhWKaV9i_2AyoAADy6VZJkiV8yroW0,327
+_cbor2.cpython-313-x86_64-linux-gnu.so,sha256=tiL_yIk9mjzJVCgBnXyyUlNeK7zlzobte71bTLEXRPo,915016
+cbor2-5.7.1.dist-info/INSTALLER,sha256=5hhM4Q4mYTT9z6QB6PGpUAW81PGNFrYrdXMj4oM_6ak,2
+cbor2-5.7.1.dist-info/METADATA,sha256=jChfdgvjQeo7FiqpFK04E1A8A8HsieWfURFOnY5znqw,5410
+cbor2-5.7.1.dist-info/RECORD,,
+cbor2-5.7.1.dist-info/REQUESTED,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+cbor2-5.7.1.dist-info/WHEEL,sha256=2iHh9e2o6T3nHtu_NVT7Cs7pebIqF94rZK8zrQfgoJI,190
+cbor2-5.7.1.dist-info/entry_points.txt,sha256=Od3b0jBICm8GDjdi1loF9kQw3n-E61DkWIErBWjFKU8,42
+cbor2-5.7.1.dist-info/licenses/LICENSE.txt,sha256=pq_RJtj1RaFRZqIvJfrf9Ln7SXi73RfpfZfZULZtL-8,1081
+cbor2-5.7.1.dist-info/top_level.txt,sha256=saWivOPqWvXfQChNvhqeWUndWDjSYMHq9H9fC8t1xDA,13
+cbor2/__init__.py,sha256=RurTl4ZS_siScJLcpwHfmgSO4h4pWn-bu41ImaqscyY,3190
+cbor2/_decoder.py,sha256=0pwgy9eeGDrXLuq_bffBFjL0ivp6hVJVKqrC8vVG-pQ,30709
+cbor2/_encoder.py,sha256=6virRoEznzXfhihnCJ0DRQkejHU2AqacStdkaYd-c84,31267
+cbor2/_types.py,sha256=7eyVlz4NZ39E0JJE-U6u1tcX8ZVgbsizFGZuUZ37hBQ,6260
+cbor2/decoder.py,sha256=4A2Z2JT447-1GbJNTj0RBTFX3G4C--pwk4wknTgpGj8,249
+cbor2/encoder.py,sha256=GwfM16ite3j845Nruqt2hCtAfg1AMVuIJHvRId6KurA,317
+cbor2/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+cbor2/tool.py,sha256=m7tXDzPfbzbD-TLOuEoxTuP3ev42jymr9q_iZxSKXGo,6795
+cbor2/types.py,sha256=2eOwwTGjVVHqoikU-5ZMR0DJiZ-SYcDY1mGqs-nyGSs,706

lib/python3.13/site-packages/cbor2-5.7.1.dist-info/WHEEL

@@ -0,0 +1,7 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: false
+Tag: cp313-cp313-manylinux_2_17_x86_64
+Tag: cp313-cp313-manylinux2014_x86_64
+Tag: cp313-cp313-manylinux_2_28_x86_64
+

lib/python3.13/site-packages/cbor2-5.7.1.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+cbor2 = cbor2.tool:main

lib/python3.13/site-packages/cbor2-5.7.1.dist-info/top_level.txt

@@ -0,0 +1,2 @@
+_cbor2
+cbor2

lib/python3.13/site-packages/cbor2/decoder.py

@@ -0,0 +1,7 @@
+from warnings import warn
+
+from ._decoder import CBORDecoder as CBORDecoder
+from ._decoder import load as load
+from ._decoder import loads as loads
+
+warn("The cbor.decoder module has been deprecated. Instead import everything directly from cbor2.")

lib/python3.13/site-packages/cbor2/tool.py

@@ -0,0 +1,222 @@
+"""Command-line tool for CBOR diagnostics and testing"""
+
+from __future__ import annotations
+
+import argparse
+import base64
+import decimal
+import fractions
+import io
+import ipaddress
+import json
+import re
+import sys
+import uuid
+from collections.abc import Callable, Collection, Iterable, Iterator
+from contextlib import ExitStack
+from datetime import datetime
+from functools import partial
+from typing import TYPE_CHECKING, Any, BinaryIO, TypeVar
+
+from . import CBORDecoder, CBORSimpleValue, CBORTag, FrozenDict, load, undefined
+
+if TYPE_CHECKING:
+    from typing import Literal, TypeAlias
+
+T = TypeVar("T")
+JSONValue: TypeAlias = "str | float | bool | None | list[JSONValue] | dict[str, JSONValue]"
+
+default_encoders: dict[type, Callable[[Any], Any]] = {
+    bytes: lambda x: x.decode(encoding="utf-8", errors="backslashreplace"),
+    decimal.Decimal: str,
+    FrozenDict: lambda x: str(dict(x)),
+    CBORSimpleValue: lambda x: f"cbor_simple:{x.value:d}",
+    type(undefined): lambda x: "cbor:undef",
+    datetime: lambda x: x.isoformat(),
+    fractions.Fraction: str,
+    uuid.UUID: lambda x: x.urn,
+    CBORTag: lambda x: {f"CBORTag:{x.tag:d}": x.value},
+    set: list,
+    re.compile("").__class__: lambda x: x.pattern,
+    ipaddress.IPv4Address: str,
+    ipaddress.IPv6Address: str,
+    ipaddress.IPv4Network: str,
+    ipaddress.IPv6Network: str,
+}
+
+
+def tag_hook(decoder: CBORDecoder, tag: CBORTag, ignore_tags: Collection[int] = ()) -> object:
+    if tag.tag in ignore_tags:
+        return tag.value
+
+    if tag.tag == 24:
+        return decoder.decode_from_bytes(tag.value)
+    elif decoder.immutable:
+        return f"CBORtag:{tag.tag}:{tag.value}"
+
+    return tag
+
+
+class DefaultEncoder(json.JSONEncoder):
+    def default(self, v: Any) -> Any:
+        obj_type = v.__class__
+        encoder = default_encoders.get(obj_type)
+        if encoder:
+            return encoder(v)
+
+        return json.JSONEncoder.default(self, v)
+
+
+def iterdecode(
+    f: BinaryIO,
+    tag_hook: Callable[[CBORDecoder, CBORTag], Any] | None = None,
+    object_hook: Callable[[CBORDecoder, dict[Any, Any]], Any] | None = None,
+    str_errors: Literal["strict", "error", "replace"] = "strict",
+) -> Iterator[Any]:
+    decoder = CBORDecoder(f, tag_hook=tag_hook, object_hook=object_hook, str_errors=str_errors)
+    while True:
+        try:
+            yield decoder.decode()
+        except EOFError:
+            return
+
+
+def key_to_str(d: T, dict_ids: set[int] | None = None) -> str | list[Any] | dict[str, Any] | T:
+    dict_ids = set(dict_ids or [])
+    rval: dict[str, Any] = {}
+    if not isinstance(d, dict):
+        if isinstance(d, CBORSimpleValue):
+            return f"cbor_simple:{d.value:d}"
+
+        if isinstance(d, (tuple, list, set)):
+            if id(d) in dict_ids:
+                raise ValueError("Cannot convert self-referential data to JSON")
+            else:
+                dict_ids.add(id(d))
+
+            v = [key_to_str(x, dict_ids) for x in d]
+            dict_ids.remove(id(d))
+            return v
+        else:
+            return d
+
+    if id(d) in dict_ids:
+        raise ValueError("Cannot convert self-referential data to JSON")
+    else:
+        dict_ids.add(id(d))
+
+    for k, v in d.items():
+        if isinstance(k, bytes):
+            k = k.decode(encoding="utf-8", errors="backslashreplace")
+        elif isinstance(k, CBORSimpleValue):
+            k = f"cbor_simple:{k.value:d}"
+        elif isinstance(k, (FrozenDict, frozenset, tuple)):
+            k = str(k)
+
+        if isinstance(v, dict):
+            v = key_to_str(v, dict_ids)
+        elif isinstance(v, (tuple, list, set)):
+            v = [key_to_str(x, dict_ids) for x in v]
+
+        rval[k] = v
+
+    return rval
+
+
+def main() -> None:
+    prog = "python -m cbor2.tool"
+    description = (
+        "A simple command line interface for cbor2 module "
+        "to validate and pretty-print CBOR objects."
+    )
+    parser = argparse.ArgumentParser(prog=prog, description=description)
+    parser.add_argument("-o", "--outfile", type=str, help="output file", default="-")
+    parser.add_argument(
+        "infiles",
+        nargs="*",
+        default=["-"],
+        help="Collection of CBOR files to process or - for stdin",
+    )
+    parser.add_argument(
+        "-k",
+        "--sort-keys",
+        action="store_true",
+        default=False,
+        help="sort the output of dictionaries alphabetically by key",
+    )
+    parser.add_argument(
+        "-p",
+        "--pretty",
+        action="store_true",
+        default=False,
+        help="indent the output to look good",
+    )
+    parser.add_argument(
+        "-s",
+        "--sequence",
+        action="store_true",
+        default=False,
+        help="Parse a sequence of concatenated CBOR items",
+    )
+    parser.add_argument(
+        "-d",
+        "--decode",
+        action="store_true",
+        default=False,
+        help="CBOR data is base64 encoded (handy for stdin)",
+    )
+    parser.add_argument(
+        "-i",
+        "--tag-ignore",
+        type=str,
+        default="",
+        help="Comma separated list of tags to ignore and only return the value",
+    )
+    options = parser.parse_args()
+
+    if options.outfile == "-":
+        outfile = 1
+        closefd = False
+    else:
+        outfile = options.outfile
+        closefd = True
+
+    ignore_s = options.tag_ignore.split(",")
+    droptags = {int(n) for n in ignore_s if (len(n) and n[0].isdigit())}
+    my_hook = partial(tag_hook, ignore_tags=droptags)
+
+    with open(
+        outfile, mode="w", encoding="utf-8", errors="backslashreplace", closefd=closefd
+    ) as outfp:
+        for path in options.infiles:
+            with ExitStack() as stack:
+                if path == "-":
+                    infile: BinaryIO = sys.stdin.buffer
+                else:
+                    infile = stack.enter_context(open(path, mode="rb"))
+
+                if options.decode:
+                    infile = io.BytesIO(base64.b64decode(infile.read()))
+
+                try:
+                    if options.sequence:
+                        objs: Iterable[Any] = iterdecode(infile, tag_hook=my_hook)
+                    else:
+                        objs = (load(infile, tag_hook=my_hook),)
+
+                    for obj in objs:
+                        json.dump(
+                            key_to_str(obj),
+                            outfp,
+                            sort_keys=options.sort_keys,
+                            indent=(None, 4)[options.pretty],
+                            cls=DefaultEncoder,
+                            ensure_ascii=False,
+                        )
+                        outfp.write("\n")
+                except (ValueError, EOFError) as e:  # pragma: no cover
+                    raise SystemExit(e)
+
+
+if __name__ == "__main__":  # pragma: no cover
+    main()

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

@@ -0,0 +1,24 @@
+# Copyright (c) 2021 - present / Neuralmagic, Inc. All Rights Reserved.
+#
+# 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.
+
+# flake8: noqa
+# isort: off
+from .logger import LoggerConfig, configure_logger, logger
+from .base import *
+
+from .compressors import *
+from .config import *
+from .quantization import QuantizationConfig, QuantizationStatus
+from .utils import *
+from .version import *

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

@@ -0,0 +1,25 @@
+# Copyright (c) 2021 - present / Neuralmagic, Inc. All Rights Reserved.
+#
+# 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.
+
+# configs
+QUANTIZATION_CONFIG_NAME = "quantization_config"
+SPARSITY_CONFIG_NAME = "sparsity_config"
+TRANSFORM_CONFIG_NAME = "transform_config"
+
+# required fields
+COMPRESSION_VERSION_NAME = "version"
+QUANTIZATION_METHOD_NAME = "quant_method"
+
+# auxillary configs
+KV_CACHE_SCHEME_NAME = "kv_cache_scheme"

lib/python3.13/site-packages/compressed_tensors/version.py

@@ -0,0 +1,21 @@
+# file generated by setuptools-scm
+# don't change, don't track in version control
+
+__all__ = ["__version__", "__version_tuple__", "version", "version_tuple"]
+
+TYPE_CHECKING = False
+if TYPE_CHECKING:
+    from typing import Tuple
+    from typing import Union
+
+    VERSION_TUPLE = Tuple[Union[int, str], ...]
+else:
+    VERSION_TUPLE = object
+
+version: str
+__version__: str
+__version_tuple__: VERSION_TUPLE
+version_tuple: VERSION_TUPLE
+
+__version__ = version = '0.12.2'
+__version_tuple__ = version_tuple = (0, 12, 2)

lib/python3.13/site-packages/gguf-0.17.1.dist-info/METADATA

@@ -0,0 +1,126 @@
+Metadata-Version: 2.3
+Name: gguf
+Version: 0.17.1
+Summary: Read and write ML models in GGUF for GGML
+Keywords: ggml,gguf,llama.cpp
+Author: GGML
+Author-email: ggml@ggml.ai
+Requires-Python: >=3.8
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+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.13
+Provides-Extra: gui
+Requires-Dist: PySide6 (>=6.9,<7.0) ; (python_version >= "3.9" and python_version < "3.14") and (extra == "gui")
+Requires-Dist: numpy (>=1.17)
+Requires-Dist: pyyaml (>=5.1)
+Requires-Dist: tqdm (>=4.27)
+Project-URL: Homepage, https://ggml.ai
+Project-URL: Repository, https://github.com/ggml-org/llama.cpp
+Description-Content-Type: text/markdown
+
+## gguf
+
+This is a Python package for writing binary files in the [GGUF](https://github.com/ggml-org/ggml/pull/302)
+(GGML Universal File) format.
+
+See [convert_hf_to_gguf.py](https://github.com/ggml-org/llama.cpp/blob/master/convert_hf_to_gguf.py)
+as an example for its usage.
+
+## Installation
+```sh
+pip install gguf
+```
+
+Optionally, you can install gguf with the extra 'gui' to enable the visual GGUF editor.
+```sh
+pip install gguf[gui]
+```
+
+## API Examples/Simple Tools
+
+[examples/writer.py](https://github.com/ggml-org/llama.cpp/blob/master/gguf-py/examples/writer.py) — Generates `example.gguf` in the current directory to demonstrate generating a GGUF file. Note that this file cannot be used as a model.
+
+[examples/reader.py](https://github.com/ggml-org/llama.cpp/blob/master/gguf-py/examples/reader.py) — Extracts and displays key-value pairs and tensor details from a GGUF file in a readable format.
+
+[gguf/scripts/gguf_dump.py](https://github.com/ggml-org/llama.cpp/blob/master/gguf-py/gguf/scripts/gguf_dump.py) — Dumps a GGUF file's metadata to the console.
+
+[gguf/scripts/gguf_set_metadata.py](https://github.com/ggml-org/llama.cpp/blob/master/gguf-py/gguf/scripts/gguf_set_metadata.py) — Allows changing simple metadata values in a GGUF file by key.
+
+[gguf/scripts/gguf_convert_endian.py](https://github.com/ggml-org/llama.cpp/blob/master/gguf-py/gguf/scripts/gguf_convert_endian.py) — Allows converting the endianness of GGUF files.
+
+[gguf/scripts/gguf_new_metadata.py](https://github.com/ggml-org/llama.cpp/blob/master/gguf-py/gguf/scripts/gguf_new_metadata.py) — Copies a GGUF file with added/modified/removed metadata values.
+
+[gguf/scripts/gguf_editor_gui.py](https://github.com/ggml-org/llama.cpp/blob/master/gguf-py/gguf/scripts/gguf_editor_gui.py) — Allows for viewing, editing, adding, or removing metadata values within a GGUF file as well as viewing its tensors with a Qt interface.
+
+## Development
+Maintainers who participate in development of this package are advised to install it in editable mode:
+
+```sh
+cd /path/to/llama.cpp/gguf-py
+
+pip install --editable .
+```
+
+**Note**: This may require to upgrade your Pip installation, with a message saying that editable installation currently requires `setup.py`.
+In this case, upgrade Pip to the latest:
+
+```sh
+pip install --upgrade pip
+```
+
+## Automatic publishing with CI
+
+There's a GitHub workflow to make a release automatically upon creation of tags in a specified format.
+
+1. Bump the version in `pyproject.toml`.
+2. Create a tag named `gguf-vx.x.x` where `x.x.x` is the semantic version number.
+
+```sh
+git tag -a gguf-v1.0.0 -m "Version 1.0 release"
+```
+
+3. Push the tags.
+
+```sh
+git push origin --tags
+```
+
+## Manual publishing
+If you want to publish the package manually for any reason, you need to have `twine` and `build` installed:
+
+```sh
+pip install build twine
+```
+
+Then, follow these steps to release a new version:
+
+1. Bump the version in `pyproject.toml`.
+2. Build the package:
+
+```sh
+python -m build
+```
+
+3. Upload the generated distribution archives:
+
+```sh
+python -m twine upload dist/*
+```
+
+## Run Unit Tests
+
+From root of this repository you can run this command to run all the unit tests
+
+```bash
+python -m unittest discover ./gguf-py -v
+```
+
+## TODO
+- [ ] Include conversion scripts as command line entry points in this package.
+

lib/python3.13/site-packages/gguf-0.17.1.dist-info/RECORD

@@ -0,0 +1,30 @@
+../../../bin/gguf-convert-endian,sha256=KWQjuTB8W9HMQqqDz-ZYz13lGkLJV1cIUim-UX13AAk,349
+../../../bin/gguf-dump,sha256=wgEgvSuu87waf4U74j3BCznoPNd4dvCopDBiUu1J89M,339
+../../../bin/gguf-editor-gui,sha256=UTmG8PiG7PnRfTQq2J6C_St3s34xcVC69J9fSpadRQQ,345
+../../../bin/gguf-new-metadata,sha256=UiWeY0bXQillsPq7hhB7016oxU39tpYDBJywzeXeBD0,347
+../../../bin/gguf-set-metadata,sha256=-OEPULN-7WJyXv1-9NgsBqz6Rq0KvW7RnNbCSHTpTQg,347
+gguf-0.17.1.dist-info/INSTALLER,sha256=5hhM4Q4mYTT9z6QB6PGpUAW81PGNFrYrdXMj4oM_6ak,2
+gguf-0.17.1.dist-info/LICENSE,sha256=73jH5mWeNMeYGU8NNE6AfHIt5wy8oTWe9UdyZh4Ryjg,1072
+gguf-0.17.1.dist-info/METADATA,sha256=pa8_ce5ufoWKHq1zzh97He53EZjFtRFONFDWtl7mkAI,4348
+gguf-0.17.1.dist-info/RECORD,,
+gguf-0.17.1.dist-info/REQUESTED,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+gguf-0.17.1.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
+gguf-0.17.1.dist-info/entry_points.txt,sha256=TozYSFmMxpOaKE3brn9nWp-QkgM_sZ3a_uFDOXUCYig,273
+gguf/__init__.py,sha256=PM_AEEzX6ojGAodDt78_LIm19HRCXeA6IXpgcjINfC8,219
+gguf/constants.py,sha256=-92nfNa8XjXbHsMV9Hf0iGHwcmoXzH2JJ73rAv73NPE,89508
+gguf/gguf.py,sha256=8MDu7a0JEXhLUv_tjhYqDrWubVNc41cFvBYZbkZZenI,478
+gguf/gguf_reader.py,sha256=6uI4vaLeRC2MJV-uUjgsRoUZ-Rdszi8mE_bEPwnk6QE,14828
+gguf/gguf_writer.py,sha256=UJXqFa3T2EOLfPZ6ej3vuyV7OBfKXXaszvHKeHIWmSI,43935
+gguf/lazy.py,sha256=Axy_plbHoC34nMeK_ORbbxEyEFm-Fz8BxFIeqeipSYA,9214
+gguf/metadata.py,sha256=v0kxoYfCk_yXZSnzlSO9AhQ6z_HOUpzs0c6ZV4BRSbA,33301
+gguf/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+gguf/quants.py,sha256=BLtCCqhHBtabaYaAp7EckyYOR5idmoKWhu_Hy3glotk,60771
+gguf/scripts/gguf_convert_endian.py,sha256=yzl_MAQ3jyn_9MmOWV1CksHqlohd7DmrG7REwas0rlo,7365
+gguf/scripts/gguf_dump.py,sha256=zDgZSSQLyO3S4YJsSUzdebDfwmdqQPN7_VtFZ5BkGAk,21785
+gguf/scripts/gguf_editor_gui.py,sha256=frdErSIB90N-sAvqUpbLfdDsaUGMMOWQ-0iumwzzm_M,64398
+gguf/scripts/gguf_hash.py,sha256=nyd8kzjRKnOFek5UaD19pNXeAVMXUfFEASZ8konkGX8,3725
+gguf/scripts/gguf_new_metadata.py,sha256=U_v5FgbH292x7bsi2dG4rbQcWc14nmAtZEWdLnbkIZs,9767
+gguf/scripts/gguf_set_metadata.py,sha256=yGEqcQlCimd-pVl23V7u1giJNN3vfvASRqW8em5YWzs,4145
+gguf/tensor_mapping.py,sha256=6pUDYgly0-yErLV8HSZFSnqyFKAp7SieditMEHMsYGI,55999
+gguf/utility.py,sha256=80rZ3MdGZ6bX0_yFvLoPTTOlxga8THcihF0q38y5h6M,10808
+gguf/vocab.py,sha256=Gr43idKqc4yBHQh20HfeW9oegYWLpM-L0ZKCVxPj4Lc,20788

lib/python3.13/site-packages/gguf-0.17.1.dist-info/WHEEL

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

lib/python3.13/site-packages/gguf-0.17.1.dist-info/entry_points.txt

@@ -0,0 +1,7 @@
+[console_scripts]
+gguf-convert-endian=gguf.scripts.gguf_convert_endian:main
+gguf-dump=gguf.scripts.gguf_dump:main
+gguf-editor-gui=gguf.scripts.gguf_editor_gui:main
+gguf-new-metadata=gguf.scripts.gguf_new_metadata:main
+gguf-set-metadata=gguf.scripts.gguf_set_metadata:main
+

lib/python3.13/site-packages/huggingface_hub/lfs.py

@@ -0,0 +1,466 @@
+# coding=utf-8
+# Copyright 2019-present, the HuggingFace Inc. team.
+#
+# 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.
+"""Git LFS related type definitions and utilities"""
+
+import inspect
+import io
+import re
+import warnings
+from dataclasses import dataclass
+from math import ceil
+from os.path import getsize
+from pathlib import Path
+from typing import TYPE_CHECKING, BinaryIO, Dict, Iterable, List, Optional, Tuple, TypedDict
+from urllib.parse import unquote
+
+from huggingface_hub import constants
+
+from .utils import (
+    build_hf_headers,
+    fix_hf_endpoint_in_url,
+    get_session,
+    hf_raise_for_status,
+    http_backoff,
+    logging,
+    tqdm,
+    validate_hf_hub_args,
+)
+from .utils._lfs import SliceFileObj
+from .utils.sha import sha256, sha_fileobj
+from .utils.tqdm import is_tqdm_disabled
+
+
+if TYPE_CHECKING:
+    from ._commit_api import CommitOperationAdd
+
+logger = logging.get_logger(__name__)
+
+OID_REGEX = re.compile(r"^[0-9a-f]{40}$")
+
+LFS_MULTIPART_UPLOAD_COMMAND = "lfs-multipart-upload"
+
+LFS_HEADERS = {
+    "Accept": "application/vnd.git-lfs+json",
+    "Content-Type": "application/vnd.git-lfs+json",
+}
+
+
+@dataclass
+class UploadInfo:
+    """
+    Dataclass holding required information to determine whether a blob
+    should be uploaded to the hub using the LFS protocol or the regular protocol
+
+    Args:
+        sha256 (`bytes`):
+            SHA256 hash of the blob
+        size (`int`):
+            Size in bytes of the blob
+        sample (`bytes`):
+            First 512 bytes of the blob
+    """
+
+    sha256: bytes
+    size: int
+    sample: bytes
+
+    @classmethod
+    def from_path(cls, path: str):
+        size = getsize(path)
+        with io.open(path, "rb") as file:
+            sample = file.peek(512)[:512]
+            sha = sha_fileobj(file)
+        return cls(size=size, sha256=sha, sample=sample)
+
+    @classmethod
+    def from_bytes(cls, data: bytes):
+        sha = sha256(data).digest()
+        return cls(size=len(data), sample=data[:512], sha256=sha)
+
+    @classmethod
+    def from_fileobj(cls, fileobj: BinaryIO):
+        sample = fileobj.read(512)
+        fileobj.seek(0, io.SEEK_SET)
+        sha = sha_fileobj(fileobj)
+        size = fileobj.tell()
+        fileobj.seek(0, io.SEEK_SET)
+        return cls(size=size, sha256=sha, sample=sample)
+
+
+@validate_hf_hub_args
+def post_lfs_batch_info(
+    upload_infos: Iterable[UploadInfo],
+    token: Optional[str],
+    repo_type: str,
+    repo_id: str,
+    revision: Optional[str] = None,
+    endpoint: Optional[str] = None,
+    headers: Optional[Dict[str, str]] = None,
+    transfers: Optional[List[str]] = None,
+) -> Tuple[List[dict], List[dict], Optional[str]]:
+    """
+    Requests the LFS batch endpoint to retrieve upload instructions
+
+    Learn more: https://github.com/git-lfs/git-lfs/blob/main/docs/api/batch.md
+
+    Args:
+        upload_infos (`Iterable` of `UploadInfo`):
+            `UploadInfo` for the files that are being uploaded, typically obtained
+            from `CommitOperationAdd.upload_info`
+        repo_type (`str`):
+            Type of the repo to upload to: `"model"`, `"dataset"` or `"space"`.
+        repo_id (`str`):
+            A namespace (user or an organization) and a repo name separated
+            by a `/`.
+        revision (`str`, *optional*):
+            The git revision to upload to.
+        headers (`dict`, *optional*):
+            Additional headers to include in the request
+        transfers (`list`, *optional*):
+            List of transfer methods to use. Defaults to ["basic", "multipart"].
+
+    Returns:
+        `LfsBatchInfo`: 3-tuple:
+            - First element is the list of upload instructions from the server
+            - Second element is a list of errors, if any
+            - Third element is the chosen transfer adapter if provided by the server (e.g. "basic", "multipart", "xet")
+
+    Raises:
+        [`ValueError`](https://docs.python.org/3/library/exceptions.html#ValueError)
+            If an argument is invalid or the server response is malformed.
+        [`HTTPError`](https://requests.readthedocs.io/en/latest/api/#requests.HTTPError)
+            If the server returned an error.
+    """
+    endpoint = endpoint if endpoint is not None else constants.ENDPOINT
+    url_prefix = ""
+    if repo_type in constants.REPO_TYPES_URL_PREFIXES:
+        url_prefix = constants.REPO_TYPES_URL_PREFIXES[repo_type]
+    batch_url = f"{endpoint}/{url_prefix}{repo_id}.git/info/lfs/objects/batch"
+    payload: Dict = {
+        "operation": "upload",
+        "transfers": transfers if transfers is not None else ["basic", "multipart"],
+        "objects": [
+            {
+                "oid": upload.sha256.hex(),
+                "size": upload.size,
+            }
+            for upload in upload_infos
+        ],
+        "hash_algo": "sha256",
+    }
+    if revision is not None:
+        payload["ref"] = {"name": unquote(revision)}  # revision has been previously 'quoted'
+
+    headers = {
+        **LFS_HEADERS,
+        **build_hf_headers(token=token),
+        **(headers or {}),
+    }
+    resp = get_session().post(batch_url, headers=headers, json=payload)
+    hf_raise_for_status(resp)
+    batch_info = resp.json()
+
+    objects = batch_info.get("objects", None)
+    if not isinstance(objects, list):
+        raise ValueError("Malformed response from server")
+
+    chosen_transfer = batch_info.get("transfer")
+    chosen_transfer = chosen_transfer if isinstance(chosen_transfer, str) else None
+
+    return (
+        [_validate_batch_actions(obj) for obj in objects if "error" not in obj],
+        [_validate_batch_error(obj) for obj in objects if "error" in obj],
+        chosen_transfer,
+    )
+
+
+class PayloadPartT(TypedDict):
+    partNumber: int
+    etag: str
+
+
+class CompletionPayloadT(TypedDict):
+    """Payload that will be sent to the Hub when uploading multi-part."""
+
+    oid: str
+    parts: List[PayloadPartT]
+
+
+def lfs_upload(
+    operation: "CommitOperationAdd",
+    lfs_batch_action: Dict,
+    token: Optional[str] = None,
+    headers: Optional[Dict[str, str]] = None,
+    endpoint: Optional[str] = None,
+) -> None:
+    """
+    Handles uploading a given object to the Hub with the LFS protocol.
+
+    Can be a No-op if the content of the file is already present on the hub large file storage.
+
+    Args:
+        operation (`CommitOperationAdd`):
+            The add operation triggering this upload.
+        lfs_batch_action (`dict`):
+            Upload instructions from the LFS batch endpoint for this object. See [`~utils.lfs.post_lfs_batch_info`] for
+            more details.
+        headers (`dict`, *optional*):
+            Headers to include in the request, including authentication and user agent headers.
+
+    Raises:
+        [`ValueError`](https://docs.python.org/3/library/exceptions.html#ValueError)
+            If `lfs_batch_action` is improperly formatted
+        [`HTTPError`](https://requests.readthedocs.io/en/latest/api/#requests.HTTPError)
+            If the upload resulted in an error
+    """
+    # 0. If LFS file is already present, skip upload
+    _validate_batch_actions(lfs_batch_action)
+    actions = lfs_batch_action.get("actions")
+    if actions is None:
+        # The file was already uploaded
+        logger.debug(f"Content of file {operation.path_in_repo} is already present upstream - skipping upload")
+        return
+
+    # 1. Validate server response (check required keys in dict)
+    upload_action = lfs_batch_action["actions"]["upload"]
+    _validate_lfs_action(upload_action)
+    verify_action = lfs_batch_action["actions"].get("verify")
+    if verify_action is not None:
+        _validate_lfs_action(verify_action)
+
+    # 2. Upload file (either single part or multi-part)
+    header = upload_action.get("header", {})
+    chunk_size = header.get("chunk_size")
+    upload_url = fix_hf_endpoint_in_url(upload_action["href"], endpoint=endpoint)
+    if chunk_size is not None:
+        try:
+            chunk_size = int(chunk_size)
+        except (ValueError, TypeError):
+            raise ValueError(
+                f"Malformed response from LFS batch endpoint: `chunk_size` should be an integer. Got '{chunk_size}'."
+            )
+        _upload_multi_part(operation=operation, header=header, chunk_size=chunk_size, upload_url=upload_url)
+    else:
+        _upload_single_part(operation=operation, upload_url=upload_url)
+
+    # 3. Verify upload went well
+    if verify_action is not None:
+        _validate_lfs_action(verify_action)
+        verify_url = fix_hf_endpoint_in_url(verify_action["href"], endpoint)
+        verify_resp = get_session().post(
+            verify_url,
+            headers=build_hf_headers(token=token, headers=headers),
+            json={"oid": operation.upload_info.sha256.hex(), "size": operation.upload_info.size},
+        )
+        hf_raise_for_status(verify_resp)
+    logger.debug(f"{operation.path_in_repo}: Upload successful")
+
+
+def _validate_lfs_action(lfs_action: dict):
+    """validates response from the LFS batch endpoint"""
+    if not (
+        isinstance(lfs_action.get("href"), str)
+        and (lfs_action.get("header") is None or isinstance(lfs_action.get("header"), dict))
+    ):
+        raise ValueError("lfs_action is improperly formatted")
+    return lfs_action
+
+
+def _validate_batch_actions(lfs_batch_actions: dict):
+    """validates response from the LFS batch endpoint"""
+    if not (isinstance(lfs_batch_actions.get("oid"), str) and isinstance(lfs_batch_actions.get("size"), int)):
+        raise ValueError("lfs_batch_actions is improperly formatted")
+
+    upload_action = lfs_batch_actions.get("actions", {}).get("upload")
+    verify_action = lfs_batch_actions.get("actions", {}).get("verify")
+    if upload_action is not None:
+        _validate_lfs_action(upload_action)
+    if verify_action is not None:
+        _validate_lfs_action(verify_action)
+    return lfs_batch_actions
+
+
+def _validate_batch_error(lfs_batch_error: dict):
+    """validates response from the LFS batch endpoint"""
+    if not (isinstance(lfs_batch_error.get("oid"), str) and isinstance(lfs_batch_error.get("size"), int)):
+        raise ValueError("lfs_batch_error is improperly formatted")
+    error_info = lfs_batch_error.get("error")
+    if not (
+        isinstance(error_info, dict)
+        and isinstance(error_info.get("message"), str)
+        and isinstance(error_info.get("code"), int)
+    ):
+        raise ValueError("lfs_batch_error is improperly formatted")
+    return lfs_batch_error
+
+
+def _upload_single_part(operation: "CommitOperationAdd", upload_url: str) -> None:
+    """
+    Uploads `fileobj` as a single PUT HTTP request (basic LFS transfer protocol)
+
+    Args:
+        upload_url (`str`):
+            The URL to PUT the file to.
+        fileobj:
+            The file-like object holding the data to upload.
+
+    Returns: `requests.Response`
+
+    Raises:
+     [`HTTPError`](https://requests.readthedocs.io/en/latest/api/#requests.HTTPError)
+        If the upload resulted in an error.
+    """
+    with operation.as_file(with_tqdm=True) as fileobj:
+        # S3 might raise a transient 500 error -> let's retry if that happens
+        response = http_backoff("PUT", upload_url, data=fileobj)
+        hf_raise_for_status(response)
+
+
+def _upload_multi_part(operation: "CommitOperationAdd", header: Dict, chunk_size: int, upload_url: str) -> None:
+    """
+    Uploads file using HF multipart LFS transfer protocol.
+    """
+    # 1. Get upload URLs for each part
+    sorted_parts_urls = _get_sorted_parts_urls(header=header, upload_info=operation.upload_info, chunk_size=chunk_size)
+
+    # 2. Upload parts (either with hf_transfer or in pure Python)
+    use_hf_transfer = constants.HF_HUB_ENABLE_HF_TRANSFER
+    if (
+        constants.HF_HUB_ENABLE_HF_TRANSFER
+        and not isinstance(operation.path_or_fileobj, str)
+        and not isinstance(operation.path_or_fileobj, Path)
+    ):
+        warnings.warn(
+            "hf_transfer is enabled but does not support uploading from bytes or BinaryIO, falling back to regular"
+            " upload"
+        )
+        use_hf_transfer = False
+
+    response_headers = (
+        _upload_parts_hf_transfer(operation=operation, sorted_parts_urls=sorted_parts_urls, chunk_size=chunk_size)
+        if use_hf_transfer
+        else _upload_parts_iteratively(operation=operation, sorted_parts_urls=sorted_parts_urls, chunk_size=chunk_size)
+    )
+
+    # 3. Send completion request
+    completion_res = get_session().post(
+        upload_url,
+        json=_get_completion_payload(response_headers, operation.upload_info.sha256.hex()),
+        headers=LFS_HEADERS,
+    )
+    hf_raise_for_status(completion_res)
+
+
+def _get_sorted_parts_urls(header: Dict, upload_info: UploadInfo, chunk_size: int) -> List[str]:
+    sorted_part_upload_urls = [
+        upload_url
+        for _, upload_url in sorted(
+            [
+                (int(part_num, 10), upload_url)
+                for part_num, upload_url in header.items()
+                if part_num.isdigit() and len(part_num) > 0
+            ],
+            key=lambda t: t[0],
+        )
+    ]
+    num_parts = len(sorted_part_upload_urls)
+    if num_parts != ceil(upload_info.size / chunk_size):
+        raise ValueError("Invalid server response to upload large LFS file")
+    return sorted_part_upload_urls
+
+
+def _get_completion_payload(response_headers: List[Dict], oid: str) -> CompletionPayloadT:
+    parts: List[PayloadPartT] = []
+    for part_number, header in enumerate(response_headers):
+        etag = header.get("etag")
+        if etag is None or etag == "":
+            raise ValueError(f"Invalid etag (`{etag}`) returned for part {part_number + 1}")
+        parts.append(
+            {
+                "partNumber": part_number + 1,
+                "etag": etag,
+            }
+        )
+    return {"oid": oid, "parts": parts}
+
+
+def _upload_parts_iteratively(
+    operation: "CommitOperationAdd", sorted_parts_urls: List[str], chunk_size: int
+) -> List[Dict]:
+    headers = []
+    with operation.as_file(with_tqdm=True) as fileobj:
+        for part_idx, part_upload_url in enumerate(sorted_parts_urls):
+            with SliceFileObj(
+                fileobj,
+                seek_from=chunk_size * part_idx,
+                read_limit=chunk_size,
+            ) as fileobj_slice:
+                # S3 might raise a transient 500 error -> let's retry if that happens
+                part_upload_res = http_backoff("PUT", part_upload_url, data=fileobj_slice)
+                hf_raise_for_status(part_upload_res)
+                headers.append(part_upload_res.headers)
+    return headers  # type: ignore
+
+
+def _upload_parts_hf_transfer(
+    operation: "CommitOperationAdd", sorted_parts_urls: List[str], chunk_size: int
+) -> List[Dict]:
+    # Upload file using an external Rust-based package. Upload is faster but support less features (no progress bars).
+    try:
+        from hf_transfer import multipart_upload
+    except ImportError:
+        raise ValueError(
+            "Fast uploading using 'hf_transfer' is enabled (HF_HUB_ENABLE_HF_TRANSFER=1) but 'hf_transfer' package is"
+            " not available in your environment. Try `pip install hf_transfer`."
+        )
+
+    supports_callback = "callback" in inspect.signature(multipart_upload).parameters
+    if not supports_callback:
+        warnings.warn(
+            "You are using an outdated version of `hf_transfer`. Consider upgrading to latest version to enable progress bars using `pip install -U hf_transfer`."
+        )
+
+    total = operation.upload_info.size
+    desc = operation.path_in_repo
+    if len(desc) > 40:
+        desc = f"(…){desc[-40:]}"
+
+    with tqdm(
+        unit="B",
+        unit_scale=True,
+        total=total,
+        initial=0,
+        desc=desc,
+        disable=is_tqdm_disabled(logger.getEffectiveLevel()),
+        name="huggingface_hub.lfs_upload",
+    ) as progress:
+        try:
+            output = multipart_upload(
+                file_path=operation.path_or_fileobj,
+                parts_urls=sorted_parts_urls,
+                chunk_size=chunk_size,
+                max_files=128,
+                parallel_failures=127,  # could be removed
+                max_retries=5,
+                **({"callback": progress.update} if supports_callback else {}),
+            )
+        except Exception as e:
+            raise RuntimeError(
+                "An error occurred while uploading using `hf_transfer`. Consider disabling HF_HUB_ENABLE_HF_TRANSFER for"
+                " better error handling."
+            ) from e
+        if not supports_callback:
+            progress.update(total)
+        return output

lib/python3.13/site-packages/huggingface_hub/repocard.py

@@ -0,0 +1,827 @@
+import os
+import re
+from pathlib import Path
+from typing import Any, Dict, Literal, Optional, Type, Union
+
+import requests
+import yaml
+
+from huggingface_hub.file_download import hf_hub_download
+from huggingface_hub.hf_api import upload_file
+from huggingface_hub.repocard_data import (
+    CardData,
+    DatasetCardData,
+    EvalResult,
+    ModelCardData,
+    SpaceCardData,
+    eval_results_to_model_index,
+    model_index_to_eval_results,
+)
+from huggingface_hub.utils import get_session, is_jinja_available, yaml_dump
+
+from . import constants
+from .errors import EntryNotFoundError
+from .utils import SoftTemporaryDirectory, logging, validate_hf_hub_args
+
+
+logger = logging.get_logger(__name__)
+
+
+TEMPLATE_MODELCARD_PATH = Path(__file__).parent / "templates" / "modelcard_template.md"
+TEMPLATE_DATASETCARD_PATH = Path(__file__).parent / "templates" / "datasetcard_template.md"
+
+# exact same regex as in the Hub server. Please keep in sync.
+# See https://github.com/huggingface/moon-landing/blob/main/server/lib/ViewMarkdown.ts#L18
+REGEX_YAML_BLOCK = re.compile(r"^(\s*---[\r\n]+)([\S\s]*?)([\r\n]+---(\r\n|\n|$))")
+
+
+class RepoCard:
+    card_data_class = CardData
+    default_template_path = TEMPLATE_MODELCARD_PATH
+    repo_type = "model"
+
+    def __init__(self, content: str, ignore_metadata_errors: bool = False):
+        """Initialize a RepoCard from string content. The content should be a
+        Markdown file with a YAML block at the beginning and a Markdown body.
+
+        Args:
+            content (`str`): The content of the Markdown file.
+
+        Example:
+            ```python
+            >>> from huggingface_hub.repocard import RepoCard
+            >>> text = '''
+            ... ---
+            ... language: en
+            ... license: mit
+            ... ---
+            ...
+            ... # My repo
+            ... '''
+            >>> card = RepoCard(text)
+            >>> card.data.to_dict()
+            {'language': 'en', 'license': 'mit'}
+            >>> card.text
+            '\\n# My repo\\n'
+
+            ```
+        > [!TIP]
+        > Raises the following error:
+        >
+        >     - [`ValueError`](https://docs.python.org/3/library/exceptions.html#ValueError)
+        >       when the content of the repo card metadata is not a dictionary.
+        """
+
+        # Set the content of the RepoCard, as well as underlying .data and .text attributes.
+        # See the `content` property setter for more details.
+        self.ignore_metadata_errors = ignore_metadata_errors
+        self.content = content
+
+    @property
+    def content(self):
+        """The content of the RepoCard, including the YAML block and the Markdown body."""
+        line_break = _detect_line_ending(self._content) or "\n"
+        return f"---{line_break}{self.data.to_yaml(line_break=line_break, original_order=self._original_order)}{line_break}---{line_break}{self.text}"
+
+    @content.setter
+    def content(self, content: str):
+        """Set the content of the RepoCard."""
+        self._content = content
+
+        match = REGEX_YAML_BLOCK.search(content)
+        if match:
+            # Metadata found in the YAML block
+            yaml_block = match.group(2)
+            self.text = content[match.end() :]
+            data_dict = yaml.safe_load(yaml_block)
+
+            if data_dict is None:
+                data_dict = {}
+
+            # The YAML block's data should be a dictionary
+            if not isinstance(data_dict, dict):
+                raise ValueError("repo card metadata block should be a dict")
+        else:
+            # Model card without metadata... create empty metadata
+            logger.warning("Repo card metadata block was not found. Setting CardData to empty.")
+            data_dict = {}
+            self.text = content
+
+        self.data = self.card_data_class(**data_dict, ignore_metadata_errors=self.ignore_metadata_errors)
+        self._original_order = list(data_dict.keys())
+
+    def __str__(self):
+        return self.content
+
+    def save(self, filepath: Union[Path, str]):
+        r"""Save a RepoCard to a file.
+
+        Args:
+            filepath (`Union[Path, str]`): Filepath to the markdown file to save.
+
+        Example:
+            ```python
+            >>> from huggingface_hub.repocard import RepoCard
+            >>> card = RepoCard("---\nlanguage: en\n---\n# This is a test repo card")
+            >>> card.save("/tmp/test.md")
+
+            ```
+        """
+        filepath = Path(filepath)
+        filepath.parent.mkdir(parents=True, exist_ok=True)
+        # Preserve newlines as in the existing file.
+        with open(filepath, mode="w", newline="", encoding="utf-8") as f:
+            f.write(str(self))
+
+    @classmethod
+    def load(
+        cls,
+        repo_id_or_path: Union[str, Path],
+        repo_type: Optional[str] = None,
+        token: Optional[str] = None,
+        ignore_metadata_errors: bool = False,
+    ):
+        """Initialize a RepoCard from a Hugging Face Hub repo's README.md or a local filepath.
+
+        Args:
+            repo_id_or_path (`Union[str, Path]`):
+                The repo ID associated with a Hugging Face Hub repo or a local filepath.
+            repo_type (`str`, *optional*):
+                The type of Hugging Face repo to push to. Defaults to None, which will use use "model". Other options
+                are "dataset" and "space". Not used when loading from a local filepath. If this is called from a child
+                class, the default value will be the child class's `repo_type`.
+            token (`str`, *optional*):
+                Authentication token, obtained with `huggingface_hub.HfApi.login` method. Will default to the stored token.
+            ignore_metadata_errors (`str`):
+                If True, errors while parsing the metadata section will be ignored. Some information might be lost during
+                the process. Use it at your own risk.
+
+        Returns:
+            [`huggingface_hub.repocard.RepoCard`]: The RepoCard (or subclass) initialized from the repo's
+                README.md file or filepath.
+
+        Example:
+            ```python
+            >>> from huggingface_hub.repocard import RepoCard
+            >>> card = RepoCard.load("nateraw/food")
+            >>> assert card.data.tags == ["generated_from_trainer", "image-classification", "pytorch"]
+
+            ```
+        """
+
+        if Path(repo_id_or_path).is_file():
+            card_path = Path(repo_id_or_path)
+        elif isinstance(repo_id_or_path, str):
+            card_path = Path(
+                hf_hub_download(
+                    repo_id_or_path,
+                    constants.REPOCARD_NAME,
+                    repo_type=repo_type or cls.repo_type,
+                    token=token,
+                )
+            )
+        else:
+            raise ValueError(f"Cannot load RepoCard: path not found on disk ({repo_id_or_path}).")
+
+        # Preserve newlines in the existing file.
+        with card_path.open(mode="r", newline="", encoding="utf-8") as f:
+            return cls(f.read(), ignore_metadata_errors=ignore_metadata_errors)
+
+    def validate(self, repo_type: Optional[str] = None):
+        """Validates card against Hugging Face Hub's card validation logic.
+        Using this function requires access to the internet, so it is only called
+        internally by [`huggingface_hub.repocard.RepoCard.push_to_hub`].
+
+        Args:
+            repo_type (`str`, *optional*, defaults to "model"):
+                The type of Hugging Face repo to push to. Options are "model", "dataset", and "space".
+                If this function is called from a child class, the default will be the child class's `repo_type`.
+
+        > [!TIP]
+        > Raises the following errors:
+        >
+        >     - [`ValueError`](https://docs.python.org/3/library/exceptions.html#ValueError)
+        >       if the card fails validation checks.
+        >     - [`HTTPError`](https://requests.readthedocs.io/en/latest/api/#requests.HTTPError)
+        >       if the request to the Hub API fails for any other reason.
+        """
+
+        # If repo type is provided, otherwise, use the repo type of the card.
+        repo_type = repo_type or self.repo_type
+
+        body = {
+            "repoType": repo_type,
+            "content": str(self),
+        }
+        headers = {"Accept": "text/plain"}
+
+        try:
+            r = get_session().post("https://huggingface.co/api/validate-yaml", body, headers=headers)
+            r.raise_for_status()
+        except requests.exceptions.HTTPError as exc:
+            if r.status_code == 400:
+                raise ValueError(r.text)
+            else:
+                raise exc
+
+    def push_to_hub(
+        self,
+        repo_id: str,
+        token: Optional[str] = None,
+        repo_type: Optional[str] = None,
+        commit_message: Optional[str] = None,
+        commit_description: Optional[str] = None,
+        revision: Optional[str] = None,
+        create_pr: Optional[bool] = None,
+        parent_commit: Optional[str] = None,
+    ):
+        """Push a RepoCard to a Hugging Face Hub repo.
+
+        Args:
+            repo_id (`str`):
+                The repo ID of the Hugging Face Hub repo to push to. Example: "nateraw/food".
+            token (`str`, *optional*):
+                Authentication token, obtained with `huggingface_hub.HfApi.login` method. Will default to
+                the stored token.
+            repo_type (`str`, *optional*, defaults to "model"):
+                The type of Hugging Face repo to push to. Options are "model", "dataset", and "space". If this
+                function is called by a child class, it will default to the child class's `repo_type`.
+            commit_message (`str`, *optional*):
+                The summary / title / first line of the generated commit.
+            commit_description (`str`, *optional*)
+                The description of the generated commit.
+            revision (`str`, *optional*):
+                The git revision to commit from. Defaults to the head of the `"main"` branch.
+            create_pr (`bool`, *optional*):
+                Whether or not to create a Pull Request with this commit. Defaults to `False`.
+            parent_commit (`str`, *optional*):
+                The OID / SHA of the parent commit, as a hexadecimal string. Shorthands (7 first characters) are also supported.
+                If specified and `create_pr` is `False`, the commit will fail if `revision` does not point to `parent_commit`.
+                If specified and `create_pr` is `True`, the pull request will be created from `parent_commit`.
+                Specifying `parent_commit` ensures the repo has not changed before committing the changes, and can be
+                especially useful if the repo is updated / committed to concurrently.
+        Returns:
+            `str`: URL of the commit which updated the card metadata.
+        """
+
+        # If repo type is provided, otherwise, use the repo type of the card.
+        repo_type = repo_type or self.repo_type
+
+        # Validate card before pushing to hub
+        self.validate(repo_type=repo_type)
+
+        with SoftTemporaryDirectory() as tmpdir:
+            tmp_path = Path(tmpdir) / constants.REPOCARD_NAME
+            tmp_path.write_text(str(self), encoding="utf-8")
+            url = upload_file(
+                path_or_fileobj=str(tmp_path),
+                path_in_repo=constants.REPOCARD_NAME,
+                repo_id=repo_id,
+                token=token,
+                repo_type=repo_type,
+                commit_message=commit_message,
+                commit_description=commit_description,
+                create_pr=create_pr,
+                revision=revision,
+                parent_commit=parent_commit,
+            )
+        return url
+
+    @classmethod
+    def from_template(
+        cls,
+        card_data: CardData,
+        template_path: Optional[str] = None,
+        template_str: Optional[str] = None,
+        **template_kwargs,
+    ):
+        """Initialize a RepoCard from a template. By default, it uses the default template.
+
+        Templates are Jinja2 templates that can be customized by passing keyword arguments.
+
+        Args:
+            card_data (`huggingface_hub.CardData`):
+                A huggingface_hub.CardData instance containing the metadata you want to include in the YAML
+                header of the repo card on the Hugging Face Hub.
+            template_path (`str`, *optional*):
+                A path to a markdown file with optional Jinja template variables that can be filled
+                in with `template_kwargs`. Defaults to the default template.
+
+        Returns:
+            [`huggingface_hub.repocard.RepoCard`]: A RepoCard instance with the specified card data and content from the
+            template.
+        """
+        if is_jinja_available():
+            import jinja2
+        else:
+            raise ImportError(
+                "Using RepoCard.from_template requires Jinja2 to be installed. Please"
+                " install it with `pip install Jinja2`."
+            )
+
+        kwargs = card_data.to_dict().copy()
+        kwargs.update(template_kwargs)  # Template_kwargs have priority
+
+        if template_path is not None:
+            template_str = Path(template_path).read_text()
+        if template_str is None:
+            template_str = Path(cls.default_template_path).read_text()
+        template = jinja2.Template(template_str)
+        content = template.render(card_data=card_data.to_yaml(), **kwargs)
+        return cls(content)
+
+
+class ModelCard(RepoCard):
+    card_data_class = ModelCardData
+    default_template_path = TEMPLATE_MODELCARD_PATH
+    repo_type = "model"
+
+    @classmethod
+    def from_template(  # type: ignore # violates Liskov property but easier to use
+        cls,
+        card_data: ModelCardData,
+        template_path: Optional[str] = None,
+        template_str: Optional[str] = None,
+        **template_kwargs,
+    ):
+        """Initialize a ModelCard from a template. By default, it uses the default template, which can be found here:
+        https://github.com/huggingface/huggingface_hub/blob/main/src/huggingface_hub/templates/modelcard_template.md
+
+        Templates are Jinja2 templates that can be customized by passing keyword arguments.
+
+        Args:
+            card_data (`huggingface_hub.ModelCardData`):
+                A huggingface_hub.ModelCardData instance containing the metadata you want to include in the YAML
+                header of the model card on the Hugging Face Hub.
+            template_path (`str`, *optional*):
+                A path to a markdown file with optional Jinja template variables that can be filled
+                in with `template_kwargs`. Defaults to the default template.
+
+        Returns:
+            [`huggingface_hub.ModelCard`]: A ModelCard instance with the specified card data and content from the
+            template.
+
+        Example:
+            ```python
+            >>> from huggingface_hub import ModelCard, ModelCardData, EvalResult
+
+            >>> # Using the Default Template
+            >>> card_data = ModelCardData(
+            ...     language='en',
+            ...     license='mit',
+            ...     library_name='timm',
+            ...     tags=['image-classification', 'resnet'],
+            ...     datasets=['beans'],
+            ...     metrics=['accuracy'],
+            ... )
+            >>> card = ModelCard.from_template(
+            ...     card_data,
+            ...     model_description='This model does x + y...'
+            ... )
+
+            >>> # Including Evaluation Results
+            >>> card_data = ModelCardData(
+            ...     language='en',
+            ...     tags=['image-classification', 'resnet'],
+            ...     eval_results=[
+            ...         EvalResult(
+            ...             task_type='image-classification',
+            ...             dataset_type='beans',
+            ...             dataset_name='Beans',
+            ...             metric_type='accuracy',
+            ...             metric_value=0.9,
+            ...         ),
+            ...     ],
+            ...     model_name='my-cool-model',
+            ... )
+            >>> card = ModelCard.from_template(card_data)
+
+            >>> # Using a Custom Template
+            >>> card_data = ModelCardData(
+            ...     language='en',
+            ...     tags=['image-classification', 'resnet']
+            ... )
+            >>> card = ModelCard.from_template(
+            ...     card_data=card_data,
+            ...     template_path='./src/huggingface_hub/templates/modelcard_template.md',
+            ...     custom_template_var='custom value',  # will be replaced in template if it exists
+            ... )
+
+            ```
+        """
+        return super().from_template(card_data, template_path, template_str, **template_kwargs)
+
+
+class DatasetCard(RepoCard):
+    card_data_class = DatasetCardData
+    default_template_path = TEMPLATE_DATASETCARD_PATH
+    repo_type = "dataset"
+
+    @classmethod
+    def from_template(  # type: ignore # violates Liskov property but easier to use
+        cls,
+        card_data: DatasetCardData,
+        template_path: Optional[str] = None,
+        template_str: Optional[str] = None,
+        **template_kwargs,
+    ):
+        """Initialize a DatasetCard from a template. By default, it uses the default template, which can be found here:
+        https://github.com/huggingface/huggingface_hub/blob/main/src/huggingface_hub/templates/datasetcard_template.md
+
+        Templates are Jinja2 templates that can be customized by passing keyword arguments.
+
+        Args:
+            card_data (`huggingface_hub.DatasetCardData`):
+                A huggingface_hub.DatasetCardData instance containing the metadata you want to include in the YAML
+                header of the dataset card on the Hugging Face Hub.
+            template_path (`str`, *optional*):
+                A path to a markdown file with optional Jinja template variables that can be filled
+                in with `template_kwargs`. Defaults to the default template.
+
+        Returns:
+            [`huggingface_hub.DatasetCard`]: A DatasetCard instance with the specified card data and content from the
+            template.
+
+        Example:
+            ```python
+            >>> from huggingface_hub import DatasetCard, DatasetCardData
+
+            >>> # Using the Default Template
+            >>> card_data = DatasetCardData(
+            ...     language='en',
+            ...     license='mit',
+            ...     annotations_creators='crowdsourced',
+            ...     task_categories=['text-classification'],
+            ...     task_ids=['sentiment-classification', 'text-scoring'],
+            ...     multilinguality='monolingual',
+            ...     pretty_name='My Text Classification Dataset',
+            ... )
+            >>> card = DatasetCard.from_template(
+            ...     card_data,
+            ...     pretty_name=card_data.pretty_name,
+            ... )
+
+            >>> # Using a Custom Template
+            >>> card_data = DatasetCardData(
+            ...     language='en',
+            ...     license='mit',
+            ... )
+            >>> card = DatasetCard.from_template(
+            ...     card_data=card_data,
+            ...     template_path='./src/huggingface_hub/templates/datasetcard_template.md',
+            ...     custom_template_var='custom value',  # will be replaced in template if it exists
+            ... )
+
+            ```
+        """
+        return super().from_template(card_data, template_path, template_str, **template_kwargs)
+
+
+class SpaceCard(RepoCard):
+    card_data_class = SpaceCardData
+    default_template_path = TEMPLATE_MODELCARD_PATH
+    repo_type = "space"
+
+
+def _detect_line_ending(content: str) -> Literal["\r", "\n", "\r\n", None]:  # noqa: F722
+    """Detect the line ending of a string. Used by RepoCard to avoid making huge diff on newlines.
+
+    Uses same implementation as in Hub server, keep it in sync.
+
+    Returns:
+        str: The detected line ending of the string.
+    """
+    cr = content.count("\r")
+    lf = content.count("\n")
+    crlf = content.count("\r\n")
+    if cr + lf == 0:
+        return None
+    if crlf == cr and crlf == lf:
+        return "\r\n"
+    if cr > lf:
+        return "\r"
+    else:
+        return "\n"
+
+
+def metadata_load(local_path: Union[str, Path]) -> Optional[Dict]:
+    content = Path(local_path).read_text()
+    match = REGEX_YAML_BLOCK.search(content)
+    if match:
+        yaml_block = match.group(2)
+        data = yaml.safe_load(yaml_block)
+        if data is None or isinstance(data, dict):
+            return data
+        raise ValueError("repo card metadata block should be a dict")
+    else:
+        return None
+
+
+def metadata_save(local_path: Union[str, Path], data: Dict) -> None:
+    """
+    Save the metadata dict in the upper YAML part Trying to preserve newlines as
+    in the existing file. Docs about open() with newline="" parameter:
+    https://docs.python.org/3/library/functions.html?highlight=open#open Does
+    not work with "^M" linebreaks, which are replaced by \n
+    """
+    line_break = "\n"
+    content = ""
+    # try to detect existing newline character
+    if os.path.exists(local_path):
+        with open(local_path, "r", newline="", encoding="utf8") as readme:
+            content = readme.read()
+            if isinstance(readme.newlines, tuple):
+                line_break = readme.newlines[0]
+            elif isinstance(readme.newlines, str):
+                line_break = readme.newlines
+
+    # creates a new file if it not
+    with open(local_path, "w", newline="", encoding="utf8") as readme:
+        data_yaml = yaml_dump(data, sort_keys=False, line_break=line_break)
+        # sort_keys: keep dict order
+        match = REGEX_YAML_BLOCK.search(content)
+        if match:
+            output = content[: match.start()] + f"---{line_break}{data_yaml}---{line_break}" + content[match.end() :]
+        else:
+            output = f"---{line_break}{data_yaml}---{line_break}{content}"
+
+        readme.write(output)
+        readme.close()
+
+
+def metadata_eval_result(
+    *,
+    model_pretty_name: str,
+    task_pretty_name: str,
+    task_id: str,
+    metrics_pretty_name: str,
+    metrics_id: str,
+    metrics_value: Any,
+    dataset_pretty_name: str,
+    dataset_id: str,
+    metrics_config: Optional[str] = None,
+    metrics_verified: bool = False,
+    dataset_config: Optional[str] = None,
+    dataset_split: Optional[str] = None,
+    dataset_revision: Optional[str] = None,
+    metrics_verification_token: Optional[str] = None,
+) -> Dict:
+    """
+    Creates a metadata dict with the result from a model evaluated on a dataset.
+
+    Args:
+        model_pretty_name (`str`):
+            The name of the model in natural language.
+        task_pretty_name (`str`):
+            The name of a task in natural language.
+        task_id (`str`):
+            Example: automatic-speech-recognition. A task id.
+        metrics_pretty_name (`str`):
+            A name for the metric in natural language. Example: Test WER.
+        metrics_id (`str`):
+            Example: wer. A metric id from https://hf.co/metrics.
+        metrics_value (`Any`):
+            The value from the metric. Example: 20.0 or "20.0 ± 1.2".
+        dataset_pretty_name (`str`):
+            The name of the dataset in natural language.
+        dataset_id (`str`):
+            Example: common_voice. A dataset id from https://hf.co/datasets.
+        metrics_config (`str`, *optional*):
+            The name of the metric configuration used in `load_metric()`.
+            Example: bleurt-large-512 in `load_metric("bleurt", "bleurt-large-512")`.
+        metrics_verified (`bool`, *optional*, defaults to `False`):
+            Indicates whether the metrics originate from Hugging Face's [evaluation service](https://huggingface.co/spaces/autoevaluate/model-evaluator) or not. Automatically computed by Hugging Face, do not set.
+        dataset_config (`str`, *optional*):
+            Example: fr. The name of the dataset configuration used in `load_dataset()`.
+        dataset_split (`str`, *optional*):
+            Example: test. The name of the dataset split used in `load_dataset()`.
+        dataset_revision (`str`, *optional*):
+            Example: 5503434ddd753f426f4b38109466949a1217c2bb. The name of the dataset dataset revision
+            used in `load_dataset()`.
+        metrics_verification_token (`bool`, *optional*):
+            A JSON Web Token that is used to verify whether the metrics originate from Hugging Face's [evaluation service](https://huggingface.co/spaces/autoevaluate/model-evaluator) or not.
+
+    Returns:
+        `dict`: a metadata dict with the result from a model evaluated on a dataset.
+
+    Example:
+        ```python
+        >>> from huggingface_hub import metadata_eval_result
+        >>> results = metadata_eval_result(
+        ...         model_pretty_name="RoBERTa fine-tuned on ReactionGIF",
+        ...         task_pretty_name="Text Classification",
+        ...         task_id="text-classification",
+        ...         metrics_pretty_name="Accuracy",
+        ...         metrics_id="accuracy",
+        ...         metrics_value=0.2662102282047272,
+        ...         dataset_pretty_name="ReactionJPEG",
+        ...         dataset_id="julien-c/reactionjpeg",
+        ...         dataset_config="default",
+        ...         dataset_split="test",
+        ... )
+        >>> results == {
+        ...     'model-index': [
+        ...         {
+        ...             'name': 'RoBERTa fine-tuned on ReactionGIF',
+        ...             'results': [
+        ...                 {
+        ...                     'task': {
+        ...                         'type': 'text-classification',
+        ...                         'name': 'Text Classification'
+        ...                     },
+        ...                     'dataset': {
+        ...                         'name': 'ReactionJPEG',
+        ...                         'type': 'julien-c/reactionjpeg',
+        ...                         'config': 'default',
+        ...                         'split': 'test'
+        ...                     },
+        ...                     'metrics': [
+        ...                         {
+        ...                             'type': 'accuracy',
+        ...                             'value': 0.2662102282047272,
+        ...                             'name': 'Accuracy',
+        ...                             'verified': False
+        ...                         }
+        ...                     ]
+        ...                 }
+        ...             ]
+        ...         }
+        ...     ]
+        ... }
+        True
+
+        ```
+    """
+
+    return {
+        "model-index": eval_results_to_model_index(
+            model_name=model_pretty_name,
+            eval_results=[
+                EvalResult(
+                    task_name=task_pretty_name,
+                    task_type=task_id,
+                    metric_name=metrics_pretty_name,
+                    metric_type=metrics_id,
+                    metric_value=metrics_value,
+                    dataset_name=dataset_pretty_name,
+                    dataset_type=dataset_id,
+                    metric_config=metrics_config,
+                    verified=metrics_verified,
+                    verify_token=metrics_verification_token,
+                    dataset_config=dataset_config,
+                    dataset_split=dataset_split,
+                    dataset_revision=dataset_revision,
+                )
+            ],
+        )
+    }
+
+
+@validate_hf_hub_args
+def metadata_update(
+    repo_id: str,
+    metadata: Dict,
+    *,
+    repo_type: Optional[str] = None,
+    overwrite: bool = False,
+    token: Optional[str] = None,
+    commit_message: Optional[str] = None,
+    commit_description: Optional[str] = None,
+    revision: Optional[str] = None,
+    create_pr: bool = False,
+    parent_commit: Optional[str] = None,
+) -> str:
+    """
+    Updates the metadata in the README.md of a repository on the Hugging Face Hub.
+    If the README.md file doesn't exist yet, a new one is created with metadata and an
+    the default ModelCard or DatasetCard template. For `space` repo, an error is thrown
+    as a Space cannot exist without a `README.md` file.
+
+    Args:
+        repo_id (`str`):
+            The name of the repository.
+        metadata (`dict`):
+            A dictionary containing the metadata to be updated.
+        repo_type (`str`, *optional*):
+            Set to `"dataset"` or `"space"` if updating to a dataset or space,
+            `None` or `"model"` if updating to a model. Default is `None`.
+        overwrite (`bool`, *optional*, defaults to `False`):
+            If set to `True` an existing field can be overwritten, otherwise
+            attempting to overwrite an existing field will cause an error.
+        token (`str`, *optional*):
+            The Hugging Face authentication token.
+        commit_message (`str`, *optional*):
+            The summary / title / first line of the generated commit. Defaults to
+            `f"Update metadata with huggingface_hub"`
+        commit_description (`str` *optional*)
+            The description of the generated commit
+        revision (`str`, *optional*):
+            The git revision to commit from. Defaults to the head of the
+            `"main"` branch.
+        create_pr (`boolean`, *optional*):
+            Whether or not to create a Pull Request from `revision` with that commit.
+            Defaults to `False`.
+        parent_commit (`str`, *optional*):
+            The OID / SHA of the parent commit, as a hexadecimal string. Shorthands (7 first characters) are also supported.
+            If specified and `create_pr` is `False`, the commit will fail if `revision` does not point to `parent_commit`.
+            If specified and `create_pr` is `True`, the pull request will be created from `parent_commit`.
+            Specifying `parent_commit` ensures the repo has not changed before committing the changes, and can be
+            especially useful if the repo is updated / committed to concurrently.
+    Returns:
+        `str`: URL of the commit which updated the card metadata.
+
+    Example:
+        ```python
+        >>> from huggingface_hub import metadata_update
+        >>> metadata = {'model-index': [{'name': 'RoBERTa fine-tuned on ReactionGIF',
+        ...             'results': [{'dataset': {'name': 'ReactionGIF',
+        ...                                      'type': 'julien-c/reactiongif'},
+        ...                           'metrics': [{'name': 'Recall',
+        ...                                        'type': 'recall',
+        ...                                        'value': 0.7762102282047272}],
+        ...                          'task': {'name': 'Text Classification',
+        ...                                   'type': 'text-classification'}}]}]}
+        >>> url = metadata_update("hf-internal-testing/reactiongif-roberta-card", metadata)
+
+        ```
+    """
+    commit_message = commit_message if commit_message is not None else "Update metadata with huggingface_hub"
+
+    # Card class given repo_type
+    card_class: Type[RepoCard]
+    if repo_type is None or repo_type == "model":
+        card_class = ModelCard
+    elif repo_type == "dataset":
+        card_class = DatasetCard
+    elif repo_type == "space":
+        card_class = RepoCard
+    else:
+        raise ValueError(f"Unknown repo_type: {repo_type}")
+
+    # Either load repo_card from the Hub or create an empty one.
+    # NOTE: Will not create the repo if it doesn't exist.
+    try:
+        card = card_class.load(repo_id, token=token, repo_type=repo_type)
+    except EntryNotFoundError:
+        if repo_type == "space":
+            raise ValueError("Cannot update metadata on a Space that doesn't contain a `README.md` file.")
+
+        # Initialize a ModelCard or DatasetCard from default template and no data.
+        # Cast to the concrete expected card type to satisfy type checkers.
+        card = card_class.from_template(CardData())  # type: ignore[return-value]
+
+    for key, value in metadata.items():
+        if key == "model-index":
+            # if the new metadata doesn't include a name, either use existing one or repo name
+            if "name" not in value[0]:
+                value[0]["name"] = getattr(card, "model_name", repo_id)
+            model_name, new_results = model_index_to_eval_results(value)
+            if card.data.eval_results is None:
+                card.data.eval_results = new_results
+                card.data.model_name = model_name
+            else:
+                existing_results = card.data.eval_results
+
+                # Iterate over new results
+                #   Iterate over existing results
+                #       If both results describe the same metric but value is different:
+                #           If overwrite=True: overwrite the metric value
+                #           Else: raise ValueError
+                #       Else: append new result to existing ones.
+                for new_result in new_results:
+                    result_found = False
+                    for existing_result in existing_results:
+                        if new_result.is_equal_except_value(existing_result):
+                            if new_result != existing_result and not overwrite:
+                                raise ValueError(
+                                    "You passed a new value for the existing metric"
+                                    f" 'name: {new_result.metric_name}, type: "
+                                    f"{new_result.metric_type}'. Set `overwrite=True`"
+                                    " to overwrite existing metrics."
+                                )
+                            result_found = True
+                            existing_result.metric_value = new_result.metric_value
+                            if existing_result.verified is True:
+                                existing_result.verify_token = new_result.verify_token
+                    if not result_found:
+                        card.data.eval_results.append(new_result)
+        else:
+            # Any metadata that is not a result metric
+            if card.data.get(key) is not None and not overwrite and card.data.get(key) != value:
+                raise ValueError(
+                    f"You passed a new value for the existing meta data field '{key}'."
+                    " Set `overwrite=True` to overwrite existing metadata."
+                )
+            else:
+                card.data[key] = value
+
+    return card.push_to_hub(
+        repo_id,
+        token=token,
+        repo_type=repo_type,
+        commit_message=commit_message,
+        commit_description=commit_description,
+        create_pr=create_pr,
+        revision=revision,
+        parent_commit=parent_commit,
+    )

lib/python3.13/site-packages/mdurl-0.1.2.dist-info/INSTALLER

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

lib/python3.13/site-packages/mdurl-0.1.2.dist-info/METADATA

@@ -0,0 +1,32 @@
+Metadata-Version: 2.1
+Name: mdurl
+Version: 0.1.2
+Summary: Markdown URL utilities
+Keywords: markdown,commonmark
+Author-email: Taneli Hukkinen <hukkin@users.noreply.github.com>
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: MacOS
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Programming Language :: Python :: Implementation :: PyPy
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Typing :: Typed
+Project-URL: Homepage, https://github.com/executablebooks/mdurl
+
+# mdurl
+
+[![Build Status](https://github.com/executablebooks/mdurl/workflows/Tests/badge.svg?branch=master)](https://github.com/executablebooks/mdurl/actions?query=workflow%3ATests+branch%3Amaster+event%3Apush)
+[![codecov.io](https://codecov.io/gh/executablebooks/mdurl/branch/master/graph/badge.svg)](https://codecov.io/gh/executablebooks/mdurl)
+[![PyPI version](https://img.shields.io/pypi/v/mdurl)](https://pypi.org/project/mdurl)
+
+This is a Python port of the JavaScript [mdurl](https://www.npmjs.com/package/mdurl) package.
+See the [upstream README.md file](https://github.com/markdown-it/mdurl/blob/master/README.md) for API documentation.
+

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

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

lib/python3.13/site-packages/msgspec/__init__.pyi

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

lib/python3.13/site-packages/msgspec/_utils.py

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

lib/python3.13/site-packages/msgspec/json.py

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

lib/python3.13/site-packages/msgspec/json.pyi

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

lib/python3.13/site-packages/msgspec/msgpack.pyi

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

lib/python3.13/site-packages/msgspec/structs.py

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

lib/python3.13/site-packages/msgspec/toml.py

@@ -0,0 +1,197 @@
+from __future__ import annotations
+
+import datetime as _datetime
+from typing import TYPE_CHECKING, overload, TypeVar, Any
+
+from . import (
+    DecodeError as _DecodeError,
+    convert as _convert,
+    to_builtins as _to_builtins,
+)
+
+if TYPE_CHECKING:
+    from typing import Callable, Optional, Type, Union, Literal
+    from typing_extensions import Buffer
+
+
+__all__ = ("encode", "decode")
+
+
+def __dir__():
+    return __all__
+
+
+def _import_tomllib():
+    try:
+        import tomllib  # type: ignore
+
+        return tomllib
+    except ImportError:
+        pass
+
+    try:
+        import tomli  # type: ignore
+
+        return tomli
+    except ImportError:
+        raise ImportError(
+            "`msgspec.toml.decode` requires `tomli` be installed.\n\n"
+            "Please either `pip` or `conda` install it as follows:\n\n"
+            "  $ python -m pip install tomli   # using pip\n"
+            "  $ conda install tomli           # or using conda"
+        ) from None
+
+
+def _import_tomli_w():
+    try:
+        import tomli_w  # type: ignore
+
+        return tomli_w
+    except ImportError:
+        raise ImportError(
+            "`msgspec.toml.encode` requires `tomli_w` be installed.\n\n"
+            "Please either `pip` or `conda` install it as follows:\n\n"
+            "  $ python -m pip install tomli_w   # using pip\n"
+            "  $ conda install tomli_w           # or using conda"
+        ) from None
+
+
+def encode(
+    obj: Any,
+    *,
+    enc_hook: Optional[Callable[[Any], Any]] = None,
+    order: Literal[None, "deterministic", "sorted"] = None,
+) -> bytes:
+    """Serialize an object as TOML.
+
+    Parameters
+    ----------
+    obj : Any
+        The object to serialize.
+    enc_hook : callable, optional
+        A callable to call for objects that aren't supported msgspec types.
+        Takes the unsupported object and should return a supported object, or
+        raise a ``NotImplementedError`` if unsupported.
+    order : {None, 'deterministic', 'sorted'}, optional
+        The ordering to use when encoding unordered compound types.
+
+        - ``None``: All objects are encoded in the most efficient manner
+          matching their in-memory representations. The default.
+        - `'deterministic'`: Unordered collections (sets, dicts) are sorted to
+          ensure a consistent output between runs. Useful when
+          comparison/hashing of the encoded binary output is necessary.
+        - `'sorted'`: Like `'deterministic'`, but *all* object-like types
+          (structs, dataclasses, ...) are also sorted by field name before
+          encoding. This is slower than `'deterministic'`, but may produce more
+          human-readable output.
+
+    Returns
+    -------
+    data : bytes
+        The serialized object.
+
+    See Also
+    --------
+    decode
+    """
+    toml = _import_tomli_w()
+    msg = _to_builtins(
+        obj,
+        builtin_types=(_datetime.datetime, _datetime.date, _datetime.time),
+        str_keys=True,
+        enc_hook=enc_hook,
+        order=order,
+    )
+    return toml.dumps(msg).encode("utf-8")
+
+
+T = TypeVar("T")
+
+
+@overload
+def decode(
+    buf: Union[Buffer, str],
+    *,
+    strict: bool = True,
+    dec_hook: Optional[Callable[[type, Any], Any]] = None,
+) -> Any:
+    pass
+
+
+@overload
+def decode(
+    buf: Union[Buffer, str],
+    *,
+    type: Type[T] = ...,
+    strict: bool = True,
+    dec_hook: Optional[Callable[[type, Any], Any]] = None,
+) -> T:
+    pass
+
+
+@overload
+def decode(
+    buf: Union[Buffer, str],
+    *,
+    type: Any = ...,
+    strict: bool = True,
+    dec_hook: Optional[Callable[[type, Any], Any]] = None,
+) -> Any:
+    pass
+
+
+def decode(buf, *, type=Any, strict=True, dec_hook=None):
+    """Deserialize an object from TOML.
+
+    Parameters
+    ----------
+    buf : bytes-like or str
+        The message to decode.
+    type : type, optional
+        A Python type (in type annotation form) to decode the object as. If
+        provided, the message will be type checked and decoded as the specified
+        type. Defaults to `Any`, in which case the message will be decoded
+        using the default TOML types.
+    strict : bool, optional
+        Whether type coercion rules should be strict. Setting to False enables
+        a wider set of coercion rules from string to non-string types for all
+        values. Default is True.
+    dec_hook : callable, optional
+        An optional callback for handling decoding custom types. Should have
+        the signature ``dec_hook(type: Type, obj: Any) -> Any``, where ``type``
+        is the expected message type, and ``obj`` is the decoded representation
+        composed of only basic TOML types. This hook should transform ``obj``
+        into type ``type``, or raise a ``NotImplementedError`` if unsupported.
+
+    Returns
+    -------
+    obj : Any
+        The deserialized object.
+
+    See Also
+    --------
+    encode
+    """
+    toml = _import_tomllib()
+    if isinstance(buf, str):
+        str_buf = buf
+    elif isinstance(buf, (bytes, bytearray)):
+        str_buf = buf.decode("utf-8")
+    else:
+        # call `memoryview` first, since `bytes(1)` is actually valid
+        str_buf = bytes(memoryview(buf)).decode("utf-8")
+    try:
+        obj = toml.loads(str_buf)
+    except toml.TOMLDecodeError as exc:
+        raise _DecodeError(str(exc)) from None
+
+    if type is Any:
+        return obj
+    return _convert(
+        obj,
+        type,
+        builtin_types=(_datetime.datetime, _datetime.date, _datetime.time),
+        str_keys=True,
+        strict=strict,
+        dec_hook=dec_hook,
+    )

lib/python3.13/site-packages/msgspec/yaml.py

@@ -0,0 +1,192 @@
+from __future__ import annotations
+
+import datetime as _datetime
+from typing import TYPE_CHECKING, overload, TypeVar, Any
+
+from . import (
+    DecodeError as _DecodeError,
+    convert as _convert,
+    to_builtins as _to_builtins,
+)
+
+if TYPE_CHECKING:
+    from typing import Callable, Optional, Type, Union, Literal
+    from typing_extensions import Buffer
+
+
+__all__ = ("encode", "decode")
+
+
+def __dir__():
+    return __all__
+
+
+def _import_pyyaml(name):
+    try:
+        import yaml  # type: ignore
+    except ImportError:
+        raise ImportError(
+            f"`msgspec.yaml.{name}` requires PyYAML be installed.\n\n"
+            "Please either `pip` or `conda` install it as follows:\n\n"
+            "  $ python -m pip install pyyaml  # using pip\n"
+            "  $ conda install pyyaml          # or using conda"
+        ) from None
+    else:
+        return yaml
+
+
+def encode(
+    obj: Any,
+    *,
+    enc_hook: Optional[Callable[[Any], Any]] = None,
+    order: Literal[None, "deterministic", "sorted"] = None,
+) -> bytes:
+    """Serialize an object as YAML.
+
+    Parameters
+    ----------
+    obj : Any
+        The object to serialize.
+    enc_hook : callable, optional
+        A callable to call for objects that aren't supported msgspec types.
+        Takes the unsupported object and should return a supported object, or
+        raise a ``NotImplementedError`` if unsupported.
+    order : {None, 'deterministic', 'sorted'}, optional
+        The ordering to use when encoding unordered compound types.
+
+        - ``None``: All objects are encoded in the most efficient manner
+          matching their in-memory representations. The default.
+        - `'deterministic'`: Unordered collections (sets, dicts) are sorted to
+          ensure a consistent output between runs. Useful when
+          comparison/hashing of the encoded binary output is necessary.
+        - `'sorted'`: Like `'deterministic'`, but *all* object-like types
+          (structs, dataclasses, ...) are also sorted by field name before
+          encoding. This is slower than `'deterministic'`, but may produce more
+          human-readable output.
+
+    Returns
+    -------
+    data : bytes
+        The serialized object.
+
+    Notes
+    -----
+    This function requires that the third-party `PyYAML library
+    <https://pyyaml.org/>`_ is installed.
+
+    See Also
+    --------
+    decode
+    """
+    yaml = _import_pyyaml("encode")
+    # Use the C extension if available
+    Dumper = getattr(yaml, "CSafeDumper", yaml.SafeDumper)
+
+    return yaml.dump_all(
+        [
+            _to_builtins(
+                obj,
+                builtin_types=(_datetime.datetime, _datetime.date),
+                enc_hook=enc_hook,
+                order=order,
+            )
+        ],
+        encoding="utf-8",
+        Dumper=Dumper,
+        allow_unicode=True,
+        sort_keys=False,
+    )
+
+
+T = TypeVar("T")
+
+
+@overload
+def decode(
+    buf: Union[Buffer, str],
+    *,
+    strict: bool = True,
+    dec_hook: Optional[Callable[[type, Any], Any]] = None,
+) -> Any:
+    pass
+
+
+@overload
+def decode(
+    buf: Union[bytes, str],
+    *,
+    type: Type[T] = ...,
+    strict: bool = True,
+    dec_hook: Optional[Callable[[type, Any], Any]] = None,
+) -> T:
+    pass
+
+
+@overload
+def decode(
+    buf: Union[bytes, str],
+    *,
+    type: Any = ...,
+    strict: bool = True,
+    dec_hook: Optional[Callable[[type, Any], Any]] = None,
+) -> Any:
+    pass
+
+
+def decode(buf, *, type=Any, strict=True, dec_hook=None):
+    """Deserialize an object from YAML.
+
+    Parameters
+    ----------
+    buf : bytes-like or str
+        The message to decode.
+    type : type, optional
+        A Python type (in type annotation form) to decode the object as. If
+        provided, the message will be type checked and decoded as the specified
+        type. Defaults to `Any`, in which case the message will be decoded
+        using the default YAML types.
+    strict : bool, optional
+        Whether type coercion rules should be strict. Setting to False enables
+        a wider set of coercion rules from string to non-string types for all
+        values. Default is True.
+    dec_hook : callable, optional
+        An optional callback for handling decoding custom types. Should have
+        the signature ``dec_hook(type: Type, obj: Any) -> Any``, where ``type``
+        is the expected message type, and ``obj`` is the decoded representation
+        composed of only basic YAML types. This hook should transform ``obj``
+        into type ``type``, or raise a ``NotImplementedError`` if unsupported.
+
+    Returns
+    -------
+    obj : Any
+        The deserialized object.
+
+    Notes
+    -----
+    This function requires that the third-party `PyYAML library
+    <https://pyyaml.org/>`_ is installed.
+
+    See Also
+    --------
+    encode
+    """
+    yaml = _import_pyyaml("decode")
+    # Use the C extension if available
+    Loader = getattr(yaml, "CSafeLoader", yaml.SafeLoader)
+    if not isinstance(buf, (str, bytes)):
+        # call `memoryview` first, since `bytes(1)` is actually valid
+        buf = bytes(memoryview(buf))
+    try:
+        obj = yaml.load(buf, Loader)
+    except yaml.YAMLError as exc:
+        raise _DecodeError(str(exc)) from None
+
+    if type is Any:
+        return obj
+    return _convert(
+        obj,
+        type,
+        builtin_types=(_datetime.datetime, _datetime.date),
+        strict=strict,
+        dec_hook=dec_hook,
+    )

lib/python3.13/site-packages/numba-0.61.2.dist-info/INSTALLER

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

lib/python3.13/site-packages/numba-0.61.2.dist-info/METADATA

@@ -0,0 +1,92 @@
+Metadata-Version: 2.4
+Name: numba
+Version: 0.61.2
+Summary: compiling Python code using LLVM
+Home-page: https://numba.pydata.org
+License: BSD
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: BSD License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+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: Topic :: Software Development :: Compilers
+Requires-Python: >=3.10
+License-File: LICENSE
+License-File: LICENSES.third-party
+Requires-Dist: llvmlite<0.45,>=0.44.0dev0
+Requires-Dist: numpy<2.3,>=1.24
+Dynamic: classifier
+Dynamic: description
+Dynamic: home-page
+Dynamic: license
+Dynamic: license-file
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+*****
+Numba
+*****
+
+.. image:: https://badges.gitter.im/numba/numba.svg
+   :target: https://gitter.im/numba/numba?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge
+   :alt: Gitter
+
+.. image:: https://img.shields.io/badge/discuss-on%20discourse-blue
+   :target: https://numba.discourse.group/
+   :alt: Discourse
+
+.. image:: https://zenodo.org/badge/3659275.svg
+   :target: https://zenodo.org/badge/latestdoi/3659275
+   :alt: Zenodo DOI
+
+.. image:: https://img.shields.io/pypi/v/numba.svg
+   :target: https://pypi.python.org/pypi/numba/
+   :alt: PyPI
+
+.. image:: https://dev.azure.com/numba/numba/_apis/build/status/numba.numba?branchName=main
+    :target: https://dev.azure.com/numba/numba/_build/latest?definitionId=1?branchName=main
+    :alt: Azure Pipelines
+
+A Just-In-Time Compiler for Numerical Functions in Python
+#########################################################
+
+Numba is an open source, NumPy-aware optimizing compiler for Python sponsored
+by Anaconda, Inc.  It uses the LLVM compiler project to generate machine code
+from Python syntax.
+
+Numba can compile a large subset of numerically-focused Python, including many
+NumPy functions.  Additionally, Numba has support for automatic
+parallelization of loops, generation of GPU-accelerated code, and creation of
+ufuncs and C callbacks.
+
+For more information about Numba, see the Numba homepage:
+https://numba.pydata.org and the online documentation:
+https://numba.readthedocs.io/en/stable/index.html
+
+Installation
+============
+
+Please follow the instructions:
+
+https://numba.readthedocs.io/en/stable/user/installing.html
+
+Demo
+====
+
+Please have a look and the demo notebooks via the mybinder service:
+
+https://mybinder.org/v2/gh/numba/numba-examples/master?filepath=notebooks
+
+Contact
+=======
+
+Numba has a discourse forum for discussions:
+
+* https://numba.discourse.group
+

lib/python3.13/site-packages/numba-0.61.2.dist-info/RECORD

@@ -0,0 +1,824 @@
+../../../bin/numba,sha256=ZTY7LpNvvvliwUn7Z_suv0feXZiIifGp_UFry8NIxV0,223
+numba-0.61.2.dist-info/INSTALLER,sha256=5hhM4Q4mYTT9z6QB6PGpUAW81PGNFrYrdXMj4oM_6ak,2
+numba-0.61.2.dist-info/METADATA,sha256=1V2oaXBcgn0-MzY2_RUXBZIcocsmOQOBwTTS3fmkoWI,2838
+numba-0.61.2.dist-info/RECORD,,
+numba-0.61.2.dist-info/REQUESTED,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+numba-0.61.2.dist-info/WHEEL,sha256=nblTQT1blkV4AqHweFiF9VczUBStdpro9HYesm10meU,151
+numba-0.61.2.dist-info/licenses/LICENSE,sha256=OnDgohytAxRyRvY2PQe_dvriFscneXB_SuXbBrys8Gc,1286
+numba-0.61.2.dist-info/licenses/LICENSES.third-party,sha256=qdg_StDkoxTMfEeYhaLes_ajVqcWZqfbpxtmg1lgKEs,24767
+numba-0.61.2.dist-info/top_level.txt,sha256=lAjxwBJKjiuhWb3Oxtg12KVAHFHBvynjw2CXL-a00Ig,6
+numba/__init__.py,sha256=lZjrM6ztmH6cI0W8tVegdLkb06JIkXLjPfJ2QUP9-mQ,8607
+numba/__main__.py,sha256=Mr67cF_MTaSs9gZGD7paaQFE8dq62dXt6ixEI0Fo7dM,152
+numba/_arraystruct.h,sha256=SgoBWBXJODhp6giCY6b4joNSoF8TPQW_YB9-jsmkm-k,499
+numba/_devicearray.cpython-313-x86_64-linux-gnu.so,sha256=cQN9vgvn2ciXKp43Z4CSCdulLblGUtstx_1uudHtX70,46904
+numba/_devicearray.h,sha256=fnyiPxdF47Um9uiMEJL-1e8qg2ZdYMy6NHFifelktg4,666
+numba/_dispatcher.cpython-313-x86_64-linux-gnu.so,sha256=AIQMMz8ujJiXHq3Kf-oHCMjriC8RORf5WVI-lBxEWDQ,505264
+numba/_dynfunc.c,sha256=3sRnmMyA_IS7IKHGvkF9tsKvGTjdkzABGX4yj1bYE6M,19615
+numba/_dynfunc.cpython-313-x86_64-linux-gnu.so,sha256=ZAzU9h4NjyhJtyGr37_QwUdMr-dK-rvHnRkxMMYTnEE,54056
+numba/_dynfuncmod.c,sha256=xFiXbTRxFkU17_QPyOL2ybgDbMix5hKXM9Bic76BgSg,2635
+numba/_hashtable.h,sha256=74Dqe0BcBgs7X9R1Msv5BJhbC4LCi_34mNoUiBP5nlo,4499
+numba/_helperlib.c,sha256=308FYR7g1xBRznTiHEYp-8akmAVkgA3v1C43wmj_pxU,34855
+numba/_helperlib.cpython-313-x86_64-linux-gnu.so,sha256=wEYjHdUYAkmr8D8U6lA2vGdsVBsavHzeVZXDtvVDzf4,811920
+numba/_helpermod.c,sha256=aDfIUK7AzWQXc7nxcJkUnFwdTqUK6CZeOTucTzP2Kl8,7461
+numba/_lapack.c,sha256=Xn8uUHFgWJk8eVilo1byHazu7fGTm7AqILxApoAlsNY,55086
+numba/_numba_common.h,sha256=qcZMEJFdEH4y2BJ4f-FVV-gzoSV4BW-5xC-RaB_5e-w,1667
+numba/_pymodule.h,sha256=b2ng0SLtGIvbLzZnxVFhs9UzWcFnqDkxJ3b7icsECUg,1268
+numba/_random.c,sha256=xplDgTp5b_XC8SYgKSSdqx6HEdxfTJNv4f_EpSRcNOc,13152
+numba/_typeof.h,sha256=TL7gz-3EUTlq5YAzNxpHFMNCXglo1witOJTIlr520s4,344
+numba/_unicodetype_db.h,sha256=BK_cQfuPjJVk5hB8AZr7o0geNkHA7R1yDJvLw6HQtuI,248614
+numba/_version.py,sha256=KL66YOdeFloWRAH-UdCmSp7bh9nGdLa5HwV7IH5CuYg,498
+numba/capsulethunk.h,sha256=q1mCpzXEqBFZjtq_N_Cq8jEezFroB8Lgqaev_YhztIg,2553
+numba/cext/__init__.py,sha256=ZGFuefIViSAZpwX2PlttNOSKuubZ9afqDDN_35SYE28,507
+numba/cext/cext.h,sha256=mivAtJMQbz6WMrlkIcOQjlW6_LAsecplyH_4TWbCy-g,638
+numba/cext/dictobject.c,sha256=zI0HZ1VhCwiqvYVLqso3xILVUEWQV3kqFeQDH0LwKhM,38175
+numba/cext/dictobject.h,sha256=AEY_44GaiJsTyTHkZqG2JGiVoFOpNpMB94ZSD2nJ8fA,5980
+numba/cext/listobject.c,sha256=h1v1VGs4td4-1XQL7pb5TNAo9-tEntYgAjrFKIG6WHY,31928
+numba/cext/listobject.h,sha256=S2605_HlvaK03buI-SFTjEl4OqZvd93-kvOVxudrZxE,4125
+numba/cext/utils.c,sha256=FW9zwCwlZIQcge2d7KQlsFU2k6EcfcrY-rhn9x71vx0,201
+numba/cloudpickle/__init__.py,sha256=vb2JCOn1EpLUdVyPe1ESyhLymcvh-Rk3ISHJ-52aDLw,308
+numba/cloudpickle/cloudpickle.py,sha256=r6fexaim62xqpJXtkpKmVcUod-d3s9ihaRBdoA58GjM,55920
+numba/cloudpickle/cloudpickle_fast.py,sha256=1GqUD4nLKsv0vv9ty2La3eVLyeWNrPFlhUCN-aNI-30,322
+numba/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+numba/core/analysis.py,sha256=WUuo8Fez3856YxXhNophQYlegY1tHAi74GLYcr7FcW0,28317
+numba/core/annotations/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+numba/core/annotations/pretty_annotate.py,sha256=_RiqUaNuc7cQwYit7z5NpvdxzYe5mPzNVjybXyhqVfM,9540
+numba/core/annotations/template.html,sha256=nU0wqR4YNRTGVTc-9JgpQvwMW9IFb4F-0GS17vvfdiQ,3464
+numba/core/annotations/type_annotations.py,sha256=O5j1DM5JZ-2BpTOP8CqI-D3O5tY0naog3-Xl7xBG4vE,11184
+numba/core/base.py,sha256=cKSN7uub3fLeC7YilyJDt70Jln8H4ov3ve4OuhUsTNo,45514
+numba/core/boxing.py,sha256=fhUz2REFdHowwl0p0-6sGrVLNCkiI-3pM8MA25WosUo,393
+numba/core/bytecode.py,sha256=i5jekhFdPYV_HKfcOUl_NW3x7YEg6y8rbVWr2x_35g4,24428
+numba/core/byteflow.py,sha256=af2m9KteTwHdnzDsXbXmxno7582ErY-SFRtm1PY9_zc,72769
+numba/core/caching.py,sha256=s9sx2Grxh5FKmrrkfqLKl8-hsDtO3RMoOVvlZVCZbZ4,25101
+numba/core/callconv.py,sha256=qrCt6ct27WCtbwJgIZIa-kY2HYtqbFWnRWXTmG_r3FA,37439
+numba/core/callwrapper.py,sha256=RxaV-p8315st3H5TfaAGidjvo8H04Lf1PSgtZlOSRAw,8450
+numba/core/ccallback.py,sha256=jfxSEbMKmbKVZfz3DC5S7p2oPnV3y3Oj8svwlP9SElQ,4312
+numba/core/cgutils.py,sha256=3G5vmPfiIGM7AqsVZwk6Hw5b73HQl45ui9EGokKFLmg,39175
+numba/core/codegen.py,sha256=2ENFuaNy_xswHyIwMrt6gN5pRIsXvObzfqprcCqmvNE,55937
+numba/core/compiler.py,sha256=qC867N-qi3iaeCI-CEkdxzrsOrjwD_TP-dN3bkzzEpQ,27864
+numba/core/compiler_lock.py,sha256=CM8ONwrW9UGLT_uQ3xpG5huU-M3XRAYA32hCLNnuTTQ,1521
+numba/core/compiler_machinery.py,sha256=PP3iSI9SB7wz_4VhZaEiG8c3ezALMtgiuCsfNHIb4sA,14381
+numba/core/config.py,sha256=DnD5DaeFISXEHUUXU6iR2wnIDUCTYg6ftPkxJVnTiUg,22580
+numba/core/consts.py,sha256=lkwM0wNPw9rjv9rcFsDufZESSo4fC0yeszec92O96ys,4501
+numba/core/controlflow.py,sha256=HQVTTUj54rHLCcr0VfsR9T0gole0Un1iy-IG-sv7Oqw,31175
+numba/core/cpu.py,sha256=WSHcPek-8zCpvCsY5l6GFf1zO7V85CE7cbB-JxJrMKY,12200
+numba/core/cpu_options.py,sha256=Bb2cZNivUKBFRvW2KEifRvDk_bGdGm8FiJcz0XiWpsA,5512
+numba/core/datamodel/__init__.py,sha256=uEqJC_eaDkBhrb1NZzU76hn5Zv5vtsPNxxic-wLd05E,225
+numba/core/datamodel/manager.py,sha256=OFSk3zpXbt0rOTHCEudW30cwn90uqhAIShd65n8Wa2M,2155
+numba/core/datamodel/models.py,sha256=2sAhRRHMQf26fpGzC6smaItExr-zjqVs2Dqodbibiek,360
+numba/core/datamodel/new_models.py,sha256=KzO7F7lUAjnlpXhZMKIu6Rtj0NVZ2t2SoYG6vBwHFag,44845
+numba/core/datamodel/old_models.py,sha256=KxsP8ymKktbMeOOZJv9SPtx7cOyOgXGn_JIGho2VerY,44497
+numba/core/datamodel/packer.py,sha256=PK-fWl1nBm2BpJwd7PMswTYACgWm41bHhkVh9CNTgBw,6645
+numba/core/datamodel/registry.py,sha256=uEJyukeEvGfyIovLfBO3Rr6maqLWhgK9msD1hg7fKmg,416
+numba/core/datamodel/testing.py,sha256=f31La03lzPAPGPF-OE-VaV-rLv0h-BT9rmRFElEDIco,5346
+numba/core/debuginfo.py,sha256=7UGcm8gFOMbO5wXWQjL9aWNdx-6_XPaxk_ANFhsKElg,17525
+numba/core/decorators.py,sha256=GIXTHwL1BJQF50k61V1FX3I7oLDAhNMeGPoP5VGTEm8,11206
+numba/core/descriptors.py,sha256=pYBrPowcj7MJob32fdZZ2WrmL4NWr69GPBsl0_QaqIA,345
+numba/core/dispatcher.py,sha256=ibOCBuMlXrCFn8wF3Ims7wdMyx-n0-EDS_fBA8fx69c,51733
+numba/core/entrypoints.py,sha256=eZkSqheZj4WuTVy0cjApQCQXs9rOxoNGXZ3PcuxDiGU,1615
+numba/core/environment.py,sha256=wCydbj-gUqqy0Ql_RFmHBazk7Wb722qa71SIQRRve1c,1639
+numba/core/errors.py,sha256=f55avuy5p7afjouhaRVLFVQ7nZr3kNAMBy52sG_EuPM,24987
+numba/core/event.py,sha256=q4eNSV-FMnlL_jbzm51sTiVqu2acj6e74qiPBtC0ong,12095
+numba/core/extending.py,sha256=5jj8CX2blZ7vH-iInDKrThXwmhjJhUgiZ4JrGOBDgLg,19581
+numba/core/externals.py,sha256=Dwxc71cCdcizy-_TZRR849eDMzNOXa1Y_KSZ8tUoCVI,4851
+numba/core/fastmathpass.py,sha256=0HQfDhMmdjKG-tTiqeoYoUtDDP6CZIEPF7pGZnbDIRc,1211
+numba/core/funcdesc.py,sha256=1VX9EhGiUTxD8ixQhC6GlXOzj9HxEpsYhf_RxLyeOR8,8273
+numba/core/generators.py,sha256=KsHYH7fC6mKrYNMFHZ4hekK8gQN0W_442QECsIOe3lU,14176
+numba/core/imputils.py,sha256=Iuh0GphkXwaA3Fg71XmsQaMlQoeiYx0LovWlyNeFR-8,14889
+numba/core/inline_closurecall.py,sha256=ZoGeN4_30n_s0354csEMiwzBXe8NW2LN9izpvH1BYUg,72127
+numba/core/interpreter.py,sha256=0bCkNGCd_skiop3svvVSX7RflfUfG2Ju4CptNAyOeVo,137522
+numba/core/intrinsics.py,sha256=IZqjKTPQ_74XdNGt3-WurTKTfgEhGVkfhPSwdv0EpSA,2008
+numba/core/ir.py,sha256=5sgGHOy2XmgWjT7xPNLARsiTnee3Hy5xbPhUyHV_Gmk,52254
+numba/core/ir_utils.py,sha256=usTx6j_XOyty0A6xraoowHr22Mu0JKxV4jYXgn-aASw,94990
+numba/core/itanium_mangler.py,sha256=k5y_dq72XKaOWCmIBzxajyDgcs63f0ufxCkbelDWDOo,6722
+numba/core/llvm_bindings.py,sha256=WbDEV7F3oyvYqucqa04pcGSz-hkXPyNPA3KJf4Ljv84,1177
+numba/core/lowering.py,sha256=u_S2fCkFZY1_ye0U5Q2F8csR8-KsM-jr_Gn6zTjk6JM,67011
+numba/core/new_boxing.py,sha256=Om9GMhScL1ixWvKBf5QF-CmXmiHOJnqiI7QgSj3IDHI,49438
+numba/core/object_mode_passes.py,sha256=XeRInu0p6iWhfthmFd40wDcqjvM9AGcd6SpE-dzS6Vw,5869
+numba/core/old_boxing.py,sha256=bLqLDRYC4ufHVyG_R5X3kAEs-ulDDuwuIrVqDzn9BXI,47236
+numba/core/optional.py,sha256=5g0Bgn4pB09yyVOP5X973f-RpVrKA1Y3l40PlJX6gd4,4182
+numba/core/options.py,sha256=QISFK5LSWEBZkl6EpOa7rWStaKrChgZx39xtskvHoEQ,2999
+numba/core/postproc.py,sha256=2DWTz4PvcPQQTj7y_L30ij1sII3OKt0l0K_azsFGLFM,9318
+numba/core/pylowering.py,sha256=OJMzHwCusj0Fa-qIR94bNVSuIJTcL5youagB6yRl8a4,24891
+numba/core/pythonapi.py,sha256=y8BTED44HqbAbFttXsRorApMGoEhgGS3cpvpUsn8Kk0,69621
+numba/core/registry.py,sha256=H0eAEHnO392xVxYpJ65gnmWsppVC_L8aCV_aDnDYl10,2625
+numba/core/removerefctpass.py,sha256=WBbqRQ5rQYXi0SK5sytOvMHzM7AY2qw6FJYC7f0zQ6E,3398
+numba/core/rewrites/__init__.py,sha256=nYQr5fLoOWzeeWbP8AeQnWij9nAoAMkFG-B6gjJ7d7E,284
+numba/core/rewrites/ir_print.py,sha256=TXGMw9NziDSAYxc3SguhdIU7Pn6NQP9X5umlAvlm14U,2969
+numba/core/rewrites/registry.py,sha256=0vubYnbutEygNYiNEbvm-Mf9mP977giP83QHBiSeKBA,3651
+numba/core/rewrites/static_binop.py,sha256=beLhF0A5FyoDKKS84jsNvMOgQAFeEWckm6z-rrI-8Bw,1146
+numba/core/rewrites/static_getitem.py,sha256=OmYFspFKSSk63fVwV2Oj8Wu4ZhVRt0rQR_E-rg_V3ZM,6624
+numba/core/rewrites/static_raise.py,sha256=aBHSyB_Djac-T2gN44aiTwBKCIDVb9h_Mv12qQF62zY,3576
+numba/core/runtime/__init__.py,sha256=g0oEnSA15s0XLF7kuPp_U7pw5KUcnZjcDdF0gD51rIM,23
+numba/core/runtime/_nrt_python.c,sha256=wQN78ajJFcmCqrr-0LdDis1xgN51gdOqoAQ3fcanRpk,14939
+numba/core/runtime/_nrt_python.cpython-313-x86_64-linux-gnu.so,sha256=i-voHSMdPJoKG_VnHSFHtUF1Zjb93WNzDwwqQhqpgyc,196224
+numba/core/runtime/_nrt_pythonmod.c,sha256=Gk3pLk3R96W5gHumuJ1eg2N-eXeNOlrsWPNbtQMBht0,6095
+numba/core/runtime/context.py,sha256=ONphIGatCFTKZKw93bhI3gEGlsS3anG7gNow2vZgk3o,15944
+numba/core/runtime/nrt.cpp,sha256=6HoAZuhcuagbBJXvZP2A8o522kYZGhwcG8NZfI2CP_0,18525
+numba/core/runtime/nrt.h,sha256=JJzmIotXg2otcSudPYPud6Wsl6fbJdSX_7M2rGJ0rH0,6453
+numba/core/runtime/nrt.py,sha256=vwfYk5NSKCqbTDX7ylE5_6P53Zjo7Zl7R_i2v1JVMCY,4071
+numba/core/runtime/nrt_external.h,sha256=q2IkdHTFlV34qrQlkOL1BJrosG-4a10vxBDcyQR_iHg,1865
+numba/core/runtime/nrtdynmod.py,sha256=zEw65U8Kz9bA1MDC1Nsp84xA6zTxjkRXZS31s_HRdQE,7490
+numba/core/runtime/nrtopt.py,sha256=OUuVG7DznCbJI6Xhwn3fLCucEbZ6nhimogNzduEQYho,5834
+numba/core/serialize.py,sha256=Gzh0soJm8G7C_FvpL-7dj6ydXGQPnbrcVxtViV2QPts,6272
+numba/core/sigutils.py,sha256=KpoyuVJ5RGgtyMK2cgzmN0P3pU39zU1M-NbxSai90d4,1613
+numba/core/ssa.py,sha256=0grM2SdX_vZjpD540O6I_gHZMzN57aRjyeFfDneF5JA,16546
+numba/core/target_extension.py,sha256=CJlJ3nb3YlIYybujExLTEFT2cO5kItqIay5Qgc6Sm3s,4606
+numba/core/targetconfig.py,sha256=TOH0CFU0XkiPuhEoVRrXTPTPnTi9FCSC-3wYurVjB18,9817
+numba/core/tracing.py,sha256=O-eQay_IuutIjEx7PMKabLyuVpT0oMgy99e57ALqqSk,6901
+numba/core/transforms.py,sha256=C6jHD3tysfhRB0n9a2wDIZh9tQfjW5d0Qa-o-cUg81g,31771
+numba/core/typeconv/__init__.py,sha256=KrF14DtWGRNjGJwRsBVGcsCNWEBQ6PqLg5o_6sJSTEM,34
+numba/core/typeconv/_typeconv.cpython-313-x86_64-linux-gnu.so,sha256=htHcuTlu41Vn5Z93saC2oFsVtgQAlmpZXVOChxaGlTs,139240
+numba/core/typeconv/castgraph.py,sha256=jSG30D_rPtiUZuQFFnlCG4N3VG-7pmMwmrtNVI0NS2A,4075
+numba/core/typeconv/rules.py,sha256=-UiVALjcbWftHB0_SwhAlttqZqNGbUcZJnw3KK598JE,2353
+numba/core/typeconv/typeconv.py,sha256=unUXurghuhnWA2pA-6CA1m_a6qVOmAj6_wopk6iuLv0,4369
+numba/core/typed_passes.py,sha256=I9AgISBV1iQzVX0Osq0lBV5jtOvyzSAhgU4Nl9hUDyM,38624
+numba/core/typeinfer.py,sha256=PiZflCE2X2m4-GyJriUTNpaDO2juf4lxPIfg-omB1pU,71283
+numba/core/types/__init__.py,sha256=te_BimK8ap8ISOJtH_W8OAMPSRpAb6Z-LZTkCi_cXCQ,10418
+numba/core/types/__init__.pyi,sha256=IfSSUu8RZKujhXcGhZ2pM-AYOsug_hZbZpw_Bf1ggms,5679
+numba/core/types/abstract.py,sha256=6izEJB0LuQcn1OomxPkENqiiOt0E4L8N6P6G0lo-GaE,15172
+numba/core/types/common.py,sha256=lcBWBAXAxtVs81G4cLzjNoXnSuvhd5newMwrJLuKxQw,3022
+numba/core/types/containers.py,sha256=zrzAQNsDW_oXgYliojfmVaRI2WHvFazDviBFPFcnEsw,27998
+numba/core/types/function_type.py,sha256=wWskEdTuvm287ZZwRdvff7dQ4yZAGVDBmANPIlWnf3Y,6551
+numba/core/types/functions.py,sha256=7AXMlfIGv3opwg0OuK3bojN0e_3PVzB-QRZSvh0KSgk,26938
+numba/core/types/iterators.py,sha256=Byq2QyPRSTL_Z-xeUJKljd3anzDny8CN1TEp-YmqISw,3534
+numba/core/types/misc.py,sha256=NcljFVerH2tvV-o2n0uWM0d53Tp91Wp3BWXmBPGgISk,14609
+numba/core/types/new_scalars/__init__.py,sha256=PNNiWfnO-lFEHVA5Nl_tgGQWn7w_HWBuls8pNCQ1noQ,775
+numba/core/types/new_scalars/machine_types.py,sha256=wYmfqP1q0fYG03IXRh-3Q-xTOdWnG1zFOeV3Z47m6Ng,3635
+numba/core/types/new_scalars/numpy_types.py,sha256=7icXUKUujP30soyxOSKeHk95Gz-d303svxZqiFgFBl0,4221
+numba/core/types/new_scalars/python_types.py,sha256=R3bkM9rN36LuDsbX68qgJbJuhTmxFI9TcQU5RKPx1hU,3742
+numba/core/types/new_scalars/scalars.py,sha256=wm4gGEn8RKqlOR5jBGw2UFR0H3UHs7ZYom-dQJR0MJ8,3858
+numba/core/types/npytypes.py,sha256=Dko5LsKPeqyD-AXg0yKj_unnBOPPCDjaCf1DtOZPMsA,20597
+numba/core/types/old_scalars.py,sha256=8nYY97-8HXWjX3ZsKR7PU_bfILwhJE5aGVmgpz9LSMU,7225
+numba/core/types/scalars.py,sha256=Q84ff0e35ZMskLMgDbuQvAeymO5GX5TnvHwkxmp9Dis,354
+numba/core/typing/__init__.py,sha256=FD8n9EBp1Dd65qpibBRAYoGMkRy-U1snNitmaSceyLE,152
+numba/core/typing/arraydecl.py,sha256=bFeyDlDyLgVBtjsKVGhL241JjwgY7pAHliR15B35JI0,31758
+numba/core/typing/asnumbatype.py,sha256=67welqrrQN_dErvwWB-jUOJMmjqdFMf6WQcGSL9Dd68,4482
+numba/core/typing/bufproto.py,sha256=zVIp31qMyQdcKftYwZMomQX2mrUm8JlOypGKR73jnOc,2206
+numba/core/typing/builtins.py,sha256=rfwnSTqOoz-M1Da9Neyc1mHE-qGTqBvDN6IutTB4Jqk,359
+numba/core/typing/cffi_utils.py,sha256=PyXrHNzWAC_7ED1pjMiF6mYk8uSce_dzehqaHDAji24,7949
+numba/core/typing/cmathdecl.py,sha256=_DnSUWl3mp9NzBZGwfT0PtwgQD8I_5OtUpDpBhonwmA,361
+numba/core/typing/collections.py,sha256=WDhsPKYV7QUd5ACfEd8zJphvCyPLSj8eb66EhFGFNbg,4025
+numba/core/typing/context.py,sha256=mpTlVzd95Oa2MvsB0gz_NGalZ1DAaI46N73DAbNowkg,25883
+numba/core/typing/ctypes_utils.py,sha256=40do9Sx-Rm_HZ3lBQ3ZjIzpnh3ycndO2n7N1tTZ1k_o,4282
+numba/core/typing/dictdecl.py,sha256=-rFhnPbP140Sy_iaJufIP5gtE8Hd61rzoHNb5lKbDZk,1872
+numba/core/typing/enumdecl.py,sha256=W9ugyhgCumA6WLM8HG9nKndU55sYal6KB28Afa47O-A,1503
+numba/core/typing/listdecl.py,sha256=mYRdzNLhAXScEj8-ldr8xSzA1rsmmY27-SonQOJTH3Y,4494
+numba/core/typing/mathdecl.py,sha256=wrdYOgW1M97hrKwBKON_VH1bwx6qtIfpSSVRhayR5Cw,359
+numba/core/typing/new_builtins.py,sha256=WIi-EJLqAdhudnNmb1F0SfcXzoMT1qYTrLyG9bUJBOc,34467
+numba/core/typing/new_cmathdecl.py,sha256=ZSkG48kPVVb3dyRKrWHxLPchwpdVFIHzsn_vJbqCVH0,1200
+numba/core/typing/new_mathdecl.py,sha256=kgHWae3pJ_Zakr3YrJgNASZvBoMYYg3yKrkTYlVblKg,2222
+numba/core/typing/npdatetime.py,sha256=anqxajPR4i3q_8GnSiG_7Y-CnGzLLn5ieiFFk6h-H-0,9202
+numba/core/typing/npydecl.py,sha256=mwOsN7x6UjZPAdcFPcBvPfsLnMRbTVgCmu1dNPZ2b8Y,25890
+numba/core/typing/old_builtins.py,sha256=p6rQWaeIRvDJm0nPjN0SN_ijnYHNjDYAb-WIYMkX_bc,34864
+numba/core/typing/old_cmathdecl.py,sha256=J7F_fnavUrRcuwgVNt4XrsoojCBZ_K-CNryk_3JY5eo,1202
+numba/core/typing/old_mathdecl.py,sha256=aSLyj4ZFC3SmkjfD_58koL9SxtuA7VAdbvwLeqcHGXc,4393
+numba/core/typing/setdecl.py,sha256=YugeSIfastKRzE5N098jUBDeEscYiKxCrr69_cDYd9g,3209
+numba/core/typing/templates.py,sha256=dhpwzt2Iq1CxbWF0Ig_1HLq4VGLxWb_VlbL77DzNSvE,49841
+numba/core/typing/typeof.py,sha256=u2DdOBY38ju7skXkVMVHlTfAgG9biiKlzM0bhxFE7Lw,8190
+numba/core/unsafe/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+numba/core/unsafe/bytes.py,sha256=2X-_9etm5LeGkKOgOR9T5CezCydxZtDstHNookgOfoA,1720
+numba/core/unsafe/eh.py,sha256=fDSxnbGv5xTjGk8dj0M4hiJoySxbUNdKEhIVCOUiK5c,1621
+numba/core/unsafe/nrt.py,sha256=3voPFKB8jZdLq8bm05_USvS6xhBerF6G7sz8uC3CHxE,468
+numba/core/unsafe/refcount.py,sha256=hYVRt3Aw2iaXX_rvB1a1tYMW-9YtFi3G5Dvx3SN2n3s,2704
+numba/core/untyped_passes.py,sha256=6JwoTnyk8Fy4Pg53GxYfm9YfyML_1whDn3ckjmLm_Vw,74778
+numba/core/utils.py,sha256=J_V_hlSxLlJoeli-6tuxx2p5qBz17ke4eo1HrKQPXp0,22200
+numba/core/withcontexts.py,sha256=_zHSMfOYY43_-dYyZ-WXd257SrsV4asEq2H5t0BNAuo,19034
+numba/cpython/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+numba/cpython/builtins.py,sha256=miK_eUabOHHlWBbu8ahNp9gLilHBejQzqUHEAJfqHs8,403
+numba/cpython/charseq.py,sha256=xprjzAQ2QaMhKmiuPvwDi6Mtm-ECn0boxT3inGGBqso,34876
+numba/cpython/cmathimpl.py,sha256=FtDWq6PtOUTZMZ4k0K0JOgmEpUZk0wM2G0-aRBTL2ME,17607
+numba/cpython/enumimpl.py,sha256=nGDz9MdYT0Zmy2En_VoyT5Aq_9-0mV1qNl1MdzbNwIw,2906
+numba/cpython/hashing.py,sha256=qt5IPK2cnOPaYWhwaGVv1tMZTHDYPjrftXPeCEmJcAU,401
+numba/cpython/heapq.py,sha256=v4AIbYVfPkAcqjcxN1r9RyIOIyqeek4UzOiOJftUYqw,6185
+numba/cpython/iterators.py,sha256=jVWfyzonVMfAM4tvctuXFQDceCzuNWs5Qm2b-EaRPLo,4879
+numba/cpython/listobj.py,sha256=ffPRQclTJa12DI0y8E3r2UytWDuwOYxRROwOma0KLeM,42953
+numba/cpython/mathimpl.py,sha256=fC2elhQmdXQ6Dkt08IAc9enD8o3Mi_CN1L3OLDXNUmw,403
+numba/cpython/new_builtins.py,sha256=dOQAJwa_JVc42Wvk09MNcJDL4zK_G1A4tzfWqTZtKYo,36214
+numba/cpython/new_hashing.py,sha256=04pgO2pwZC-vgfUXEZiHoWyTNNAFqIUEgU_dECJSnEo,27269
+numba/cpython/new_mathimpl.py,sha256=R6OS20bpz1dEuCH_3I220FrxCGFvmY3NtXSBDwKvqL8,16139
+numba/cpython/new_numbers.py,sha256=z0xPBjKbfMMnCwPxkFZMeHQQIvkY7v2WUVhjrLBJxkY,50121
+numba/cpython/new_tupleobj.py,sha256=6Grugb03mT718jcozmhH95YpatAaHIBZ3vbQcEsgjhQ,17001
+numba/cpython/numbers.py,sha256=1yXT3hnWsxvtQwu8E4JkbLZfTuIZrPBB9IXskoAdFKA,401
+numba/cpython/old_builtins.py,sha256=NiB5aKwgigRaVrtvqASmXJgw1z0NYIwi8FFWvZXf9vM,36165
+numba/cpython/old_hashing.py,sha256=Jf0uvGv3-envazAV96ury6Rv1l2jKppX4ZGlpHlWrM4,27042
+numba/cpython/old_mathimpl.py,sha256=5Q9nZLY1LwnSNBb3UBsU5JtcdcqPBOV6YPByChqVOaE,16111
+numba/cpython/old_numbers.py,sha256=mXvK0Z43f1tuppj1jz8kDuBX3r8cxOfwx8NIJfm7LJQ,50138
+numba/cpython/old_tupleobj.py,sha256=PJnDm23QFGHdQvtP8IvM0gdYElsX80WcvRK2zr0qDJc,16858
+numba/cpython/printimpl.py,sha256=b3_D82zXQUyZHv6UubXlF_cXY6jp6HhbELpBk05xp4w,2482
+numba/cpython/randomimpl.py,sha256=-7Cky4MEfkjb8E59U6TLm5NEYHQdJ8CeQ5_tS6hnl3k,81584
+numba/cpython/rangeobj.py,sha256=yPtwzScgatNzZ3BM7oowPxNfvZrBlG7EXtysqUAkJ0E,8814
+numba/cpython/setobj.py,sha256=Wo4TmkOfyaV2NfBYMMxhAGK3L4ZWTMMjYKEf_Xmo1BE,57246
+numba/cpython/slicing.py,sha256=BJIh9WSWE5hksbkjpNJFclfofEXSkvB_kLYNGcrWk0g,9435
+numba/cpython/tupleobj.py,sha256=vt9UVEq9kb0n31Xgu_jhTFDqX-PJyE8V-SXjhVLvL4Q,403
+numba/cpython/unicode.py,sha256=IJkQdswixHt6YYsXwCxxSnLfWW9Lgl2N0VRdT7CUlMg,90026
+numba/cpython/unicode_support.py,sha256=nwARWQQlJsEb3gT9HvH_qVlp4ceSby_PY8Y5TGapN8k,27405
+numba/cpython/unsafe/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+numba/cpython/unsafe/numbers.py,sha256=99pqDh2kEopxjAX8H0GZ3RFNV0eFMnMWjp7g6qwM7mQ,1719
+numba/cpython/unsafe/tuple.py,sha256=t2IJz9N3DzBbgE5cy6g5dWAZ17a3Td9PDNWWHsp5aWY,2883
+numba/cuda/__init__.py,sha256=dVzRg7REcZRsrS8h6DSsMjij418I281Mha1tYhwO5uo,620
+numba/cuda/api.py,sha256=e9Y7RQWh8mEl3Eie3xzgniSgjHC_nlLrjBCiYx5pNs8,17601
+numba/cuda/api_util.py,sha256=aQfUV2-4RM_oGVvckMjbMr5e3effOQNX04v1T0O2EfQ,861
+numba/cuda/args.py,sha256=HloHkw_PQal2DT-I70Xf_XbnGObS1jiUgcRrQ85Gq28,1978
+numba/cuda/cg.py,sha256=9V1uZqyGOJX1aFd9c6GAPbLSqq83lE8LoP-vxxrKENY,1490
+numba/cuda/codegen.py,sha256=raBoCDNt_qkDgB12yU0tbJQlA5_eTlUMemgcRHen1Vk,12174
+numba/cuda/compiler.py,sha256=seanDEVVsiBqGmHUivIxcYf6mPWEgPYam1rects5-vs,15886
+numba/cuda/cpp_function_wrappers.cu,sha256=iv84_F6Q9kFjV_kclrQz1msh6Dud8mI3qNkswTid7Qc,953
+numba/cuda/cuda_fp16.h,sha256=1IC0mdNdkvKbvAe0-f4uYVS7WFrVqOyI1nRUbBiqr6A,126844
+numba/cuda/cuda_fp16.hpp,sha256=vJ7NUr2X2tKhAP7ojydAiCoOjVO6n4QGoXD6m9Srrlw,89130
+numba/cuda/cuda_paths.py,sha256=_fPrwCysDSoxwUvU_2xyGe9KSDxtHzunkxVqQNLtTBg,7723
+numba/cuda/cudadecl.py,sha256=ynUidit8oPGjedc6p1miMGtS20DOji3DiQHzwmx6m0s,23192
+numba/cuda/cudadrv/__init__.py,sha256=0TL4MZcJXUoo9qA7uu0vLv7eHrXRerVmyfi7O149ITw,199
+numba/cuda/cudadrv/_extras.cpython-313-x86_64-linux-gnu.so,sha256=bDFO79GDQMw2TtX0aZ30J-M46fJnswdG3ammY3yVb7A,26008
+numba/cuda/cudadrv/devicearray.py,sha256=B3ItYQywTnwTWjltxVRx6oaKRq7rxTtvOaiqTWsMQ2w,31123
+numba/cuda/cudadrv/devices.py,sha256=6SneNmoq83gue0txFWWx4A65vViAa8xA06FzkApoqAk,7992
+numba/cuda/cudadrv/driver.py,sha256=_qxCcnuwf4sBfhxm6Oic5wxzDmuS0StlZFGz9HN6-mo,106838
+numba/cuda/cudadrv/drvapi.py,sha256=gDalZLaZBRQIDU-LUXgV7MwPJlgKuiu8h0YEcTA6_SM,17129
+numba/cuda/cudadrv/dummyarray.py,sha256=nXRngdr-k3h_BNGQuJUxmp89yGNWxqEDJedpwDPEZ44,14209
+numba/cuda/cudadrv/enums.py,sha256=E0lnh17jO4EvZ_hSIq3ZtfsE5bObmINtKb_lbK7rmMg,23708
+numba/cuda/cudadrv/error.py,sha256=zEIryW6aIy8GG4ypmTliB6RgY4Gy2n8ckz7I6W99LUM,524
+numba/cuda/cudadrv/libs.py,sha256=PRyxal4bz9jVZmuLpKiYw-VaR59LekfwJgWKo7R5uRY,6005
+numba/cuda/cudadrv/ndarray.py,sha256=HtULWWFyDlgqvrH5459yyPTvU4UbUo2DSdtcNfvbH00,473
+numba/cuda/cudadrv/nvrtc.py,sha256=CLpuD9VzPcYoXj8dZ2meSoqbWXHOOC5V5D6dFNdXqmg,9693
+numba/cuda/cudadrv/nvvm.py,sha256=v2hJJTAQeRmoG59-hnhgMEp5BSVA73QHtEoy636VKao,24107
+numba/cuda/cudadrv/rtapi.py,sha256=WdeUoWzsYNYodx8kMRLVIjnNs0QzwpCihd2Q0AaqItE,226
+numba/cuda/cudadrv/runtime.py,sha256=Tj9ACrzQqNmDSO6xfpzw12EsQknSywQ-ZGuWMbDdHnQ,4255
+numba/cuda/cudaimpl.py,sha256=3YMxQSCv2KClBrpuXGchrTNICV1F6NIjjL2rie5fDZ4,38628
+numba/cuda/cudamath.py,sha256=EFNtdzEytAZuwijdRoFGzVKCeal76UzzaNy7wUFQx8I,3978
+numba/cuda/decorators.py,sha256=hLCBs8Ah8v-uJHStr9NE4gtLPI1TI3zNiQpXg_UPyT8,7813
+numba/cuda/descriptor.py,sha256=rNMaurJkjNjIBmHPozDoLC35DMURE0fn_LtnXRmaG_w,985
+numba/cuda/device_init.py,sha256=orQK7anhnmEkYPRjHEs5I9uhdBwaHeXbaSD4ViX2_14,3460
+numba/cuda/deviceufunc.py,sha256=yxAH71dpgJWK8okmCJm0FUV6z2AqdThCYOTZspT7z0M,30775
+numba/cuda/dispatcher.py,sha256=Gt9DbmtuAxeglZtOzYESWaTGLO76_p--pDauhMCJsJc,40157
+numba/cuda/errors.py,sha256=XwWHzCllx0DXU6BQdoRH0m3pznGxnTFOBTVYXMmCfqg,1724
+numba/cuda/extending.py,sha256=URsyBYls2te-mgE0yvDY6akvawYCA0blBFfD7Lf9DO4,142
+numba/cuda/initialize.py,sha256=TQGHGLQoq4ch4J6CLDcJdGsZzXM-g2kDgdyO1u-Rbhg,546
+numba/cuda/intrinsic_wrapper.py,sha256=zbcUbegbfF3GdnC2Rl-z26-gozE8xBtaMxpS8LpOhfo,2239
+numba/cuda/intrinsics.py,sha256=zk7KCyzRyXlBpxwEJLg_3oGRXOA7bODX4RPEsMKns9A,5983
+numba/cuda/kernels/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+numba/cuda/kernels/reduction.py,sha256=fQnaWtoNB2yp143MNbE1DujqFIYy0KV_2moQVvbaROU,9362
+numba/cuda/kernels/transpose.py,sha256=5FSu-nbTfhintxwfU-bjT2px2otQF5QkKH-JPDDWq_k,2061
+numba/cuda/libdevice.py,sha256=476LeIEaAth409m-0OO1SMMmY5AHzN2AotXI__k_yYE,60065
+numba/cuda/libdevicedecl.py,sha256=xdZbb_rCaftMf8Pbw63g_Lr230N-1QoaYzBxq8udKTg,532
+numba/cuda/libdevicefuncs.py,sha256=c80lGpGoFIYkAdgr4fzbxzdNCyJYrLdss64bwa0Mc6w,37471
+numba/cuda/libdeviceimpl.py,sha256=a9BmJ5kRtZ_mB7KjbDWW-PEpRuNiO_SMOxQTyy0abqs,2806
+numba/cuda/mathimpl.py,sha256=d_gCoQ4hJzNBFNc2hvRON5h1F052epgQ8zh_RKTlLlI,14416
+numba/cuda/models.py,sha256=2c_seT-cWX-VyWYmcapaqOEl1M4FX6_kdIOusj4s5aE,1328
+numba/cuda/nvvmutils.py,sha256=W1zr1TpnmFjTkHF0qeu5wnBHub6gzrnpzsvgmu2OLcU,8295
+numba/cuda/printimpl.py,sha256=Eg_RvmOcmFeL6s2RlTD-oOxebGdYLN9VZM1gcY3YMms,2789
+numba/cuda/random.py,sha256=khX8iDdde_RTUPWhAqrxZacHRQAorFr7BokPuxRWzrg,10456
+numba/cuda/simulator/__init__.py,sha256=crW0VQ_8e7DMRSHKoAIziZ37ea5mpbh_49tR9M3d5YY,1610
+numba/cuda/simulator/api.py,sha256=_O9lox-obYn2j4843uZ2hZjIWgu7PXSqQGy3EiSwnnc,2620
+numba/cuda/simulator/compiler.py,sha256=eXnvmzSKzIZZzBz6ZFJ-vMNyRAgqbCiB-AO5IJXuUyM,232
+numba/cuda/simulator/cudadrv/__init__.py,sha256=MC6WHlTloHxGen9kIpH1Hp2p1PPyCNmoK5f3K9f7jXA,135
+numba/cuda/simulator/cudadrv/devicearray.py,sha256=brhVnaKiJFIvZbNlE-3yft_YXTmNm4S8s95VXWT_nMc,13789
+numba/cuda/simulator/cudadrv/devices.py,sha256=RYvLHarMNeHNrCYFokxXtg1nBIDRMu3ZohQ82hLQXN0,2689
+numba/cuda/simulator/cudadrv/driver.py,sha256=mRz-PV4lqc-Mg3w5yUJWdrj0XS_d-3CM93uI2ZR1MTY,1124
+numba/cuda/simulator/cudadrv/drvapi.py,sha256=76gXxRAQgr8bU-m8XizvqyXyXAZWp6QhUnS6rI-6E6Q,111
+numba/cuda/simulator/cudadrv/dummyarray.py,sha256=DYIpIehz3cZSane651UYdJP5fehDuJkxyCg_90A1heU,163
+numba/cuda/simulator/cudadrv/error.py,sha256=ACSQ7ZvhuCHnvV4GmvRuKWZ5bBLVzq7ncZ75oiWyLdM,87
+numba/cuda/simulator/cudadrv/libs.py,sha256=ry5rerpZrnAy70LU_YBa1KNaqKBGLHE9cMxljdSzaik,101
+numba/cuda/simulator/cudadrv/nvvm.py,sha256=vIFQi4ewYXyzUYssfw78QLfoZmoVgloFCLTk55Gg1tw,474
+numba/cuda/simulator/cudadrv/runtime.py,sha256=K63p7puZJZD3BQ6ZT0qoII_Z3xJiUckp2dhozFjrnEs,358
+numba/cuda/simulator/kernel.py,sha256=GO4HuXBlEstJtgiuMRB_6hjNizBSINR9_hganvMjHH4,10593
+numba/cuda/simulator/kernelapi.py,sha256=ZYC_XQqnA51TJCPlAjVHHkOjXeww0yUP6JZeibXw3T8,12397
+numba/cuda/simulator/reduction.py,sha256=jVo9YiWv8W2CN5_oQ-xdS3nuxv1HZmWh9O-Vck8hsQc,300
+numba/cuda/simulator/vector_types.py,sha256=jAQC3JrWtabSmOA-ZGBq7PMW40EZTNPkPpKCzC5pz1c,1769
+numba/cuda/simulator_init.py,sha256=W_bPRtmPGOQVuiprbgt7ENnnnELv_LPCeLDIsfsvFZ8,460
+numba/cuda/stubs.py,sha256=a9smsDwbimTKy0YnV88OkcbYqldMgkx-WiV8LB4-MGs,22280
+numba/cuda/target.py,sha256=EI6XuKQeqvng0uSx_V9jDoxbgFivqSz-4jczFzAbs5o,16837
+numba/cuda/testing.py,sha256=E0wP2vfno1yWsl0v1zg31kpbU8FrKxTF-5y9Iv4WjA4,6412
+numba/cuda/tests/__init__.py,sha256=lvnEpX0TruMCga3PnDpryR3oVxLwOMyTyZKgMINCerg,984
+numba/cuda/tests/cudadrv/__init__.py,sha256=KeAvH3QOb-KXXkFtzwvYkQp2ZrQmzgfKDkBCVIOKXXE,257
+numba/cuda/tests/cudadrv/test_array_attr.py,sha256=cjHQ0J6F8APrLm23ZCFr0S7dtQmLqwq9vxMoI5lyn68,5300
+numba/cuda/tests/cudadrv/test_context_stack.py,sha256=lSEuEM7x-x95m_lS_wSIBKnBxOhzn-AJ3WjYw8bW0y4,4492
+numba/cuda/tests/cudadrv/test_cuda_array_slicing.py,sha256=RVFiuTx5wTFBECzEolJqquhfWCD6BlrK49IPyDPdmY0,14112
+numba/cuda/tests/cudadrv/test_cuda_auto_context.py,sha256=Bhut5gxKb8H-RNu8LKp0nEmyQT5FZVRA-aOrV6X8h3E,564
+numba/cuda/tests/cudadrv/test_cuda_devicerecord.py,sha256=rikIJQ266l_yiSMoncEeKJZizYdoVOiTg1R0gD_1nZY,5766
+numba/cuda/tests/cudadrv/test_cuda_driver.py,sha256=y--0AZFVpp2nmbeI1jbgZsWbBP-iVEmG8WKgR9XrxKE,7663
+numba/cuda/tests/cudadrv/test_cuda_libraries.py,sha256=sqNbo8pk4Zl5ptuGXrXFndia4IyttbuGnqjVTOtGuuw,801
+numba/cuda/tests/cudadrv/test_cuda_memory.py,sha256=MDJMIWm1jCsBOcuwdshzqwaE__uqX0562uSjxFhud3M,6627
+numba/cuda/tests/cudadrv/test_cuda_ndarray.py,sha256=67dmVO6v5gzp89pgb4wpxqDrWAx1UjX4vhdDQH4mebQ,20403
+numba/cuda/tests/cudadrv/test_deallocations.py,sha256=BR1ccEj_TCVToHoHS8KwwCfKLMUl6KGb92Cx6nX-XPg,8404
+numba/cuda/tests/cudadrv/test_detect.py,sha256=lCt2E8gxnd8O-fRobDEwgX4jBZ15W7cImQcZc8_u2Sg,2774
+numba/cuda/tests/cudadrv/test_emm_plugins.py,sha256=ah82yaWFvBfUTTSfbkZBKLsUf2tTSSJNvlSxrk1RI1E,7094
+numba/cuda/tests/cudadrv/test_events.py,sha256=rjBrFDxZUpfwRkAGMvMEcdjOQ7sKB_94Spv1ccxTCjQ,1075
+numba/cuda/tests/cudadrv/test_host_alloc.py,sha256=1zGjcSFSym-LZ7XQwlOPalU-GjTOYUOEPTeSG4iNQhI,2181
+numba/cuda/tests/cudadrv/test_init.py,sha256=kPbjDhLJr1Rl18UJZoGpT3E0l9Cm-HcyPRbKr-BD7L0,4493
+numba/cuda/tests/cudadrv/test_inline_ptx.py,sha256=eMImGlfYRQM5esoFhWHOwDGYK3RuXdrNvStURwcFDlc,1287
+numba/cuda/tests/cudadrv/test_is_fp16.py,sha256=0KPe4E9wOZsSV_0QI0LmjUeMTjWpYT8BXExUUsmUCDI,394
+numba/cuda/tests/cudadrv/test_linker.py,sha256=_l2_EQEko2Jet5ooj4XMT0L4BjOuqLjbONGj1_MVI50,10161
+numba/cuda/tests/cudadrv/test_managed_alloc.py,sha256=kYXYMkx_3GPAITKp4reLeM8KSzKkpxiC8nxnBvXpaTA,4979
+numba/cuda/tests/cudadrv/test_mvc.py,sha256=984jATSa01SRoSrVqxPeO6ujJ7w2jsnZa39ABInFLVI,1529
+numba/cuda/tests/cudadrv/test_nvvm_driver.py,sha256=VTw8-TZ7DvjNEqsrzZ-RKKzLRiSKEyAAZ3pRDYEQiVk,7252
+numba/cuda/tests/cudadrv/test_pinned.py,sha256=u_TthSS2N-2J4eBIuF4PGg33AjD-wxly7MKpz0vRAKc,944
+numba/cuda/tests/cudadrv/test_profiler.py,sha256=MQWZx1j3lbEpWmIpQ1bV9szrGOV3VHN0QrEnJRjAhW4,508
+numba/cuda/tests/cudadrv/test_ptds.py,sha256=S8y-j_ZB4Y_r2S5GGtfFxfracnJflQAhHYfhybKIcUE,4949
+numba/cuda/tests/cudadrv/test_reset_device.py,sha256=tPDkdkqNZEix2dLqe4UBcsejhauAc1oEQlrZDtPKWFE,1073
+numba/cuda/tests/cudadrv/test_runtime.py,sha256=h4ZIHkZbDjoZhgvFUWVfwWcktkgkoHMuDJq6SWn6hXc,3071
+numba/cuda/tests/cudadrv/test_select_device.py,sha256=DjfS3hGTDRFAQsk7QiH-v6-_1HEdaLeSyTiquwUPCTM,987
+numba/cuda/tests/cudadrv/test_streams.py,sha256=Yyzj1riNWRKM4FX3CtbMOQ_LWp92M5HXW6g_aq2r9Oc,4195
+numba/cuda/tests/cudapy/__init__.py,sha256=KeAvH3QOb-KXXkFtzwvYkQp2ZrQmzgfKDkBCVIOKXXE,257
+numba/cuda/tests/cudapy/cache_usecases.py,sha256=Cm2YupAQE7IFsiHp4TnC9kb_CLXGFMEK4zMaELrktIk,5834
+numba/cuda/tests/cudapy/cache_with_cpu_usecases.py,sha256=xm035XOas_2AXORGEQHz7hcDuXwL-bdpy3gL5AKp6ik,1142
+numba/cuda/tests/cudapy/extensions_usecases.py,sha256=l-tW4F935zxOvKb1erFiGf9R1iJXjMbvWInrdzJLub0,1604
+numba/cuda/tests/cudapy/recursion_usecases.py,sha256=7Wz7i_6VVq5EeZuqkcg1dVfW9DbfC1rp44H7pe4voqI,1781
+numba/cuda/tests/cudapy/test_alignment.py,sha256=dik8i4fG6MPlxVilW4l9pM5o_vBMAsRGItldeE9hvvU,1218
+numba/cuda/tests/cudapy/test_array.py,sha256=bS6rzvp6BKVLFyW8mFRbVoZbxIbc2WCl5SzQ6XG0s8c,10515
+numba/cuda/tests/cudapy/test_array_args.py,sha256=XTX4cT7BZexmw0BZPzeudf4OZgM6GNqzjDPyIxJyTdk,4979
+numba/cuda/tests/cudapy/test_array_methods.py,sha256=shdeSAOKaoZbrvC8hXhETWH8FhyZPTmHg_TMw2DcdUA,969
+numba/cuda/tests/cudapy/test_atomics.py,sha256=NvZ2XxQMa6Psyg9PQAFYcdYMOr9OjhGMYvYD3Vp5WiI,58449
+numba/cuda/tests/cudapy/test_blackscholes.py,sha256=dpPWyCnxRUThaK6npGvN5_fhU-KT1b1GifU5Tj3AHMI,4023
+numba/cuda/tests/cudapy/test_boolean.py,sha256=S8fNBS4gVEZyKk6PpeF5GfG0TLEu_0NvTgybyPNNGLU,547
+numba/cuda/tests/cudapy/test_caching.py,sha256=5o1VcVbir1Lro6yFCerbfbjsxH9xNsYFl7N4Rud6ntw,19082
+numba/cuda/tests/cudapy/test_casting.py,sha256=XrMWIMhGwUGRzh6gocw1Ogj8RORyZZrcFWOuc1ABUtU,8802
+numba/cuda/tests/cudapy/test_cffi.py,sha256=FFbFBA8xJrTfwmlt5LRsRt4xXC93P0aa-bxgzaItwKU,938
+numba/cuda/tests/cudapy/test_compiler.py,sha256=fQ1tLxahLrawlIe1VJlDHciKkrTVutirmOzjp2fEiRo,10821
+numba/cuda/tests/cudapy/test_complex.py,sha256=PO1ySqBsttB9lFnQ1psWDss_JEMbqiHye0c2QBRRVU8,10290
+numba/cuda/tests/cudapy/test_complex_kernel.py,sha256=G08aM81rARqojCKnsunVG7vJB9ggon7H8S8xFaZoK_o,497
+numba/cuda/tests/cudapy/test_const_string.py,sha256=er2ANBSHGby_QxcsZvOKgo9znjKZfcPxKAAT1DoLGhI,4279
+numba/cuda/tests/cudapy/test_constmem.py,sha256=rdnGaRKWqjks3rug1stx5gC0w7Md20_15U8xnj-N3LE,5166
+numba/cuda/tests/cudapy/test_cooperative_groups.py,sha256=ZQuct24GEZnb2JBDvo7ZrUbtTHchysVGoY2BGnSXsfk,5039
+numba/cuda/tests/cudapy/test_cuda_array_interface.py,sha256=73FCQbNaAKpuybAwMOt4eW_dL_K6ZjrRgQw09ojkSbY,15844
+numba/cuda/tests/cudapy/test_cuda_jit_no_types.py,sha256=iqYs48wLh6kR2RwGuuBmuSFUBaOyBdV1BNhxZghJcrM,2126
+numba/cuda/tests/cudapy/test_datetime.py,sha256=2in1Cq8y9zAFoka7H72wF1D0awEd3n7bv56sUPgoNAQ,3508
+numba/cuda/tests/cudapy/test_debug.py,sha256=0H_c9Cm4kNJCem0CkSeL8EQY1IhJ43ho1wDXGEds2Ic,3557
+numba/cuda/tests/cudapy/test_debuginfo.py,sha256=jDPgxSe0G0nAib3wgbfrOg6uvnwmCcuB9GhrzXEvlc0,7875
+numba/cuda/tests/cudapy/test_device_func.py,sha256=aTRyZSOJB3sAShw0YAEgHILrR-TCuowW9KYjtlRErKM,6892
+numba/cuda/tests/cudapy/test_dispatcher.py,sha256=oX-l_L4H8rME1IolwhAyordSGJ152nnuqGAFdWjfgas,26587
+numba/cuda/tests/cudapy/test_enums.py,sha256=0GWiwvZ1FTzSl1FfMxttkWaWrowASfXrSDT8XAR4ZHw,3560
+numba/cuda/tests/cudapy/test_errors.py,sha256=jwHbNb2Ro5pbGOPFetmUhI-vG4s36OKCqMJ-lgWxHMY,2620
+numba/cuda/tests/cudapy/test_exception.py,sha256=Y7VF25tzz2w5MIZjYD3vG1eTfmowFO-RBea2HiJilag,5501
+numba/cuda/tests/cudapy/test_extending.py,sha256=jcu7BXC0wwpnxZd25gbREukjiEMk7YXmIhc-nev5Mvs,4118
+numba/cuda/tests/cudapy/test_fastmath.py,sha256=eZ9KowHlnNByZfUU-8ZB2NhlGBlZhG-5N_sipXhVGgE,8401
+numba/cuda/tests/cudapy/test_forall.py,sha256=rcSiGr_RAqPbc9o4-wrBuH3ucMMlsNdf2ZjjbVUUwvY,1457
+numba/cuda/tests/cudapy/test_freevar.py,sha256=e8KMNFxJYLXcFv2V4OIh7YmI1cwo-NdCaamVmKWnANw,745
+numba/cuda/tests/cudapy/test_frexp_ldexp.py,sha256=82y4vgKIwHTJnA9nqvHOyvLgkdLezqWstge2tChDytI,2024
+numba/cuda/tests/cudapy/test_globals.py,sha256=b_i_JZ6ijBXuxTq5QBqzfCg9c48tOuGhRw1_fc72NBs,1384
+numba/cuda/tests/cudapy/test_gufunc.py,sha256=0NWfQqHmx7tFh6vdS7QtxT86uB9-GmYYfg2ldFlFQLU,15603
+numba/cuda/tests/cudapy/test_gufunc_scalar.py,sha256=Uhe8Q0u42jySrpwAZh8vCf4GMYkiy9NOMolyzEBuri0,5382
+numba/cuda/tests/cudapy/test_gufunc_scheduling.py,sha256=luDtBxFS_5ZbVemXe1Z7gfqMliaU_EAOR4SuLsU5rhw,2677
+numba/cuda/tests/cudapy/test_idiv.py,sha256=HLJ_f2lX8m_NNJjUbl_8zZ0-8GsBlRdBP2CUo_yWb0Y,1056
+numba/cuda/tests/cudapy/test_inspect.py,sha256=lP9-8SbWFn2Xc-qmF6UNhcY6LreKTnveaK5CGW2pu8E,5196
+numba/cuda/tests/cudapy/test_intrinsics.py,sha256=e6lABWy8YBgYheYYGfD75_y8vMbPP71GHb95A4hlLmA,34931
+numba/cuda/tests/cudapy/test_ipc.py,sha256=Ky9d9BnndVgqRFFEcvEX-mn9ai7q1oBpkHykx6ChGM4,10441
+numba/cuda/tests/cudapy/test_iterators.py,sha256=daQW3kSkp7icCmlTn9pCvnaauz60k_eBf4x1UQF-XVY,2344
+numba/cuda/tests/cudapy/test_lang.py,sha256=U1BCVZMjU1AZ4wDSmjsRIPPcAReiq4dB77Cz7GmrdmA,1691
+numba/cuda/tests/cudapy/test_laplace.py,sha256=yD--H5p_NrBHklFNCnxuQ0S8yUIBYScBkvn7hBlZ5ZM,3211
+numba/cuda/tests/cudapy/test_libdevice.py,sha256=4NsZBXweDPQpqfgo6T7eQHaWDVBof1CZDTpI1QTkV74,6545
+numba/cuda/tests/cudapy/test_lineinfo.py,sha256=sKPF5l1cDTyA4UT0IO8Yeq6pYPGt9pIBQtrMAJMJHCM,6855
+numba/cuda/tests/cudapy/test_localmem.py,sha256=uv9UYuytIXQgzHpPgEoWVVVq5-a7-6Io_mWMiNsZ45I,5376
+numba/cuda/tests/cudapy/test_mandel.py,sha256=crVQBw46l4iyAv8_pu7v1eBy9ZJG7OkigB5zsyi6s3A,1085
+numba/cuda/tests/cudapy/test_math.py,sha256=T-KRh9qzwOL3usl_6Cly3FVlvauzGhGnedfAG1hBQy8,27615
+numba/cuda/tests/cudapy/test_matmul.py,sha256=cZpJZ66UFmszLBQ4m1GdPyi27YHFkA6jo29cgQHjozQ,2084
+numba/cuda/tests/cudapy/test_minmax.py,sha256=Lgd9OSELTwOeOI7JwbOf2E15mxv_XkgIrhC0mkoHTvg,2409
+numba/cuda/tests/cudapy/test_montecarlo.py,sha256=jH_LxlcoA8Vb3C3YXg93XQw8J8O8WGCWoLRPg1mmxDg,603
+numba/cuda/tests/cudapy/test_multigpu.py,sha256=4lC9G6LI0MRBDQEkRyTPb019NUFoU9cGrDWV4quomWY,4140
+numba/cuda/tests/cudapy/test_multiprocessing.py,sha256=AjYbSa9nOlv_ycZORifdm7B-b9KdKC1HV-cGLDtrJ-w,1224
+numba/cuda/tests/cudapy/test_multithreads.py,sha256=MfCbyJZu1XsCJOCSw6vvhs4eiP4LZPcF-e9huPmW-ys,2861
+numba/cuda/tests/cudapy/test_nondet.py,sha256=mYMX0R1tmBLRe5ZAwiDVFFuSyMuPav5guuqL3WHWGPY,1378
+numba/cuda/tests/cudapy/test_operator.py,sha256=0nJej4D898_JU-jhlif44fR2yu42keK4GoCLP810l3U,13295
+numba/cuda/tests/cudapy/test_optimization.py,sha256=SvqRsSFgcGxkFDZS-kul5B-mi8GxINTS98uUzAy4dhw,2647
+numba/cuda/tests/cudapy/test_overload.py,sha256=yYgtrf0aER3i6VaPrPpzI_uDa8xjEmdCCDSSAcx91y0,8251
+numba/cuda/tests/cudapy/test_powi.py,sha256=TI82rYRnkSnwv9VN6PMpBnr9JqMJ_F3HhH4cKY6O8tw,3276
+numba/cuda/tests/cudapy/test_print.py,sha256=trOElKENWGwWVcJ3uN4wzqtZiJiQtjLh4vx07iobz9U,3643
+numba/cuda/tests/cudapy/test_py2_div_issue.py,sha256=R88Vfgg3mSAZ0Jy6WT6dJNmkFTsxnVnEmO7XqpqyxuU,986
+numba/cuda/tests/cudapy/test_random.py,sha256=rLw7_8a7BBhD_8GNqMal0l_AbWXzLs_Q0hC6_X8gdjA,3467
+numba/cuda/tests/cudapy/test_record_dtype.py,sha256=grR64kdRlsLcR0K3IxSfI2VKsTrrqxsXuROOpvj-6nw,18769
+numba/cuda/tests/cudapy/test_recursion.py,sha256=8dA2HfAGT6si2OioEx_IkCEgbDhbrjQ94Y7yojPtFjA,3641
+numba/cuda/tests/cudapy/test_reduction.py,sha256=ffut_O9EZAwAwdbEXoYPzy8GkRI6tFKC5XafNdAymgY,2528
+numba/cuda/tests/cudapy/test_retrieve_autoconverted_arrays.py,sha256=LPYAxouZ7JYiu3z4HnNjkGtjYLuIscOxKXiY6RiTv6o,2404
+numba/cuda/tests/cudapy/test_serialize.py,sha256=alE5-lTwbjz3Tv6OvQPSmgtUtu0X9UwFzB2aKs2rYag,2321
+numba/cuda/tests/cudapy/test_slicing.py,sha256=qW2Btdfj9wl5aB6vDFYcrc-BiT3BzzocKiQQ0klqPHY,3156
+numba/cuda/tests/cudapy/test_sm.py,sha256=kh1F0wwQ2_bd54Q4GUX99y2oiWHQwBpyC__ckk-jiTU,14575
+numba/cuda/tests/cudapy/test_sm_creation.py,sha256=bTXDjU94ezo6Bz_lktlPyowTcJHBOWfy7-nJB9e-B_s,7231
+numba/cuda/tests/cudapy/test_sync.py,sha256=Y851UqNkT80U9q_C05SQfvPRCY7jjRARHOMk6g0lU4Y,7837
+numba/cuda/tests/cudapy/test_transpose.py,sha256=JAQX2EUHwlpKCfJDGspaldmsIRbHxnXpsNUrvRrnIEE,3134
+numba/cuda/tests/cudapy/test_ufuncs.py,sha256=-ehvkxelr45aT8sUNL9Hq8cn2GU_K4GL1yWeX-rHqEM,9680
+numba/cuda/tests/cudapy/test_userexc.py,sha256=4ch3Lw8X_w832lU0J5Y5ZLAfxUMUSzbxnWE0bLEWdEg,1470
+numba/cuda/tests/cudapy/test_vector_type.py,sha256=hH3G4XtOTUNr31KyBJVAbbT4053cuJon_PPzoUVlupY,10515
+numba/cuda/tests/cudapy/test_vectorize.py,sha256=iCCiMQERoTnpa2cxU-08bs-AbgGyrQgAC7b9J5nsMUk,9248
+numba/cuda/tests/cudapy/test_vectorize_complex.py,sha256=0cIAvARp4w4Jw38T2qZKg7RD_UZyPVWDOYC0x3AGunE,548
+numba/cuda/tests/cudapy/test_vectorize_decor.py,sha256=rA2Jk1wKbTQXnVvVXeVnhjft8R3zPRWNjVa76M6iI3k,2071
+numba/cuda/tests/cudapy/test_vectorize_device.py,sha256=bsC4rJAvVtoBOaVDBulLC7oY3mDPe7E77z9LUA5mzCk,983
+numba/cuda/tests/cudapy/test_vectorize_scalar_arg.py,sha256=Ivl3RtFjwKJRHAxaFD8Xby5PxjK-mmkxbFXHUHYipNA,937
+numba/cuda/tests/cudapy/test_warning.py,sha256=Bpcj9-pehYW20vn4KY98pADQd5A0gzDUuUk2y48HzyM,4265
+numba/cuda/tests/cudapy/test_warp_ops.py,sha256=OGGXn4beVIjjIB5akR2keyY7gQFaMAxM_AoZNN_I3Bk,9042
+numba/cuda/tests/cudasim/__init__.py,sha256=B1ma2w-Eyk_ooILO3PPxb2K5HMyZY8WZhikDIBATzQQ,154
+numba/cuda/tests/cudasim/support.py,sha256=JjRrfrrLKS0V5p6GX6ibs6QTuFb1NanKfBQSgbLeiHs,114
+numba/cuda/tests/cudasim/test_cudasim_issues.py,sha256=IsjJlxq6LMMDh_1kiO9LefXkOX_Hc1bxeSwXZdB59yU,3179
+numba/cuda/tests/data/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+numba/cuda/tests/data/cuda_include.cu,sha256=1wj5Of86-kP0hxK5Gr6AhapuyTiiWWJAoFbCuCpyKfA,294
+numba/cuda/tests/data/error.cu,sha256=5m65RDHgh39d0bIW6Dvj0xh9ffhKH1iILeCCR4p2ReI,138
+numba/cuda/tests/data/jitlink.cu,sha256=ne8LLu7RHgbw2lAyJGrVlJHJ08kxUuOLBD9pH-cNxFU,541
+numba/cuda/tests/data/jitlink.ptx,sha256=fBPV1l6krgtGfHasRfaL708M05eNszjAQG33z-NtvUg,896
+numba/cuda/tests/data/warn.cu,sha256=6L-qsXJIxAr_n3hVMAz_EZ5j0skcJAfgzuJfDEISG_I,172
+numba/cuda/tests/doc_examples/__init__.py,sha256=B1ma2w-Eyk_ooILO3PPxb2K5HMyZY8WZhikDIBATzQQ,154
+numba/cuda/tests/doc_examples/ffi/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+numba/cuda/tests/doc_examples/ffi/functions.cu,sha256=mRZEyCfZbq4ACTN3sj1236XmTpj1d0IxZ4QTMbI3g_E,877
+numba/cuda/tests/doc_examples/test_cg.py,sha256=9UQAez1jp3vQ0BIfoRCnGJGP17nznNcon-XFR4grqzQ,2905
+numba/cuda/tests/doc_examples/test_cpu_gpu_compat.py,sha256=DRzvoE2iCaISJb2lkshBkJyYBEfdpqZLRXG_N9XRaFk,2305
+numba/cuda/tests/doc_examples/test_ffi.py,sha256=RgZO7xYkJIlSIuJK4k3_APEJAekjkKy5wKOMFdfRoAM,2654
+numba/cuda/tests/doc_examples/test_laplace.py,sha256=UH15R0DbMA4iHLmoZ0GtcttGCNctOUif-u2448JMmRo,5177
+numba/cuda/tests/doc_examples/test_matmul.py,sha256=hS-X_T7x3-BcBanazmnmGxJE_o1A9b9f_VGk0YlJP4o,6135
+numba/cuda/tests/doc_examples/test_montecarlo.py,sha256=_0snszis_UE7LxU5lw9ReNF19Dh5iV0yRy18mUWNd1c,3491
+numba/cuda/tests/doc_examples/test_random.py,sha256=VTgzB55bfjeNQHKg9MINnKa70KNYzxpTOktKwYNYUkc,2192
+numba/cuda/tests/doc_examples/test_reduction.py,sha256=9d40rXxrqvWSkI8r0lMJ42LgU98dVF3Aeon6RAqUIik,2274
+numba/cuda/tests/doc_examples/test_sessionize.py,sha256=kNep6Y7q1WJ9dLeoMYuk9NBKTGLsIJwNiW-um86BOoc,4334
+numba/cuda/tests/doc_examples/test_ufunc.py,sha256=UXwXjL9ybg0OuYOFKnHZk75bMjRMRzrp_xfxAdMR198,1418
+numba/cuda/tests/doc_examples/test_vecadd.py,sha256=0RMJv3iXf9OlAMCF4aIB4Pyp4AnoKUuqC_tY-yNQGbI,2043
+numba/cuda/tests/nocuda/__init__.py,sha256=KeAvH3QOb-KXXkFtzwvYkQp2ZrQmzgfKDkBCVIOKXXE,257
+numba/cuda/tests/nocuda/test_dummyarray.py,sha256=hpdNlYhZLKrrN3TF4i65djpOlcPpEkTG1MX8385Qov0,13567
+numba/cuda/tests/nocuda/test_function_resolution.py,sha256=o4DYocyHK7KVPil6LQI2jzZ2xSWop8bLZYGtV067CSs,1425
+numba/cuda/tests/nocuda/test_import.py,sha256=teiL8rpFGQOh41kyBSSNHHFYAJYgpdStXkTcpK4_fxo,1641
+numba/cuda/tests/nocuda/test_library_lookup.py,sha256=7kJOPHEcrjy_kTA9Ym-iT_B972bgFRu3UkRtwIgWtuI,7948
+numba/cuda/tests/nocuda/test_nvvm.py,sha256=n0_-xFaw6QqiZbhe55oy7lnEeOwqTvA55p5EUFiTpNw,2006
+numba/cuda/types.py,sha256=WVfjcly_VUpG9FfKueiEPzZm2NV8Hg0XAFg3bNzPdVc,1314
+numba/cuda/ufuncs.py,sha256=4ZhGEF9VXN4o61h7kbly6DdiQeDADGet9L13fipK4QQ,23325
+numba/cuda/vector_types.py,sha256=s18dY0IUpT-RcaBvQsa_zEbYuuL2IT0Vh6afCeccwmQ,6750
+numba/cuda/vectorizers.py,sha256=u_0EzaD5tqVH8uOz4Gmqn3FgPC1rckwDAQuROm0BXm8,8915
+numba/experimental/__init__.py,sha256=RBZ2sMQEP7NKSKqucS8ij-dOOZrmHiWM_qVLVP1pPe0,30
+numba/experimental/function_type.py,sha256=KH0BteKy-Oo8hpGutWX1ujbD7Nz9ILp3Bw9cI96vt7k,12475
+numba/experimental/jitclass/__init__.py,sha256=3Emu3qLxfO6zhqsLfzRu12vATnGwqLYERSV_jRW9g9k,219
+numba/experimental/jitclass/_box.cpython-313-x86_64-linux-gnu.so,sha256=xeqTYmqxBA1D3YD5t48Z9M4l3KEr9bmxisbl5yYvF1I,32112
+numba/experimental/jitclass/base.py,sha256=p8sCrSDvRiwqA9weQEqYDSmQn6Yw0uYx-Swt17adNWk,21254
+numba/experimental/jitclass/boxing.py,sha256=FTZy8P4Zs9s8IbWF0kSaO9LYnrt5sk8wFdD9jaTuIps,8245
+numba/experimental/jitclass/decorators.py,sha256=y_Y-ugNa6jnmIX1fhLpadlu702857iRUb2tYhS3Ke3w,2404
+numba/experimental/jitclass/overloads.py,sha256=jcOA2xeCv7OrH3iv5_9rVQPOst_75cyDHHnqaKkiw2U,7264
+numba/experimental/structref.py,sha256=LVa_0xU50jzrmNp4PC1tjnb8LUkRKTB7ckZ-kB9_jx0,11491
+numba/extending.py,sha256=dkGJPNMggy7xd1NRV1ws6teIK7Ze2lTFvpAz7Cw5drI,133
+numba/mathnames.h,sha256=pNbqCU38izsPBn6EaZDfT_HURKIaEkmpm2STVyFtaEs,1774
+numba/misc/POST.py,sha256=JrY0ygk5v272TXHpqQNnDKIX2FJK04pDAkmdtAVaWEc,811
+numba/misc/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+numba/misc/appdirs.py,sha256=zyXqBFfj1ERckcERX_G9d3AAGciKuB06Aj5_mnyGrTQ,22388
+numba/misc/cffiimpl.py,sha256=5ubOeU-F0MNi2aQ5Y44AxcYvegLjPW-w3Zs8hfPhW-g,615
+numba/misc/cmdlang.gdb,sha256=hX5t_27IhOlfgGAwV3aVPyZ8v1m7hedd6myQbE8mMB8,101
+numba/misc/coverage_support.py,sha256=6V0xMNtFjcDzv5buTq-65CohX8_8UZjfrPIBzJlyHYo,2541
+numba/misc/dump_style.py,sha256=TTQm7BmBzLT9VRuWRjpYkGqg_lXwtoAvEbcK5wIC-XQ,2265
+numba/misc/findlib.py,sha256=r7bP2GeCTXsGHa5bWKNKsVCvqDrarMlvORqWmJoeOHg,1848
+numba/misc/firstlinefinder.py,sha256=kjPhJhGlWkQflBFcd-avzAKXbnyEDzADCC9UbU_z_Mc,2895
+numba/misc/gdb_hook.py,sha256=qX-ZHzj3Id1eGW5eQpXALeGZD8Cj2cZyfCqdoixd8K4,8567
+numba/misc/gdb_print_extension.py,sha256=RcKxCFhzbwr7TrZsX6DZGjJkEaNzoZn19W9vCktG4-o,7728
+numba/misc/help/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+numba/misc/help/inspector.py,sha256=9tgx8tKuYEffMWTjnayD7NJbwaxcu7q7aDYKSh6AdFU,12903
+numba/misc/init_utils.py,sha256=2vEcU37csAn4Ogoi6eyCEyNiUnEf4P-9PLcFvkk6xRI,1242
+numba/misc/inspection.py,sha256=SSHPt4V-CphtwEIEbOFhjYURe1hHvX8a_FDpMyq-P7A,4499
+numba/misc/literal.py,sha256=AQnd2XF5fJYnR8BuOCRcoCt97-U3APuEGViyZTie3VQ,705
+numba/misc/llvm_pass_timings.py,sha256=Mnm8MprZZCioJS9BdHeQ2CNJ8cpj9fUdOGwJnQXOkRs,11703
+numba/misc/mergesort.py,sha256=H4XyN8Lmw4NBZ3m_UEltHK7T5ZADc3fbok2KwOKATm8,3548
+numba/misc/numba_entry.py,sha256=OTSqI4hYcr91ZXyNmbJmbQG6hMEQgTGZ-no6McXz4o4,2618
+numba/misc/numba_gdbinfo.py,sha256=Dunek2AGTgxNZFQnlsEFHzjc0806J8Abz2eTTj0TZEI,5962
+numba/misc/numba_sysinfo.py,sha256=Kr7r5A9TVqkw7wGmnuBhfzsLxiDMqB7ou4OxCZACjw8,27048
+numba/misc/quicksort.py,sha256=7tp5Cv8fcyc1h9tJv1o47Mz4-_QPI_YCThXVkuTA6f4,7727
+numba/misc/special.py,sha256=eEIAB_07X8EO7BkrQVz2Z374kjHLIXe75JFnx2j0uqs,3320
+numba/misc/timsort.py,sha256=tSAqreRk39eRy7FD6GRCGLIpUhG-BgVygXphkxtcJiw,33503
+numba/mviewbuf.c,sha256=BLH7Khu9GTcI4pyj7ApEmqdOTpIkTdDLLN5cG0J4_IU,11731
+numba/mviewbuf.cpython-313-x86_64-linux-gnu.so,sha256=64fDHSkNUbGn_IzZWaMLEnxW8gKRfYt_-aJinNK-rsk,44784
+numba/np/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+numba/np/arraymath.py,sha256=tCmQnwxp_ax8rKl_qrrycZ5SqlYVYt6KHFOFyosle3g,395
+numba/np/arrayobj.py,sha256=1X3PVhrD26xIihYccRHfabpcAkuHlQEP1xR-V7D4t5w,252093
+numba/np/extensions.py,sha256=YEN2b5udrIy4uhHrp7Os6FEW_h4lv-dp4aRB2Z8Irhg,96
+numba/np/linalg.py,sha256=ux_AiVkdycuPsy8MfSNNMCShfhRIXJQ_1chu7OPqDgc,92462
+numba/np/math/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+numba/np/math/cmathimpl.py,sha256=RZwO6pYJjgX7d4kTmymDgXIECfJzZ_oW8xG-nmDo5xY,17628
+numba/np/math/mathimpl.py,sha256=wM19VO-kAQIPRL2XxyTqUtyFWA9kSlmHngsO6d8HucU,15580
+numba/np/math/numbers.py,sha256=XrzM_xxyKkidhRYDRAdXrV0yaRT7dY208NbXx5_uLks,50276
+numba/np/new_arraymath.py,sha256=5xtN_4JpgiXJzcEi4b-PgBpZg71dNuNbBG8l5VdHJAo,152202
+numba/np/npdatetime.py,sha256=tbIyF7pOSoC5-THyo9-7PGzNWTv0X-CDoiP-kI4ANnQ,34289
+numba/np/npdatetime_helpers.py,sha256=JPUTOYJ9Eg-3H4K3oLp2q0lLXKZcML3fBpG7WwJ3l8g,6649
+numba/np/npyfuncs.py,sha256=ML76eRXBLphl1PRNz7t3ugXkrAYEb-WKAtL7tdET3Dc,63100
+numba/np/npyimpl.py,sha256=GDhAOy-FBulItjDnwGC_k-Erkg1YsLNhxhzMRwcQzJw,36977
+numba/np/numpy_support.py,sha256=o5iUlwUEAqzRs7392C1L2wG_QT-q9Vm2hbLw6bT07Ek,27633
+numba/np/old_arraymath.py,sha256=EU_fmvqn5-dejg12fAzqivwc7zduVQGJt9NTlEcJeM4,152294
+numba/np/polynomial/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+numba/np/polynomial/polynomial_core.py,sha256=t_4zkvCCjPQis9q9oq-6ja-eaafnE2eIbUJBRNGU8kw,9003
+numba/np/polynomial/polynomial_functions.py,sha256=jH4uH46RBg2NJ6t_sAUwEwvrHcVrLxMdln_xsJLr-P8,10765
+numba/np/random/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+numba/np/random/_constants.py,sha256=lbWbj6z1gzNQMZV-BUIcmLeYlzTl-YytJUeorQtaU-c,72630
+numba/np/random/distributions.py,sha256=2snTdcIFjUEFVIVMMEwY52VThBE6hGzRjNAOnh4o9uw,397
+numba/np/random/generator_core.py,sha256=HY44_ZraEXCVVBbO4gjGjA5vpuLlGAwAOG5wcJXiyK0,4712
+numba/np/random/generator_methods.py,sha256=MsZifo13zLPcipABAdlabQxQQUdNS2OySkZJmEzhNWE,34316
+numba/np/random/new_distributions.py,sha256=0t3nZ-QhJhb0ba0C-67OjR0zFOy8jgKDh3ZGVCxTnlM,20333
+numba/np/random/new_random_methods.py,sha256=Rcsaqn8LixshPZg_W_lWH7WHPA7LkexO7hph3HgWKz4,10273
+numba/np/random/old_distributions.py,sha256=MxdSHYVvaoAFWgSJeMma-AHazvqfLJmuCcHvx2CnsnA,20906
+numba/np/random/old_random_methods.py,sha256=H18TXrqkFTqnLOrAHo_y-KUcM_iETWHDpczdLEs0_e0,10210
+numba/np/random/random_methods.py,sha256=R-RzWPb3MvSgKU6mrKqtr9sYJaSZyxf-bbF8fPYBNLE,399
+numba/np/ufunc/__init__.py,sha256=TUc7_N8172fYX5n0ZxnUn-LEbaL88rZBHmqPu_OdCdU,1070
+numba/np/ufunc/_internal.cpython-313-x86_64-linux-gnu.so,sha256=Bk0yn6gGWuNEPSQmegf8JlGBOxBC5vbjHXefJUFzuLA,100672
+numba/np/ufunc/_num_threads.cpython-313-x86_64-linux-gnu.so,sha256=950KFZIBYk_M-IfRBdiGjXnr6aueKP00ogCHB1n1VDg,26936
+numba/np/ufunc/array_exprs.py,sha256=pJbWr9S8zCpkZPXFRJIpnjf-FKe3QfYeTB6vyZIyTrg,16878
+numba/np/ufunc/decorators.py,sha256=_J7b_05KDBPBnyFvEcL-ys5WGSkUPfml0oIdCAnC-IA,6107
+numba/np/ufunc/dufunc.py,sha256=1nWLfq_oM9GFuKRaU7VK2-b_aFNXe6C8yEBTnLgqf2A,34585
+numba/np/ufunc/gufunc.py,sha256=0Az_-P3xlEHePgipw3pQyW8hwWO509U4kHY_9WhDt3M,12727
+numba/np/ufunc/omppool.cpython-313-x86_64-linux-gnu.so,sha256=pCycFBG3Jl4S_ef2eBBZvFsIyqmL9HfkOvzgEillEog,600089
+numba/np/ufunc/parallel.py,sha256=183lH6RYkvPYnLad65h7Ujt3lYeaST3KBKOTO0vAnsg,26282
+numba/np/ufunc/sigparse.py,sha256=r9068xH89U-U-sU9nL4e8JGhAuMGQv8op8ucremc8AA,1846
+numba/np/ufunc/tbbpool.cpython-313-x86_64-linux-gnu.so,sha256=xvtujRBNCRPsAXs4absoB2cDmaKya5eOJRdvplkXFYg,1054537
+numba/np/ufunc/ufunc_base.py,sha256=LhdG5z2lvspsCIadAP7IS8h706uzWjQBuyNtJcyY4Nw,3335
+numba/np/ufunc/ufuncbuilder.py,sha256=viLjO4-V7OHdYbWpysoRyEk9DrMUp6g5IZnM-c08O5k,14303
+numba/np/ufunc/workqueue.cpython-313-x86_64-linux-gnu.so,sha256=w_ayxYQfhkQP2oJHS8N1fUb3-khurquU4WLWsj9GArA,606544
+numba/np/ufunc/wrappers.py,sha256=CdWTlT1USqb-tw_3tAj_CRC0VWv4tIyeDJr3n2Cq6DQ,27203
+numba/np/ufunc_db.py,sha256=OTgMbz79rRzmRkZZ7US5-bcZ5NxZ3dKoiv9msxGUs8c,42510
+numba/np/unsafe/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+numba/np/unsafe/ndarray.py,sha256=dzc0UlE86z_idhAN73eDs9A21rF4v6BkOpmEHbFYlsU,2704
+numba/parfors/__init__.py,sha256=YXMWaFldoQqHT12hNUQyS7nd7Zg85htjssj1UopkA-o,42
+numba/parfors/array_analysis.py,sha256=4k6K-fDMVFEhqEw0R71gbHoNhBsG00J6RReUjCm5JIg,124117
+numba/parfors/parfor.py,sha256=nssZCvQ7hnr9QLMrr4TLiBNNseFdEPqTfICmIOVgsHk,225383
+numba/parfors/parfor_lowering.py,sha256=_sHTb2pBZQjmoZ7UArlF5IvEmRS3sp7zx17btqGLjWo,87616
+numba/parfors/parfor_lowering_utils.py,sha256=3LEZBxMZ0mN-X9a-a31hQ5MtgV9VSlO5fSaHe61ciKI,5544
+numba/pycc/__init__.py,sha256=TzLOywD1B2CPTXQ1c_mzyPOSQTY5C3-JR_VfNZMG4ts,1220
+numba/pycc/cc.py,sha256=xZnsrVcSa9My6R6zZEuTU0KdXknD32AJ67M2Qt-ckhE,10626
+numba/pycc/compiler.py,sha256=1Sqv3wRKVDB6Una0LGAPvMKa-VBMu8SZYkzv02NbDUc,17982
+numba/pycc/decorators.py,sha256=n4WakJj9iRYkdrRFoLLohE4ibhuNhy6TDQ8I3LMwvuM,1884
+numba/pycc/llvm_types.py,sha256=n0obSYyFc7h356LmVqGhwFMKH4NpXIXF5BxztoU240o,1239
+numba/pycc/modulemixin.c,sha256=0SmPP7pbDLRWtCE8HzlllpfT_AWWTFPnyIqWyz6k7h8,5577
+numba/pycc/platform.py,sha256=xIy_JUOilVFCLwNG_6h0VU41IRoKSmv4G8NuO4ybLUA,7421
+numba/pythoncapi_compat.h,sha256=wB8PCPCqYqpYR3YIdArroyYJ3WsEc5GhG1xKAp0DSZo,45414
+numba/runtests.py,sha256=xv1W8XbzPewB_X32KXFugsmwt3lZL7lfKfryaC7N7KY,237
+numba/scripts/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+numba/scripts/generate_lower_listing.py,sha256=WCaoIzn_LmFHS-pYTW6vdKufcnXl1e41-_XsV1mxnm8,5165
+numba/stencils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+numba/stencils/stencil.py,sha256=FTJs2phQeT91x0mxMU4DGbdFKkIEWAlTPCgHQbxik4g,39893
+numba/stencils/stencilparfor.py,sha256=Ar6Ge9UT25ybCsMnE8R40vDpHufK8zhzKVRW3YwA2vA,44974
+numba/testing/__init__.py,sha256=QL904urGyqVF5OOfyq1uLnAn-uhgRcbboaQlj2obaMU,1976
+numba/testing/__main__.py,sha256=MJrAbExox9UHv1UnMDx0f6JG_oA43cvhzHQoTOSl7IY,106
+numba/testing/_runtests.py,sha256=V7XJTU_iTftXIu3Rv8FqQd_ECjCXG6B4vDdujOizMfI,3727
+numba/testing/loader.py,sha256=pQdHO6VLZo0Lzbju4g0dptXGc64IJlbguzym0w006fM,1113
+numba/testing/main.py,sha256=nUbyFwCjID4trB0Th4PgRgvvdcZ2OtCVblZJ2YdQV7g,29758
+numba/testing/notebook.py,sha256=zuBfj8QHXFkNvV2oyz23gjFZe1Ixt7OFAMtgjCSqm-Y,5501
+numba/tests/__init__.py,sha256=h3tyMOp0uUiirVDAOEY3Cymim51mHA77xTpwATXeu0w,829
+numba/tests/annotation_usecases.py,sha256=0O7hw4-dVfAQ2mUoSLbjWYakSNzcv6B6nyBJCRPajdo,316
+numba/tests/cache_usecases.py,sha256=bFw9cZVyvN9GQTdg_Ci4U0wF_8DLAKBwf5tXh95kTQQ,3566
+numba/tests/cffi_usecases.py,sha256=xGpQl4X7akIxuqMOjx6mxt9tXVbIhVhHe0B6nmaF9tM,4927
+numba/tests/cfunc_cache_usecases.py,sha256=XqWmWzZZy2Oztz3iTiig1TsJ6fpZaZyB6B99ThHZYKM,1608
+numba/tests/chained_assign_usecases.py,sha256=KjBf_w7zeb-OPAYsNzJImekuRzLyj0EcMqJ8TZys9rU,1045
+numba/tests/cloudpickle_main_class.py,sha256=GzSO01WRCCrXYlp8HShxryKJTwUvcAImg9F68WuLnc0,155
+numba/tests/compile_with_pycc.py,sha256=0gA4UTDzds3oQ6aVgi47bhB0wcBtTJuTHoN3TZzhpVk,2980
+numba/tests/complex_usecases.py,sha256=xlbm0rUg5prZV4qIUsekCRFjJCpIGBhLpgABnefor2U,1515
+numba/tests/ctypes_usecases.py,sha256=lOXJpgWXqBG0AJ7IguSW-zuyA6iovRqIH67drTQj4Gg,2425
+numba/tests/doc_examples/__init__.py,sha256=AQs2XphXAaU5K8g8XL27zyLP1L3VOYH1AP1aCg1uf48,267
+numba/tests/doc_examples/test_examples.py,sha256=vGS3EIVT2p4LzK5MVbQrLhN4AzGFkR0UH0h8Ro3PsJA,23610
+numba/tests/doc_examples/test_interval_example.py,sha256=FhXF9YCYOiWilLYzjlEzI1NB_aDcebTb84_8IBAGZ1w,8867
+numba/tests/doc_examples/test_jitclass.py,sha256=hEKPXpD_3JmNAGPC3fhz6GHxofYRtM8ZwM2ZLJEigSA,3057
+numba/tests/doc_examples/test_literal_container_usage.py,sha256=BKapYbcT80Kwe_QYDVTb89sGIi-hQ-r0x0q8mwlqfUQ,5762
+numba/tests/doc_examples/test_literally_usage.py,sha256=9LK3Tw3gW1bhpqOd2IlscVXf4q0S7esdo2fcC6Kb9eQ,1878
+numba/tests/doc_examples/test_llvm_pass_timings.py,sha256=aolHZB8rDoUUGlYzmWhcmJR9Y9mU9d5mRNZ6SBCVFGk,953
+numba/tests/doc_examples/test_numpy_generators.py,sha256=CDWKZS7CpJy5Z_inqu6LLPDVpnhWouIWhk7w4-M1wMM,1099
+numba/tests/doc_examples/test_parallel_chunksize.py,sha256=pKI38Udgb58Uaf37vsVASo6WEr8l10I4bI0AM_0ZwRs,4176
+numba/tests/doc_examples/test_rec_array.py,sha256=fhCOCXYunEcO2D2ieOs6W2Iqe28vCDfi8avyuBuSF2M,1313
+numba/tests/doc_examples/test_structref_usage.py,sha256=hbBFmHR2s6oD3KK4yqF5Bn17iIoGzIObQ1Q7jiJ6iYQ,4852
+numba/tests/doc_examples/test_typed_dict_usage.py,sha256=XCrsqc6dZUX2-90UZwniAVL5Qqj-_dkqCS6IVX6Rdk0,4051
+numba/tests/doc_examples/test_typed_list_usage.py,sha256=x9XKxjziN8dMxPsjMzvQwvAI0hT7_cuUvVM_JLgn76M,2941
+numba/tests/doctest_usecase.py,sha256=i7DEqCXsEPt3XxRAk6tzMTJnHbdAJGpxPwCCXTuInjQ,484
+numba/tests/dummy_module.py,sha256=HnzviWYvQx54SYXKY--jg7JgDDNVwSyawn1yWkyISUM,57
+numba/tests/enum_usecases.py,sha256=rGVSwqi8zpbjsLoPdUO-vooLjL8PbNdOZcvG7ey_pZs,1018
+numba/tests/error_usecases.py,sha256=Bf8ZmO68Vw3T2KU0pzxlmx1L8OoqYMK2IJxNsnXxcWQ,79
+numba/tests/errorhandling_usecases.py,sha256=Ds-kMSAGf6SywK1xTyMPoXl1vwlDtIRtmchnAwluHDo,284
+numba/tests/gdb/__init__.py,sha256=AQs2XphXAaU5K8g8XL27zyLP1L3VOYH1AP1aCg1uf48,267
+numba/tests/gdb/test_array_arg.py,sha256=VlK8wthLszkVlo6WorHxfFO-skKhHteavYOagHedCCE,1723
+numba/tests/gdb/test_basic.py,sha256=ttVJkT_1ZbTdAkRCN1mHq4jHt6rL_Q60At9FUfLMinQ,1162
+numba/tests/gdb/test_break_on_symbol.py,sha256=ArsXuGi-1Zw2cLQ0TH3pQlHH-tpvEsj9FEhNBJ8WD7Y,976
+numba/tests/gdb/test_break_on_symbol_version.py,sha256=uSK3IvYXac0RMqpqD-IAsUEzHx1Z0livBTKZjxH_dCQ,1940
+numba/tests/gdb/test_conditional_breakpoint.py,sha256=hvzxre17KzBE9bN-NcNLg3Eg37MYk2XUgGhmDfIRD9w,1224
+numba/tests/gdb/test_pretty_print.py,sha256=cb4bPcYpoOr_2n9CHHxiDTzpsx1I0ZB1f9CeT3oEi74,2416
+numba/tests/gdb_support.py,sha256=geLjuf9hcrZonEuhKz3YkJo4s5Kui7O0lEj1q7HjpCc,7439
+numba/tests/inlining_usecases.py,sha256=oC8Y29RUNdqSR0nWmEZ3JC0JeaRXCbP3wE45TauiiH4,1019
+numba/tests/matmul_usecase.py,sha256=97UclzEySdrOuvhWLcWSvpqro5WXRMGgomZIA6M3Qdc,552
+numba/tests/npyufunc/__init__.py,sha256=AQs2XphXAaU5K8g8XL27zyLP1L3VOYH1AP1aCg1uf48,267
+numba/tests/npyufunc/cache_usecases.py,sha256=-XasSXNW7ewG8-HLpDj8yZThQOg38455UtWDuMfDGaE,1488
+numba/tests/npyufunc/test_caching.py,sha256=ZFL7l3K4ma3RIOHfZTScN30NfUNhk0FeykIMKfOIScE,8569
+numba/tests/npyufunc/test_dufunc.py,sha256=TkFmpHH2WXIta-SV3WK72WLMZMRgbS4LqfKnTrljXsA,34555
+numba/tests/npyufunc/test_errors.py,sha256=zaR-AvH0tF2Ep1yFxR75cJkfcApmWBMFHRST_qD8o04,5497
+numba/tests/npyufunc/test_gufunc.py,sha256=6mbQmZK5FHMll1kyBG0k7ZiC8dHmvctPP3MdW2FNr7g,28222
+numba/tests/npyufunc/test_parallel_env_variable.py,sha256=NMlVyeMdSoFV3oBXxoR8VHeayPGDLMaNrgGG588MpBA,1264
+numba/tests/npyufunc/test_parallel_low_work.py,sha256=BPeAxpfoZu9H2S880AeVAtWlIKO9FM9DryWG6niFeYY,1056
+numba/tests/npyufunc/test_parallel_ufunc_issues.py,sha256=Rv5Ztyj1QG2sszCPBso5Mex6c01d4uDAx2sUNNsZns8,4310
+numba/tests/npyufunc/test_ufunc.py,sha256=oaiPMmJubzPAYDNNhu3fDwkSaGK6Atyhs8HO2qN0Cjs,5219
+numba/tests/npyufunc/test_ufuncbuilding.py,sha256=B3BkVrm9svA58wXiJey-FUXD1Z8HBkNd9wf9stGxeqs,16809
+numba/tests/npyufunc/test_update_inplace.py,sha256=sr748I5uqoaWhW1YNrG4j2ScagmUM1Lrq7NWZgTuj4o,5078
+numba/tests/npyufunc/test_vectorize_decor.py,sha256=Z7NS7QmTt0CmCZbOsI-e4K_ujz6EmgvAIdqn1mZ4eAk,4504
+numba/tests/npyufunc/ufuncbuilding_usecases.py,sha256=CM-gB-XcZqb-CKUqhEt0NiK-9slc_yUstDlYyzibaqw,1061
+numba/tests/orphaned_semaphore_usecase.py,sha256=Lwc2zeGSfc3In51ROGkwGE7fyLeZoIwfz9_1vb5yC9Y,592
+numba/tests/overload_usecases.py,sha256=ySd2qYfd7CYCnzbG5NJHyEvtZCTCFySM6fixrQrbWR0,582
+numba/tests/parfor_iss9490_usecase.py,sha256=aNDICFHJvtXpKEMYcI9STPuCYuVLm7lP-OY4s75P4kM,2640
+numba/tests/parfors_cache_usecases.py,sha256=rj-UN7QzYamC-xAYEVRihggNCyTFEpFK0ZzktUqVxxc,1778
+numba/tests/pdlike_usecase.py,sha256=eDi-ks_pldk6qbYMRsLTDFhnCe7-fRA3g41PJGPpYNU,8780
+numba/tests/pycc_distutils_usecase/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+numba/tests/pycc_distutils_usecase/nested/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+numba/tests/pycc_distutils_usecase/nested/source_module.py,sha256=SXWOoaRIkoBpDt-8Djmy5Tj7aOUCQ-DMAFgMnrgB5wI,328
+numba/tests/pycc_distutils_usecase/setup_distutils.py,sha256=uO6Qiv98Wqw_DUSup-GvyNsTVD2u-N6YOgijFIzEuZQ,207
+numba/tests/pycc_distutils_usecase/setup_distutils_nested.py,sha256=d-HOlctJ8Mz0iF1eGfVfPgf5PC9YQtBx4SIi5BVVyj8,215
+numba/tests/pycc_distutils_usecase/setup_setuptools.py,sha256=19kQpIjGjT-0AcYfONCTHb33JyC7lkv-IrVBSYkWkA8,173
+numba/tests/pycc_distutils_usecase/setup_setuptools_nested.py,sha256=zWLMLRjwyBO3p-51165Qpw29fUlc4hvLWi_wBPFoIXU,180
+numba/tests/pycc_distutils_usecase/source_module.py,sha256=XdiOyXf33sIsFquozugu4-qVkNK8uDyap2M6cR3FhzM,326
+numba/tests/recursion_usecases.py,sha256=NIkXj_bUe2MUjK5lSlDAszG7Th3llrLWtdOv3c1AMrU,4133
+numba/tests/serialize_usecases.py,sha256=RfKx44jFPUvfEjaumYOj3XKHeOcBKCaP6hIkV-t1gqM,1982
+numba/tests/support.py,sha256=htXOBKvMlLUu2IJEPTPXoK0BalPA3MCadvPg94EbPD8,45401
+numba/tests/test_alignment.py,sha256=y0vaLiqkDWaUwL10r3o3yx65OgpHVQ9FbFITSvhgC1k,1086
+numba/tests/test_analysis.py,sha256=0LFFvQb2q7JS9mvaFA6zROc9fr5uAzowpP4LwcQ2WS4,34576
+numba/tests/test_annotations.py,sha256=LATeDSyu9gYwo-3jYnVDSKerPEPu_RSoe9X6NbnhyQ8,7540
+numba/tests/test_api.py,sha256=kAPv2qeCKuCmYnnYIcNmhbUU_Q00EczpTN1lqoLP-lo,2614
+numba/tests/test_array_analysis.py,sha256=JQaBbSuA2_8GI_j3XuXsNCEN2UmqbTUtmk6bF3yuI_k,42447
+numba/tests/test_array_attr.py,sha256=ZzHGgVD2U2ouaNjbHK8LgiC35gH-Qvf9uFfCZpRzDzk,11665
+numba/tests/test_array_constants.py,sha256=QYL1Zz-sSYuvGxKUYnCSi65i-9CunsOiiiC_jxUNoS8,4826
+numba/tests/test_array_exprs.py,sha256=wb-w01blMvQJSHrAiW43_D3ofCDPPc-6e6wjbDZ1zA8,24123
+numba/tests/test_array_iterators.py,sha256=wQ6z2BkrbEaqWwTWirNZCrH6e_sKAIfCqXgGilaDGpY,17452
+numba/tests/test_array_manipulation.py,sha256=s9NrClPyvxuPsPf3O9VjpDIliWMU-YjIIewJXcA78v4,54748
+numba/tests/test_array_methods.py,sha256=ITX22egr-iYIwXRAuZasTpyZ22rRzltokhCLGddy6n0,64552
+numba/tests/test_array_reductions.py,sha256=WF1ELY9XPohjk39oVAkuRFV52qUyEJDY_5jMLLk_a6U,37921
+numba/tests/test_array_return.py,sha256=xPqpMaVkFYUlV4zfr7gINoJD6UDRMf3eFJ4wvjkZkV8,856
+numba/tests/test_asnumbatype.py,sha256=9xXP4O04kgzq5JxD9R2DvBnSsUKclYGZoL6aD9V5fV4,5668
+numba/tests/test_auto_constants.py,sha256=IEjzoT8_H88ferTGYz93Sszb8uUSi0hr8SOxwW7Oklw,688
+numba/tests/test_blackscholes.py,sha256=7-eHw17Vhrd_tn9RXhQA_5aw6dVxURI-6VkW6TaMebs,3599
+numba/tests/test_boundscheck.py,sha256=rX_OPNrDOef2IEz_GLD6pS7YJYzLjBHSUaQfgu5EkOs,8113
+numba/tests/test_buffer_protocol.py,sha256=dZ8W-fkn0A3I41CbQu91mvScgU7SLvxfYjDX29EyIjE,8810
+numba/tests/test_builtins.py,sha256=wMcXu7uubH6Q3DEbBiQN7dB_HnxkYrZwowJmrn0_S0M,50501
+numba/tests/test_byteflow.py,sha256=fSiY82ci3R4OsxIthMlTqt1Y42O-Pn7rBa5nHaojqBY,2426
+numba/tests/test_caching.py,sha256=ytBONNtM64a7SjT4K-ajb1VqhSDtY5dinUmAIVPXbvs,40044
+numba/tests/test_casting.py,sha256=KcHdtGTQgBXgMr5Yi6ghpw-4AW3io-inYTPv0mas2xs,3913
+numba/tests/test_cffi.py,sha256=lnFqpoWcsoAz5EibxKym9TtbWYFXBYCWKd75qagQczQ,6695
+numba/tests/test_cfunc.py,sha256=YIxEkOhtmse0d7nNzhB5NKA0vXd36oE90n260mcD1pE,13079
+numba/tests/test_cgutils.py,sha256=CwjjiiRlPsuFKN6gybHAcGeRrSIYsx1_8vUZO26NA1Q,4863
+numba/tests/test_chained_assign.py,sha256=Qy0fLfmKP10z24BTTyf8NSRIBaUp9Y9Cl8HRKtaLWTA,2480
+numba/tests/test_chrome_trace.py,sha256=yBVKUJdic4GrutGM5e09lDHy1KyG-xjN6gqfAKsrIhM,1432
+numba/tests/test_cli.py,sha256=ryU8WuXwMeKn792ephhhIPl5xolbOvDplFwz_8Qxg7E,10413
+numba/tests/test_closure.py,sha256=GF7F90PzJiOZyxONKf1rxaLMP8nQwt6I03lBOFUsi94,13629
+numba/tests/test_codegen.py,sha256=LsfZNz31W4nT811cHrtvgqhVmPTg9rBioYnBeBAQN5s,9048
+numba/tests/test_compile_cache.py,sha256=_nvI7rUTKsCPQWoiEln45I1fy2zYAB7cH_ioGDDgMG4,6456
+numba/tests/test_compiler_flags.py,sha256=DKZkORlXLVM9qWL6mT7M5NL9a6_D8tKVn_eXJgGasME,3554
+numba/tests/test_compiler_lock.py,sha256=lojUn2JRt9uINgVJobHwFfNOvJiKaGTWvjuNZ8_xyIg,511
+numba/tests/test_complex.py,sha256=m8OZlNlu6yuIrb_9zwgyd9iT-qKIGpoPOoZyLS4eLsQ,11325
+numba/tests/test_comprehension.py,sha256=jDRvorPUS11cCrlosHY8JE-LwcjwY93CwSIDXBiJL8k,17093
+numba/tests/test_conditions_as_predicates.py,sha256=EC925MaOIm_6fVmn4YtvlwwOCX0i_4T-kI6I0Oql9wY,5275
+numba/tests/test_config.py,sha256=DkRUifyGOL7Pawt99wsb_hxiZQZXZkA3ZbJNl7D9Z3o,7934
+numba/tests/test_conversion.py,sha256=AYC5UL9SjzPl1sS89Tj9kPMZBiZMMvIVtfo7GAome4I,6900
+numba/tests/test_copy_propagate.py,sha256=-IY8udIT0z9LKBKgjs0f-799OLsuhfXptJ1x4TFtNbI,5658
+numba/tests/test_ctypes.py,sha256=OYEIJ75kdAUrE5sYNDSiF26t8jRazbELiscDu1_LBJY,7431
+numba/tests/test_dataflow.py,sha256=P77UdUTt6_pZiUsG6Kn-VyIPlixcAvDoqbpK0gYQylY,4848
+numba/tests/test_datamodel.py,sha256=sRe5QyCVkX7y-p105AGpK45C84YGJFMt5R9lvuq_B6I,7014
+numba/tests/test_debug.py,sha256=XqMCqhst5NTom5mpLIhueWNb3rCypwse6jRfKtyutA4,12083
+numba/tests/test_debuginfo.py,sha256=cHIQnKBf-yE0Fu70WSic4iBmqZS7zivrzq-KavlcX-E,29266
+numba/tests/test_deprecations.py,sha256=J9_Y4eO_RDdxymBb15GvJex9e1ASzSkPupYSQrAlp1g,10186
+numba/tests/test_dictimpl.py,sha256=3ybNw_n9O0n7QmWMEmmLj_1IQcZnjTiQBEUMRwkAZPs,20038
+numba/tests/test_dictobject.py,sha256=fAYf8VLCcC31ogEobb4nUTug3M7qvC-6RK7cpZDIVmg,71341
+numba/tests/test_dicts.py,sha256=qNiyJx7wv_UcWuoeP2iDaXJjiWOO6sLncpCKgnuVr6s,6066
+numba/tests/test_dispatcher.py,sha256=8r3ou5lBhuE0ipcFXXSjM5_LrdkrMOBF_fOUpct0cPQ,38635
+numba/tests/test_doctest.py,sha256=ntvCtFkfebvihMiW7NhAeFK9Mn5f3Om-DR4fiTburzI,795
+numba/tests/test_dyn_array.py,sha256=bwVWSOlsu2FwsIX6r6CUcoutiixTnD2PscBBKDzSTYE,55276
+numba/tests/test_dyn_func.py,sha256=VeYpJCAymujXN1nBuyHl0W8pHS3cbpBDBpAGQ2CiYJM,811
+numba/tests/test_entrypoints.py,sha256=33rd8aC3S_B14v3T80KmdcLfC9Jk_Covn2EbV5Aljto,8152
+numba/tests/test_enums.py,sha256=svJ3SzcmpvnFe9jw9Ig56jpNtgZeZjEkA-bFrqU2q8k,4988
+numba/tests/test_errorhandling.py,sha256=dfb4VWL8da0VFippIGrmcoyPlFXawg0WWrFiTqJ9CKA,15032
+numba/tests/test_errormodels.py,sha256=1Cxqp7-0pwdJlArxDyeohTAfImHYpMKb7_acbW7OqRA,585
+numba/tests/test_event.py,sha256=j0QylybHn5QEJhrVvQPyeI9F__kHrn4m7jpB9JRw6rE,7333
+numba/tests/test_exceptions.py,sha256=VfkBSIQh4LhUW2gM81bcKCzobwEHIeMArLBoKIMzGAM,16069
+numba/tests/test_extended_arg.py,sha256=2Ql7lSu0TBuU61Z0zoP4cKlmZd1mrcqZtOWowb70wKE,1569
+numba/tests/test_extending.py,sha256=u1_NaqUmnwbgwi3Fsv9cgKVqVTZ_QvR0bVqkN2ScMVU,68192
+numba/tests/test_extending_types.py,sha256=3T4005XZFWOzscGAmNB6qwnC5HlVz4_AcsO47dW_Wvg,4990
+numba/tests/test_fancy_indexing.py,sha256=GflLNu9YY_yi13KzFY8V_5YcRg6HbxNQbKa-nAaE7JI,19713
+numba/tests/test_fastmath.py,sha256=WmCUk3znkhiBhkxhTsudEaA4ci2B6UN_ZnfQky6ib4I,4564
+numba/tests/test_findlib.py,sha256=Tt9Xzn0-3EprPqAEt946-Ses3I8-YwYCN-hMi-ctfig,324
+numba/tests/test_firstlinefinder.py,sha256=r0RgId51Ac794Io2a6YOrdUVbQfI4hL_EoDkgYJIanQ,3392
+numba/tests/test_flow_control.py,sha256=Enpxf95eTr3Hrfq-5th0ffEYMPJiB0PQAgZXj85d1Ho,42596
+numba/tests/test_func_interface.py,sha256=pOMEhD3kH27XbNpe79TahiFRN8ueCcUanbNTwAH1OXg,1038
+numba/tests/test_func_lifetime.py,sha256=3cETb4trG71QeIMSN4foYos7DkZTLQufrc9ENs8ACmY,4908
+numba/tests/test_funcdesc.py,sha256=PJ4s19wiKGYUTlO5wpHNroM2H5ifddYsPiPpIgiKNv8,1698
+numba/tests/test_function_type.py,sha256=A5aFUTuGpgxzOhtTgl56DvcYjrytVYP_kDSCOgjwByQ,39010
+numba/tests/test_gdb_bindings.py,sha256=gPD5l-zxMGrhQziarBEC_QaGM0eoL38SRDBqgc2CRrg,8317
+numba/tests/test_gdb_dwarf.py,sha256=HYg0qUCIP0ucW1UGD85v0OLZ_Rr0Tfu4s3uP5B9Ytu0,9269
+numba/tests/test_generators.py,sha256=b_0h4IZfKRTnb-rWanA02GcP0t2neBOW3bQzIEVVKQo,16981
+numba/tests/test_getitem_on_types.py,sha256=hsEpV7IgJXWNUYP1L77xKaNujlbmOvbLK4uIdRc6ri4,3564
+numba/tests/test_gil.py,sha256=WRDNrOROgZhDb3lNMhh9TBqlfIa-ZE0W2tXBwwgzEEI,5889
+numba/tests/test_globals.py,sha256=VQgRuotHnILWTfFY7Bg91VGxDsNmmMM2GKPF1AeXAiU,7329
+numba/tests/test_hashing.py,sha256=ss_UGyIxaCiHwUVcgu5y2ztLMgziDJ-8zITrpLOTAsI,19226
+numba/tests/test_heapq.py,sha256=VXHJSinvSStGoVQLpgBOx17G3ytBbKrsUBJezPUW_O4,14456
+numba/tests/test_help.py,sha256=VAYX2JIdCqrjtFuJo72r-_4Kj9iPcF8JSIKtRwxzSMs,3523
+numba/tests/test_import.py,sha256=fur18iYNN1gsQ5WSGKK9y_nRCtHKU4n3jRp-MBBKuEw,4036
+numba/tests/test_indexing.py,sha256=A75GHibuaQJsXKAq_xVEQYUZKCIkVi3j69S6qDO9yz4,38601
+numba/tests/test_init_utils.py,sha256=GVZ3bG9xAfp6rWmfmtAYoJk9FyxyqhEq0VSBY9JA4M0,1557
+numba/tests/test_inlining.py,sha256=-pMzweKPnI9HkbgEUc4Kc3gzzm-UKYFP99Bi4HsvcAk,11520
+numba/tests/test_interpreter.py,sha256=qVSslKyVjndqJp5957QZz2nndMrRAGBYqsTuFI598vE,30293
+numba/tests/test_interproc.py,sha256=NLOub2C1frPWw7dlVKHTllI2_rLF5BcAzFEg4a3Fgkc,1099
+numba/tests/test_intwidth.py,sha256=A9JymBQSHZtQaGkQqmMOCKdbDgY97JMKnYjIEWVMdMg,2703
+numba/tests/test_ir.py,sha256=cHqnyUh2-f6fd66wbUOiQqUHFMBR75bWAzCyhDb8_ok,20060
+numba/tests/test_ir_inlining.py,sha256=hS7raQOqe9Gvnd7g97qyIdlsmn7fxhSlqKkEC6AY7Cs,44707
+numba/tests/test_ir_utils.py,sha256=ErZ7XgZ8oNntp0TrvVh20QkreQoFZpOBJThukdKO3m4,9457
+numba/tests/test_itanium_mangler.py,sha256=eGG6LBnVcAXltL3laDLJuMnQN34gfI_GbGzaRXiPFbc,2561
+numba/tests/test_iteration.py,sha256=xyYG4PgnanlE7M9SNzv33vJo8PKNPC_pk8rd7D_vDBQ,7049
+numba/tests/test_jit_module.py,sha256=gAkHb87P2kk3ppThgeCWOdag-8PDhvQBdTvu0CmA0PY,5248
+numba/tests/test_jitclasses.py,sha256=DgyUWYCigq9M104wfDVuRqit6Qum4RrLKdb2wbl4J40,59199
+numba/tests/test_jitmethod.py,sha256=g2RTCmvFbNyNO4JaKcsLWeAdmrrOXrjB30pOUGyH_iU,2000
+numba/tests/test_linalg.py,sha256=xz6w0KYO3_FEuEi5muJA0AaCVkbFFXxKeFMLAs4Ybhw,96098
+numba/tests/test_listimpl.py,sha256=FEgWroRVAkeiorccJFwfmgLhXsJsyiCVkGvQzUvjESE,16147
+numba/tests/test_listobject.py,sha256=52f6E2RX0vASiB6d7CjmQ62tjmcFFGu9pUAHyx8dYkM,44676
+numba/tests/test_lists.py,sha256=ARmbrrb3sFU3yyUfBtI-XGlKEQl7gbBR_ngEWg-NNFY,51554
+numba/tests/test_literal_dispatch.py,sha256=cYQ6P4o7rYyJc6jNTV66-knNKo02B-anN3Ctccvplpk,11732
+numba/tests/test_llvm_pass_timings.py,sha256=z8MXzdlTAqIQ_KWFqPZCrULg4usUNCPk2eUm---59zQ,4493
+numba/tests/test_llvm_version_check.py,sha256=o8RSkDrsnljJ3xzbtsDQAkkqUEJwI3F2SEN9b1f1uMA,1284
+numba/tests/test_locals.py,sha256=8d61r5d1lkIXllE1ObI5oDZ1IwTTyeAtkHFaiLG4orw,335
+numba/tests/test_looplifting.py,sha256=DAPyP8Y60Bam8p4CaGsL8xCDIK_CKYf-gKnf2uBUD6I,16335
+numba/tests/test_make_function_to_jit_function.py,sha256=JFsIpGLwunSUqImiWUcik_3AX7JRqRTY4qgZNMnPgmc,8288
+numba/tests/test_mandelbrot.py,sha256=ZLrAAKncKA74KLlgLbyfu6y7gp3FwZy_riAIwVlRkx4,595
+numba/tests/test_mangling.py,sha256=TtBFeN7EKTKtozvkwuAktbnKONG-bCH1jlHD-3n4EWw,1264
+numba/tests/test_map_filter_reduce.py,sha256=xyfL19UnK8WGXY2cNXBbiAKU7ZX3q5wZSVWZqaWLrYE,2031
+numba/tests/test_mathlib.py,sha256=hcnmbl9isPlZW9fyTB6LBGC8Ki7Hce80mdUvHjgjbEA,17432
+numba/tests/test_maxmin.py,sha256=UDqYYUfJveub3U1xEqvjR_w1t7q67vPG86mZtizXzEA,747
+numba/tests/test_misc_coverage_support.py,sha256=UdIHgJsBLc0QQMuyrd5-D-plIGD-pDITqKux71QRB6I,2134
+numba/tests/test_mixed_tuple_unroller.py,sha256=TMVAg_qm39WVfnz6XT_TZM4NgrLg7S20FeMAcOdBEfA,62041
+numba/tests/test_moved_modules.py,sha256=OcjNSGqNgvXwFQT0ipI4j8XP-ZbHPRFrXi1-8rjZIZE,1319
+numba/tests/test_multi3.py,sha256=hCHPIsHlx5wXW1PgkycrEVAxw7J1HGbn8NmnnbLN5Zw,1229
+numba/tests/test_nan.py,sha256=hmWtRaxUQvuBSQlfQkksgwaw4ZZ7Xjq6oyOktMnCU6M,751
+numba/tests/test_ndarray_subclasses.py,sha256=Jw2Zf5fanHlhihcp6BwzzxOlTYPhSQ3FcIdOOcK0v_0,10687
+numba/tests/test_nested_calls.py,sha256=G80JzLpJGN9oCYhHX2NMviQ7dpCG5loYW_vfS0cbHoo,3771
+numba/tests/test_new_type_system.py,sha256=Cr-Zhg3DuZY6cry5d0xBeqU2OWlzFifT9DLkDX7J6Qs,898
+numba/tests/test_np_functions.py,sha256=ZhMucHRXJ4iYoJCTe3ZrJdbJ9RH6T-dpXiavijYNwls,229133
+numba/tests/test_np_randomgen.py,sha256=jp7Pj3sL_oXrfX9587Ou_wqohzHhs_ktbEkvSQqI5Ig,54301
+numba/tests/test_npdatetime.py,sha256=fGxZIY3spAsYsetl7JgXCJbpwmsvK0ZtQs8NHTNvSdY,43615
+numba/tests/test_nrt.py,sha256=mJQubsvf8o6m4KbF9RMXhB50qY8cyr0KTprNQnSwcB8,29787
+numba/tests/test_nrt_refct.py,sha256=k09EmgKBFPL3aCXBUaf7PYm9RmMXf3aqG2Fe2ZjR_Ic,2911
+numba/tests/test_num_threads.py,sha256=ZpuRV1hDfNYqStXZZ-pBkJP-8Iz7QKHjeTvJn1DyPMw,23511
+numba/tests/test_numberctor.py,sha256=uMpKKjN7S3quNI-ajwBxatwy12RHhbR8Parg1E4BYyw,7179
+numba/tests/test_numbers.py,sha256=iV9xS_t0FC0_ecUgva1pRY3-2_X3_1Xd58yk1oUw5hk,3415
+numba/tests/test_numconv.py,sha256=dFdTlZA1_agMuxP1OER02cKqZ-RR8dh0ES_69XdP20w,1008
+numba/tests/test_numpy_support.py,sha256=YsOjgIHdwiqzeerH3cP-Uth13jgZAoAZ39Bb8MnO5ec,17397
+numba/tests/test_numpyadapt.py,sha256=f9iBBwwkwxrIpHC1Frp-bf0gl0oqcWhB9OwF3AzbuMk,1307
+numba/tests/test_obj_lifetime.py,sha256=g8N8pszctyim9xlC_SFdWlEkB9POJdXbi3E2NuOnPXU,15316
+numba/tests/test_object_mode.py,sha256=V1b7c32dfpcQqMTuJIAsHVzjpC4aLORDgi6FzH2E_18,5368
+numba/tests/test_objects.py,sha256=RtRWC40agdYKfJubbWD2VUIp99U-8Vlel-KLAJOl4_o,1319
+numba/tests/test_operators.py,sha256=lDzhL6OxdPeZQJnolwknGU5fUma8GxjAuLyKy6o4Ukc,50699
+numba/tests/test_optimisation_pipelines.py,sha256=z4n9_uQYGFPFOOAwth0IugJrWmcejyjBi9Pe4yigjpw,1692
+numba/tests/test_optional.py,sha256=0its7sre69mtSqePamMqOzudWdYGcdRYbcHWn99HeT4,6502
+numba/tests/test_overlap.py,sha256=P8MUVACNycTX54KFFmYzVlNxogayjlVspS9HtKZH-2w,3839
+numba/tests/test_parallel_backend.py,sha256=8PyoHAyXzkpuFf9Zzx2qvllZcYahPN1-B8nzTaypIKY,42150
+numba/tests/test_parfors.py,sha256=ApV5WmBGB7siKTDFMiOuJUc3d8qYSdnNTHQoMqORFU8,166099
+numba/tests/test_parfors_caching.py,sha256=rf148DXLmLZNWFQgNCnW26lIBECRop4PufbWgk-pC7I,2962
+numba/tests/test_parfors_passes.py,sha256=TP_mY4NjR9dicGgOhSSeLqB3uxvYo2HwrbL40KfU254,21064
+numba/tests/test_pipeline.py,sha256=pqCu3ZyutdOxwGwPf2UEgh0BuajETlnb1m7UqwVjxV8,5254
+numba/tests/test_polynomial.py,sha256=wiK0QaSAV49M0DFNMGN_XfX8NLpxEdyc0ahWwLpmyzU,19776
+numba/tests/test_practical_lowering_issues.py,sha256=ecFnAiMhzk7fwxAHvvVXaoepQZDjhvW4U15ixnL0oRM,6953
+numba/tests/test_print.py,sha256=EaNmfFd8gx4RsLKc0d22fVtAdLqi4LMXEh3f03UJLFI,6144
+numba/tests/test_profiler.py,sha256=T-46A6_bMjHc3izo9zrmjIdZ7EQSewAbEAQ1AFK1AfM,4060
+numba/tests/test_pycc.py,sha256=vyr4DJmBwAlqYYqE2yusz_1CKBYVHXf0APpj5tUXcAw,13233
+numba/tests/test_python_int.py,sha256=bZhwlvC2KpAn1x0ID8HOerUpSuOULPMz-cLO4gNXVIs,1690
+numba/tests/test_pythonapi.py,sha256=pLN9H8hX-xP8SfWPLdh_OOC0dn7jOvrtY8j5trV3Rls,3935
+numba/tests/test_random.py,sha256=xunfNU0MU_kTRAKjjxwBQMEGk2HdCNOOT66a5uEPsy8,73909
+numba/tests/test_range.py,sha256=J9xJJeu-xOv-qnC4CFqRB0Y8APAfJwFw4tUBaSvLWnc,5179
+numba/tests/test_recarray_usecases.py,sha256=v5UuuUNowgDnJ3nx5vPKBNt00tQMZMg9BBQ6_KzWcjk,3839
+numba/tests/test_record_dtype.py,sha256=8TIJbFz92G6FmSuPys-ym2biuU_JTjVnG4lA0_3YLxE,57298
+numba/tests/test_recursion.py,sha256=K6Z1vT5beETZgN5Xz6qs-3vHP7zEY_KDT7XDjHJeshI,4602
+numba/tests/test_refop_pruning.py,sha256=K5YmwkDN41c-pIUcPcK-N9LYy-cDSShz0RX0Zhy28iA,5826
+numba/tests/test_remove_dead.py,sha256=KUEbJ1uujvquy8exzEhpFeytZfYxm1CWRnTMvcQZxcc,13717
+numba/tests/test_repr.py,sha256=vMYY2byejl_KyZTB5JopGMKCD8NeYeNjnjJ_uYFRgdU,1656
+numba/tests/test_return_values.py,sha256=KCLvJRAoSJugioiXe45HZHAWbPGy35-v7TWi-joEodM,2062
+numba/tests/test_runtests.py,sha256=VyYj2gOZ3GxSjoFXMVlJA5W4lYGYx14PwL9ZGH4Trfw,11292
+numba/tests/test_serialize.py,sha256=UhQQCzPwzODqbI8DqROlLYyyYvaX9VKIsgg3mcH9MA8,11088
+numba/tests/test_sets.py,sha256=2JbWMI63gfq85FoGfqYNF1XgPWodbI1SohfvSgvdTgo,23282
+numba/tests/test_slices.py,sha256=4zotg9-XrVJEyYf7AMWt5AwKp-luxJ-_nEIRHl-Oiy4,8449
+numba/tests/test_sort.py,sha256=3YBVPEFORrRMcupu41BsULuEEUB3MuIt51H3dpse188,40742
+numba/tests/test_ssa.py,sha256=08zQ9c7R6FOL3iOoW6dlG2pwUU8Q8Wz0wXLh__5P1cE,18974
+numba/tests/test_stencils.py,sha256=OA7TyK4Mq1V6EHTaNLIflJPCQYEp5_zISkTts69aYII,127272
+numba/tests/test_storeslice.py,sha256=LVlURBWUfpaGUsk8TC5rv2uSLZM-FuPAnaz3PiEhFE0,1940
+numba/tests/test_struct_ref.py,sha256=_nZ4BJ4vzQ-2wCLrLd2MQtgdlZAySQ30Q9dWzgYG7jo,12185
+numba/tests/test_support.py,sha256=GhJ1s3hZl2GOhdm29WzMKzg-POIS8-bPoVc2Q-hOJ4I,14133
+numba/tests/test_svml.py,sha256=B6B_wUTNnuKO40UOC9YD4La8X8pcJEcYHgiiwUIuO_k,15726
+numba/tests/test_sys_monitoring.py,sha256=TsKgrsc5rx9iX77-9JFRImN0P6XiIBdjyFgAad5iOR4,32717
+numba/tests/test_sys_stdin_assignment.py,sha256=NfkWGUZSKP9S1Ljr8FHjh58xnqTnOWrdh6OtEo8N148,1665
+numba/tests/test_sysinfo.py,sha256=MgPhaN0xtlOTse6OLSYjiFykAXvWWXINGYOkxa_zjGc,5890
+numba/tests/test_target_extension.py,sha256=wGmlHdocHb0CLD32Lf9saq01rNmsbbyYF-68X16dtEU,28255
+numba/tests/test_target_overloadselector.py,sha256=mLwsAg2bdMfVT9gZA1Xh40ejOpkHvrVpeuxn48PTSow,6226
+numba/tests/test_threadsafety.py,sha256=R-5T_uNcy27TX57izO7GuTf5WZXpkXdEiofc0VJT5QU,2787
+numba/tests/test_tracing.py,sha256=DC1Gabw7E9b3BzwdApxlE6oEM73nmQoYxBucL8jAoAU,4855
+numba/tests/test_try_except.py,sha256=jP0chLxOfQtF_omHJJ0Vx-I015jmS4g4cZXdEsPwUyc,23797
+numba/tests/test_tuples.py,sha256=fbYmlJA7wtogDauMsiz6lZzicPqu3nK0F4ezt-yyTS4,23912
+numba/tests/test_typeconv.py,sha256=M3S82AjZTIiuBDx-AUZNfTOhrVIgT6tEPEPRB2XY5gQ,11167
+numba/tests/test_typedlist.py,sha256=w3IUmFnfZ8M2jC20ZOkCi1kgCMcrNud5SDrOdzoG-jE,50620
+numba/tests/test_typedobjectutils.py,sha256=wORlAhi7rywQ1JpHduOJDlZH_l_a7JAhEgqdSvdU5Ck,2352
+numba/tests/test_typeguard.py,sha256=0kLxdIvu-C6kcbSfBb2yI9Ylb4L3MCZ0T5oleiHEQuQ,1153
+numba/tests/test_typeinfer.py,sha256=hx001QWC1PkEsPfph9AEWqqlcrvjIXTxM1lSDEOQ_I4,30851
+numba/tests/test_typenames.py,sha256=ua0hmkv8rTcEqg-7nMnAEmHkiyr3Z7Ugoe9J9jN9OUI,432
+numba/tests/test_typeof.py,sha256=nXjg6V9ELNCG0Yrfv_2PabB86SI7TA5l6fn4-XrH1rI,21678
+numba/tests/test_types.py,sha256=gbFsY60LX4Da4sxUeMjZhqre_poj0LVoxIijpe09Mzw,30661
+numba/tests/test_typingerror.py,sha256=zSFlST4KnTw2wNJe84mvYCIQxk3c-O5PXj9gnNw0dds,7235
+numba/tests/test_ufuncs.py,sha256=E2SOccs_8YI-LDxs0KnQm8r4qrQFMSBABQrrY84Geso,71263
+numba/tests/test_unicode.py,sha256=37amh2t_5QukaKLuZ6TcOyxwREHcF6Kx1RiprZzxF-c,98531
+numba/tests/test_unicode_array.py,sha256=DHLGut0dDX2n3KR0RmV4iSTRuWZYNF2KfiObwLuHqwI,28996
+numba/tests/test_unicode_names.py,sha256=YPJbxE4DzjQpFi7Wow7DGb4mwdqaTGTb5det8ayiupw,1563
+numba/tests/test_unpack_sequence.py,sha256=7edSjmBZUOJz0uxPsj1nELfYWlh0MxgN8nzxVjyuwDs,6745
+numba/tests/test_unpickle_without_module.py,sha256=OVLcy0Zwui5SPjr_Hs12ShxzhfPMmF7oS9XkX4iDQDo,1631
+numba/tests/test_unsafe_intrinsics.py,sha256=WCYZrNyu_70rX2ep7WgP5sw9vvOv730YWfQWO5j7oBo,7619
+numba/tests/test_usecases.py,sha256=gn3HkS--zzZ5U9b08oY2T5nzhySxg7AHlIyLiuacVMU,5893
+numba/tests/test_vectorization.py,sha256=tMLcZ6_7CPimUNwhymiQJGw7mInOktOc8mIhKi1zoyA,2932
+numba/tests/test_vectorization_type_inference.py,sha256=Hd9WtE3urYqslprNdKbbNk4X5lOzL2IM7aWr1rKAxrk,1162
+numba/tests/test_warnings.py,sha256=pm4J3GKggNbi2WWu6mmIazz7pDGT6E_-ZlUXOo6RvXw,7408
+numba/tests/test_withlifting.py,sha256=WYF_SHfw4jFnFk-RxeLKZS9JAZYry7LpNHOBBXeR9Ak,35112
+numba/tests/threading_backend_usecases.py,sha256=q0In5DcjTg6LqAQY-Q1_WnmG7-4MhGBqIMDrSuysz8Y,618
+numba/tests/typedlist_usecases.py,sha256=Uo-2XbzPxNwPBeWh1U4yr7KkfEjADZ4NouO_PP6oX3o,287
+numba/tests/usecases.py,sha256=q5AbT3VfeLTN7P4whdfQ-851Y56BrnZ4K4EvbiegeLk,1618
+numba/typed/__init__.py,sha256=WljiSoGMqByzcozGuYCbTb3N_ZcrpT6LFkD5jyDucVs,484
+numba/typed/dictimpl.py,sha256=7qPLFW3ex2n1wmysA7IyZqehPoUHG6ICuiwVGXDLAU0,1101
+numba/typed/dictobject.py,sha256=VGX9Mx0w8LcohJynyWU8OTIJZ3mX0YpK4R3JbOEy8z0,40958
+numba/typed/listobject.py,sha256=oRXamf2CGRnqKbcJyluTmau4-6mWEQcxlrAKagdxYoo,46154
+numba/typed/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+numba/typed/typeddict.py,sha256=tfQWKMur0hwxlOiaiy8fTxQ0O1gCPEPmhA33_NBV6QA,12216
+numba/typed/typedlist.py,sha256=0Mipv8f1LK3nOt6FfN1jImEzKzbt8OFpAfNAPAtpVJk,18791
+numba/typed/typedobjectutils.py,sha256=EsOTnBwYCQMG-IqoRsCDU1s3gbdlEJDjoCaYo8QZEGc,7036
+numba/types/__init__.py,sha256=bSQKeXj0suDD-j13RK4CxMnB5TXbgab4jo2536aMQI4,134

lib/python3.13/site-packages/numba-0.61.2.dist-info/WHEEL

@@ -0,0 +1,6 @@
+Wheel-Version: 1.0
+Generator: setuptools (78.1.0)
+Root-Is-Purelib: false
+Tag: cp313-cp313-manylinux_2_17_x86_64
+Tag: cp313-cp313-manylinux2014_x86_64
+

lib/python3.13/site-packages/numba-0.61.2.dist-info/top_level.txt

@@ -0,0 +1 @@
+numba

lib/python3.13/site-packages/pandas-2.3.3.dist-info/WHEEL

@@ -0,0 +1,6 @@
+Wheel-Version: 1.0
+Generator: meson
+Root-Is-Purelib: false
+Tag: cp313-cp313-manylinux_2_24_x86_64
+Tag: cp313-cp313-manylinux_2_28_x86_64
+