Upload folder using huggingface_hub (part 5)

.gitattributes

@@ -73,3 +73,8 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 .venv/lib/python3.11/site-packages/h5py/h5s.cpython-311-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
 .venv/lib/python3.11/site-packages/h5py/h5t.cpython-311-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
 .venv/lib/python3.11/site-packages/h5py/h5z.cpython-311-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
+.venv/lib/python3.11/site-packages/h5py/utils.cpython-311-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
+.venv/lib/python3.11/site-packages/h5py.libs/libhdf5-9e18f0c6.so.320.0.0 filter=lfs diff=lfs merge=lfs -text
+.venv/lib/python3.11/site-packages/h5py.libs/libhdf5_hl-69da89c9.so.320.0.0 filter=lfs diff=lfs merge=lfs -text
+.venv/lib/python3.11/site-packages/hf_xet/hf_xet.abi3.so filter=lfs diff=lfs merge=lfs -text
+.venv/lib/python3.11/site-packages/huggingface_hub/__pycache__/hf_api.cpython-311.pyc filter=lfs diff=lfs merge=lfs -text

.venv/lib/python3.11/site-packages/h5py-3.16.0.dist-info/INSTALLER

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

.venv/lib/python3.11/site-packages/h5py-3.16.0.dist-info/METADATA

@@ -0,0 +1,64 @@
+Metadata-Version: 2.4
+Name: h5py
+Version: 3.16.0
+Summary: Read and write HDF5 files from Python
+Author-email: Andrew Collette <andrew.collette@gmail.com>
+Maintainer-email: Thomas Kluyver <thomas@kluyver.me.uk>, Thomas A Caswell <tcaswell@bnl.gov>
+License-Expression: BSD-3-Clause
+Project-URL: Homepage, https://www.h5py.org/
+Project-URL: Source, https://github.com/h5py/h5py
+Project-URL: Documentation, https://docs.h5py.org/en/stable/
+Project-URL: Release notes, https://docs.h5py.org/en/stable/whatsnew/index.html
+Project-URL: Discussion forum, https://forum.hdfgroup.org/c/hdf5/h5py
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Information Technology
+Classifier: Intended Audience :: Science/Research
+Classifier: Operating System :: Unix
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Operating System :: MacOS :: MacOS X
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Programming Language :: Cython
+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: Programming Language :: Python :: 3.14
+Classifier: Programming Language :: Python :: Free Threading :: 1 - Unstable
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Topic :: Scientific/Engineering
+Classifier: Topic :: Database
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.10
+Description-Content-Type: text/x-rst
+License-File: LICENSE
+License-File: lzf/LICENSE.txt
+License-File: licenses/hdf5.txt
+License-File: licenses/license.txt
+License-File: licenses/pytables.txt
+License-File: licenses/python.txt
+License-File: licenses/stdint.txt
+Requires-Dist: numpy>=1.21.2
+Dynamic: license-file
+Dynamic: requires-dist
+
+The h5py package provides both a high- and low-level interface to the HDF5
+library from Python. The low-level interface is intended to be a complete
+wrapping of the HDF5 API, while the high-level component supports  access to
+HDF5 files, datasets and groups using established Python and NumPy concepts.
+
+A strong emphasis on automatic conversion between Python (Numpy) datatypes and
+data structures and their HDF5 equivalents vastly simplifies the process of
+reading and writing data from Python.
+
+Wheels are provided for several popular platforms, with an included copy of
+the HDF5 library (usually the latest version when h5py is released).
+
+You can also `build h5py from source
+<https://docs.h5py.org/en/stable/build.html#source-installation>`_
+with any HDF5 stable release from version 1.10.4 onwards, although naturally new
+HDF5 versions released after this version of h5py may not work.
+Odd-numbered minor versions of HDF5 (e.g. 1.13) are experimental, and may not
+be supported.

.venv/lib/python3.11/site-packages/h5py-3.16.0.dist-info/RECORD

@@ -0,0 +1,106 @@
+h5py-3.16.0.dist-info/INSTALLER,sha256=5hhM4Q4mYTT9z6QB6PGpUAW81PGNFrYrdXMj4oM_6ak,2
+h5py-3.16.0.dist-info/METADATA,sha256=5GH89-uf7mJCIF-SJcwXhFWgIS0cDLj5l_fuv4zZaV4,3007
+h5py-3.16.0.dist-info/RECORD,,
+h5py-3.16.0.dist-info/REQUESTED,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+h5py-3.16.0.dist-info/WHEEL,sha256=Op2QaqlU71fNSBP2nIljEWzUWxRUBAuK-SqS4BfzclU,113
+h5py-3.16.0.dist-info/licenses/LICENSE,sha256=5XSylmVc-wylGA7G7uPJXRIrCQZzbTyn484Z4PKX8Mk,1520
+h5py-3.16.0.dist-info/licenses/licenses/hdf5.txt,sha256=K4L--O2KAgumVs4tslBe2FiTnLfDtvffCEvYMDLXe8c,3766
+h5py-3.16.0.dist-info/licenses/licenses/license.txt,sha256=-s9D4DGTz0z42LzdZ84E_GHvaUjdBmcqTl2leeZKOUg,1739
+h5py-3.16.0.dist-info/licenses/licenses/pytables.txt,sha256=mi1dboFWOMajwRMPZr58z_CehMDoIeVz8q3WnURiJBQ,1640
+h5py-3.16.0.dist-info/licenses/licenses/python.txt,sha256=hITnBcmcf12_FXcjtOPNHa_5z-QcdAtXJVWHjwWFiYQ,2503
+h5py-3.16.0.dist-info/licenses/licenses/stdint.txt,sha256=HUwLpl1NqiPvjWwFcevpazCrrr2inCbWbOE1QNTxKyg,1394
+h5py-3.16.0.dist-info/licenses/lzf/LICENSE.txt,sha256=qPjFSrwA0azRV0AVV7Psb1AKx2pe_Reg6qZE4tMua-s,1556
+h5py-3.16.0.dist-info/top_level.txt,sha256=fO7Bsaa0F3Nx6djErCCbSw4-E7rBFMWrBVTGLEMxUMg,5
+h5py.libs/libaec-a27cf049.so.0.1.4,sha256=mnI5kmsWLg2-QaH8AYHlXs0p1dv6Vv_eQr7IrUtPLbY,50545
+h5py.libs/libhdf5-9e18f0c6.so.320.0.0,sha256=H2PzwC8C3NcC_OY6D23GeGQwvxuYmSbGhQ0gJrLItCQ,6132905
+h5py.libs/libhdf5_hl-69da89c9.so.320.0.0,sha256=xC-1hG-mWDV1ZmGETFmmDd6EghL0s14EuuHZ-xd1Nvk,198665
+h5py.libs/libsz-c6be10dd.so.2.0.1,sha256=pKlk1m-DS3eHyWl94BlWUzPs0ZCtGVeeoYBQVvm8fVY,54057
+h5py/__init__.py,sha256=1KRoAwhyR872fuNKTZjXl74vVbH5IwvF-KH6NY-NG4c,3705
+h5py/_conv.cpython-311-x86_64-linux-gnu.so,sha256=86f18GMgtaax4dfi8ZXOaDiEj657dJOB7JmaSzR1dMQ,459673
+h5py/_errors.cpython-311-x86_64-linux-gnu.so,sha256=1cKD22D2spMDBWskavz2_RdK1nq0jEtBCHeAZNn_HWc,159673
+h5py/_hl/__init__.py,sha256=R6siZWBApRmGrOkxi8kNKxZ0Hcp2MieM-0EBWwbp7vc,457
+h5py/_hl/attrs.py,sha256=v9v8fJ9AaqGRXBDVDm89Pbms_7eqRQW4Ta45lUop1A4,10209
+h5py/_hl/base.py,sha256=TGEn-w9w297bIQy-8--DfeMf5khezya6lO1bq7JhKDU,15701
+h5py/_hl/compat.py,sha256=UXvt42U_OiXAcPcrr1FwVP_ScD4yL-ONPercjyUx6FA,1523
+h5py/_hl/dataset.py,sha256=Vzq8QU7sLBDgM86qPzNjjyYbAZERHdrkk6yR-7dOZVc,45291
+h5py/_hl/datatype.py,sha256=-kIh5Ha9K21VLqInUmZ6SZdXag1yvyo30MpgsM3H0P0,1548
+h5py/_hl/dims.py,sha256=rbjYav9D7dFG-Tns_RDuP24B6bwR80LO_2d2NQYihh8,5109
+h5py/_hl/files.py,sha256=kmhW1WMm27-M1qaYFpwF6Nb1STLUDcmYk1GzCOA1jTY,25154
+h5py/_hl/filters.py,sha256=8e00taWWH4eV9y0Hq9CIRsCNZMqJyN9x2sUjKkYya-Y,14604
+h5py/_hl/group.py,sha256=6q_QLDGOLHgXlw0Qmr56WlQ8Qk9tbyVyeADgFu7GX7c,34321
+h5py/_hl/selections.py,sha256=MThKzB1B4N9x9T5CwfQvTqLCXP_GwGrLP1HatNV1yBg,14686
+h5py/_hl/selections2.py,sha256=PcKxIbSCYjL_QrbeCHw8-MHWDBxOlEDG_UHvP4aBuKY,2723
+h5py/_hl/vds.py,sha256=QpMLtumI_uaJ1CdqMXyxgGaW3rxAztcwSIB4rEjLC3U,9468
+h5py/_npystrings.cpython-311-x86_64-linux-gnu.so,sha256=GqlAY4hUG7phhRzb0tC9Afdhrme-Py4ZSrfeZWW29OU,154849
+h5py/_objects.cpython-311-x86_64-linux-gnu.so,sha256=Lv29s0RkqNPn-Dm8fdZRgmZwAn5CEyaVihp_Hs8hWQ8,360785
+h5py/_proxy.cpython-311-x86_64-linux-gnu.so,sha256=vqzGOpz3Fne-WzIDkYDD87hYNL1Y1h1LX2VzDR0ZCS8,142321
+h5py/_selector.cpython-311-x86_64-linux-gnu.so,sha256=PtYkVj6sWMEuStPNF-PbPhfaPMHWeUzQbPNVjlnEZ8A,364945
+h5py/defs.cpython-311-x86_64-linux-gnu.so,sha256=jReZI6HVK9hXR8TxiqYqwUoofism1bdCfPRbyIYcHIM,512497
+h5py/h5.cpython-311-x86_64-linux-gnu.so,sha256=g_uzy5YKyzdPSL2EZLrV-f3obiWiceqaxL9Zc2I2Hvw,257665
+h5py/h5a.cpython-311-x86_64-linux-gnu.so,sha256=CXAB8DvXN9t88oCRBchXVU7a43Dp9WJWQ3U6lNTvt1U,319121
+h5py/h5ac.cpython-311-x86_64-linux-gnu.so,sha256=xecNlWm9uIx_2WGhg0EwnYbDoSiR_La3Ig2-4xDpcvg,216257
+h5py/h5d.cpython-311-x86_64-linux-gnu.so,sha256=hHGhKMb8L0ZRLW51RhukB1rkQLIkEkeD8-W5KvqrZSw,577985
+h5py/h5ds.cpython-311-x86_64-linux-gnu.so,sha256=ctcMYks7lOFzV8wKAcHWkgpk-cEbdcTKWQbpdJV5r48,224825
+h5py/h5f.cpython-311-x86_64-linux-gnu.so,sha256=bKdZMDaC82rt-e0EqgcA9hjLaax18jZDClvIkrQU_bI,352025
+h5py/h5fd.cpython-311-x86_64-linux-gnu.so,sha256=zwo74dnNsIv0M_3uCZ-ngdny1GhRgFhsCe9qmKMOFn8,364857
+h5py/h5g.cpython-311-x86_64-linux-gnu.so,sha256=7bphFJdzlfqSjAhGycM43DuT9FPOiBwxLTV1n8dKpGc,381033
+h5py/h5i.cpython-311-x86_64-linux-gnu.so,sha256=NCe1NW1amlKjOZFlKu09hlF_TBGoswlrIDnhUb3coHs,175457
+h5py/h5l.cpython-311-x86_64-linux-gnu.so,sha256=3BKvrhWKEKl_pTGhb3-1cXpqRVINy_ZAozFDZZc1xp0,274001
+h5py/h5o.cpython-311-x86_64-linux-gnu.so,sha256=5bE5Q7z2grHZyrI9_LemJVl95F1cezW1xZZjrcEmgS0,343609
+h5py/h5p.cpython-311-x86_64-linux-gnu.so,sha256=c-yPWSc4TzT8O3wXIW4vsYznvu8rBt5YDr2tShB529E,885185
+h5py/h5pl.cpython-311-x86_64-linux-gnu.so,sha256=LBFTKE-RL0YZSW89pGXbkOzkVxuishZ1lfCcA9kQG64,162889
+h5py/h5py_warnings.py,sha256=bNPu7wWPt1xLVZVB-lpycIoMux1kcNfaKf4NE78dK90,523
+h5py/h5r.cpython-311-x86_64-linux-gnu.so,sha256=EluXGlvs36y_OeT5-uji1rlebS-lj0hEc2ibZ8rRoCE,200169
+h5py/h5s.cpython-311-x86_64-linux-gnu.so,sha256=3aUO9A77EAQjVmV5icOTeXO6_vKJFZlgDHailgjyHXs,319049
+h5py/h5t.cpython-311-x86_64-linux-gnu.so,sha256=REVuP3pTUBWGp2ihJklbPo5LKAsgzuVLQ_ZBdLn4jcY,919425
+h5py/h5z.cpython-311-x86_64-linux-gnu.so,sha256=pQh4ME-qhAKMhW1CECUnk6fLlr9SLJQAHyeUdZv4wFk,171313
+h5py/ipy_completer.py,sha256=dGKYNK3CE32jwRVrBeUssdXRocu45VnrA3cvLRp-2E0,3733
+h5py/tests/__init__.py,sha256=oPTnFGaf5_48QHzq0mpTwlxbagBvnvU3W9s2AWRcWFU,613
+h5py/tests/common.py,sha256=YuWJ5cblajJUGbejKVDl7C_FVzFgjWeKr1p3EIBO0sc,9278
+h5py/tests/conftest.py,sha256=-aF7Ig1w4yd00YxOS9ScB4hFunPLXPXUGF8rDL43WSg,545
+h5py/tests/data_files/__init__.py,sha256=WgwvU8ZVG00ZN2EOOnZ7TYJX_NzF_JCSd7nSEDJrbrE,193
+h5py/tests/data_files/compound-dtype-complex.h5,sha256=682WWAlgZPFuRqLXS5UyyeamrVtnqCfy-09jefawU4A,13792
+h5py/tests/data_files/vlen_string_dset.h5,sha256=kA-LrxnT2MTRGTrBrGAZ7nd0AF6FwDCvROZ1ezjSl5M,6304
+h5py/tests/data_files/vlen_string_dset_utc.h5,sha256=hbcoOCuDPB2mFie5ozTiKCLVwcs1n-O6byUmKvRTL2M,169904
+h5py/tests/data_files/vlen_string_s390x.h5,sha256=6pkMaOA3G6-rSWb3UvoTVbO59kNgBm9tna_48bfnTKU,9008
+h5py/tests/test_attribute_create.py,sha256=YWXGzX53dryJT2eW-tSXOEPq80Vrq-s4B9aJpV_Wjsg,3181
+h5py/tests/test_attrs.py,sha256=jt2w-bbIgNV-U1LJ71LmoN9ltqePrlmAzYZOOM7YLdo,9652
+h5py/tests/test_attrs_data.py,sha256=hLttIRENNppMAY7zGVHiuly1QOg54gndk9OA3fFuxI8,10154
+h5py/tests/test_base.py,sha256=8zkoukhM7XqR08lvFHFxmP-3B5RLYCaXwEJvDvXuDpQ,3971
+h5py/tests/test_big_endian_file.py,sha256=-IYw7zyybjYIGKgZu1ys5D74ur4WMHeJRCHXiohlWvQ,1469
+h5py/tests/test_completions.py,sha256=5IoOj-sdctWpf_shX4sCweZEEgrzZRMv4KDalWPsJtM,1894
+h5py/tests/test_dataset.py,sha256=ikpvsbNnSPe91fUG3Uqne6bewfxVAHvayBPWpn2NDLw,88749
+h5py/tests/test_dataset_getitem.py,sha256=9IlFGNFs-ioNe7YsXBVrkZMYi0YxagUD_nls7ftIV1U,21005
+h5py/tests/test_dataset_swmr.py,sha256=cwkcX4GwGuLXD3IRlrgPnstbeWCUOhJXBEWthJWSakw,4060
+h5py/tests/test_datatype.py,sha256=Gr-0IgmeC7ldt5rQMX3r4zlPwhUTsh7Fru6sMCRj0vU,1091
+h5py/tests/test_dimension_scales.py,sha256=qA_dlkb5WYbqz8eXKpy6g_VcOsKKamT71t010kJH6b0,8424
+h5py/tests/test_dims_dimensionproxy.py,sha256=OzhpDSYjKegKusgqaCcxcjIlLtELzKndzlpbqqpCu54,591
+h5py/tests/test_dtype.py,sha256=ScTD9_PI3wsdBnfmlbfHcioCB_o0okjccwoANQK-hCQ,20109
+h5py/tests/test_errors.py,sha256=jRWnUxN9bwlhdcSrcsgElto1amVHOg564_StvA9WcVA,2369
+h5py/tests/test_file.py,sha256=FimQtXH8zbjVeqtEUaBA-HsTgA3Jztrq_X7StmSZFA8,35243
+h5py/tests/test_file2.py,sha256=R3eoUPK-DwIl_bU3Xr2IJ5iLdEbuUNoc8138nWJ0WRg,11160
+h5py/tests/test_file_alignment.py,sha256=Ov8hhi6ZfcIf-sntv9OGBQ0kk8aAag9yXjsN-yA64kI,4488
+h5py/tests/test_file_image.py,sha256=w7COnNE--O_zfmJKdADzNjTsJp8zUC5Z5XzX0p9OGeY,2009
+h5py/tests/test_filters.py,sha256=GeU-WR6C3fblqRrfUG7hxK90E3LeDNn-ADwS9GQ8qzg,3218
+h5py/tests/test_group.py,sha256=bx0pd8pI7JiKQuIE-ARZ-cXGeNfShGn92OAQVlcAx6k,48757
+h5py/tests/test_h5.py,sha256=FlYZcVxxP1kIYCZdSEC3sR7o72dPWYiUbhyFO0rvN-8,1216
+h5py/tests/test_h5d_direct_chunk.py,sha256=xDEEP-djvITkMNMk3T7TPFnZ5g4kpvshXdIvgVJ1Nmo,7811
+h5py/tests/test_h5f.py,sha256=eNZAcfQ2Au1W5nwewZ6FDbA0JURlY5R4hhjZPijdGnI,3929
+h5py/tests/test_h5o.py,sha256=5bob6Brn-lW-xSNgSS5rLiuwKWQ0SzP4aTYoccgYfDQ,522
+h5py/tests/test_h5p.py,sha256=qWO3u5JOQ4XkgLm2t0kSZgj0RgAylFWlSHia_M2r9AI,8094
+h5py/tests/test_h5pl.py,sha256=2LZY4glHa9lMQLXfuPFFs_mcdGHMgUxpixKQ6RyEIx8,1847
+h5py/tests/test_h5s.py,sha256=TGgvWcqPmBKuyNnEDmQxwOCXqvW9Uj0KTt9bVZ2IGOw,2149
+h5py/tests/test_h5t.py,sha256=EjYXQl70rJaUfE9NOYnWjTltP0g02IYGWpmq1uMQsx8,6595
+h5py/tests/test_h5z.py,sha256=WuQljb3J9K_dv29sysjnwc9lnPeUUAEHrjFx90BypOg,1972
+h5py/tests/test_native_complex.py,sha256=Sog3Dm0TSHFEY-r8td-9k_apFFw1TsRzt_BAVYJQurY,5684
+h5py/tests/test_npystrings.py,sha256=IwssUPMLTBq7kpTZuU4Xj7k0QTAkYZ_gpuC7o3U4O5g,5846
+h5py/tests/test_objects.py,sha256=ia_kwGyWdD0e8fXunF2MP4apuJ3vc1I49jfKu1aPIS8,3043
+h5py/tests/test_ros3.py,sha256=19xBp3LF0QnFwKbcuZDAa2YEt90hl44_bB2Qdo2F0JM,3378
+h5py/tests/test_selections.py,sha256=gXYA8OStDr_LwUGbBEwRC14yRRBmRRxz-HBp6fOwuFk,4891
+h5py/tests/test_slicing.py,sha256=ql5vshPyFoyqvZetERA2NPqu0tkSTXqU0nTveaI7ngY,14158
+h5py/tests/test_vds/__init__.py,sha256=2mnHIhOAdjMVjHQjBp9VFDLfltPEOR02aoZ1yTJU5hY,103
+h5py/tests/test_vds/test_highlevel_vds.py,sha256=p38uAjBJ252qXnwnMMeP4DA7WX9j_XVpu6cSbBRrgpw,17852
+h5py/tests/test_vds/test_lowlevel_vds.py,sha256=Gp2dX53EaGmJ4Vd7N7K_e0efGkkqPkdnQtZBmjSVLOc,11934
+h5py/tests/test_vds/test_virtual_source.py,sha256=eJglh9M8-JZsKFbOq__dLgnhafs91UcujxdD1Ng6ryA,6055
+h5py/utils.cpython-311-x86_64-linux-gnu.so,sha256=e24uxED3CLW1YrrR-M3Cwvc-rSv9muBWuxgXfq_fCKk,175529
+h5py/version.py,sha256=uR4EyeOssFzeBCJ0F_16laX3Plet5Dx7iXTSTMNJ6fw,1911

.venv/lib/python3.11/site-packages/h5py-3.16.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.0)
+Root-Is-Purelib: false
+Tag: cp311-cp311-manylinux_2_28_x86_64
+

.venv/lib/python3.11/site-packages/h5py-3.16.0.dist-info/licenses/LICENSE

@@ -0,0 +1,30 @@
+Copyright (c) 2008 Andrew Collette and contributors
+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.

.venv/lib/python3.11/site-packages/h5py-3.16.0.dist-info/licenses/licenses/hdf5.txt

@@ -0,0 +1,69 @@
+HDF5 (Hierarchical Data Format 5) Software Library and Utilities
+Copyright 2006-2007 by The HDF Group (THG).
+
+NCSA HDF5 (Hierarchical Data Format 5) Software Library and Utilities
+Copyright 1998-2006 by the Board of Trustees of the University of Illinois.
+
+All rights reserved.
+
+Contributors: National Center for Supercomputing Applications (NCSA)
+at the University of Illinois, Fortner Software, Unidata Program
+Center (netCDF), The Independent JPEG Group (JPEG), Jean-loup Gailly
+and Mark Adler (gzip), and Digital Equipment Corporation (DEC).
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted for any purpose (including commercial
+purposes) 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 materials provided with the
+distribution.
+   3. In addition, redistributions of modified forms of the source or
+binary code must carry prominent notices stating that the original
+code was changed and the date of the change.
+   4. All publications or advertising materials mentioning features or
+use of this software are asked, but not required, to acknowledge that
+it was developed by The HDF Group and by the National Center for
+Supercomputing Applications at the University of Illinois at
+Urbana-Champaign and credit the contributors.
+   5. Neither the name of The HDF Group, the name of the University,
+nor the name of any Contributor may be used to endorse or promote
+products derived from this software without specific prior written
+permission from THG, the University, or the Contributor, respectively.
+
+DISCLAIMER: THIS SOFTWARE IS PROVIDED BY THE HDF GROUP (THG) AND THE
+CONTRIBUTORS "AS IS" WITH NO WARRANTY OF ANY KIND, EITHER EXPRESSED OR
+IMPLIED. In no event shall THG or the Contributors be liable for any
+damages suffered by the users arising out of the use of this software,
+even if advised of the possibility of such damage.
+
+Portions of HDF5 were developed with support from the University of
+California, Lawrence Livermore National Laboratory (UC LLNL). The
+following statement applies to those portions of the product and must
+be retained in any redistribution of source code, binaries,
+documentation, and/or accompanying materials:
+
+This work was partially produced at the University of California,
+Lawrence Livermore National Laboratory (UC LLNL) under contract
+no. W-7405-ENG-48 (Contract 48) between the U.S. Department of Energy
+(DOE) and The Regents of the University of California (University) for
+the operation of UC LLNL.
+
+DISCLAIMER: This work was prepared as an account of work sponsored by
+an agency of the United States Government. Neither the United States
+Government nor the University of California nor any of their
+employees, makes any warranty, express or implied, or assumes any
+liability or responsibility for the accuracy, completeness, or
+usefulness of any information, apparatus, product, or process
+disclosed, or represents that its use would not infringe privately-
+owned rights. Reference herein to any specific commercial products,
+process, or service by trade name, trademark, manufacturer, or
+otherwise, does not necessarily constitute or imply its endorsement,
+recommendation, or favoring by the United States Government or the
+University of California. The views and opinions of authors expressed
+herein do not necessarily state or reflect those of the United States
+Government or the University of California, and shall not be used for
+advertising or product endorsement purposes.

.venv/lib/python3.11/site-packages/h5py-3.16.0.dist-info/licenses/licenses/license.txt

@@ -0,0 +1,34 @@
+Copyright Notice and Statement for the h5py Project
+===================================================
+
+    Copyright (c) 2008-2013 Andrew Collette and contributors
+    http://www.h5py.org
+    All rights reserved.
+
+    Redistribution and use in source and binary forms, with or without
+    modification, are permitted provided that the following conditions are
+    met:
+
+    a. Redistributions of source code must retain the above copyright
+       notice, this list of conditions and the following disclaimer.
+
+    b. 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.
+
+    c. Neither the name of the author nor the names of contributors may
+       be used to endorse or promote products derived from this software
+       without specific prior written permission.
+
+    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+    "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+    LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+    A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+    OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+    SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+    LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+    DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+    THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+    (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+    OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

.venv/lib/python3.11/site-packages/h5py-3.16.0.dist-info/licenses/licenses/pytables.txt

@@ -0,0 +1,33 @@
+Copyright Notice and Statement for PyTables Software Library and Utilities:
+
+Copyright (c) 2002, 2003, 2004  Francesc Altet
+Copyright (c) 2005, 2006, 2007  Carabos Coop. V.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are
+met:
+
+a. Redistributions of source code must retain the above copyright
+   notice, this list of conditions and the following disclaimer.
+
+b. 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.
+
+c. Neither the name of the Carabos Coop. V. nor the names of its
+   contributors may be used to endorse or promote products derived
+   from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

.venv/lib/python3.11/site-packages/h5py-3.16.0.dist-info/licenses/licenses/python.txt

@@ -0,0 +1,44 @@
+Python license
+==============
+
+#. This LICENSE AGREEMENT is between the Python Software Foundation ("PSF"), and
+   the Individual or Organization ("Licensee") accessing and otherwise using Python
+   Python 2.7.5 software in source or binary form and its associated documentation.
+
+#. Subject to the terms and conditions of this License Agreement, PSF hereby
+   grants Licensee a nonexclusive, royalty-free, world-wide license to reproduce,
+   analyze, test, perform and/or display publicly, prepare derivative works,
+   distribute, and otherwise use Python Python 2.7.5 alone or in any derivative
+   version, provided, however, that PSF's License Agreement and PSF's notice of
+   copyright, i.e., "Copyright 2001-2013 Python Software Foundation; All Rights
+   Reserved" are retained in Python Python 2.7.5 alone or in any derivative version
+   prepared by Licensee.
+
+#. In the event Licensee prepares a derivative work that is based on or
+   incorporates Python Python 2.7.5 or any part thereof, and wants to make the
+   derivative work available to others as provided herein, then Licensee hereby
+   agrees to include in any such work a brief summary of the changes made to Python
+   Python 2.7.5.
+
+#. PSF is making Python Python 2.7.5 available to Licensee on an "AS IS" basis.
+   PSF MAKES NO REPRESENTATIONS OR WARRANTIES, EXPRESS OR IMPLIED.  BY WAY OF
+   EXAMPLE, BUT NOT LIMITATION, PSF MAKES NO AND DISCLAIMS ANY REPRESENTATION OR
+   WARRANTY OF MERCHANTABILITY OR FITNESS FOR ANY PARTICULAR PURPOSE OR THAT THE
+   USE OF PYTHON Python 2.7.5 WILL NOT INFRINGE ANY THIRD PARTY RIGHTS.
+
+#. PSF SHALL NOT BE LIABLE TO LICENSEE OR ANY OTHER USERS OF PYTHON Python 2.7.5
+   FOR ANY INCIDENTAL, SPECIAL, OR CONSEQUENTIAL DAMAGES OR LOSS AS A RESULT OF
+   MODIFYING, DISTRIBUTING, OR OTHERWISE USING PYTHON Python 2.7.5, OR ANY DERIVATIVE
+   THEREOF, EVEN IF ADVISED OF THE POSSIBILITY THEREOF.
+
+#. This License Agreement will automatically terminate upon a material breach of
+   its terms and conditions.
+
+#. Nothing in this License Agreement shall be deemed to create any relationship
+   of agency, partnership, or joint venture between PSF and Licensee.  This License
+   Agreement does not grant permission to use PSF trademarks or trade name in a
+   trademark sense to endorse or promote products or services of Licensee, or any
+   third party.
+
+#. By copying, installing or otherwise using Python Python 2.7.5, Licensee agrees
+   to be bound by the terms and conditions of this License Agreement.

.venv/lib/python3.11/site-packages/h5py-3.16.0.dist-info/licenses/licenses/stdint.txt

@@ -0,0 +1,25 @@
+Copyright (c) 2006-2008 Alexander Chemeris
+
+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. The name of the author may be used to endorse or promote products
+     derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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.

.venv/lib/python3.11/site-packages/h5py-3.16.0.dist-info/licenses/lzf/LICENSE.txt

@@ -0,0 +1,33 @@
+Copyright Notice and Statement for LZF filter
+
+Copyright (c) 2008-2009 Andrew Collette
+http://h5py.org
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are
+met:
+
+a. Redistributions of source code must retain the above copyright
+   notice, this list of conditions and the following disclaimer.
+
+b. 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.
+
+c. Neither the name of the author nor the names of contributors may
+   be used to endorse or promote products derived from this software
+   without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

.venv/lib/python3.11/site-packages/h5py-3.16.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+h5py

.venv/lib/python3.11/site-packages/h5py.libs/libhdf5-9e18f0c6.so.320.0.0

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

.venv/lib/python3.11/site-packages/h5py.libs/libhdf5_hl-69da89c9.so.320.0.0

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

.venv/lib/python3.11/site-packages/h5py/tests/test_objects.py

@@ -0,0 +1,92 @@
+# This file is part of h5py, a Python interface to the HDF5 library.
+#
+# http://www.h5py.org
+#
+# Copyright 2008-2013 Andrew Collette and contributors
+#
+# License:  Standard 3-clause BSD; see "license.txt" for full license terms
+#           and contributor agreement.
+import os
+import threading
+import time
+
+import pytest
+
+from h5py import _objects as o
+from .common import TestCase
+
+
+class TestObjects(TestCase):
+
+    def test_invalid(self):
+        # Check for segfault on close
+        oid = o.ObjectID(0)
+        del oid
+        oid = o.ObjectID(1)
+        del oid
+
+    def test_equality(self):
+        # Identifier-based equality
+        oid1 = o.ObjectID(42)
+        oid2 = o.ObjectID(42)
+        oid3 = o.ObjectID(43)
+
+        self.assertEqual(oid1, oid2)
+        self.assertNotEqual(oid1, oid3)
+
+    def test_hash(self):
+        # Default objects are not hashable
+        oid = o.ObjectID(42)
+        with self.assertRaises(TypeError):
+            hash(oid)
+
+    @pytest.mark.thread_unsafe(reason="fork() from a thread may deadlock")
+    @pytest.mark.filterwarnings(
+        # https://github.com/python/cpython/pull/100229
+        r"ignore:.*use of fork\(\) may lead to deadlocks:DeprecationWarning"
+    )
+    @pytest.mark.skipif(not hasattr(os, "fork"), reason="fork() not available")
+    def test_phil_fork_with_threads(self):
+        """Test that handling of the phil Lock after fork is correct.
+
+        h5py uses os.register_at_fork() to cause os.fork() to acquire the phil lock
+        before forking and release it afterwards, so that the global state of libhdf5
+        cannot be cloned in a corrupted state.
+        """
+        thread_acquired_phil_event = threading.Event()
+
+        def f():
+            # Simulate another thread holding the phil lock while it updates
+            # the libhdf5 global state
+            with o.phil:
+                thread_acquired_phil_event.set()
+                time.sleep(1)
+
+        thread = threading.Thread(target=f)
+        thread.start()
+        thread_acquired_phil_event.wait()
+
+        try:
+            # Now fork the current (main) thread while the other thread holds the lock.
+            # os.fork() acquires the phil lock, so this will block until the other
+            # thread releases it.
+            pid = os.fork()
+            if pid == 0:
+                # Child process
+                # If we handle the phil lock correctly, this should not deadlock, and we
+                # should be able to acquire the lock here.
+                if o.phil.acquire(blocking=False):
+                    o.phil.release()
+                    os._exit(0)
+                else:
+                    os._exit(1)
+            else:
+                # Parent process
+                assert o.phil.acquire(blocking=False)
+                o.phil.release()
+                # Wait for the child process to finish
+                _, status = os.waitpid(pid, 0)
+                assert os.WIFEXITED(status)
+                assert os.WEXITSTATUS(status) == 0
+        finally:
+            thread.join()

.venv/lib/python3.11/site-packages/h5py/tests/test_ros3.py

@@ -0,0 +1,112 @@
+# This file is part of h5py, a Python interface to the HDF5 library.
+#
+# http://www.h5py.org
+#
+# Copyright 2008-2013 Andrew Collette and contributors
+#
+# License:  Standard 3-clause BSD; see "license.txt" for full license terms
+#           and contributor agreement.
+
+"""
+    Read-only S3 virtual file driver (VFD) test module.
+"""
+
+import h5py
+from h5py._hl.files import make_fapl
+import pytest
+
+
+pytestmark = [
+    pytest.mark.skipif(
+        not h5py.h5.get_config().ros3,
+        reason="ros3 driver not available")
+]
+
+
+@pytest.mark.network
+@pytest.mark.parametrize(
+    "kwargs",
+    [
+        pytest.param(
+            {},
+            id="HDF5-v1",
+            marks=pytest.mark.skipif(
+                h5py.version.hdf5_version_tuple >= (2, 0, 0),
+                reason="Requires HDF5 < 2.0",
+            ),
+        ),
+        pytest.param(
+            {"aws_region": b"us-east-2"},
+            id="HDF5-v2",
+            marks=pytest.mark.skipif(
+                h5py.version.hdf5_version_tuple < (2, 0, 0),
+                reason="Requires HDF5 >= 2.0",
+            ),
+        ),
+    ],
+)
+def test_ros3(kwargs):
+    """ ROS3 driver and options """
+
+    with h5py.File("https://dandiarchive.s3.amazonaws.com/ros3test.hdf5", 'r',
+                   driver='ros3', **kwargs) as f:
+        assert f
+        assert 'mydataset' in f.keys()
+        assert f["mydataset"].shape == (100,)
+
+
+@pytest.mark.parametrize(
+    "exc,match_exc",
+    [
+        pytest.param(
+            ValueError,
+            [
+                "AWS region required for s3:// location",
+                r"^foo://wrong/scheme: S3 location must begin with",
+            ],
+            id="HDF5-v1",
+            marks=pytest.mark.skipif(
+                h5py.version.hdf5_version_tuple >= (2, 0, 0),
+                reason="Requires HDF5 < 2.0",
+            ),
+        ),
+        pytest.param(
+            OSError,
+            [None, "can't parse object key from path"],
+            id="HDF5-v2",
+            marks=pytest.mark.skipif(
+                h5py.version.hdf5_version_tuple < (2, 0, 0),
+                reason="Requires HDF5 >= 2.0",
+            ),
+        ),
+    ],
+)
+def test_ros3_s3_fails(exc, match_exc):
+    """ROS3 exceptions for s3:// location"""
+    with pytest.raises(exc, match=match_exc[0]):
+        h5py.File('s3://fakebucket/fakekey', 'r', driver='ros3')
+
+    with pytest.raises(exc, match=match_exc[1]):
+        h5py.File('foo://wrong/scheme', 'r', driver='ros3')
+
+
+@pytest.mark.network
+def test_ros3_s3uri():
+    """Use S3 URI with ROS3 driver"""
+    with h5py.File('s3://dandiarchive/ros3test.hdf5', 'r', driver='ros3',
+                   aws_region=b'us-east-2') as f:
+        assert f
+        assert 'mydataset' in f.keys()
+        assert f["mydataset"].shape == (100,)
+
+
+@pytest.mark.skipif(h5py.version.hdf5_version_tuple < (1, 14, 2),
+                    reason='AWS S3 access token support in HDF5 >= 1.14.2')
+def test_ros3_temp_token():
+    """Set and get S3 access token"""
+    token = b'#0123FakeToken4567/8/9'
+    fapl = make_fapl('ros3', libver=None, rdcc_nslots=None, rdcc_nbytes=None,
+                     rdcc_w0=None, locking=None, page_buf_size=None, min_meta_keep=None,
+                     min_raw_keep=None, alignment_threshold=1, alignment_interval=1,
+                     meta_block_size=None, session_token=token)
+    assert token, fapl.get_fapl_ros3_token()

.venv/lib/python3.11/site-packages/h5py/tests/test_selections.py

@@ -0,0 +1,142 @@
+# This file is part of h5py, a Python interface to the HDF5 library.
+#
+# http://www.h5py.org
+#
+# Copyright 2008-2013 Andrew Collette and contributors
+#
+# License:  Standard 3-clause BSD; see "license.txt" for full license terms
+#           and contributor agreement.
+
+"""
+    Tests for the (internal) selections module
+"""
+
+import numpy as np
+import h5py
+import h5py._hl.selections as sel
+import h5py._hl.selections2 as sel2
+
+from .common import TestCase, make_name
+
+class BaseSelection(TestCase):
+    def setUp(self):
+        self.f = h5py.File(self.mktemp(), 'w')
+        self.dsid = self.f.create_dataset('x', (), "f4").id
+
+    def tearDown(self):
+        if self.f:
+            self.f.close()
+
+class TestTypeGeneration(BaseSelection):
+
+    """
+        Internal feature: Determine output types from dataset dtype and fields.
+    """
+
+    def test_simple(self):
+        """ Non-compound types are handled appropriately """
+        dt = np.dtype('i')
+        out, format = sel2.read_dtypes(dt, ())
+        self.assertEqual(out, format)
+        self.assertEqual(out, np.dtype('i'))
+
+    def test_simple_fieldexc(self):
+        """ Field names for non-field types raises ValueError """
+        dt = np.dtype('i')
+        with self.assertRaises(ValueError):
+            out, format = sel2.read_dtypes(dt, ('a',))
+
+    def test_compound_simple(self):
+        """ Compound types with elemental subtypes """
+        dt = np.dtype( [('a','i'), ('b','f'), ('c','|S10')] )
+
+        # Implicit selection of all fields -> all fields
+        out, format = sel2.read_dtypes(dt, ())
+        self.assertEqual(out, format)
+        self.assertEqual(out, dt)
+
+        # Explicit selection of fields -> requested fields
+        out, format = sel2.read_dtypes(dt, ('a','b'))
+        self.assertEqual(out, format)
+        self.assertEqual(out, np.dtype( [('a','i'), ('b','f')] ))
+
+        # Explicit selection of exactly one field -> no fields
+        out, format = sel2.read_dtypes(dt, ('a',))
+        self.assertEqual(out, np.dtype('i'))
+        self.assertEqual(format, np.dtype( [('a','i')] ))
+
+        # Field does not appear in named typed
+        with self.assertRaises(ValueError):
+            out, format = sel2.read_dtypes(dt, ('j', 'k'))
+
+class TestScalarSliceRules(BaseSelection):
+
+    """
+        Internal feature: selections rules for scalar datasets
+    """
+
+    def test_args(self):
+        """ Permissible arguments for scalar slicing """
+        shape, selection = sel2.read_selections_scalar(self.dsid, ())
+        self.assertEqual(shape, None)
+        self.assertEqual(selection.get_select_npoints(), 1)
+
+        shape, selection = sel2.read_selections_scalar(self.dsid, (Ellipsis,))
+        self.assertEqual(shape, ())
+        self.assertEqual(selection.get_select_npoints(), 1)
+
+        with self.assertRaises(ValueError):
+            shape, selection = sel2.read_selections_scalar(self.dsid, (1,))
+
+        dsid = self.f.create_dataset(make_name(), (1,), "f4").id
+        with self.assertRaises(RuntimeError):
+            shape, selection = sel2.read_selections_scalar(dsid, (1,))
+
+class TestSelection(BaseSelection):
+
+    """ High-level routes to generate a selection
+    """
+
+    def test_selection(self):
+        dset = self.f.create_dataset(make_name(), (100,100), "f4")
+        regref = dset.regionref[0:100, 0:100]
+
+        # args is list, return a FancySelection
+        st = sel.select((10,), list([1,2,3]), dset)
+        self.assertIsInstance(st, sel.FancySelection)
+
+        # args[0] is tuple, return a FancySelection
+        st = sel.select((10,), ((1, 2, 3),), dset)
+        self.assertIsInstance(st, sel.FancySelection)
+
+        # args is a Boolean mask, return a PointSelection
+        st1 = sel.select((5,), np.array([True,False,False,False,True]), dset)
+        self.assertIsInstance(st1, sel.PointSelection)
+
+        # args is int, return a SimpleSelection
+        st2 = sel.select((10,), 1, dset)
+        self.assertIsInstance(st2, sel.SimpleSelection)
+
+        # args is str, should be rejected
+        with self.assertRaises(TypeError):
+            sel.select((100,), "foo", dset)
+
+        # args is RegionReference, return a Selection instance
+        st3 = sel.select((100,100), regref, dset)
+        self.assertIsInstance(st3, sel.Selection)
+
+        # args is RegionReference, but dataset is None
+        with self.assertRaises(TypeError):
+            sel.select((100,), regref, None)
+
+        # args is RegionReference, but its shape doesn't match dataset shape
+        with self.assertRaises(TypeError):
+            sel.select((100,), regref, dset)
+
+        # args is a single Selection instance, return the arg
+        st4 = sel.select((100,100), st3, dset)
+        self.assertEqual(st4,st3)
+
+        # args is a single Selection instance, but args shape doesn't match Shape
+        with self.assertRaises(TypeError):
+            sel.select((100,), st3, dset)

.venv/lib/python3.11/site-packages/h5py/tests/test_slicing.py

@@ -0,0 +1,421 @@
+# This file is part of h5py, a Python interface to the HDF5 library.
+#
+# http://www.h5py.org
+#
+# Copyright 2008-2013 Andrew Collette and contributors
+#
+# License:  Standard 3-clause BSD; see "license.txt" for full license terms
+#           and contributor agreement.
+
+"""
+    Dataset slicing test module.
+
+    Tests all supported slicing operations, including read/write and
+    broadcasting operations.  Does not test type conversion except for
+    corner cases overlapping with slicing; for example, when selecting
+    specific fields of a compound type.
+"""
+
+import numpy as np
+
+from .common import TestCase, make_name
+
+import h5py
+from h5py import File, MultiBlockSlice
+
+class BaseSlicing(TestCase):
+
+    def setUp(self):
+        self.f = File(self.mktemp(), 'w')
+
+    def tearDown(self):
+        if self.f:
+            self.f.close()
+
+class TestSingleElement(BaseSlicing):
+
+    """
+        Feature: Retrieving a single element works with NumPy semantics
+    """
+
+    def test_single_index(self):
+        """ Single-element selection with [index] yields array scalar """
+        dset = self.f.create_dataset(make_name(), (1,), dtype='i1')
+        out = dset[0]
+        self.assertIsInstance(out, np.int8)
+
+    def test_single_null(self):
+        """ Single-element selection with [()] yields ndarray """
+        dset = self.f.create_dataset(make_name(), (1,), dtype='i1')
+        out = dset[()]
+        self.assertIsInstance(out, np.ndarray)
+        self.assertEqual(out.shape, (1,))
+
+    def test_scalar_index(self):
+        """ Slicing with [...] yields scalar ndarray """
+        dset = self.f.create_dataset(make_name(), shape=(), dtype='f')
+        out = dset[...]
+        self.assertIsInstance(out, np.ndarray)
+        self.assertEqual(out.shape, ())
+
+    def test_scalar_null(self):
+        """ Slicing with [()] yields array scalar """
+        dset = self.f.create_dataset(make_name(), shape=(), dtype='i1')
+        out = dset[()]
+        self.assertIsInstance(out, np.int8)
+
+    def test_compound(self):
+        """ Compound scalar is numpy.void, not tuple (issue 135) """
+        dt = np.dtype([('a','i4'),('b','f8')])
+        v = np.ones((4,), dtype=dt)
+        dset = self.f.create_dataset(make_name(), (4,), data=v)
+        self.assertEqual(dset[0], v[0])
+        self.assertIsInstance(dset[0], np.void)
+
+class TestObjectIndex(BaseSlicing):
+
+    """
+        Feature: numpy.object_ subtypes map to real Python objects
+    """
+
+    def test_reference(self):
+        """ Indexing a reference dataset returns a h5py.Reference instance """
+        dset = self.f.create_dataset(make_name(), (1,), dtype=h5py.ref_dtype)
+        dset[0] = self.f.ref
+        self.assertEqual(type(dset[0]), h5py.Reference)
+
+    def test_regref(self):
+        """ Indexing a region reference dataset returns a h5py.RegionReference
+        """
+        dset1 = self.f.create_dataset(make_name("x"), (10,10), "f4")
+        regref = dset1.regionref[...]
+        dset2 = self.f.create_dataset(make_name("y"), (1,), dtype=h5py.regionref_dtype)
+        dset2[0] = regref
+        self.assertEqual(type(dset2[0]), h5py.RegionReference)
+
+    def test_reference_field(self):
+        """ Compound types of which a reference is an element work right """
+        dt = np.dtype([('a', 'i'),('b', h5py.ref_dtype)])
+
+        dset = self.f.create_dataset(make_name(), (1,), dtype=dt)
+        dset[0] = (42, self.f['/'].ref)
+
+        out = dset[0]
+        self.assertEqual(type(out[1]), h5py.Reference)  # isinstance does NOT work
+
+    def test_scalar(self):
+        """ Indexing returns a real Python object on scalar datasets """
+        dset = self.f.create_dataset(make_name(), (), dtype=h5py.ref_dtype)
+        dset[()] = self.f.ref
+        self.assertEqual(type(dset[()]), h5py.Reference)
+
+    def test_bytestr(self):
+        """ Indexing a byte string dataset returns a real python byte string
+        """
+        dset = self.f.create_dataset(make_name(), (1,), dtype=h5py.string_dtype(encoding='ascii'))
+        dset[0] = b"Hello there!"
+        self.assertEqual(type(dset[0]), bytes)
+
+class TestSimpleSlicing(TestCase):
+
+    """
+        Feature: Simple NumPy-style slices (start:stop:step) are supported.
+    """
+
+    def setUp(self):
+        self.f = File(self.mktemp(), 'w')
+        self.arr = np.arange(10)
+        self.dset = self.f.create_dataset('x', data=self.arr)
+
+    def tearDown(self):
+        if self.f:
+            self.f.close()
+
+    def test_negative_stop(self):
+        """ Negative stop indexes work as they do in NumPy """
+        self.assertArrayEqual(self.dset[2:-2], self.arr[2:-2])
+
+    def test_write(self):
+        """Assigning to a 1D slice of a 2D dataset
+        """
+        dset = self.f.create_dataset(make_name(), (10, 2), "f4")
+
+        x = np.zeros((10, 1))
+        dset[:, 0] = x[:, 0]
+        with self.assertRaises(TypeError):
+            dset[:, 1] = x
+
+class TestArraySlicing(BaseSlicing):
+
+    """
+        Feature: Array types are handled appropriately
+    """
+
+    def test_read(self):
+        """ Read arrays tack array dimensions onto end of shape tuple """
+        dt = np.dtype('(3,)f8')
+        dset = self.f.create_dataset(make_name(), (10,), dtype=dt)
+        self.assertEqual(dset.shape, (10,))
+        self.assertEqual(dset.dtype, dt)
+
+        # Full read
+        out = dset[...]
+        self.assertEqual(out.dtype, np.dtype('f8'))
+        self.assertEqual(out.shape, (10,3))
+
+        # Single element
+        out = dset[0]
+        self.assertEqual(out.dtype, np.dtype('f8'))
+        self.assertEqual(out.shape, (3,))
+
+        # Range
+        out = dset[2:8:2]
+        self.assertEqual(out.dtype, np.dtype('f8'))
+        self.assertEqual(out.shape, (3,3))
+
+    def test_write_broadcast(self):
+        """ Array fill from constant is not supported (issue 211).
+        """
+        dt = np.dtype('(3,)i')
+
+        dset = self.f.create_dataset(make_name(), (10,), dtype=dt)
+
+        with self.assertRaises(TypeError):
+            dset[...] = 42
+
+    def test_write_element(self):
+        """ Write a single element to the array
+
+        Issue 211.
+        """
+        dt = np.dtype('(3,)f8')
+        dset = self.f.create_dataset(make_name(), (10,), dtype=dt)
+
+        data = np.array([1,2,3.0])
+        dset[4] = data
+
+        out = dset[4]
+        self.assertTrue(np.all(out == data))
+
+    def test_write_slices(self):
+        """ Write slices to array type """
+        dt = np.dtype('(3,)i')
+
+        data1 = np.ones((2,), dtype=dt)
+        data2 = np.ones((4,5), dtype=dt)
+
+        dset = self.f.create_dataset(make_name(), (10,9,11), dtype=dt)
+
+        dset[0,0,2:4] = data1
+        self.assertArrayEqual(dset[0,0,2:4], data1)
+
+        dset[3, 1:5, 6:11] = data2
+        self.assertArrayEqual(dset[3, 1:5, 6:11], data2)
+
+
+    def test_roundtrip(self):
+        """ Read the contents of an array and write them back
+
+        Issue 211.
+        """
+        dt = np.dtype('(3,)f8')
+        dset = self.f.create_dataset(make_name(), (10,), dtype=dt)
+
+        out = dset[...]
+        dset[...] = out
+
+        self.assertTrue(np.all(dset[...] == out))
+
+
+class TestZeroLengthSlicing(BaseSlicing):
+
+    """
+        Slices resulting in empty arrays
+    """
+
+    def test_slice_zero_length_dimension(self):
+        """ Slice a dataset with a zero in its shape vector
+            along the zero-length dimension """
+        for i, shape in enumerate([(0,), (0, 3), (0, 2, 1)]):
+            dset = self.f.create_dataset(make_name(f"x{i}"), shape, dtype=int, maxshape=(None,)*len(shape))
+            self.assertEqual(dset.shape, shape)
+            out = dset[...]
+            self.assertIsInstance(out, np.ndarray)
+            self.assertEqual(out.shape, shape)
+            out = dset[:]
+            self.assertIsInstance(out, np.ndarray)
+            self.assertEqual(out.shape, shape)
+            if len(shape) > 1:
+                out = dset[:, :1]
+                self.assertIsInstance(out, np.ndarray)
+                self.assertEqual(out.shape[:2], (0, 1))
+
+    def test_slice_other_dimension(self):
+        """ Slice a dataset with a zero in its shape vector
+            along a non-zero-length dimension """
+        for i, shape in enumerate([(3, 0), (1, 2, 0), (2, 0, 1)]):
+            dset = self.f.create_dataset(make_name(f"x{i}"), shape, dtype=int, maxshape=(None,)*len(shape))
+            self.assertEqual(dset.shape, shape)
+            out = dset[:1]
+            self.assertIsInstance(out, np.ndarray)
+            self.assertEqual(out.shape, (1,)+shape[1:])
+
+    def test_slice_of_length_zero(self):
+        """ Get a slice of length zero from a non-empty dataset """
+        for i, shape in enumerate([(3,), (2, 2,), (2,  1, 5)]):
+            dset = self.f.create_dataset(make_name(f"x{i}"), data=np.zeros(shape, int), maxshape=(None,)*len(shape))
+            self.assertEqual(dset.shape, shape)
+            out = dset[1:1]
+            self.assertIsInstance(out, np.ndarray)
+            self.assertEqual(out.shape, (0,)+shape[1:])
+
+class TestFieldNames(BaseSlicing):
+
+    """
+        Field names for read & write
+    """
+
+    dt = np.dtype([('a', 'f'), ('b', 'i'), ('c', 'f4')])
+    data = np.ones((100,), dtype=dt)
+
+    def setUp(self):
+        BaseSlicing.setUp(self)
+        self.dset = self.f.create_dataset('x', (100,), dtype=self.dt)
+        self.dset[...] = self.data
+
+    def test_read(self):
+        """ Test read with field selections """
+        self.assertArrayEqual(self.dset['a'], self.data['a'])
+
+    def test_unicode_names(self):
+        """ Unicode field names for for read and write """
+        self.assertArrayEqual(self.dset['a'], self.data['a'])
+
+        data = self.data.copy()
+        dset = self.f.create_dataset(make_name(), data=data)
+        dset['a'] = 42
+        data['a'] = 42
+        self.assertArrayEqual(dset['a'], data['a'])
+
+    def test_write(self):
+        """ Test write with field selections """
+        data = self.data.copy()
+        dset = self.f.create_dataset(make_name(), data=data)
+
+        data['a'] *= 2
+        dset['a'] = data
+        self.assertTrue(np.all(dset[...] == data))
+        data['b'] *= 4
+        dset['b'] = data
+        self.assertTrue(np.all(dset[...] == data))
+        data['a'] *= 3
+        data['c'] *= 3
+        dset['a','c'] = data
+        self.assertTrue(np.all(dset[...] == data))
+
+    def test_write_noncompound(self):
+        """ Test write with non-compound source (single-field) """
+        data = self.data.copy()
+        dset = self.f.create_dataset(make_name(), data=data)
+
+        data['b'] = 1.0
+        dset['b'] = 1.0
+        self.assertTrue(np.all(dset[...] == data))
+
+
+class TestMultiBlockSlice(BaseSlicing):
+
+    def setUp(self):
+        super().setUp()
+        self.arr = np.arange(10)
+        self.dset = self.f.create_dataset('x', data=self.arr)
+
+    def test_default(self):
+        # Default selects entire dataset as one block
+        mbslice = MultiBlockSlice()
+
+        self.assertEqual(mbslice.indices(10), (0, 1, 10, 1))
+        np.testing.assert_array_equal(self.dset[mbslice], self.arr)
+
+    def test_default_explicit(self):
+        mbslice = MultiBlockSlice(start=0, count=10, stride=1, block=1)
+
+        self.assertEqual(mbslice.indices(10), (0, 1, 10, 1))
+        np.testing.assert_array_equal(self.dset[mbslice], self.arr)
+
+    def test_start(self):
+        mbslice = MultiBlockSlice(start=4)
+
+        self.assertEqual(mbslice.indices(10), (4, 1, 6, 1))
+        np.testing.assert_array_equal(self.dset[mbslice], np.array([4, 5, 6, 7, 8, 9]))
+
+    def test_count(self):
+        mbslice = MultiBlockSlice(count=7)
+
+        self.assertEqual(mbslice.indices(10), (0, 1, 7, 1))
+        np.testing.assert_array_equal(
+            self.dset[mbslice], np.array([0, 1, 2, 3, 4, 5, 6])
+        )
+
+    def test_count_more_than_length_error(self):
+        mbslice = MultiBlockSlice(count=11)
+        with self.assertRaises(ValueError):
+            mbslice.indices(10)
+
+    def test_stride(self):
+        mbslice = MultiBlockSlice(stride=2)
+
+        self.assertEqual(mbslice.indices(10), (0, 2, 5, 1))
+        np.testing.assert_array_equal(self.dset[mbslice], np.array([0, 2, 4, 6, 8]))
+
+    def test_stride_zero_error(self):
+        with self.assertRaises(ValueError):
+            # This would cause a ZeroDivisionError if not caught
+            MultiBlockSlice(stride=0, block=0).indices(10)
+
+    def test_stride_block_equal(self):
+        mbslice = MultiBlockSlice(stride=2, block=2)
+
+        self.assertEqual(mbslice.indices(10), (0, 2, 5, 2))
+        np.testing.assert_array_equal(self.dset[mbslice], self.arr)
+
+    def test_block_more_than_stride_error(self):
+        with self.assertRaises(ValueError):
+            MultiBlockSlice(block=3)
+
+        with self.assertRaises(ValueError):
+            MultiBlockSlice(stride=2, block=3)
+
+    def test_stride_more_than_block(self):
+        mbslice = MultiBlockSlice(stride=3, block=2)
+
+        self.assertEqual(mbslice.indices(10), (0, 3, 3, 2))
+        np.testing.assert_array_equal(self.dset[mbslice], np.array([0, 1, 3, 4, 6, 7]))
+
+    def test_block_overruns_extent_error(self):
+        # If fully described then must fit within extent
+        mbslice = MultiBlockSlice(start=2, count=2, stride=5, block=4)
+        with self.assertRaises(ValueError):
+            mbslice.indices(10)
+
+    def test_fully_described(self):
+        mbslice = MultiBlockSlice(start=1, count=2, stride=5, block=4)
+
+        self.assertEqual(mbslice.indices(10), (1, 5, 2, 4))
+        np.testing.assert_array_equal(
+            self.dset[mbslice], np.array([1, 2, 3, 4, 6, 7, 8, 9])
+        )
+
+    def test_count_calculated(self):
+        # If not given, count should be calculated to select as many full blocks as possible
+        mbslice = MultiBlockSlice(start=1, stride=3, block=2)
+
+        self.assertEqual(mbslice.indices(10), (1, 3, 3, 2))
+        np.testing.assert_array_equal(self.dset[mbslice], np.array([1, 2, 4, 5, 7, 8]))
+
+    def test_zero_count_calculated_error(self):
+        # In this case, there is no possible count to select even one block, so error
+        mbslice = MultiBlockSlice(start=8, stride=4, block=3)
+
+        with self.assertRaises(ValueError):
+            mbslice.indices(10)

.venv/lib/python3.11/site-packages/h5py/tests/test_vds/__init__.py

@@ -0,0 +1,4 @@
+
+from .test_virtual_source import *
+from .test_highlevel_vds import *
+from .test_lowlevel_vds import *

.venv/lib/python3.11/site-packages/h5py/tests/test_vds/test_highlevel_vds.py

@@ -0,0 +1,482 @@
+'''
+Unit test for the high level vds interface for eiger
+https://support.hdfgroup.org/HDF5/docNewFeatures/VDS/HDF5-VDS-requirements-use-cases-2014-12-10.pdf
+'''
+import os
+import os.path as osp
+import shutil
+import tempfile
+
+import numpy as np
+from numpy.testing import assert_array_equal
+import pytest
+
+import h5py as h5
+from ..common import ut, make_name
+from ..._hl.vds import vds_support
+
+
+@ut.skipUnless(vds_support,
+               'VDS requires HDF5 >= 1.9.233')
+class TestEigerHighLevel(ut.TestCase):
+    def setUp(self):
+        self.working_dir = tempfile.mkdtemp()
+        self.fname = ['raw_file_1.h5', 'raw_file_2.h5', 'raw_file_3.h5']
+        for k, outfile in enumerate(self.fname):
+            filename = osp.join(self.working_dir, outfile)
+            f = h5.File(filename, 'w')
+            f['data'] = np.ones((20, 200, 200)) * k
+            f.close()
+
+        f = h5.File(osp.join(self.working_dir, 'raw_file_4.h5'), 'w')
+        f['data'] = np.ones((18, 200, 200)) * 3
+        self.fname.append('raw_file_4.h5')
+        self.fname = [osp.join(self.working_dir, ix) for ix in self.fname]
+        f.close()
+
+    def test_eiger_high_level(self):
+        outfile = osp.join(self.working_dir, make_name('eiger{}.h5'))
+        layout = h5.VirtualLayout(shape=(78, 200, 200), dtype=float)
+
+        M_minus_1 = 0
+        # Create the virtual dataset file
+        with h5.File(outfile, 'w', libver='latest') as f:
+            for foo in self.fname:
+                in_data = h5.File(foo, 'r')['data']
+                src_shape = in_data.shape
+                in_data.file.close()
+                M = M_minus_1 + src_shape[0]
+                vsource = h5.VirtualSource(foo, 'data', shape=src_shape)
+                layout[M_minus_1:M, :, :] = vsource
+                M_minus_1 = M
+            f.create_virtual_dataset('data', layout, fillvalue=45)
+
+        f = h5.File(outfile, 'r')['data']
+        self.assertEqual(f[10, 100, 10], 0.0)
+        self.assertEqual(f[30, 100, 100], 1.0)
+        self.assertEqual(f[50, 100, 100], 2.0)
+        self.assertEqual(f[70, 100, 100], 3.0)
+        f.file.close()
+
+    def tearDown(self):
+        shutil.rmtree(self.working_dir)
+
+'''
+Unit test for the high level vds interface for excalibur
+https://support.hdfgroup.org/HDF5/docNewFeatures/VDS/HDF5-VDS-requirements-use-cases-2014-12-10.pdf
+'''
+
+class ExcaliburData:
+    FEM_PIXELS_PER_CHIP_X = 256
+    FEM_PIXELS_PER_CHIP_Y = 256
+    FEM_CHIPS_PER_STRIPE_X = 8
+    FEM_CHIPS_PER_STRIPE_Y = 1
+    FEM_STRIPES_PER_MODULE = 2
+
+    @property
+    def sensor_module_dimensions(self):
+        x_pixels = self.FEM_PIXELS_PER_CHIP_X * self.FEM_CHIPS_PER_STRIPE_X
+        y_pixels = self.FEM_PIXELS_PER_CHIP_Y * self.FEM_CHIPS_PER_STRIPE_Y * self.FEM_STRIPES_PER_MODULE
+        return y_pixels, x_pixels,
+
+    @property
+    def fem_stripe_dimensions(self):
+        x_pixels = self.FEM_PIXELS_PER_CHIP_X * self.FEM_CHIPS_PER_STRIPE_X
+        y_pixels = self.FEM_PIXELS_PER_CHIP_Y * self.FEM_CHIPS_PER_STRIPE_Y
+        return y_pixels, x_pixels,
+
+    def generate_sensor_module_image(self, value, dtype='uint16'):
+        dset = np.empty(shape=self.sensor_module_dimensions, dtype=dtype)
+        dset.fill(value)
+        return dset
+
+    def generate_fem_stripe_image(self, value, dtype='uint16'):
+        dset = np.empty(shape=self.fem_stripe_dimensions, dtype=dtype)
+        dset.fill(value)
+        return dset
+
+
+@ut.skipUnless(vds_support,
+               'VDS requires HDF5 >= 1.9.233')
+class TestExcaliburHighLevel(ut.TestCase):
+    def create_excalibur_fem_stripe_datafile(self, fname, nframes, excalibur_data,scale):
+        shape = (nframes,) + excalibur_data.fem_stripe_dimensions
+        max_shape = shape#(None,) + excalibur_data.fem_stripe_dimensions
+        chunk = (1,) + excalibur_data.fem_stripe_dimensions
+        with h5.File(fname, 'w', libver='latest') as f:
+            dset = f.create_dataset('data', shape=shape, maxshape=max_shape, chunks=chunk, dtype='uint16')
+            for data_value_index in np.arange(nframes):
+                dset[data_value_index] = excalibur_data.generate_fem_stripe_image(data_value_index*scale)
+
+    def setUp(self):
+        self.working_dir = tempfile.mkdtemp()
+        self.fname = ["stripe_%d.h5" % stripe for stripe in range(1,7)]
+        self.fname = [osp.join(self.working_dir, f) for f in self.fname]
+        nframes = 5
+        self.edata = ExcaliburData()
+        for k, raw_file in enumerate(self.fname):
+            self.create_excalibur_fem_stripe_datafile(raw_file, nframes, self.edata,k)
+
+    def test_excalibur_high_level(self):
+        outfile = osp.join(self.working_dir, make_name('excalibur{}.h5'))
+        f = h5.File(outfile,'w',libver='latest') # create an output file.
+        in_key = 'data' # where is the data at the input?
+        in_sh = h5.File(self.fname[0],'r')[in_key].shape # get the input shape
+        dtype = h5.File(self.fname[0],'r')[in_key].dtype # get the datatype
+
+        # now generate the output shape
+        vertical_gap = 10 # pixels spacing in the vertical
+        nfiles = len(self.fname)
+        nframes = in_sh[0]
+        width = in_sh[2]
+        height = (in_sh[1]*nfiles) + (vertical_gap*(nfiles-1))
+        out_sh = (nframes, height, width)
+
+        # Virtual layout is a representation of the output dataset
+        layout = h5.VirtualLayout(shape=out_sh, dtype=dtype)
+        offset = 0 # initial offset
+        for i, filename in enumerate(self.fname):
+            # A representation of the input dataset
+            vsource = h5.VirtualSource(filename, in_key, shape=in_sh)
+            layout[:, offset:(offset + in_sh[1]), :] = vsource # map them with indexing
+            offset += in_sh[1] + vertical_gap # increment the offset
+
+        # pass the fill value and list of maps
+        f.create_virtual_dataset('data', layout, fillvalue=0x1)
+        f.close()
+
+        f = h5.File(outfile,'r')['data']
+        self.assertEqual(f[3,100,0], 0.0)
+        self.assertEqual(f[3,260,0], 1.0)
+        self.assertEqual(f[3,350,0], 3.0)
+        self.assertEqual(f[3,650,0], 6.0)
+        self.assertEqual(f[3,900,0], 9.0)
+        self.assertEqual(f[3,1150,0], 12.0)
+        self.assertEqual(f[3,1450,0], 15.0)
+        f.file.close()
+
+    def tearDown(self):
+        shutil.rmtree(self.working_dir)
+
+
+'''
+Unit test for the high level vds interface for percival
+https://support.hdfgroup.org/HDF5/docNewFeatures/VDS/HDF5-VDS-requirements-use-cases-2014-12-10.pdf
+'''
+
+
+@ut.skipUnless(vds_support,
+               'VDS requires HDF5 >= 1.9.233')
+class TestPercivalHighLevel(ut.TestCase):
+
+    def setUp(self):
+        self.working_dir = tempfile.mkdtemp()
+        self.fname = ['raw_file_1.h5','raw_file_2.h5','raw_file_3.h5']
+        k = 0
+        for outfile in self.fname:
+            filename = osp.join(self.working_dir, outfile)
+            f = h5.File(filename,'w')
+            f['data'] = np.ones((20,200,200))*k
+            k +=1
+            f.close()
+
+        f = h5.File(osp.join(self.working_dir, 'raw_file_4.h5'), 'w')
+        f['data'] = np.ones((19,200,200))*3
+        self.fname.append('raw_file_4.h5')
+        self.fname = [osp.join(self.working_dir, ix) for ix in self.fname]
+        f.close()
+
+    def test_percival_high_level(self):
+        outfile = osp.join(self.working_dir,  make_name('percival{}.h5'))
+
+        # Virtual layout is a representation of the output dataset
+        layout = h5.VirtualLayout(shape=(79, 200, 200), dtype=np.float64)
+        for k, filename in enumerate(self.fname):
+            dim1 = 19 if k == 3 else 20
+            vsource = h5.VirtualSource(filename, 'data',shape=(dim1, 200, 200))
+            layout[k:79:4, :, :] = vsource[:, :, :]
+
+        # Create the virtual dataset file
+        with h5.File(outfile, 'w', libver='latest') as f:
+            f.create_virtual_dataset('data', layout, fillvalue=-5)
+
+        foo = np.array(2 * list(range(4)))
+        with h5.File(outfile,'r') as f:
+            ds = f['data']
+            line = ds[:8,100,100]
+            self.assertEqual(ds.shape, (79,200,200),)
+            assert_array_equal(line, foo)
+
+    def test_percival_source_from_dataset(self):
+        outfile = osp.join(self.working_dir,  make_name('percival{}.h5'))
+
+        # Virtual layout is a representation of the output dataset
+        layout = h5.VirtualLayout(shape=(79, 200, 200), dtype=np.float64)
+        for k, filename in enumerate(self.fname):
+            with h5.File(filename, 'r') as f:
+                vsource = h5.VirtualSource(f['data'])
+                layout[k:79:4, :, :] = vsource
+
+        # Create the virtual dataset file
+        with h5.File(outfile, 'w', libver='latest') as f:
+            f.create_virtual_dataset('data', layout, fillvalue=-5)
+
+        foo = np.array(2 * list(range(4)))
+        with h5.File(outfile,'r') as f:
+            ds = f['data']
+            line = ds[:8,100,100]
+            self.assertEqual(ds.shape, (79,200,200),)
+            assert_array_equal(line, foo)
+
+    def tearDown(self):
+        shutil.rmtree(self.working_dir)
+
+@ut.skipUnless(vds_support,
+               'VDS requires HDF5 >= 1.9.233')
+class SlicingTestCase(ut.TestCase):
+
+    def setUp(self):
+        self.tmpdir = tempfile.mkdtemp()
+        # Create source files (1.h5 to 4.h5)
+        for n in range(1, 5):
+            with h5.File(osp.join(self.tmpdir, '{}.h5'.format(n)), 'w') as f:
+                d = f.create_dataset('data', (100,), 'i4')
+                d[:] = np.arange(100) + n
+
+    def make_virtual_ds(self):
+        # Assemble virtual dataset
+        layout = h5.VirtualLayout((4, 100), 'i4', maxshape=(4, None))
+
+        for n in range(1, 5):
+            filename = osp.join(self.tmpdir, "{}.h5".format(n))
+            vsource = h5.VirtualSource(filename, 'data', shape=(100,))
+            # Fill the first half with positions 0, 2, 4... from the source
+            layout[n - 1, :50] = vsource[0:100:2]
+            # Fill the second half with places 1, 3, 5... from the source
+            layout[n - 1, 50:] = vsource[1:100:2]
+
+        outfile = osp.join(self.tmpdir, make_name('VDS{}.h5'))
+
+        # Add virtual dataset to output file
+        with h5.File(outfile, 'w', libver='latest') as f:
+            f.create_virtual_dataset('/group/data', layout, fillvalue=-5)
+
+        return outfile
+
+    def test_slice_source(self):
+        outfile = self.make_virtual_ds()
+
+        with h5.File(outfile, 'r') as f:
+            assert_array_equal(f['/group/data'][0][:3], [1, 3, 5])
+            assert_array_equal(f['/group/data'][0][50:53], [2, 4, 6])
+            assert_array_equal(f['/group/data'][3][:3], [4, 6, 8])
+            assert_array_equal(f['/group/data'][3][50:53], [5, 7, 9])
+
+    def test_inspection(self):
+        with h5.File(osp.join(self.tmpdir, '1.h5'), 'r') as f:
+            assert not f['data'].is_virtual
+
+        outfile = self.make_virtual_ds()
+
+        with h5.File(outfile, 'r') as f:
+            ds = f['/group/data']
+            assert ds.is_virtual
+
+            src_files = {osp.join(self.tmpdir, '{}.h5'.format(n))
+                         for n in range(1, 5)}
+            assert {s.file_name for s in ds.virtual_sources()} == src_files
+
+    def test_mismatched_selections(self):
+        layout = h5.VirtualLayout((4, 100), 'i4', maxshape=(4, None))
+
+        filename = osp.join(self.tmpdir, "1.h5")
+        vsource = h5.VirtualSource(filename, 'data', shape=(100,))
+        with self.assertRaisesRegex(ValueError, r'different number'):
+            layout[0, :49] = vsource[0:100:2]
+
+    def tearDown(self):
+        shutil.rmtree(self.tmpdir)
+
+@ut.skipUnless(vds_support,
+               'VDS requires HDF5 >= 1.9.233')
+class IndexingTestCase(ut.TestCase):
+
+    def setUp(self):
+        self.tmpdir = tempfile.mkdtemp()
+        # Create source file (1.h5)
+        with h5.File(osp.join(self.tmpdir, '1.h5'), 'w') as f:
+            d = f.create_dataset('data', (10,), 'i4')
+            d[:] = np.arange(10)*10
+
+    def test_index_layout(self):
+        # Assemble virtual dataset (indexing target)
+        layout = h5.VirtualLayout((100,), 'i4')
+
+        inds = [3,6,20,25,33,47,70,75,96,98]
+
+        filename = osp.join(self.tmpdir, "1.h5")
+        vsource = h5.VirtualSource(filename, 'data', shape=(10,))
+        layout[inds] = vsource
+
+        outfile = osp.join(self.tmpdir, make_name('VDS{}.h5'))
+
+        # Assembly virtual dataset (indexing source)
+        layout2 = h5.VirtualLayout((6,), 'i4')
+
+        inds2 = [0,1,4,5,8]
+        layout2[1:] = vsource[inds2]
+
+        # Add virtual datasets to output file and close
+        with h5.File(outfile, 'w', libver='latest') as f:
+            f.create_virtual_dataset('/data', layout, fillvalue=-5)
+            f.create_virtual_dataset(b'/data2', layout2, fillvalue=-3)
+
+        # Read data from virtual datasets
+        with h5.File(outfile, 'r') as f:
+            data = f['/data'][()]
+            data2 = f['/data2'][()]
+
+        # Verify
+        assert_array_equal(data[inds], np.arange(10)*10)
+        assert_array_equal(data2[1:], [0,10,40,50,80])
+
+        mask = np.zeros(100)
+        mask[inds] = 1
+        self.assertEqual(data[mask == 0].min(), -5)
+        self.assertEqual(data[mask == 0].max(), -5)
+        self.assertEqual(data2[0], -3)
+
+    def tearDown(self):
+        shutil.rmtree(self.tmpdir)
+
+@ut.skipUnless(vds_support,
+               'VDS requires HDF5 >= 1.9.233')
+class RelativeLinkTestCase(ut.TestCase):
+
+    def setUp(self):
+        self.tmpdir = tempfile.mkdtemp()
+        self.f1 = osp.join(self.tmpdir, 'testfile1.h5')
+        self.f2 = osp.join(self.tmpdir, 'testfile2.h5')
+
+        self.data1 = np.arange(10)
+        self.data2 = np.arange(10) * -1
+
+        with h5.File(self.f1, 'w') as f:
+            # dataset
+            ds = f.create_dataset('data', (10,), 'f4')
+            ds[:] = self.data1
+
+        with h5.File(self.f2, 'w') as f:
+            # dataset
+            ds = f.create_dataset('data', (10,), 'f4')
+            ds[:] = self.data2
+            self.make_vds(f)
+
+    def make_vds(self, f):
+        # virtual dataset
+        layout = h5.VirtualLayout((2, 10), 'f4')
+        vsource1 = h5.VirtualSource(self.f1, 'data', shape=(10,))
+        vsource2 = h5.VirtualSource(self.f2, 'data', shape=(10,))
+        layout[0] = vsource1
+        layout[1] = vsource2
+        f.create_virtual_dataset('virtual', layout)
+
+    @pytest.mark.thread_unsafe(reason="Renames shared files")
+    def test_relative_vds(self):
+        with h5.File(self.f2) as f:
+            data = f['virtual'][:]
+            np.testing.assert_array_equal(data[0], self.data1)
+            np.testing.assert_array_equal(data[1], self.data2)
+
+        # move f2 -> f3
+        f3 = osp.join(self.tmpdir, 'testfile3.h5')
+        os.rename(self.f2, f3)
+
+        with h5.File(f3) as f:
+            data = f['virtual'][:]
+            assert data.dtype == 'f4'
+            np.testing.assert_array_equal(data[0], self.data1)
+            np.testing.assert_array_equal(data[1], self.data2)
+
+        # moving other file
+        f4 = osp.join(self.tmpdir, 'testfile4.h5')
+        os.rename(self.f1, f4)
+
+        with h5.File(f3) as f:
+            data = f['virtual'][:]
+            assert data.dtype == 'f4'
+            # unavailable data is silently converted to default value
+            np.testing.assert_array_equal(data[0], 0)
+            np.testing.assert_array_equal(data[1], self.data2)
+
+    def tearDown(self):
+        shutil.rmtree(self.tmpdir)
+
+class RelativeLinkBuildVDSTestCase(RelativeLinkTestCase):
+    # Test a link to the same file with the virtual dataset created by
+    # File.build_virtual_dataset()
+    def make_vds(self, f):
+        with f.build_virtual_dataset('virtual', (2, 10), dtype='f4') as layout:
+            layout[0] = h5.VirtualSource(self.f1, 'data', shape=(10,))
+            layout[1] = h5.VirtualSource(self.f2, 'data', shape=(10,))
+
+@ut.skipUnless(vds_support,
+               'VDS requires HDF5 >= 1.9.233')
+class VDSUnlimitedTestCase(ut.TestCase):
+
+    def setUp(self):
+        self.tmpdir = tempfile.mkdtemp()
+        self.path = osp.join(self.tmpdir, "resize.h5")
+        with h5.File(self.path, "w") as f:
+            source_dset = f.create_dataset(
+                "source",
+                data=np.arange(20),
+                shape=(10, 2),
+                maxshape=(None, 2),
+                chunks=(10, 1),
+                fillvalue=-1
+            )
+            self.layout = h5.VirtualLayout((10, 1), int, maxshape=(None, 1))
+            layout_source = h5.VirtualSource(source_dset)
+            self.layout[:h5.UNLIMITED, 0] = layout_source[:h5.UNLIMITED, 1]
+
+            f.create_virtual_dataset("virtual", self.layout)
+
+    def test_unlimited_axis(self):
+        comp1 = np.arange(1, 20, 2).reshape(10, 1)
+        comp2 = np.vstack((
+            comp1,
+            np.full(shape=(10, 1), fill_value=-1)
+        ))
+        comp3 = np.vstack((
+            comp1,
+            np.full(shape=(10, 1), fill_value=0)
+        ))
+        fname = osp.join(self.tmpdir, make_name("resize2{}.h5"))
+        shutil.copyfile(self.path, fname)
+        with h5.File(fname, "a") as f:
+            source_dset = f['source']
+            virtual_dset = f['virtual']
+            np.testing.assert_array_equal(comp1, virtual_dset)
+            source_dset.resize(20, axis=0)
+            np.testing.assert_array_equal(comp2, virtual_dset)
+            source_dset[10:, 1] = np.zeros((10,), dtype=int)
+            np.testing.assert_array_equal(comp3, virtual_dset)
+
+    def tearDown(self):
+        shutil.rmtree(self.tmpdir)
+
+
+def test_no_mappings(writable_file):
+    name = make_name()
+    with writable_file.build_virtual_dataset(name, (10, 20), np.int32):
+        pass
+
+    dset = writable_file[name]
+    assert dset.is_virtual
+    assert dset.virtual_sources() == []
+    np.testing.assert_array_equal(dset[()], np.zeros((10, 20), np.int32))
+
+
+if __name__ == "__main__":
+    ut.main()

.venv/lib/python3.11/site-packages/h5py/tests/test_vds/test_lowlevel_vds.py

@@ -0,0 +1,298 @@
+'''
+Unit test for the low level vds interface for eiger
+https://support.hdfgroup.org/HDF5/docNewFeatures/VDS/HDF5-VDS-requirements-use-cases-2014-12-10.pdf
+'''
+
+import os.path as osp
+import tempfile
+
+import numpy as np
+
+import h5py as h5
+from ..common import ut, make_name
+
+
+class TestEigerLowLevel(ut.TestCase):
+    def setUp(self):
+        self.working_dir = tempfile.TemporaryDirectory()
+        self.fname = ['raw_file_1.h5', 'raw_file_2.h5', 'raw_file_3.h5']
+        k = 0
+        for outfile in self.fname:
+            filename = osp.join(self.working_dir.name, outfile)
+            with h5.File(filename, 'w') as f:
+                f['data'] = np.ones((20, 200, 200))*k
+            k += 1
+
+        with h5.File(osp.join(self.working_dir.name, 'raw_file_4.h5'), 'w') as f:
+            f['data'] = np.ones((18, 200, 200))*3
+        self.fname.append('raw_file_4.h5')
+        self.fname = [osp.join(self.working_dir.name, ix) for ix in self.fname]
+
+    def test_eiger_low_level(self):
+        outfile = osp.join(self.working_dir.name, make_name('eiger{}.h5'))
+        with h5.File(outfile, 'w', libver='latest') as f:
+            vdset_shape = (78, 200, 200)
+            vdset_max_shape = vdset_shape
+            virt_dspace = h5.h5s.create_simple(vdset_shape, vdset_max_shape)
+            dcpl = h5.h5p.create(h5.h5p.DATASET_CREATE)
+            dcpl.set_fill_value(np.array([-1]))
+            # Create the source dataset dataspace
+            k = 0
+            for foo in self.fname:
+                with h5.File(foo, 'r') as in_f:
+                    src_shape = in_f['data'].shape
+                src_dspace = h5.h5s.create_simple(src_shape, src_shape)
+                # Select the source dataset hyperslab
+                src_dspace.select_hyperslab(start=(0, 0, 0),
+                                            stride=(1, 1, 1),
+                                            count=(1, 1, 1),
+                                            block=src_shape)
+
+                virt_dspace.select_hyperslab(start=(k, 0, 0),
+                                             stride=(1, 1, 1),
+                                             count=(1, 1, 1),
+                                             block=src_shape)
+
+                dcpl.set_virtual(virt_dspace, foo.encode('utf-8'),
+                                 b'data', src_dspace)
+                k += src_shape[0]
+
+            # Create the virtual dataset
+            h5.h5d.create(f.id, name=b"data", tid=h5.h5t.NATIVE_INT16,
+                          space=virt_dspace, dcpl=dcpl)
+
+        with h5.File(outfile, 'r') as f:
+            d = f['data']
+            self.assertEqual(d[10, 100, 10], 0.0)
+            self.assertEqual(d[30, 100, 100], 1.0)
+            self.assertEqual(d[50, 100, 100], 2.0)
+            self.assertEqual(d[70, 100, 100], 3.0)
+
+    def tearDown(self):
+        self.working_dir.cleanup()
+
+
+if __name__ == "__main__":
+    ut.main()
+'''
+Unit test for the low level vds interface for excalibur
+https://support.hdfgroup.org/HDF5/docNewFeatures/VDS/HDF5-VDS-requirements-use-cases-2014-12-10.pdf
+'''
+
+
+class ExcaliburData:
+    FEM_PIXELS_PER_CHIP_X = 256
+    FEM_PIXELS_PER_CHIP_Y = 256
+    FEM_CHIPS_PER_STRIPE_X = 8
+    FEM_CHIPS_PER_STRIPE_Y = 1
+    FEM_STRIPES_PER_MODULE = 2
+
+    @property
+    def sensor_module_dimensions(self):
+        x_pixels = self.FEM_PIXELS_PER_CHIP_X * self.FEM_CHIPS_PER_STRIPE_X
+        y_pixels = self.FEM_PIXELS_PER_CHIP_Y * self.FEM_CHIPS_PER_STRIPE_Y * self.FEM_STRIPES_PER_MODULE
+        return y_pixels, x_pixels,
+
+    @property
+    def fem_stripe_dimensions(self):
+        x_pixels = self.FEM_PIXELS_PER_CHIP_X * self.FEM_CHIPS_PER_STRIPE_X
+        y_pixels = self.FEM_PIXELS_PER_CHIP_Y * self.FEM_CHIPS_PER_STRIPE_Y
+        return y_pixels, x_pixels,
+
+    def generate_sensor_module_image(self, value, dtype='uint16'):
+        dset = np.empty(shape=self.sensor_module_dimensions, dtype=dtype)
+        dset.fill(value)
+        return dset
+
+    def generate_fem_stripe_image(self, value, dtype='uint16'):
+        dset = np.empty(shape=self.fem_stripe_dimensions, dtype=dtype)
+        dset.fill(value)
+        return dset
+
+
+class TestExcaliburLowLevel(ut.TestCase):
+    def create_excalibur_fem_stripe_datafile(self, fname, nframes, excalibur_data,scale):
+        shape = (nframes,) + excalibur_data.fem_stripe_dimensions
+        max_shape = (nframes,) + excalibur_data.fem_stripe_dimensions
+        chunk = (1,) + excalibur_data.fem_stripe_dimensions
+        with h5.File(fname, 'w', libver='latest') as f:
+            dset = f.create_dataset('data', shape=shape, maxshape=max_shape, chunks=chunk, dtype='uint16')
+            for data_value_index in np.arange(nframes):
+                dset[data_value_index] = excalibur_data.generate_fem_stripe_image(data_value_index*scale)
+
+    def setUp(self):
+        self.working_dir = tempfile.TemporaryDirectory()
+        self.fname = ["stripe_%d.h5" % stripe for stripe in range(1,7)]
+        self.fname = [osp.join(self.working_dir.name, ix) for ix in self.fname]
+        nframes = 5
+        self.edata = ExcaliburData()
+        k=0
+        for raw_file in self.fname:
+            self.create_excalibur_fem_stripe_datafile(raw_file, nframes, self.edata,k)
+            k+=1
+
+    def test_excalibur_low_level(self):
+
+        excalibur_data = self.edata
+        outfile = osp.join(self.working_dir.name, make_name('excalibur{}.h5'))
+        vdset_stripe_shape = (1,) + excalibur_data.fem_stripe_dimensions
+        vdset_stripe_max_shape = (5, ) + excalibur_data.fem_stripe_dimensions
+        vdset_shape = (5,
+                       excalibur_data.fem_stripe_dimensions[0] * len(self.fname) + (10 * (len(self.fname)-1)),
+                       excalibur_data.fem_stripe_dimensions[1])
+        vdset_max_shape = (5,
+                           excalibur_data.fem_stripe_dimensions[0] * len(self.fname) + (10 * (len(self.fname)-1)),
+                           excalibur_data.fem_stripe_dimensions[1])
+        vdset_y_offset = 0
+
+        # Create the virtual dataset file
+        with h5.File(outfile, 'w', libver='latest') as f:
+
+            # Create the source dataset dataspace
+            src_dspace = h5.h5s.create_simple(vdset_stripe_shape, vdset_stripe_max_shape)
+            # Create the virtual dataset dataspace
+            virt_dspace = h5.h5s.create_simple(vdset_shape, vdset_max_shape)
+
+            # Create the virtual dataset property list
+            dcpl = h5.h5p.create(h5.h5p.DATASET_CREATE)
+            dcpl.set_fill_value(np.array([0x01]))
+
+            # Select the source dataset hyperslab
+            src_dspace.select_hyperslab(start=(0, 0, 0), count=(1, 1, 1), block=vdset_stripe_max_shape)
+
+            for raw_file in self.fname:
+                # Select the virtual dataset hyperslab (for the source dataset)
+                virt_dspace.select_hyperslab(start=(0, vdset_y_offset, 0),
+                                             count=(1, 1, 1),
+                                             block=vdset_stripe_max_shape)
+                # Set the virtual dataset hyperslab to point to the real first dataset
+                dcpl.set_virtual(virt_dspace, raw_file.encode('utf-8'),
+                                 b"/data", src_dspace)
+                vdset_y_offset += vdset_stripe_shape[1] + 10
+
+            # Create the virtual dataset
+            h5.h5d.create(
+                f.id,
+                name=b"data",
+                tid=h5.h5t.NATIVE_INT16,
+                space=virt_dspace,
+                dcpl=dcpl,
+            )
+            assert(f['data'].fillvalue == 0x01)
+
+        with h5.File(outfile,'r') as f:
+            d = f['data']
+            self.assertEqual(d[3,100,0], 0.0)
+            self.assertEqual(d[3,260,0], 1.0)
+            self.assertEqual(d[3,350,0], 3.0)
+            self.assertEqual(d[3,650,0], 6.0)
+            self.assertEqual(d[3,900,0], 9.0)
+            self.assertEqual(d[3,1150,0], 12.0)
+            self.assertEqual(d[3,1450,0], 15.0)
+
+    def tearDown(self):
+        self.working_dir.cleanup()
+
+'''
+Unit test for the low level vds interface for percival
+https://support.hdfgroup.org/HDF5/docNewFeatures/VDS/HDF5-VDS-requirements-use-cases-2014-12-10.pdf
+'''
+
+
+class TestPercivalLowLevel(ut.TestCase):
+
+    def setUp(self):
+        self.working_dir = tempfile.TemporaryDirectory()
+        self.fname = ['raw_file_1.h5','raw_file_2.h5','raw_file_3.h5']
+        k = 0
+        for outfile in self.fname:
+            filename = osp.join(self.working_dir.name, outfile)
+            with h5.File(filename,'w') as f:
+                f['data'] = np.ones((20,200,200))*k
+            k +=1
+
+        with h5.File(osp.join(self.working_dir.name, 'raw_file_4.h5'),'w') as f:
+            f['data'] = np.ones((19,200,200))*3
+        self.fname.append('raw_file_4.h5')
+        self.fname = [osp.join(self.working_dir.name, ix) for ix in self.fname]
+
+    def test_percival_low_level(self):
+        outfile = osp.join(self.working_dir.name, make_name('percival{}.h5'))
+
+        with h5.File(outfile, 'w', libver='latest') as f:
+            vdset_shape = (1,200,200)
+            num = h5.h5s.UNLIMITED
+            vdset_max_shape = (num,)+vdset_shape[1:]
+            virt_dspace = h5.h5s.create_simple(vdset_shape, vdset_max_shape)
+            dcpl = h5.h5p.create(h5.h5p.DATASET_CREATE)
+            dcpl.set_fill_value(np.array([-1]))
+            # Create the source dataset dataspace
+            k = 0
+            for foo in self.fname:
+                with h5.File(foo, 'r') as in_f:
+                    src_shape = in_f['data'].shape
+                max_src_shape = (num,)+src_shape[1:]
+                src_dspace = h5.h5s.create_simple(src_shape, max_src_shape)
+                # Select the source dataset hyperslab
+                src_dspace.select_hyperslab(start=(0, 0, 0),
+                                            stride=(1,1,1),
+                                            count=(num, 1, 1),
+                                            block=(1,)+src_shape[1:])
+
+                virt_dspace.select_hyperslab(start=(k, 0, 0),
+                                             stride=(4,1,1),
+                                             count=(num, 1, 1),
+                                             block=(1,)+src_shape[1:])
+
+                dcpl.set_virtual(virt_dspace, foo.encode('utf-8'), b'data', src_dspace)
+                k+=1
+
+            # Create the virtual dataset
+            h5.h5d.create(
+                f.id,
+                name=b"data",
+                tid=h5.h5t.NATIVE_INT16,
+                space=virt_dspace,
+                dcpl=dcpl,
+            )
+
+        with h5.File(outfile, 'r') as f:
+            sh = f['data'].shape
+            line = f['data'][:8,100,100]
+        foo = np.array(2*list(range(4)))
+        self.assertEqual(sh,(79,200,200),)
+        np.testing.assert_array_equal(line,foo)
+
+    def tearDown(self):
+        self.working_dir.cleanup()
+
+
+def test_virtual_prefix(tmp_path):
+    a = tmp_path / make_name('a')
+    b = tmp_path / make_name('b')
+    a.mkdir()
+    b.mkdir()
+    src_file = h5.File(a / 'src.h5', 'w')
+    src_file['data'] = np.arange(10)
+
+    vds_file = h5.File(b / 'vds.h5', 'w')
+    layout = h5.VirtualLayout(shape=(10,), dtype=np.int64)
+    layout[:] = h5.VirtualSource('src.h5', 'data', shape=(10,))
+    vds_file.create_virtual_dataset('data', layout, fillvalue=-1)
+
+    # Path doesn't resolve
+    np.testing.assert_array_equal(vds_file['data'], np.full(10, fill_value=-1))
+
+    a_bytes = bytes(a)
+    dapl = h5.h5p.create(h5.h5p.DATASET_ACCESS)
+    dapl.set_virtual_prefix(a_bytes)
+    vds_id = h5.h5d.open(vds_file.id, b'data', dapl=dapl)
+    vds = h5.Dataset(vds_id)
+
+    # Now it should find the source file and read the data correctly
+    np.testing.assert_array_equal(vds[:], np.arange(10))
+    # Check that get_virtual_prefix gives back what we put in
+    assert vds.id.get_access_plist().get_virtual_prefix() == a_bytes
+
+    src_file.close()
+    vds_file.close()

.venv/lib/python3.11/site-packages/h5py/tests/test_vds/test_virtual_source.py

@@ -0,0 +1,166 @@
+from ..common import ut, make_name
+import h5py as h5
+import numpy as np
+
+
+class TestVirtualSource(ut.TestCase):
+    def test_full_slice(self):
+        dataset = h5.VirtualSource('test','test',(20,30,30))
+        sliced = dataset[:,:,:]
+        self.assertEqual(dataset.shape,sliced.shape)
+
+    # def test_full_slice_inverted(self):
+    #     dataset = h5.VirtualSource('test','test',(20,30,30))
+    #     sliced = dataset[:,:,::-1]
+    #     self.assertEqual(dataset.shape,sliced.shape)
+    #
+    # def test_subsampled_slice_inverted(self):
+    #     dataset = h5.VirtualSource('test','test',(20,30,30))
+    #     sliced = dataset[:,:,::-2]
+    #     self.assertEqual((20,30,15),sliced.shape)
+
+    def test_integer_indexed(self):
+        dataset = h5.VirtualSource('test','test',(20,30,30))
+        sliced = dataset[5,:,:]
+        self.assertEqual((30,30),sliced.shape)
+
+    def test_integer_single_indexed(self):
+        dataset = h5.VirtualSource('test','test',(20,30,30))
+        sliced = dataset[5]
+        self.assertEqual((30,30),sliced.shape)
+
+    def test_two_integer_indexed(self):
+        dataset = h5.VirtualSource('test','test',(20,30,30))
+        sliced = dataset[5,:,10]
+        self.assertEqual((30,),sliced.shape)
+
+    def test_single_range(self):
+        dataset = h5.VirtualSource('test','test',(20,30,30))
+        sliced = dataset[5:10,:,:]
+        self.assertEqual((5,)+dataset.shape[1:],sliced.shape)
+
+    def test_shape_calculation_positive_step(self):
+        dataset = h5.VirtualSource('test','test',(20,))
+        cmp = []
+        for i in range(5):
+            d = dataset[2:12+i:3].shape[0]
+            ref = np.arange(20)[2:12+i:3].size
+            cmp.append(ref==d)
+        self.assertEqual(5, sum(cmp))
+
+    # def test_shape_calculation_positive_step_switched_start_stop(self):
+    #     dataset = h5.VirtualSource('test','test',(20,))
+    #     cmp = []
+    #     for i in range(5):
+    #         d = dataset[12+i:2:3].shape[0]
+    #         ref = np.arange(20)[12+i:2:3].size
+    #         cmp.append(ref==d)
+    #     self.assertEqual(5, sum(cmp))
+    #
+    #
+    # def test_shape_calculation_negative_step(self):
+    #     dataset = h5.VirtualSource('test','test',(20,))
+    #     cmp = []
+    #     for i in range(5):
+    #         d = dataset[12+i:2:-3].shape[0]
+    #         ref = np.arange(20)[12+i:2:-3].size
+    #         cmp.append(ref==d)
+    #     self.assertEqual(5, sum(cmp))
+    #
+    # def test_shape_calculation_negative_step_switched_start_stop(self):
+    #     dataset = h5.VirtualSource('test','test',(20,))
+    #     cmp = []
+    #     for i in range(5):
+    #         d = dataset[2:12+i:-3].shape[0]
+    #         ref = np.arange(20)[2:12+i:-3].size
+    #         cmp.append(ref==d)
+    #     self.assertEqual(5, sum(cmp))
+
+
+    def test_double_range(self):
+        dataset = h5.VirtualSource('test','test',(20,30,30))
+        sliced = dataset[5:10,:,20:25]
+        self.assertEqual((5,30,5),sliced.shape)
+
+    def test_double_strided_range(self):
+        dataset = h5.VirtualSource('test','test',(20,30,30))
+        sliced = dataset[6:12:2,:,20:26:3]
+        self.assertEqual((3,30,2,),sliced.shape)
+
+    # def test_double_strided_range_inverted(self):
+    #     dataset = h5.VirtualSource('test','test',(20,30,30))
+    #     sliced = dataset[12:6:-2,:,26:20:-3]
+    #     self.assertEqual((3,30,2),sliced.shape)
+
+    def test_negative_start_index(self):
+        dataset = h5.VirtualSource('test','test',(20,30,30))
+        sliced = dataset[-10:16]
+        self.assertEqual((6,30,30),sliced.shape)
+
+    def test_negative_stop_index(self):
+        dataset = h5.VirtualSource('test','test',(20,30,30))
+        sliced = dataset[10:-4]
+        self.assertEqual((6,30,30),sliced.shape)
+
+    def test_negative_start_and_stop_index(self):
+        dataset = h5.VirtualSource('test','test',(20,30,30))
+        sliced = dataset[-10:-4]
+        self.assertEqual((6,30,30),sliced.shape)
+
+    # def test_negative_start_and_stop_and_stride_index(self):
+    #     dataset = h5.VirtualSource('test','test',(20,30,30))
+    #     sliced = dataset[-4:-10:-2]
+    #     self.assertEqual((3,30,30),sliced.shape)
+#
+    def test_ellipsis(self):
+        dataset = h5.VirtualSource('test','test',(20,30,30))
+        sliced = dataset[...]
+        self.assertEqual(dataset.shape,sliced.shape)
+
+    def test_ellipsis_end(self):
+        dataset = h5.VirtualSource('test','test',(20,30,30))
+        sliced = dataset[0:1,...]
+        self.assertEqual((1,)+dataset.shape[1:],sliced.shape)
+
+    def test_ellipsis_start(self):
+        dataset = h5.VirtualSource('test','test',(20,30,30))
+        sliced = dataset[...,0:1]
+        self.assertEqual(dataset.shape[:-1]+(1,),sliced.shape)
+
+    def test_ellipsis_sandwich(self):
+        dataset = h5.VirtualSource('test','test',(20,30,30,40))
+        sliced = dataset[0:1,...,5:6]
+        self.assertEqual((1,)+dataset.shape[1:-1]+(1,),sliced.shape)
+
+    def test_integer_shape(self):
+        dataset = h5.VirtualSource('test','test', 20)
+        self.assertEqual(dataset.shape, (20,))
+
+    def test_integer_maxshape(self):
+        dataset = h5.VirtualSource('test','test', 20, maxshape=30)
+        self.assertEqual(dataset.maxshape, (30,))
+
+    def test_extra_args(self):
+        with h5.File(make_name("f1{}.h5"), driver='core',
+                     backing_store=False, mode='w') as ftest:
+            ftest['a'] = [1, 2, 3]
+            a = ftest['a']
+
+            with self.assertRaises(TypeError):
+                h5.VirtualSource(a, 'b')
+            with self.assertRaises(TypeError):
+                h5.VirtualSource(a, shape=(1, ))
+            with self.assertRaises(TypeError):
+                h5.VirtualSource(a, maxshape=(None,))
+            with self.assertRaises(TypeError):
+                h5.VirtualSource(a, dtype=int)
+
+    def test_repeated_slice(self):
+        dataset = h5.VirtualSource('test', 'test', (20, 30, 30))
+        sliced = dataset[5:10, :, :]
+        with self.assertRaises(RuntimeError):
+            sliced[:, :4]
+
+
+if __name__ == "__main__":
+    ut.main()

.venv/lib/python3.11/site-packages/h5py/utils.cpython-311-x86_64-linux-gnu.so

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

.venv/lib/python3.11/site-packages/h5py/version.py

@@ -0,0 +1,65 @@
+# This file is part of h5py, a Python interface to the HDF5 library.
+#
+# http://www.h5py.org
+#
+# Copyright 2008-2013 Andrew Collette and contributors
+#
+# License:  Standard 3-clause BSD; see "license.txt" for full license terms
+#           and contributor agreement.
+
+"""
+    Versioning module for h5py.
+"""
+
+from collections import namedtuple
+from . import h5 as _h5
+import sys
+import numpy
+
+# All should be integers, except pre, as validating versions is more than is
+# needed for our use case
+_H5PY_VERSION_CLS = namedtuple("_H5PY_VERSION_CLS",
+                               "major minor bugfix pre post dev")
+
+hdf5_built_version_tuple = _h5.HDF5_VERSION_COMPILED_AGAINST
+
+version_tuple = _H5PY_VERSION_CLS(3, 16, 0, None, None, None)
+
+version = "{0.major:d}.{0.minor:d}.{0.bugfix:d}".format(version_tuple)
+if version_tuple.pre is not None:
+    version += version_tuple.pre
+if version_tuple.post is not None:
+    version += ".post{0.post:d}".format(version_tuple)
+if version_tuple.dev is not None:
+    version += ".dev{0.dev:d}".format(version_tuple)
+
+hdf5_version_tuple = _h5.get_libversion()
+hdf5_version = "%d.%d.%d" % hdf5_version_tuple
+
+api_version_tuple = (1,8)
+api_version = "%d.%d" % api_version_tuple
+
+info = """\
+Summary of the h5py configuration
+---------------------------------
+
+h5py    %(h5py)s
+HDF5    %(hdf5)s
+Python  %(python)s
+sys.platform    %(platform)s
+sys.maxsize     %(maxsize)s
+numpy   %(numpy)s
+cython (built with) %(cython_version)s
+numpy (built against) %(numpy_build_version)s
+HDF5 (built against) %(hdf5_build_version)s
+""" % {
+    'h5py': version,
+    'hdf5': hdf5_version,
+    'python': sys.version,
+    'platform': sys.platform,
+    'maxsize': sys.maxsize,
+    'numpy': numpy.__version__,
+    'cython_version': _h5.CYTHON_VERSION_COMPILED_WITH,
+    'numpy_build_version': _h5.NUMPY_VERSION_COMPILED_AGAINST,
+    'hdf5_build_version': "%d.%d.%d" % hdf5_built_version_tuple,
+}

.venv/lib/python3.11/site-packages/hf_xet-1.5.1.dist-info/INSTALLER

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

.venv/lib/python3.11/site-packages/hf_xet-1.5.1.dist-info/METADATA

@@ -0,0 +1,87 @@
+Metadata-Version: 2.4
+Name: hf-xet
+Version: 1.5.1
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Programming Language :: Rust
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Programming Language :: Python :: Implementation :: PyPy
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.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
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Programming Language :: Python :: Free Threading
+Classifier: Programming Language :: Python :: Free Threading :: 2 - Beta
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Dist: pytest ; extra == 'tests'
+Provides-Extra: tests
+License-File: LICENSE
+Summary: Fast transfer of large files with the Hugging Face Hub.
+Maintainer-email: Rajat Arya <rajat@rajatarya.com>, Jared Sulzdorf <j.sulzdorf@gmail.com>, Di Xiao <di@huggingface.co>, Assaf Vayner <assaf@huggingface.co>, Hoyt Koepke <hoytak@gmail.com>
+License-Expression: Apache-2.0
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown; charset=UTF-8; variant=GFM
+Project-URL: Documentation, https://huggingface.co/docs/hub/xet/index
+Project-URL: Homepage, https://github.com/huggingface/xet-core
+Project-URL: Issues, https://github.com/huggingface/xet-core/issues
+Project-URL: Repository, https://github.com/huggingface/xet-core.git
+
+<!---
+Copyright 2024 The HuggingFace Team. 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.
+-->
+<p align="center">
+    <a href="https://github.com/huggingface/xet-core/blob/main/LICENSE"><img alt="License" src="https://img.shields.io/github/license/huggingface/xet-core.svg?color=blue"></a>
+    <a href="https://github.com/huggingface/xet-core/releases"><img alt="GitHub release" src="https://img.shields.io/github/release/huggingface/xet-core.svg"></a>
+    <a href="https://github.com/huggingface/xet-core/blob/main/CODE_OF_CONDUCT.md"><img alt="Contributor Covenant" src="https://img.shields.io/badge/Contributor%20Covenant-v2.0%20adopted-ff69b4.svg"></a>
+</p>
+
+<h3 align="center">
+  <p>🤗 hf-xet - xet client tech, used in <a target="_blank" href="https://github.com/huggingface/huggingface_hub/">huggingface_hub</a></p>
+</h3>
+
+## Welcome
+
+`hf-xet` enables `huggingface_hub` to utilize xet storage for uploading and downloading to HF Hub. Xet storage provides chunk-based deduplication, efficient storage/retrieval with local disk caching, and backwards compatibility with Git LFS. This library is not meant to be used directly, and is instead intended to be used from [huggingface_hub](https://pypi.org/project/huggingface-hub).
+
+## Key features
+
+♻ **chunk-based deduplication implementation**: avoid transferring and storing chunks that are shared across binary files (models, datasets, etc).
+
+🤗 **Python bindings**: bindings for [huggingface_hub](https://github.com/huggingface/huggingface_hub/) package.
+
+↔ **network communications**: concurrent communication to HF Hub Xet backend services (CAS).
+
+🔖 **local disk caching**: chunk-based cache that sits alongside the existing [huggingface_hub disk cache](https://huggingface.co/docs/huggingface_hub/guides/manage-cache).
+
+## Installation
+
+Install the `hf_xet` package with [pip](https://pypi.org/project/hf-xet/):
+
+```bash
+pip install hf_xet
+```
+
+## Quick Start
+
+`hf_xet` is not intended to be run independently as it is expected to be used from `huggingface_hub`, so to get started with `huggingface_hub` check out the documentation [here]("https://hf.co/docs/huggingface_hub").
+
+## Contributions (feature requests, bugs, etc.) are encouraged & appreciated 💙💚💛💜🧡❤️
+
+Please join us in making hf-xet better. We value everyone's contributions. Code is not the only way to help. Answering questions, helping each other, improving documentation, filing issues all help immensely. If you are interested in contributing (please do!), check out the [contribution guide](https://github.com/huggingface/xet-core/blob/main/CONTRIBUTING.md) for this repository.

.venv/lib/python3.11/site-packages/hf_xet-1.5.1.dist-info/RECORD

@@ -0,0 +1,9 @@
+hf_xet-1.5.1.dist-info/INSTALLER,sha256=5hhM4Q4mYTT9z6QB6PGpUAW81PGNFrYrdXMj4oM_6ak,2
+hf_xet-1.5.1.dist-info/METADATA,sha256=Ng3NIurLVmsxfHrQzB0hVplUWdfDjyPgOB1vV43zU9s,4882
+hf_xet-1.5.1.dist-info/RECORD,,
+hf_xet-1.5.1.dist-info/REQUESTED,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+hf_xet-1.5.1.dist-info/WHEEL,sha256=OkX4wPsZin6E8CKOzxYqaTQ7om8YEJGkDJxzf2dJ9DM,143
+hf_xet-1.5.1.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+hf_xet-1.5.1.dist-info/sboms/hf_xet.cyclonedx.json,sha256=qwtR4a6GgW2Y-ybzx9ThgMyHXF11N79IyEWcWf1CeBw,304991
+hf_xet/__init__.py,sha256=E8UDdyQ8glZ_nve9hHEf22bPang8-RKx4VuApXYeQUo,107
+hf_xet/hf_xet.abi3.so,sha256=67AVYfNTLATTgxnYRWZSV5vBoS_6j1FFDErdBM-hhTY,11601472

.venv/lib/python3.11/site-packages/hf_xet-1.5.1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: maturin (1.13.3)
+Root-Is-Purelib: false
+Tag: cp37-abi3-manylinux_2_17_x86_64
+Tag: cp37-abi3-manylinux2014_x86_64

.venv/lib/python3.11/site-packages/hf_xet-1.5.1.dist-info/licenses/LICENSE

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

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

@@ -0,0 +1,5 @@
+from .hf_xet import *
+
+__doc__ = hf_xet.__doc__
+if hasattr(hf_xet, "__all__"):
+    __all__ = hf_xet.__all__

.venv/lib/python3.11/site-packages/hf_xet/hf_xet.abi3.so

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

.venv/lib/python3.11/site-packages/httpcore-1.0.9.dist-info/INSTALLER

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

.venv/lib/python3.11/site-packages/httpcore-1.0.9.dist-info/METADATA

@@ -0,0 +1,625 @@
+Metadata-Version: 2.4
+Name: httpcore
+Version: 1.0.9
+Summary: A minimal low-level HTTP client.
+Project-URL: Documentation, https://www.encode.io/httpcore
+Project-URL: Homepage, https://www.encode.io/httpcore/
+Project-URL: Source, https://github.com/encode/httpcore
+Author-email: Tom Christie <tom@tomchristie.com>
+License-Expression: BSD-3-Clause
+License-File: LICENSE.md
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Web Environment
+Classifier: Framework :: AsyncIO
+Classifier: Framework :: Trio
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: BSD License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Internet :: WWW/HTTP
+Requires-Python: >=3.8
+Requires-Dist: certifi
+Requires-Dist: h11>=0.16
+Provides-Extra: asyncio
+Requires-Dist: anyio<5.0,>=4.0; extra == 'asyncio'
+Provides-Extra: http2
+Requires-Dist: h2<5,>=3; extra == 'http2'
+Provides-Extra: socks
+Requires-Dist: socksio==1.*; extra == 'socks'
+Provides-Extra: trio
+Requires-Dist: trio<1.0,>=0.22.0; extra == 'trio'
+Description-Content-Type: text/markdown
+
+# HTTP Core
+
+[![Test Suite](https://github.com/encode/httpcore/workflows/Test%20Suite/badge.svg)](https://github.com/encode/httpcore/actions)
+[![Package version](https://badge.fury.io/py/httpcore.svg)](https://pypi.org/project/httpcore/)
+
+> *Do one thing, and do it well.*
+
+The HTTP Core package provides a minimal low-level HTTP client, which does
+one thing only. Sending HTTP requests.
+
+It does not provide any high level model abstractions over the API,
+does not handle redirects, multipart uploads, building authentication headers,
+transparent HTTP caching, URL parsing, session cookie handling,
+content or charset decoding, handling JSON, environment based configuration
+defaults, or any of that Jazz.
+
+Some things HTTP Core does do:
+
+* Sending HTTP requests.
+* Thread-safe / task-safe connection pooling.
+* HTTP(S) proxy & SOCKS proxy support.
+* Supports HTTP/1.1 and HTTP/2.
+* Provides both sync and async interfaces.
+* Async backend support for `asyncio` and `trio`.
+
+## Requirements
+
+Python 3.8+
+
+## Installation
+
+For HTTP/1.1 only support, install with:
+
+```shell
+$ pip install httpcore
+```
+
+There are also a number of optional extras available...
+
+```shell
+$ pip install httpcore['asyncio,trio,http2,socks']
+```
+
+## Sending requests
+
+Send an HTTP request:
+
+```python
+import httpcore
+
+response = httpcore.request("GET", "https://www.example.com/")
+
+print(response)
+# <Response [200]>
+print(response.status)
+# 200
+print(response.headers)
+# [(b'Accept-Ranges', b'bytes'), (b'Age', b'557328'), (b'Cache-Control', b'max-age=604800'), ...]
+print(response.content)
+# b'<!doctype html>\n<html>\n<head>\n<title>Example Domain</title>\n\n<meta charset="utf-8"/>\n ...'
+```
+
+The top-level `httpcore.request()` function is provided for convenience. In practice whenever you're working with `httpcore` you'll want to use the connection pooling functionality that it provides.
+
+```python
+import httpcore
+
+http = httpcore.ConnectionPool()
+response = http.request("GET", "https://www.example.com/")
+```
+
+Once you're ready to get going, [head over to the documentation](https://www.encode.io/httpcore/).
+
+## Motivation
+
+You *probably* don't want to be using HTTP Core directly. It might make sense if
+you're writing something like a proxy service in Python, and you just want
+something at the lowest possible level, but more typically you'll want to use
+a higher level client library, such as `httpx`.
+
+The motivation for `httpcore` is:
+
+* To provide a reusable low-level client library, that other packages can then build on top of.
+* To provide a *really clear interface split* between the networking code and client logic,
+  so that each is easier to understand and reason about in isolation.
+
+## Dependencies
+
+The `httpcore` package has the following dependencies...
+
+* `h11`
+* `certifi`
+
+And the following optional extras...
+
+* `anyio` - Required by `pip install httpcore['asyncio']`.
+* `trio` - Required by `pip install httpcore['trio']`.
+* `h2` - Required by `pip install httpcore['http2']`.
+* `socksio` - Required by `pip install httpcore['socks']`.
+
+## Versioning
+
+We use [SEMVER for our versioning policy](https://semver.org/).
+
+For changes between package versions please see our [project changelog](CHANGELOG.md).
+
+We recommend pinning your requirements either the most current major version, or a more specific version range:
+
+```python
+pip install 'httpcore==1.*'
+```
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
+
+## Version 1.0.9 (April 24th, 2025)
+
+- Resolve https://github.com/advisories/GHSA-vqfr-h8mv-ghfj with h11 dependency update. (#1008)
+
+## Version 1.0.8 (April 11th, 2025)
+
+- Fix `AttributeError` when importing on Python 3.14. (#1005)
+
+## Version 1.0.7 (November 15th, 2024)
+
+- Support `proxy=…` configuration on `ConnectionPool()`. (#974)
+
+## Version 1.0.6 (October 1st, 2024)
+
+- Relax `trio` dependency pinning. (#956)
+- Handle `trio` raising `NotImplementedError` on unsupported platforms. (#955)
+- Handle mapping `ssl.SSLError` to `httpcore.ConnectError`. (#918)
+
+## 1.0.5 (March 27th, 2024)
+
+- Handle `EndOfStream` exception for anyio backend. (#899)
+- Allow trio `0.25.*` series in package dependancies. (#903)
+
+## 1.0.4 (February 21st, 2024)
+
+- Add `target` request extension. (#888)
+- Fix support for connection `Upgrade` and `CONNECT` when some data in the stream has been read. (#882)
+
+## 1.0.3 (February 13th, 2024)
+
+- Fix support for async cancellations. (#880)
+- Fix trace extension when used with socks proxy. (#849)
+- Fix SSL context for connections using the "wss" scheme (#869)
+
+## 1.0.2 (November 10th, 2023)
+
+- Fix `float("inf")` timeouts in `Event.wait` function. (#846)
+
+## 1.0.1 (November 3rd, 2023)
+
+- Fix pool timeout to account for the total time spent retrying. (#823)
+- Raise a neater RuntimeError when the correct async deps are not installed. (#826)
+- Add support for synchronous TLS-in-TLS streams. (#840)
+
+## 1.0.0 (October 6th, 2023)
+
+From version 1.0 our async support is now optional, as the package has minimal dependencies by default.
+
+For async support use either `pip install 'httpcore[asyncio]'` or `pip install 'httpcore[trio]'`.
+
+The project versioning policy is now explicitly governed by SEMVER. See https://semver.org/.
+
+- Async support becomes fully optional. (#809)
+- Add support for Python 3.12. (#807)
+
+## 0.18.0 (September 8th, 2023)
+
+- Add support for HTTPS proxies. (#745, #786)
+- Drop Python 3.7 support. (#727)
+- Handle `sni_hostname` extension with SOCKS proxy. (#774)
+- Handle HTTP/1.1 half-closed connections gracefully. (#641)
+- Change the type of `Extensions` from `Mapping[Str, Any]` to `MutableMapping[Str, Any]`. (#762)
+
+## 0.17.3 (July 5th, 2023)
+
+- Support async cancellations, ensuring that the connection pool is left in a clean state when cancellations occur. (#726)
+- The networking backend interface has [been added to the public API](https://www.encode.io/httpcore/network-backends). Some classes which were previously private implementation detail are now part of the top-level public API. (#699)
+- Graceful handling of HTTP/2 GoAway frames, with requests being transparently retried on a new connection. (#730)
+- Add exceptions when a synchronous `trace callback` is passed to an asynchronous request or an asynchronous `trace callback` is passed to a synchronous request. (#717)
+- Drop Python 3.7 support. (#727)
+
+## 0.17.2 (May 23th, 2023)
+
+- Add `socket_options` argument to `ConnectionPool` and `HTTProxy` classes. (#668)
+- Improve logging with per-module logger names. (#690)
+- Add `sni_hostname` request extension. (#696)
+- Resolve race condition during import of `anyio` package. (#692)
+- Enable TCP_NODELAY for all synchronous sockets. (#651)
+
+## 0.17.1 (May 17th, 2023)
+
+- If 'retries' is set, then allow retries if an SSL handshake error occurs. (#669)
+- Improve correctness of tracebacks on network exceptions, by raising properly chained exceptions. (#678)
+- Prevent connection-hanging behaviour when HTTP/2 connections are closed by a server-sent 'GoAway' frame. (#679)
+- Fix edge-case exception when removing requests from the connection pool. (#680)
+- Fix pool timeout edge-case. (#688)
+
+## 0.17.0 (March 16th, 2023)
+
+- Add DEBUG level logging. (#648)
+- Respect HTTP/2 max concurrent streams when settings updates are sent by server. (#652)
+- Increase the allowable HTTP header size to 100kB. (#647)
+- Add `retries` option to SOCKS proxy classes. (#643)
+
+## 0.16.3 (December 20th, 2022)
+
+- Allow `ws` and `wss` schemes. Allows us to properly support websocket upgrade connections. (#625)
+- Forwarding HTTP proxies use a connection-per-remote-host. Required by some proxy implementations. (#637)
+- Don't raise `RuntimeError` when closing a connection pool with active connections. Removes some error cases when cancellations are used. (#631)
+- Lazy import `anyio`, so that it's no longer a hard dependancy, and isn't imported if unused. (#639)
+
+## 0.16.2 (November 25th, 2022)
+
+- Revert 'Fix async cancellation behaviour', which introduced race conditions. (#627)
+- Raise `RuntimeError` if attempting to us UNIX domain sockets on Windows. (#619)
+
+## 0.16.1 (November 17th, 2022)
+
+- Fix HTTP/1.1 interim informational responses, such as "100 Continue". (#605)
+
+## 0.16.0 (October 11th, 2022)
+
+- Support HTTP/1.1 informational responses. (#581)
+- Fix async cancellation behaviour. (#580)
+- Support `h11` 0.14. (#579)
+
+## 0.15.0 (May 17th, 2022)
+
+- Drop Python 3.6 support (#535)
+- Ensure HTTP proxy CONNECT requests include `timeout` configuration. (#506)
+- Switch to explicit `typing.Optional` for type hints. (#513)
+- For `trio` map OSError exceptions to `ConnectError`. (#543)
+
+## 0.14.7 (February 4th, 2022)
+
+- Requests which raise a PoolTimeout need to be removed from the pool queue. (#502)
+- Fix AttributeError that happened when Socks5Connection were terminated. (#501)
+
+## 0.14.6 (February 1st, 2022)
+
+- Fix SOCKS support for `http://` URLs. (#492)
+- Resolve race condition around exceptions during streaming a response. (#491)
+
+## 0.14.5 (January 18th, 2022)
+
+- SOCKS proxy support. (#478)
+- Add proxy_auth argument to HTTPProxy. (#481)
+- Improve error message on 'RemoteProtocolError' exception when server disconnects without sending a response. (#479)
+
+## 0.14.4 (January 5th, 2022)
+
+- Support HTTP/2 on HTTPS tunnelling proxies. (#468)
+- Fix proxy headers missing on HTTP forwarding. (#456)
+- Only instantiate SSL context if required. (#457)
+- More robust HTTP/2 handling. (#253, #439, #440, #441)
+
+## 0.14.3 (November 17th, 2021)
+
+- Fix race condition when removing closed connections from the pool. (#437)
+
+## 0.14.2 (November 16th, 2021)
+
+- Failed connections no longer remain in the pool. (Pull #433)
+
+## 0.14.1 (November 12th, 2021)
+
+- `max_connections` becomes optional. (Pull #429)
+- `certifi` is now included in the install dependancies. (Pull #428)
+- `h2` is now strictly optional. (Pull #428)
+
+## 0.14.0 (November 11th, 2021)
+
+The 0.14 release is a complete reworking of `httpcore`, comprehensively addressing some underlying issues in the connection pooling, as well as substantially redesigning the API to be more user friendly.
+
+Some of the lower-level API design also makes the components more easily testable in isolation, and the package now has 100% test coverage.
+
+See [discussion #419](https://github.com/encode/httpcore/discussions/419) for a little more background.
+
+There's some other neat bits in there too, such as the "trace" extension, which gives a hook into inspecting the internal events that occur during the request/response cycle. This extension is needed for the HTTPX cli, in order to...
+
+* Log the point at which the connection is established, and the IP/port on which it is made.
+* Determine if the outgoing request should log as HTTP/1.1 or HTTP/2, rather than having to assume it's HTTP/2 if the --http2 flag was passed. (Which may not actually be true.)
+* Log SSL version info / certificate info.
+
+Note that `curio` support is not currently available in 0.14.0. If you're using `httpcore` with `curio` please get in touch, so we can assess if we ought to prioritize it as a feature or not.
+
+## 0.13.7 (September 13th, 2021)
+
+- Fix broken error messaging when URL scheme is missing, or a non HTTP(S) scheme is used. (Pull #403)
+
+## 0.13.6 (June 15th, 2021)
+
+### Fixed
+
+- Close sockets when read or write timeouts occur. (Pull #365)
+
+## 0.13.5 (June 14th, 2021)
+
+### Fixed
+
+- Resolved niggles with AnyIO EOF behaviours. (Pull #358, #362)
+
+## 0.13.4 (June 9th, 2021)
+
+### Added
+
+- Improved error messaging when URL scheme is missing, or a non HTTP(S) scheme is used. (Pull #354)
+
+### Fixed
+
+- Switched to `anyio` as the default backend implementation when running with `asyncio`. Resolves some awkward [TLS timeout issues](https://github.com/encode/httpx/discussions/1511).
+
+## 0.13.3 (May 6th, 2021)
+
+### Added
+
+- Support HTTP/2 prior knowledge, using `httpcore.SyncConnectionPool(http1=False)`. (Pull #333)
+
+### Fixed
+
+- Handle cases where environment does not provide `select.poll` support. (Pull #331)
+
+## 0.13.2 (April 29th, 2021)
+
+### Added
+
+- Improve error message for specific case of `RemoteProtocolError` where server disconnects without sending a response. (Pull #313)
+
+## 0.13.1 (April 28th, 2021)
+
+### Fixed
+
+- More resiliant testing for closed connections. (Pull #311)
+- Don't raise exceptions on ungraceful connection closes. (Pull #310)
+
+## 0.13.0 (April 21st, 2021)
+
+The 0.13 release updates the core API in order to match the HTTPX Transport API,
+introduced in HTTPX 0.18 onwards.
+
+An example of making requests with the new interface is:
+
+```python
+with httpcore.SyncConnectionPool() as http:
+    status_code, headers, stream, extensions = http.handle_request(
+        method=b'GET',
+        url=(b'https', b'example.org', 443, b'/'),
+        headers=[(b'host', b'example.org'), (b'user-agent', b'httpcore')]
+        stream=httpcore.ByteStream(b''),
+        extensions={}
+    )
+    body = stream.read()
+    print(status_code, body)
+```
+
+### Changed
+
+- The `.request()` method is now `handle_request()`. (Pull #296)
+- The `.arequest()` method is now `.handle_async_request()`. (Pull #296)
+- The `headers` argument is no longer optional. (Pull #296)
+- The `stream` argument is no longer optional. (Pull #296)
+- The `ext` argument is now named `extensions`, and is no longer optional. (Pull #296)
+- The `"reason"` extension keyword is now named `"reason_phrase"`. (Pull #296)
+- The `"reason_phrase"` and `"http_version"` extensions now use byte strings for their values. (Pull #296)
+- The `httpcore.PlainByteStream()` class becomes `httpcore.ByteStream()`. (Pull #296)
+
+### Added
+
+- Streams now support a `.read()` interface. (Pull #296)
+
+### Fixed
+
+- Task cancellation no longer leaks connections from the connection pool. (Pull #305)
+
+## 0.12.3 (December 7th, 2020)
+
+### Fixed
+
+- Abort SSL connections on close rather than waiting for remote EOF when using `asyncio`.  (Pull #167)
+- Fix exception raised in case of connect timeouts when using the `anyio` backend. (Pull #236)
+- Fix `Host` header precedence for `:authority` in HTTP/2. (Pull #241, #243)
+- Handle extra edge case when detecting for socket readability when using `asyncio`. (Pull #242, #244)
+- Fix `asyncio` SSL warning when using proxy tunneling. (Pull #249)
+
+## 0.12.2 (November 20th, 2020)
+
+### Fixed
+
+- Properly wrap connect errors on the asyncio backend. (Pull #235)
+- Fix `ImportError` occurring on Python 3.9 when using the HTTP/1.1 sync client in a multithreaded context. (Pull #237)
+
+## 0.12.1 (November 7th, 2020)
+
+### Added
+
+- Add connect retries. (Pull #221)
+
+### Fixed
+
+- Tweak detection of dropped connections, resolving an issue with open files limits on Linux. (Pull #185)
+- Avoid leaking connections when establishing an HTTP tunnel to a proxy has failed. (Pull #223)
+- Properly wrap OS errors when using `trio`. (Pull #225)
+
+## 0.12.0 (October 6th, 2020)
+
+### Changed
+
+- HTTP header casing is now preserved, rather than always sent in lowercase. (#216 and python-hyper/h11#104)
+
+### Added
+
+- Add Python 3.9 to officially supported versions.
+
+### Fixed
+
+- Gracefully handle a stdlib asyncio bug when a connection is closed while it is in a paused-for-reading state. (#201)
+
+## 0.11.1 (September 28nd, 2020)
+
+### Fixed
+
+- Add await to async semaphore release() coroutine (#197)
+- Drop incorrect curio classifier (#192)
+
+## 0.11.0 (September 22nd, 2020)
+
+The Transport API with 0.11.0 has a couple of significant changes.
+
+Firstly we've moved changed the request interface in order to allow extensions, which will later enable us to support features
+such as trailing headers, HTTP/2 server push, and CONNECT/Upgrade connections.
+
+The interface changes from:
+
+```python
+def request(method, url, headers, stream, timeout):
+    return (http_version, status_code, reason, headers, stream)
+```
+
+To instead including an optional dictionary of extensions on the request and response:
+
+```python
+def request(method, url, headers, stream, ext):
+    return (status_code, headers, stream, ext)
+```
+
+Having an open-ended extensions point will allow us to add later support for various optional features, that wouldn't otherwise be supported without these API changes.
+
+In particular:
+
+* Trailing headers support.
+* HTTP/2 Server Push
+* sendfile.
+* Exposing raw connection on CONNECT, Upgrade, HTTP/2 bi-di streaming.
+* Exposing debug information out of the API, including template name, template context.
+
+Currently extensions are limited to:
+
+* request: `timeout` - Optional. Timeout dictionary.
+* response: `http_version` - Optional. Include the HTTP version used on the response.
+* response: `reason` - Optional. Include the reason phrase used on the response. Only valid with HTTP/1.*.
+
+See https://github.com/encode/httpx/issues/1274#issuecomment-694884553 for the history behind this.
+
+Secondly, the async version of `request` is now namespaced as `arequest`.
+
+This allows concrete transports to support both sync and async implementations on the same class.
+
+### Added
+
+- Add curio support. (Pull #168)
+- Add anyio support, with `backend="anyio"`. (Pull #169)
+
+### Changed
+
+- Update the Transport API to use 'ext' for optional extensions. (Pull #190)
+- Update the Transport API to use `.request` and `.arequest` so implementations can support both sync and async. (Pull #189)
+
+## 0.10.2 (August 20th, 2020)
+
+### Added
+
+- Added Unix Domain Socket support. (Pull #139)
+
+### Fixed
+
+- Always include the port on proxy CONNECT requests. (Pull #154)
+- Fix `max_keepalive_connections` configuration. (Pull #153)
+- Fixes behaviour in HTTP/1.1 where server disconnects can be used to signal the end of the response body. (Pull #164)
+
+## 0.10.1 (August 7th, 2020)
+
+- Include `max_keepalive_connections` on `AsyncHTTPProxy`/`SyncHTTPProxy` classes.
+
+## 0.10.0 (August 7th, 2020)
+
+The most notable change in the 0.10.0 release is that HTTP/2 support is now fully optional.
+
+Use either `pip install httpcore` for HTTP/1.1 support only, or `pip install httpcore[http2]` for HTTP/1.1 and HTTP/2 support.
+
+### Added
+
+- HTTP/2 support becomes optional. (Pull #121, #130)
+- Add `local_address=...` support. (Pull #100, #134)
+- Add `PlainByteStream`, `IteratorByteStream`, `AsyncIteratorByteStream`. The `AsyncByteSteam` and `SyncByteStream` classes are now pure interface classes. (#133)
+- Add `LocalProtocolError`, `RemoteProtocolError` exceptions. (Pull #129)
+- Add `UnsupportedProtocol` exception. (Pull #128)
+- Add `.get_connection_info()` method. (Pull #102, #137)
+- Add better TRACE logs. (Pull #101)
+
+### Changed
+
+- `max_keepalive` is deprecated in favour of `max_keepalive_connections`. (Pull #140)
+
+### Fixed
+
+- Improve handling of server disconnects. (Pull #112)
+
+## 0.9.1 (May 27th, 2020)
+
+### Fixed
+
+- Proper host resolution for sync case, including IPv6 support. (Pull #97)
+- Close outstanding connections when connection pool is closed. (Pull #98)
+
+## 0.9.0 (May 21th, 2020)
+
+### Changed
+
+- URL port becomes an `Optional[int]` instead of `int`. (Pull #92)
+
+### Fixed
+
+- Honor HTTP/2 max concurrent streams settings. (Pull #89, #90)
+- Remove incorrect debug log. (Pull #83)
+
+## 0.8.4 (May 11th, 2020)
+
+### Added
+
+- Logging via HTTPCORE_LOG_LEVEL and HTTPX_LOG_LEVEL environment variables
+and TRACE level logging. (Pull #79)
+
+### Fixed
+
+- Reuse of connections on HTTP/2 in close concurrency situations. (Pull #81)
+
+## 0.8.3 (May 6rd, 2020)
+
+### Fixed
+
+- Include `Host` and `Accept` headers on proxy "CONNECT" requests.
+- De-duplicate any headers also contained in proxy_headers.
+- HTTP/2 flag not being passed down to proxy connections.
+
+## 0.8.2 (May 3rd, 2020)
+
+### Fixed
+
+- Fix connections using proxy forwarding requests not being added to the
+connection pool properly. (Pull #70)
+
+## 0.8.1 (April 30th, 2020)
+
+### Changed
+
+- Allow inherintance of both `httpcore.AsyncByteStream`, `httpcore.SyncByteStream` without type conflicts.
+
+## 0.8.0 (April 30th, 2020)
+
+### Fixed
+
+- Fixed tunnel proxy support.
+
+### Added
+
+- New `TimeoutException` base class.
+
+## 0.7.0 (March 5th, 2020)
+
+- First integration with HTTPX.

.venv/lib/python3.11/site-packages/httpcore-1.0.9.dist-info/RECORD

@@ -0,0 +1,38 @@
+httpcore-1.0.9.dist-info/INSTALLER,sha256=5hhM4Q4mYTT9z6QB6PGpUAW81PGNFrYrdXMj4oM_6ak,2
+httpcore-1.0.9.dist-info/METADATA,sha256=_i1P2mGZEol4d54M8n88BFxTGGP83Zh-rMdPOhjUHCE,21529
+httpcore-1.0.9.dist-info/RECORD,,
+httpcore-1.0.9.dist-info/REQUESTED,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+httpcore-1.0.9.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+httpcore-1.0.9.dist-info/licenses/LICENSE.md,sha256=_ctZFUx0y6uhahEkL3dAvqnyPW_rVUeRfYxflKgDkqU,1518
+httpcore/__init__.py,sha256=9kT_kqChCCJUTHww24ZmR_ezcdbpRYWksD-gYNzkZP8,3445
+httpcore/_api.py,sha256=unZmeDschBWCGCPCwkS3Wot9euK6bg_kKxLtGTxw214,3146
+httpcore/_async/__init__.py,sha256=EWdl2v4thnAHzJpqjU4h2a8DUiGAvNiWrkii9pfhTf0,1221
+httpcore/_async/connection.py,sha256=6OcPXqMEfc0BU38_-iHUNDd1vKSTc2UVT09XqNb_BOk,8449
+httpcore/_async/connection_pool.py,sha256=DOIQ2s2ZCf9qfwxhzMprTPLqCL8OxGXiKF6qRHxvVyY,17307
+httpcore/_async/http11.py,sha256=-qM9bV7PjSQF5vxs37-eUXOIFwbIjPcZbNliuX9TtBw,13880
+httpcore/_async/http2.py,sha256=azX1fcmtXaIwjputFlZ4vd92J8xwjGOa9ax9QIv4394,23936
+httpcore/_async/http_proxy.py,sha256=2zVkrlv-Ds-rWGaqaXlrhEJiAQFPo23BT3Gq_sWoBXU,14701
+httpcore/_async/interfaces.py,sha256=jTiaWL83pgpGC9ziv90ZfwaKNMmHwmOalzaKiuTxATo,4455
+httpcore/_async/socks_proxy.py,sha256=lLKgLlggPfhFlqi0ODeBkOWvt9CghBBUyqsnsU1tx6Q,13841
+httpcore/_backends/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+httpcore/_backends/anyio.py,sha256=x8PgEhXRC8bVqsdzk_YJx8Y6d9Tub06CuUSwnbmtqoY,5252
+httpcore/_backends/auto.py,sha256=zO136PKZmsaTDK-HRk84eA-MUg8_2wJf4NvmK432Aio,1662
+httpcore/_backends/base.py,sha256=aShgRdZnMmRhFWHetjumlM73f8Kz1YOAyCUP_4kHslA,3042
+httpcore/_backends/mock.py,sha256=er9T436uSe7NLrfiLa4x6Nuqg5ivQ693CxWYCWsgbH4,4077
+httpcore/_backends/sync.py,sha256=bhE4d9iK9Umxdsdsgm2EfKnXaBms2WggGYU-7jmUujU,7977
+httpcore/_backends/trio.py,sha256=LHu4_Mr5MswQmmT3yE4oLgf9b_JJfeVS4BjDxeJc7Ro,5996
+httpcore/_exceptions.py,sha256=looCKga3_YVYu3s-d3L9RMPRJyhsY7fiuuGxvkOD0c0,1184
+httpcore/_models.py,sha256=IO2CcXcdpovRcLTdGFGB6RyBZdEm2h_TOmoCc4rEKho,17623
+httpcore/_ssl.py,sha256=srqmSNU4iOUvWF-SrJvb8G_YEbHFELOXQOwdDIBTS9c,187
+httpcore/_sync/__init__.py,sha256=JBDIgXt5la1LCJ1sLQeKhjKFpLnpNr8Svs6z2ni3fgg,1141
+httpcore/_sync/connection.py,sha256=9exGOb3PB-Mp2T1-sckSeL2t-tJ_9-NXomV8ihmWCgU,8238
+httpcore/_sync/connection_pool.py,sha256=a-T8LTsUxc7r0Ww1atfHSDoWPjQ0fA8Ul7S3-F0Mj70,16955
+httpcore/_sync/http11.py,sha256=IFobD1Md5JFlJGKWnh1_Q3epikUryI8qo09v8MiJIEA,13476
+httpcore/_sync/http2.py,sha256=AxU4yhcq68Bn5vqdJYtiXKYUj7nvhYbxz3v4rT4xnvA,23400
+httpcore/_sync/http_proxy.py,sha256=_al_6crKuEZu2wyvu493RZImJdBJnj5oGKNjLOJL2Zo,14463
+httpcore/_sync/interfaces.py,sha256=snXON42vUDHO5JBJvo8D4VWk2Wat44z2OXXHDrjbl94,4344
+httpcore/_sync/socks_proxy.py,sha256=zegZW9Snqj2_992DFJa8_CppOVBkVL4AgwduRkStakQ,13614
+httpcore/_synchronization.py,sha256=zSi13mAColBnknjZBknUC6hKNDQT4C6ijnezZ-r0T2s,9434
+httpcore/_trace.py,sha256=ck6ZoIzYTkdNAIfq5MGeKqBXDtqjOX-qfYwmZFbrGco,3952
+httpcore/_utils.py,sha256=_RLgXYOAYC350ikALV59GZ68IJrdocRZxPs9PjmzdFY,1537
+httpcore/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0

.venv/lib/python3.11/site-packages/httpcore-1.0.9.dist-info/WHEEL

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

.venv/lib/python3.11/site-packages/httpcore-1.0.9.dist-info/licenses/LICENSE.md

@@ -0,0 +1,27 @@
+Copyright © 2020, [Encode OSS Ltd](https://www.encode.io/).
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+* Redistributions of source code must retain the above copyright notice, this
+  list of conditions and the following disclaimer.
+
+* Redistributions in binary form must reproduce the above copyright notice,
+  this list of conditions and the following disclaimer in the documentation
+  and/or other materials provided with the distribution.
+
+* Neither the name of the copyright 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.

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

@@ -0,0 +1,141 @@
+from ._api import request, stream
+from ._async import (
+    AsyncConnectionInterface,
+    AsyncConnectionPool,
+    AsyncHTTP2Connection,
+    AsyncHTTP11Connection,
+    AsyncHTTPConnection,
+    AsyncHTTPProxy,
+    AsyncSOCKSProxy,
+)
+from ._backends.base import (
+    SOCKET_OPTION,
+    AsyncNetworkBackend,
+    AsyncNetworkStream,
+    NetworkBackend,
+    NetworkStream,
+)
+from ._backends.mock import AsyncMockBackend, AsyncMockStream, MockBackend, MockStream
+from ._backends.sync import SyncBackend
+from ._exceptions import (
+    ConnectError,
+    ConnectionNotAvailable,
+    ConnectTimeout,
+    LocalProtocolError,
+    NetworkError,
+    PoolTimeout,
+    ProtocolError,
+    ProxyError,
+    ReadError,
+    ReadTimeout,
+    RemoteProtocolError,
+    TimeoutException,
+    UnsupportedProtocol,
+    WriteError,
+    WriteTimeout,
+)
+from ._models import URL, Origin, Proxy, Request, Response
+from ._ssl import default_ssl_context
+from ._sync import (
+    ConnectionInterface,
+    ConnectionPool,
+    HTTP2Connection,
+    HTTP11Connection,
+    HTTPConnection,
+    HTTPProxy,
+    SOCKSProxy,
+)
+
+# The 'httpcore.AnyIOBackend' class is conditional on 'anyio' being installed.
+try:
+    from ._backends.anyio import AnyIOBackend
+except ImportError:  # pragma: nocover
+
+    class AnyIOBackend:  # type: ignore
+        def __init__(self, *args, **kwargs):  # type: ignore
+            msg = (
+                "Attempted to use 'httpcore.AnyIOBackend' but 'anyio' is not installed."
+            )
+            raise RuntimeError(msg)
+
+
+# The 'httpcore.TrioBackend' class is conditional on 'trio' being installed.
+try:
+    from ._backends.trio import TrioBackend
+except ImportError:  # pragma: nocover
+
+    class TrioBackend:  # type: ignore
+        def __init__(self, *args, **kwargs):  # type: ignore
+            msg = "Attempted to use 'httpcore.TrioBackend' but 'trio' is not installed."
+            raise RuntimeError(msg)
+
+
+__all__ = [
+    # top-level requests
+    "request",
+    "stream",
+    # models
+    "Origin",
+    "URL",
+    "Request",
+    "Response",
+    "Proxy",
+    # async
+    "AsyncHTTPConnection",
+    "AsyncConnectionPool",
+    "AsyncHTTPProxy",
+    "AsyncHTTP11Connection",
+    "AsyncHTTP2Connection",
+    "AsyncConnectionInterface",
+    "AsyncSOCKSProxy",
+    # sync
+    "HTTPConnection",
+    "ConnectionPool",
+    "HTTPProxy",
+    "HTTP11Connection",
+    "HTTP2Connection",
+    "ConnectionInterface",
+    "SOCKSProxy",
+    # network backends, implementations
+    "SyncBackend",
+    "AnyIOBackend",
+    "TrioBackend",
+    # network backends, mock implementations
+    "AsyncMockBackend",
+    "AsyncMockStream",
+    "MockBackend",
+    "MockStream",
+    # network backends, interface
+    "AsyncNetworkStream",
+    "AsyncNetworkBackend",
+    "NetworkStream",
+    "NetworkBackend",
+    # util
+    "default_ssl_context",
+    "SOCKET_OPTION",
+    # exceptions
+    "ConnectionNotAvailable",
+    "ProxyError",
+    "ProtocolError",
+    "LocalProtocolError",
+    "RemoteProtocolError",
+    "UnsupportedProtocol",
+    "TimeoutException",
+    "PoolTimeout",
+    "ConnectTimeout",
+    "ReadTimeout",
+    "WriteTimeout",
+    "NetworkError",
+    "ConnectError",
+    "ReadError",
+    "WriteError",
+]
+
+__version__ = "1.0.9"
+
+
+__locals = locals()
+for __name in __all__:
+    # Exclude SOCKET_OPTION, it causes AttributeError on Python 3.14
+    if not __name.startswith(("__", "SOCKET_OPTION")):
+        setattr(__locals[__name], "__module__", "httpcore")  # noqa